Altering references within a reference parameter

Question

I am trying to pass an array to a method. The array contains objects which need to be nulled. The method would simply null each object in a loop. I need this to reflect back in the caller.

Sample code (code goodness & minor syntactical issues can be ignored):

public class ABC
{
  ...
}

private void SomeMethod()
{
  var toBeNulledObj1 = new ABC();
  var toBeNulledObj2 = new ABC();
  var arrayOfNullableObjects = new ABC[]{toBeNulledObj1 ,toBeNulledObj2};
  NullingFunction(arrayOfNullableObjects);
}

private void NullingFunction(ABC[] arrayOfNullableObjects)
{
   for(int i = 0; i< arrayOfNullableObjects.Length ; i++)
     {
        arrayOfNullableObjects[i] = null;
     }
}

Clearly upon returning, toBeNulledObj1 & toBeNulledObj2 are not null but retain their older values though arrayOfNullableObjects now has two null objects. I realise that ref & out only apply to the collection parameter (here, arrayOfNullableObjects which doesn't even need a ref). I tried passing them in as params instead of a collection but that doesn't help, either (ref & params cannot be combined).

Question: How can I alter each/any object in a collection of objects within a method such that the change is visible to the caller? I am not altering the collection itself. Please note, I am not changing the contents/members of toBeNulledObj1 but the reference itself (to either null or a new object).

Answer 1

Solution #1: Unsafe code

One solution is using a unsafe code. You have to think twice before using it, and I do not know if you will be happy with my answer, but here it is.

static private void SomeMethod()
{
    ABC toBeNulledObj1 = new ABC();
    ABC toBeNulledObj2 = new ABC();

    IntPtr[] arrayOfNullableObjects = new IntPtr[] { MakeReference(ref toBeNulledObj1), MakeReference(ref toBeNulledObj2) };
    NullingFunction(arrayOfNullableObjects);
}

static private void NullingFunction(IntPtr[] arrayOfNullableObjects)
{
    foreach (IntPtr reference in arrayOfNullableObjects)
        ClearReference(reference);
}

/// <summary>
/// Makes the reference to the reference value of a reference type.
/// </summary>
static unsafe private IntPtr MakeReference<T>(ref T value)
    where T: class
{
    TypedReference reference = __makeref(value);
    return *(IntPtr*)&reference;
}

/// <summary>
/// Clears the reference to a reference type, using a reference to that reference value.
/// </summary>
static unsafe private void ClearReference(IntPtr reference)
{
    if (sizeof(IntPtr) == 4)
        *((int*)reference) = 0;
    else
        *((long*)reference) = 0;
}

Solution #2: Anonymous class

The second solution could be done by using an anonymous class which holds your data. The fields inside this anonymous class are cleared. A disadvantage is that you have a second class and the reference to this class also should to be cleared. (This can be done by adding ref to o and in the NullingFunction set o to null.) Of course you can also use a predefined class, but his solution is the closest to your code in your OP.

public static void SomeMethod()
{
    var container = new
    {
        toBeNulledObj1 = new ABC(),
        toBeNulledObj2 = new ABC(),
    };

    NullingFunction(container);
}

private static void NullingFunction<T>(T container)
    where T : class
{
    if (container == null)
        return;
    foreach(FieldInfo f in container.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic))
        if (f.FieldType.IsClass)
            f.SetValue(container, null);
}

Answer 2

Is wrapping acceptable?

class Wrapped<T> where T : new() {
   private T val = new T();
   ...
   public void Nullify() { val = null; }
}

private void SomeMethod()
{
  var toBeNulledObj1 = new Wrapped<ABC>();
  var toBeNulledObj2 = new Wrapped<ABC>();
  var arrayOfNullableObjects = new Wrapped<ABC>[]{toBeNulledObj1 ,toBeNulledObj2};
  NullingFunction(arrayOfNullableObjects);

  Debug.Assert(toBeNulledObj1.Get() == null);
  // Or...
  Debug.Assert(toBeNulledObj1.IsDefined == false);
  // Or...
  Debug.Assert(toBeNulledObj1.IsNull == true);
}

private void NullingFunction(Wrapped<ABC>[] arrayOfNullableObjects)
{
   for(int i = 0; i< arrayOfNullableObjects.Length ; i++)
     {
        arrayOfNullableObjects[i].Nullify();
     }
}

(Disclaimer: hand-compiled code :) may contain errors)

If you need it as a general pattern, you can make NullingFunction parametric (T, U), with a constaint where U: Wrapped<T>

The idea is to make something similar to Nullable for ref types, or something that looks like a smart pointer, if you are familiar with C++.

Thus, wrapper could have T Get() (or an implicit conversion to T) to get out the value, an IsDefined property, and so on.

Answer 3

If function A holds a reference to a variable i.e:

  var toBeNulledObj1 = new ABC();
  var toBeNulledObj2 = new ABC();

And does not pass this into function B:

private NullingFunction(ABC[] arrayOfNullableObjects)

Then there is nothing that function B can do to change the reference that toBeNulledObj1 / 2 points to.

Since ref is not allowed along with params (as you mentioned):

 private void NullingFunction(ref params ABC[] arrayOfNullableObjects)
    {
        for (int i = 0; i < arrayOfNullableObjects.Length; i++)
        {
            arrayOfNullableObjects[i] = null;
        }
    }

The available alternative is to create overloads e.g.:

private void SomeMethod()
{
    var toBeNulledObj1 = new ABC();
    var toBeNulledObj2 = new ABC();
    NullingFunction(ref toBeNulledObj1, ref toBeNulledObj2);
    Console.ReadKey();
}

private void NullingFunction(ref ABC one)
{
    one = null;
}

private void NullingFunction(ref ABC one, ref ABC two)
{
    one = null;
    two = null;
}

Answer 4

When you say you want to set them to null, do you mean that you want to destroy the object?

C# has automatic garbage collection, so as soon as an object goes out of scope (that is, when no other objects make reference to it), the garbage collector will destroy it.

In the code above, the label "tobeNulledObj1" still refers to an object, and your array also points to it before you call the NullingFunction.

After you call the NullingFunction, you still have one reference pointing to the object (that is, tobeNulledObj1). If you set tobeNulledObj1 to null, then the Garbage Collector will collect it.

EDIT: I second cheedep's question - what is it exactly that you are trying to do? What do you want your variables to hold at the end?