Sometimes, you want to pass or store data which is in a value type in a context where only a reference type makes sense. This is either because you want to be able to modify the value from another location (as in
this question[
^]), or because you want to pass it as a type parameter to a generic class or method which has a
where T: class
(or
where T: new()
) restriction.
You can write a boxing class which can be used in such scenarios:
public class Box<T> where T:struct {
public T Value { get; set; }
public Box() : this(default(T)) {}
public Box(T value) { this.Value = value; }
public static implicit operator T(Box<T> box) { return box.Value; }
public static implicit operator Box<T>(T value) { return new Box<T>(value); }
}
Usage: If you want to use it as a 'pointer', you need to store the reference and pass it explicitly:
Box<int> refint = 5;
ModifyingClass instance = new ModifyingClass(refint);
instance.Adjust();
Debug.Assert(6 == refint);
class ModifyingClass {
Box<int> target;
public ModifyingClass(Box<int> i) { target = i; }
public void Adjust() { target.Value++; }
}
To pass it as a prototype to a generic class, simply do
SomeRestrictedGeneric<Box<T>> variable = new SomeRestrictedGeneric<Box<T>>()