Блог

Я хотел бы назначить ссылку на поле участника. Но я, очевидно, не очень хорошо понимаю эту часть C #, потому что я потерпел неудачу 🙂 Итак, вот мой код:

 public class End {
    public string parameter;

    public End(ref string parameter) {
        this.parameter = parameter;
        this.Init();
        Console.WriteLine("Inside: {0}", parameter);
    }

    public void Init() {
        this.parameter = "success";
    }
}

class MainClass {
    public static void Main(string[] args) {
            string s = "failed";
        End e = new End(ref s);
        Console.WriteLine("After: {0}", s);
    }
}
  

Вывод:

 Inside: failed
After: failed
  

Как мне получить «успех» на консоли?

Заранее спасибо, dijxtra

Как указывали другие, вы не можете хранить ссылку на переменную в поле на C # или, действительно, на любом языке CLR.

Конечно, вы можете достаточно легко получить ссылку на экземпляр класса, содержащий переменную:

 sealed class MyRef<T>
{
  public T Value { get; set; }
}
public class End 
{
  public MyRef<string> parameter;
  public End(MyRef<string> parameter) 
  {
    this.parameter = parameter;
    this.Init();
    Console.WriteLine("Inside: {0}", parameter.Value);
  }
  public void Init() 
  {
    this.parameter.Value = "success";
  }
}
class MainClass 
{
  public static void Main() 
  {
    MyRef<string> s = new MyRef<string>();
    s.Value = "failed";
    End e = new End(s);
    Console.WriteLine("After: {0}", s.Value);
  }
}
  

Проще простого.

Здесь действительно две проблемы.

Во-первых, как уже говорилось на других плакатах, вы не можете строго делать то, что хотите (как вы можете сделать с C и тому подобным). Однако — поведение и намерение по-прежнему легко выполнимы в C # — вам просто нужно сделать это способом C #.

Другая проблема заключается в вашей неудачной попытке попытаться использовать строки, которые, как упоминалось в одном из других плакатов, являются неизменяемыми и по определению копируются.

Итак, сказав это, ваш код можно легко преобразовать в это, что, я думаю, делает то, что вы хотите:

 public class End
{
    public StringBuilder parameter;

    public End(StringBuilder parameter)
    {
        this.parameter = parameter;
        this.Init();
        Console.WriteLine("Inside: {0}", parameter);
    }

    public void Init()
    {
        this.parameter.Clear();
        this.parameter.Append("success");
    }
}

class MainClass
{
    public static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder("failed");
        End e = new End(s);
        Console.WriteLine("After: {0}", s);
    }
}
  

Похоже, что вы пытаетесь сделать здесь, это сделать поле ссылкой на другое место хранения. По сути, у вас есть ref поле так же, как у вас есть ref параметр. В C # это невозможно.

Одна из основных проблем, связанных с этим, заключается в том, что для проверки CLR (и C #) должна быть способна доказать, что объект, содержащий поле, не будет жить дольше, чем местоположение, на которое он указывает. Обычно это невозможно, поскольку объекты находятся в куче, и a ref может легко указывать на стек. Эти два места имеют очень разную семантику жизненного цикла (куча обычно длиннее стека), и, следовательно ref , нельзя доказать, что промежуток между ними является действительным.

Если вы не хотите вводить другой класс, например MyRef or StringBuilder , потому что ваша строка уже является свойством в существующем классе, вы можете использовать Func и Action для достижения результата, который вы ищете.

 public class End {
    private readonly Func<string> getter;
    private readonly Action<string> setter;

    public End(Func<string> getter, Action<string> setter) {
        this.getter = getter;
        this.setter = setter;
        this.Init();
        Console.WriteLine("Inside: {0}", getter());
    }

    public void Init() {
        setter("success");
    }
}

class MainClass 
{
    public static void Main(string[] args) 
    {
        string s = "failed";
        End e = new End(() => s, (x) => {s = x; });
        Console.WriteLine("After: {0}", s);
    }
}
  

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

     /// <summary>
    /// Convert a lambda expression for a getter into a setter
    /// </summary>
    public static Action<T, U> GetSetter<T,U>(Expression<Func<T, U>> expression)
    {
        var memberExpression = (MemberExpression)expression.Body;
        var property = (PropertyInfo)memberExpression.Member;
        var setMethod = property.GetSetMethod();

        var parameterT = Expression.Parameter(typeof(T), "x");
        var parameterU = Expression.Parameter(typeof(U), "y");

        var newExpression =
            Expression.Lambda<Action<T, U>>(
                Expression.Call(parameterT, setMethod, parameterU),
                parameterT,
                parameterU
            );

        return newExpression.Compile();
    }
  

В этой строке:

 this.parameter = parameter;
  

… вы копируете параметр метода в член класса parameter . Затем Init() вы снова присваиваете значение «успех» члену класса parameter . В вашей консоли.Writeline, затем вы записываете значение параметра метода «сбой», потому что вы никогда фактически не изменяете параметр метода.

То, что вы пытаетесь сделать — так, как вы пытаетесь это сделать, — невозможно, я верю в C #. Я бы не стал пытаться передавать a string с ref модификатором.

Как ответил JaredPar, вы не можете.

Но проблема отчасти в том, что строка неизменяема. Измените свой параметр на значение of class Basket { public string status; } , и ваш код будет в основном работать. ref Ключевое слово не требуется, просто измените parameter.status .

И, конечно, есть другой вариант Console.WriteLine("After: {0}", e.parameter); . Сделайте перенос параметра в свойство (только для записи).