实例成员的引用变量

Question

I have this data class:

class MyClass
{
    Foo Foo1 { get; set; }
    Foo Foo2 { get; set; }
    Foo Foo3 { get; set; }
    Foo Foo4 { get; set; }
}

Now, somewhere else in my program, I have this function:

void ModifyMyClass(MyClass myClassInstance)
{
    var rightFooToModify = myclassInstance.Foo1;

    rightFooToModify = new Foo();  // Here, my intention is to
                                   // modify MyClass, not just the
                                   // local variable 'rightFooToModify'
}

I need to be able to choose one of Foo1, Foo2, Foo3, Foo4 (depending on some conditions) and then set it to a new Foo object.

What would be the best way to achieve this? Are there some kind of reference variable that I can use for this in C#?

EDIT:

I could use (and it is actually what I use right now):

myClassInstance.Foo1 = new Foo();

But, ModifyMyClass() is actually a bit more complicated, for example:

void ModifyMyClass(MyClass myClassInstance)
{
    if (someCondition)
    {
        var rightFooToModify = myClassInstance.Foo1
        // ... Do some computation with rightFooToModify
        myClassInstance.Foo1 = new Foo(/* some parameters */);
    }
    else if (someOtherCondition)
    {
        // The exact same code as the if above , but with
        // myClassInstance.Foo2 instance.
    }
}

I would like to avoid duplicating the code in the if block in all the following else if . That is why I would like to just use var rightFooToModify = myClassInstance.Foo1 at the start of the method and not duplicate the code needlessly in mutliple if s.

Answer 1

You can think of it like this

When you assign your property to a local variable,

var rightFooToModify = myclassInstance.Foo1;

all you are doing is writing a post-it-Note with the location of some memory on.

If someone gives you another post-it-note with some more, replacing the original one

rightFooToModify = new Foo();

It doesn't change the original memory, its still there, nothing happened.

This is how pointers/references work. They point/reference a location in memory, you can copy a reference yet overwriting that reference doesn't do anything to the original memory location, you just have a new post-it-note pointing to somewhere else.

However, now for a really contrived example of a way to overcome this with ref return and ref Local

Disclaimer , i don't really advocate doing this in your situation, however for sheer academic purposes lets look at this language feature

Given

public class MyClass
{
   private Foo _foo1;

   public Foo Foo1
   {
      get => _foo1;
      set => _foo1 = value;
   }

   public ref Foo ModifyMyClass()
   {
      return ref _foo1;
   }
}

Example

// create class
var someClass = new MyClass();

// create some memory for it
someClass.Foo1 = new Foo();
someClass.Foo1.SomeValue = "test";

// copy the reference to it
var copy = someClass.Foo1; 

// overwrite it
copy = new Foo();
copy.SomeValue = "test2";

// oh nossssssssss!!!! is didn't change!!
Console.WriteLine(someClass.Foo1.SomeValue);


//enter ref local
ref var  actualLocation = ref someClass.ModifyMyClass();

// create some memory
actualLocation = new Foo();
actualLocation.SomeValue = "test3";

// omg it worked!!!!
Console.WriteLine(someClass.Foo1.SomeValue);

Output

test
test3

And yet another bizarre and weird usage of ref

someClass.ModifyMyClass() = new Foo();
someClass.ModifyMyClass().SomeValue = "I hope i never see this in my code base";
Console.WriteLine(someClass.Foo1.SomeValue);

Answer 2

I don't know if this will be of any help, but you can have a method returning the correct setter of type Action<MyClass, Foo> , ie

Action<MyClass, Foo> GetFooSetter()
{
    if (someCondition)
    {
        return (myClass, foo) => myClass.Foo1 = foo;
    }
    else if (someOtherCondition)
    {
        return (myClass, foo) => myClass.Foo2 = foo;
    }
}

and then call it like this:

GetFooSetter()(myClassInstance, new Foo());

Answer 3

The use case is not so clear, so I will suggest two options:

1. If Foo is not immutable, then just modify it's values instead of assigning it to a new instance. You can even add a copy function to copy values from another Foo :

    Foo fooToChange = myClassInstance.Foo1; fooToChange.CopyFrom(new Foo()); 

2. Refactor to hold the Foos in an array, then you can ask for it and assign with an index:

    class MyClass { public Foo[] Foos = new Foo[4]; } int fooToChange = 3; myClassInstance.Foos[3] = new Foo();