.NET Double Reference

• Download demo - 13.67 KB

Introduction

The DoubleReference class below wraps a reference which gives one reference to references. When used, they act like double pointers in C and in some cases can increase efficiency a great deal.

Background

Double pointers in C give one the ability to have objects point to a "placeholder". The placeholder can change value and all the objects pointing to the placeholder will see the change. The placeholder itself is usually a reference/pointer to the object of interest. This can be achieved similarly in .NET by wrapping a reference in a class.

Using the Code

Use the class...

public class DoubleReference<T>
{
    public T Reference { get; set; }
    public DoubleReference(T reference) { Reference = reference; }
    public static implicit operator T(DoubleReference<T> x) { return x.Reference; }
    public static T operator ~(DoubleReference<T> x) { return x.Reference; }
}        

...as you would any reference but simply wrap them with this class. You can provide a direct link to a reference but wrap it in a property of the original type. This allows complete transparency.

DoubleReference<Test2> reff;
public Test2 RootTest { get { return reff.Reference; } set { reff.Reference = value; } }

Here we have a double reference placeholder. RootTest simply wraps the double reference and returns whatever it points to. Alternatively, we could expose the double reference if we want to avoid possible issues that changes to RootTest might incur. We could also remove the setter for Root Test.

The idea here is that we can create a single DoubleReference class and pass that around. As long as objects that reference this object do not change their reference, any changes to the double reference's reference will "propagate" to all objects using it.

You can use this, for example, in a collection where every element in the collection has a "Current" property. The Current property points to some current element. When the value has to change, it should propagate to all elements. By using a double reference, you can do this instantaneously at the cost of the extra memory.

History

• 29^th March, 2011: Initial version