Question

Let me explain my situation. I have a program who reads an external connection and gives me an array of integers (or booleans). Those inputs should feed an object that has some properties (X, Y, Z, for example). So, if a read a value on array, i should write those values in the properties. Is there a way to pass those values by ref (for example) ? Thinking logically , the best way way would be pointers (property X pointing to array[0]), but these aren’t very unclear to me.

I can create a way to look for changes in array (but is a very large array, +60000), then update my object. But i think this would be a bad ideia.

Sorry if i wrote any crap, i’m just starting on C#.

Some pseudo code to help.

class obj
{
      int X {get; set;}
      public obj(ref int x)
      {
          X = x;
      }
}

class main 
{
      void main()
      {
         int a;

         obj test = new obj(ref a);
      }
}

So if: a = 10, obj.X = 10 too.

Answer 1

public class MyClass
{
    private int[] backingArray;
    public int X
    {
        get
        {
            if (backingArray == null)
                return -1;
            else
                return backingArray[0];
        }
    }
    public MyClass(int[] array)
    {
        if (array.Length > 0)
            backingArray = array;
    }
}

class Main
{
    void Main()
    {
        int[] array = new int[] { 2 };

        MyClass test = new MyClass(array);
        array[0] = 6;
        Console.WriteLine(test.X);//prints 6
    }
}

Of course this only works with reference types (arrays are reference types). If you wanted to do this whole thing with a value type, you’d need to “wrap” it in some reference type. You can use a class such as the following to wrap anything if you don’t have anything convenient.

public class Wrapper<T>
{
    public T Value { get; set; }
}

It’s not possible to use ref in the manor that you’ve shown in the OP. You wouldn’t be able to store the value that was passed by reference. If you could, then you could end up passing some value on the stack and then having the created object that holds the reference living longer than the item on the stack. If that happened you would end up with a reference it a location in memory that no longer holds the variable you intended. This was somewhat of a gotcha in C++ that the designers of C# went out of their way to ensure can’t happen (at least not without a lot of work).