Comment puis-je transmettre efficacement des propriétés par référence en C# ?

Passer des propriétés par référence en C#

Transmettre des propriétés par référence en C# n'est pas trivial car les propriétés n'exposent pas de références à leurs champs de support. Il existe cependant des moyens d’obtenir un comportement similaire.

1. Valeur de retour :

Cette méthode renvoie la valeur d'entrée si elle n'est pas nulle ou vide, sinon renvoie la valeur de la propriété d'origine.

<code class="language-csharp">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");
}</code>

2. Délégué :

À l'aide de délégués, les valeurs d'entrée peuvent être attribuées aux propriétés via des opérations de délégué.

<code class="language-csharp">void SetStringValue(string input, Action<string> setOutput)
{
    if (!string.IsNullOrEmpty(input))
    {
        setOutput(input);
    }
}

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

3.Expression LINQ :

Cette méthode utilise une expression LINQ pour récupérer les champs de support de la propriété et attribuer la valeur d'entrée. (L'exemple de code de cette méthode contient des erreurs de syntaxe dans le texte original et ne peut pas être exécuté directement. Un exemple corrigé est fourni ci-dessous, mais il devra peut-être être ajusté en fonction de la situation réelle.)

<code class="language-csharp">void SetStringProperty<T, TProperty>(string input, T target, Expression<Func<T, TProperty>> propertyExpression)
{
    if (!string.IsNullOrEmpty(input))
    {
        var memberExpression = (MemberExpression)propertyExpression.Body;
        var propertyInfo = (PropertyInfo)memberExpression.Member;
        propertyInfo.SetValue(target, Convert.ChangeType(input, propertyInfo.PropertyType));
    }
}


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

4. Réflexion :

La réflexion peut être utilisée pour accéder aux champs sous-jacents d'une propriété et attribuer des valeurs d'entrée.

<code class="language-csharp">void SetPropertyValue(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();
    SetPropertyValue("test", person, nameof(Person.Name));
    Debug.Assert(person.Name == "test");
}</code>

Il convient de noter que bien que la méthode d'utilisation des expressions de réflexion et LINQ puisse atteindre son objectif, elle est relativement inefficace et la lisibilité et la maintenabilité du code peuvent également être réduites. Il est recommandé de donner la priorité aux valeurs de retour ou aux méthodes déléguées sauf besoins particuliers. De plus, tous les exemples nécessitent la définition d'une classe Person, contenant un attribut Name nommé string.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!