C# Массив ссылок на объекты Variables и/или Form

То, о чем вы конкретно просите, невозможно; что было бы более подходящим (и имеет удобство для фактической работы!) Было бы разработать структуру класса вокруг того, что вы пытаетесь сделать.

Например, что-то вроде этого:

public class MyObject // Name it appropriately
{
    public object Value { get; set; }
    public string Key { get; set; }
    public TextBox TextBox { get; set; }
}

Затем в своем коде вы можете сделать что-то вроде этого...

Dictionary<string, object> values = ...
List<MyObject> objects = ...

foreach(var item in objects)
{
    item.Value = values[item.Key];

    // process your data

    item.TextBox = item.Value.ToString();
}

Очевидно, что это всего лишь грубый дизайн, и класс здесь служит не более чем контейнером для передачи данных. Вы можете сделать класс «умнее», например, используя установщик для свойства Value для автоматической установки значения TextBox. Но мы надеемся, что это должно дать вам общее представление о том, как что-то подобное можно сделать в ОО-стиле.

ИЗМЕНИТЬ Вот как будет выглядеть ваш пример.

MyObject a = new MyObject() { Value = 4 };
MyObject b = new MyObject() { Value = 5 };
MyObject c = new MyObject() { Value = 6 };
List<MyObject> tmp = new List<MyObject>();

tmp.Add(a);
tmp.Add(b);
tmp.Add(c);

tmp[0].Value = 16;
tmp[1].Value = 3;
tmp[2].Value = 1000;

Console.Writeline(tmp[0].Value.ToString() + " " + a.Value.ToString()); // 16 16
Console.Writeline(tmp[1].Value.ToString() + " " + b.Value.ToString()); // 3 3
Console.Writeline(tmp[2].Value.ToString() + " " + c.Value.ToString()); // 1000 1000

Вы не можете хранить ссылки с помощью C#. Вы можете использовать только ключевое слово ref при вызове метода.

Вы можете использовать указатели, но только с выражением fixed и в контексте unsafe.

Можно подделать такие вещи с помощью делегатов, но я не уверен, что это то, что вы ищете. Я также совершенно уверен, что вам действительно нужно изменить свой подход, но, тем не менее, вот пример того, как вы можете его подделать...

Во-первых, напишите класс «оболочки значений» следующим образом:

public class ValueWrapper<T>
{
    readonly Func<T>   get;
    readonly Action<T> set;

    public ValueWrapper(Func<T> get, Action<T> set)
    {
        this.get = get;
        this.set = set;
    }

    public T Value
    {
        get
        {
            return get();
        }

        set
        {
            set(value);
        }
    }
}

Затем вы можете использовать это для изменения значений:

void run()
{
    int x = 0;

    var intWrapper = new ValueWrapper<int>(() => x, value => x = value);

    test(intWrapper);

    Console.WriteLine(x);  // Prints 42, which shows that x was changed.

    TextBox textBox = new TextBox {Text = ""};

    var stringWrapper = new ValueWrapper<string>(() => textBox.Text, value => textBox.Text = value);

    test(stringWrapper);

    Console.WriteLine(textBox.Text); // Prints "Changed".
}

static void test(ValueWrapper<int> wrapper)
{
    wrapper.Value = 42;
}

static void test(ValueWrapper<string> wrapper)
{
    wrapper.Value = "Changed";
}

Вы также можете создать оболочку в одном методе и передать ее другому методу, который использует оболочку для изменения свойства в исходном обернутом объекте, например:

void run()
{
    TextBox textBox = new TextBox {Text = ""};

    var wrapper = test1(textBox);
    test2(wrapper);
    Console.WriteLine(textBox.Text); // Prints "Changed"
}

void test2(ValueWrapper<string> wrapper)
{
    wrapper.Value = "Changed";
}

ValueWrapper<string> test1(TextBox textBox)
{
    return new ValueWrapper<string>(() => textBox.Text, value => textBox.Text = value);
}

Предупреждение: это приводит к довольно головокружительному коду, например:

void run()
{
    var intWrapper = test();
    intWrapper.Value = 42;
    Console.WriteLine(intWrapper.Value); // Works, but where is the value? It can't be the x inside test()!
}

ValueWrapper<int> test()
{
    int x = 0;
    var intWrapper = new ValueWrapper<int>(() => x, value => x = value);
    return intWrapper;
}

Таким образом, мы вернули ValueWrapper из test(), который, по-видимому, является оберткой для локальной переменной из test(). И тогда мы, по-видимому, можем изменить значение и распечатать его...

Это, конечно, не совсем то, что происходит, но это может сбивать с толку!

в этом случае вы можете использовать указатели, использовать небезопасное ключевое слово для метода и установить небезопасный проект, чтобы разрешить указатели в С#, также вы можете инкапсулировать значение в классе, а в С# каждый класс имеет ссылочный тип

я использовал это и отлично работает:

эксп.

public int value1 = 3;
public int value2 = 4;
public int value3 = 5;

public void Method1()
{
    int[] values = { value1, value2, value3};
    for (int i = 0; i < values.Length; i ++)
    {
        Console.WriteLine(values[i]);
    }
}