Dynamically add/change attributes of values in C#

Question

I want to tag the values of variables with a "quality" attribute that can be changed dynamically during my programs execution. My first thought was to abuse the standard attribute functionality by tagging the value with my custom quality attribute. EG

[QualityAttribute(Quality.Bad)]
int value = 0;
...
value = 1;
(** somehow set QualityAttribute of value to Quality.Good **)

But from what I have seen attributes were intended as a static measure and are baked into meta-data, making what I want to do apparently impossible.

An alternative would be to make a struct/class that contains both the variable and the quality. EG

class Value
{
  public Quality quality = Quality.Bad;
  public int value = 0;
}
...
Value value = new Value();
value.value = 1;
value.quality = Quality.Good;

This will work (and is similar to what is used to support nullable types) but I don't really like the extra layer of indirection to get to the value.

Is there any other way that allows direct access to the value and easily supports tagging value with a custom, dynamically alterable attribute?

Answer 1

This is basically a expansion over @CandiedOrange's answer, go pop an upvote to them if you end up liking this.

Why not implementing something similar to a nullable?

Enters the "Qualitable" class:

public class Qualitable<T>
{
    T Value { get; set; }
    QualityEnum Quality;  

    public Qualitable(T Value, QualityEnum Quality)
    {
        this.Value = Value;
        this.Quality = Quality;
    }
}

Then, you can just do this on your code:

Qualitable<int> myThing = new Qualitable<int>(10, QualityEnum.VeryGood)

if(myThing.Quality == QualityEnum.VeryGood)
{
    DoSomething(myThing.Value);
    //Pop an upvote 
}
else
{ 
    DoSomethingElse(myThing.Value);
   //Do it anyway, me tries hard :(
}

Answer 2

I like the struct/class alternative that contains both the variable and the quality. I don't like to use static stuff without a darn good reason. Except I also don't like squishing together two different abstractions. Meta info simply isn't at the same level as what it describes.

This is screaming "use a monadic style" to me.

You can nest these and put value at one level and quality at another. Or keep quality as a property on what's basically a generic container.

This means your value can be anything and isn't tied to your quality interface. You can swap types as needed.

You might be about to complain that this isn't direct but look up the proper way to access a monad and ask yourself if this isn't better.

---

This answer is sparking some controversy so let me explain it a little more without drowning it in detail.

The main thing I'm looking for in this design is to not force branching.

If this is just a struct or a pile of getters then users are forced to test quality and make a decision based on that. What would be nice is if that logic were pushed down and abstracted away so that good or bad you get the value you need when you ask for it.

Whether that means adding methods like UnlessBad(T other) or something else I'm not entirely sure. Just thought it worth considering.

---

public Quality<Integer> qualityAdd(Quality<Integer> val1, Quality<Integer> val2) {
    return
        val1.flatMap( first =>
        val2.flatMap( second =>
        Quality.of(first + second)
    ));
}

This will add the int's together to make a new good Quality provided both were of good quality. Otherwise a bad Quality is returned. This is a short chain but there is no set limit to it.

Done this way all the checking for quality is hidden. When bad quality is detected the chain can be stopped by simply not calling any more lambdas and returning a bad quality. Alternatively, all int's can be summed and quality can be OR'ed on the way back from the return. Either way, one bad would turn all bad.

Answer 3

Attributes are static and cannot changed at runtime, so it's kind of a dead end. You may want to look at the Type Descriptor, it may solve your problem...

https://blogs.msdn.microsoft.com/parthopdas/2006/01/04/understanding-the-typedescriptor-a-metadata-engine-for-designtime-code/

https://msdn.microsoft.com/en-us/library/system.componentmodel.typedescriptor.aspx