Przekazywanie właściwości przez referencję w języku C #

Próbuję wykonać następujące czynności:

GetString(
    inputString,
    ref Client.WorkPhone)

private void GetString(string inValue, ref string outValue)
{
    if (!string.IsNullOrEmpty(inValue))
    {
        outValue = inValue;
    }
}

To daje mi błąd kompilacji. Myślę, że to całkiem jasne, co próbuję osiągnąć. Zasadniczo chcę GetStringskopiować zawartość ciągu wejściowego do WorkPhonewłaściwości Client.

Czy można przekazać właściwość przez referencję?

Właściwości nie mogą być przekazywane przez odwołanie. Oto kilka sposobów obejścia tego ograniczenia.

1. Wartość zwracana

string GetString(string input, string output)
{
    if (!string.IsNullOrEmpty(input))
    {
        return input;
    }
    return output;
}

void Main()
{
    var person = new Person();
    person.Name = GetString("test", person.Name);
    Debug.Assert(person.Name == "test");
}

2. Deleguj

void GetString(string input, Action<string> setOutput)
{
    if (!string.IsNullOrEmpty(input))
    {
        setOutput(input);
    }
}

void Main()
{
    var person = new Person();
    GetString("test", value => person.Name = value);
    Debug.Assert(person.Name == "test");
}

3. Wyrażenie LINQ

void GetString<T>(string input, T target, Expression<Func<T, string>> outExpr)
{
    if (!string.IsNullOrEmpty(input))
    {
        var expr = (MemberExpression) outExpr.Body;
        var prop = (PropertyInfo) expr.Member;
        prop.SetValue(target, input, null);
    }
}

void Main()
{
    var person = new Person();
    GetString("test", person, x => x.Name);
    Debug.Assert(person.Name == "test");
}

4. Refleksja

void GetString(string input, object target, string propertyName)
{
    if (!string.IsNullOrEmpty(input))
    {
        var prop = target.GetType().GetProperty(propertyName);
        prop.SetValue(target, input);
    }
}

void Main()
{
    var person = new Person();
    GetString("test", person, nameof(Person.Name));
    Debug.Assert(person.Name == "test");
}

bez powielania właściwości

void Main()
{
    var client = new Client();
    NullSafeSet("test", s => client.Name = s);
    Debug.Assert(person.Name == "test");

    NullSafeSet("", s => client.Name = s);
    Debug.Assert(person.Name == "test");

    NullSafeSet(null, s => client.Name = s);
    Debug.Assert(person.Name == "test");
}

void NullSafeSet(string value, Action<string> setter)
{
    if (!string.IsNullOrEmpty(value))
    {
        setter(value);
    }
}

Napisałem opakowanie używając wariantu ExpressionTree ic # 7 (jeśli ktoś jest zainteresowany):

public class Accessor<T>
{
    private Action<T> Setter;
    private Func<T> Getter;

    public Accessor(Expression<Func<T>> expr)
    {
        var memberExpression = (MemberExpression)expr.Body;
        var instanceExpression = memberExpression.Expression;
        var parameter = Expression.Parameter(typeof(T));

        if (memberExpression.Member is PropertyInfo propertyInfo)
        {
            Setter = Expression.Lambda<Action<T>>(Expression.Call(instanceExpression, propertyInfo.GetSetMethod(), parameter), parameter).Compile();
            Getter = Expression.Lambda<Func<T>>(Expression.Call(instanceExpression, propertyInfo.GetGetMethod())).Compile();
        }
        else if (memberExpression.Member is FieldInfo fieldInfo)
        {
            Setter = Expression.Lambda<Action<T>>(Expression.Assign(memberExpression, parameter), parameter).Compile();
            Getter = Expression.Lambda<Func<T>>(Expression.Field(instanceExpression,fieldInfo)).Compile();
        }

    }

    public void Set(T value) => Setter(value);

    public T Get() => Getter();
}

I używaj go w następujący sposób:

var accessor = new Accessor<string>(() => myClient.WorkPhone);
accessor.Set("12345");
Assert.Equal(accessor.Get(), "12345");

Jeśli chcesz uzyskać i ustawić właściwość zarówno, możesz użyć tego w C # 7:

GetString(
    inputString,
    (() => client.WorkPhone, x => client.WorkPhone = x))

void GetString(string inValue, (Func<string> get, Action<string> set) outValue)
{
    if (!string.IsNullOrEmpty(outValue))
    {
        outValue.set(inValue);
    }
}

Inną sztuczką, o której jeszcze nie wspomniano, jest to, aby klasa, która implementuje właściwość (np. FooTypu Bar), również zdefiniowała delegata delegate void ActByRef<T1,T2>(ref T1 p1, ref T2 p2);i zaimplementowała metodę ActOnFoo<TX1>(ref Bar it, ActByRef<Bar,TX1> proc, ref TX1 extraParam1)(ewentualnie wersje również dla dwóch i trzech „dodatkowych parametrów”), która przekaże swoją wewnętrzną reprezentację Foodo dostarczona procedura jako refparametr. Ma to kilka dużych zalet w porównaniu z innymi metodami pracy z nieruchomością:

1. Właściwość jest aktualizowana „na miejscu”; jeśli właściwość jest typu zgodnego z metodami „Interlocked” lub jest strukturą z odsłoniętymi polami tego typu, metody „Interlocked” można użyć do przeprowadzenia atomowych aktualizacji właściwości.
2. Jeśli właściwość jest strukturą pola odsłoniętego, pola struktury mogą być modyfikowane bez konieczności tworzenia zbędnych kopii.
3. Jeśli metoda `ActByRef` przekazuje jeden lub więcej parametrów` ref` przez swojego wywołującego do dostarczonego delegata, może być możliwe użycie singletona lub statycznego delegata, unikając w ten sposób potrzeby tworzenia zamknięć lub delegatów w czasie wykonywania.
4. Właściwość wie, kiedy jest „obsługiwana”. Chociaż zawsze należy zachować ostrożność podczas wykonywania kodu zewnętrznego, trzymając blokadę, jeśli można zaufać, że dzwoniący nie zrobią nic w ich wywołaniu zwrotnym, co może wymagać kolejnej blokady, może być praktyczne, aby metoda chroniła dostęp do właściwości za pomocą blokada, tak że aktualizacje, które nie są kompatybilne z programem „CompareExchange”, mogą być nadal wykonywane quasi-atomowo.

Przekazywanie rzeczy refjest doskonałym wzorcem; szkoda, że ​​nie jest więcej używany.

Tylko małe rozszerzenie do rozwiązania Nathan Linq Expression . Użyj wielu ogólnych parametrów, aby właściwość nie ograniczała się do łańcucha.

void GetString<TClass, TProperty>(string input, TClass outObj, Expression<Func<TClass, TProperty>> outExpr)
{
    if (!string.IsNullOrEmpty(input))
    {
        var expr = (MemberExpression) outExpr.Body;
        var prop = (PropertyInfo) expr.Member;
        if (!prop.GetValue(outObj).Equals(input))
        {
            prop.SetValue(outObj, input, null);
        }
    }
}

Jest to omówione w sekcji 7.4.1 specyfikacji języka C #. Tylko odwołanie do zmiennej można przekazać jako parametr ref lub out na liście argumentów. Właściwość nie kwalifikuje się jako odwołanie do zmiennej i dlatego nie można jej użyć.

To jest niemożliwe. Można powiedzieć

Client.WorkPhone = GetString(inputString, Client.WorkPhone);

gdzie WorkPhonejest stringwłaściwość do zapisu i zmieniono definicję GetStringna

private string GetString(string input, string current) { 
    if (!string.IsNullOrEmpty(input)) {
        return input;
    }
    return current;
}

Będzie to miało tę samą semantykę, o którą się starasz.

Nie jest to możliwe, ponieważ właściwość jest naprawdę parą ukrytych metod. Każda właściwość udostępnia obiekty pobierające i ustawiające, które są dostępne poprzez składnię polową. Gdy próbujesz zadzwonić GetStringzgodnie z propozycją, przekazujesz wartość, a nie zmienną. Przekazywana wartość to wartość zwracana przez moduł pobierający get_WorkPhone.

Możesz spróbować utworzyć obiekt, w którym będzie przechowywana wartość właściwości. W ten sposób możesz przekazać obiekt i nadal mieć dostęp do nieruchomości w środku.

Właściwości nie mogą być przekazywane przez odwołanie? Uczyń go więc polem i użyj właściwości, aby odwoływać się do niego publicznie:

public class MyClass
{
    public class MyStuff
    {
        string foo { get; set; }
    }

    private ObservableCollection<MyStuff> _collection;

    public ObservableCollection<MyStuff> Items { get { return _collection; } }

    public MyClass()
    {
        _collection = new ObservableCollection<MyStuff>();
        this.LoadMyCollectionByRef<MyStuff>(ref _collection);
    }

    public void LoadMyCollectionByRef<T>(ref ObservableCollection<T> objects_collection)
    {
        // Load refered collection
    }
}

Nie możesz mieć refwłaściwości, ale jeśli twoje funkcje potrzebują obu geti setdostępu, możesz przekazać instancję klasy ze zdefiniowaną właściwością:

public class Property<T>
{
    public delegate T Get();
    public delegate void Set(T value);
    private Get get;
    private Set set;
    public T Value {
        get {
            return get();
        }
        set {
            set(value);
        }
    }
    public Property(Get get, Set set) {
        this.get = get;
        this.set = set;
    }
}

Przykład:

class Client
{
    private string workPhone; // this could still be a public property if desired
    public readonly Property<string> WorkPhone; // this could be created outside Client if using a regular public property
    public int AreaCode { get; set; }
    public Client() {
        WorkPhone = new Property<string>(
            delegate () { return workPhone; },
            delegate (string value) { workPhone = value; });
    }
}
class Usage
{
    public void PrependAreaCode(Property<string> phone, int areaCode) {
        phone.Value = areaCode.ToString() + "-" + phone.Value;
    }
    public void PrepareClientInfo(Client client) {
        PrependAreaCode(client.WorkPhone, client.AreaCode);
    }
}

Przyjęta odpowiedź jest dobra, jeśli ta funkcja znajduje się w kodzie i można ją zmodyfikować. Ale czasami trzeba użyć obiektu i funkcji z jakiejś zewnętrznej biblioteki i nie można zmienić definicji właściwości i funkcji. Następnie możesz po prostu użyć zmiennej tymczasowej.

var phone = Client.WorkPhone;
GetString(input, ref phone);
Client.WorkPhone = phone;

Aby głosować w tej sprawie, oto jedna aktywna sugestia, w jaki sposób można ją dodać do języka. Nie twierdzę, że jest to najlepszy sposób na zrobienie tego (w ogóle), zachęcamy do przedstawienia własnych sugestii. Ale zezwolenie na przekazywanie właściwości przez referencje, jak to już robi Visual Basic, znacznie pomogłoby uprościć niektóre kody i dość często!

https://github.com/dotnet/csharplang/issues/1235