Question

We have come across a scenario where we need to track the setting and unsettling of a nullable type.

so something like

int? value

if(value.isSet())
{
  addTocollection();
}

we would also need a clear function

value.clear();

The concept is that the data has an extra state that is the set state.

so NULL(set) and NULL(unset) have different meanings.
and then you have the value (set) for most cases and the value(unset) (this last case would have no meaning)

is there a way using extension methods or some other pattern that could solve this problem.
my current thought is that we will have to revert to an extended class of some sort.

Answer 1

I’m trying to understand what you’re after. I think it is something like the below (Dump is from LINQPad, just think Console.WriteLine). Overall, I don’t think this is a good idea, because you provide something obscure that does not work as expected. Unless I mis-understand what you want.

void Main()
{
    int? x = null;
    var wrap = new NullableWrapper<int>( x );

    wrap.HasBeenSet.Dump();  // false
    wrap.HasValue.Dump();   // false

    wrap = 10;

    wrap.HasBeenSet.Dump();  // true
    wrap.HasValue.Dump();    // true
    wrap.Value.Dump();       // 10

    int? y = wrap;

    y.HasValue.Dump();   // True
    y.Value.Dump();      // 10

    wrap = null;
    wrap.HasBeenSet.Dump();  // Does now work like expected => bad
}

public class NullableWrapper<T> where T : struct
{
  private Nullable<T> _impl;
  private bool _hasBeenSet = false;

  public NullableWrapper( Nullable<T> t )
  {
    _impl = t;
    _hasBeenSet = t.HasValue;
  }

  public bool HasBeenSet
  {
    get { return _hasBeenSet; }
  }

  public bool HasValue
  {
    get { return _impl.HasValue; }
  }

  public T Value
  {
    get { return _impl.Value; }
    set { _impl = value; _hasBeenSet = true; }
  }

  public void Clear()
  {
    _hasBeenSet = false;
  }

  public static implicit operator Nullable<T>( NullableWrapper<T> lhs )
  {
    return lhs._impl;
  }

  public static implicit operator NullableWrapper<T>( T rhs )
  {
    return( new NullableWrapper<T>( rhs ) );
  }
}