Looking for c# Answers? Try Ask4KnowledgeBase
Looking for c# Keywords? Try Ask4Keywords

C# Language Membres de la fonction avec expression


Exemple

Les membres de fonctions à corps d'expression permettent l'utilisation d'expressions lambda en tant que corps membres. Pour les membres simples, le code peut être plus propre et plus lisible.

Les fonctions avec expression peuvent être utilisées pour les propriétés, les indexeurs, les méthodes et les opérateurs.


Propriétés

public decimal TotalPrice => BasePrice + Taxes;

Est équivalent à:

public decimal TotalPrice
{
    get
    {
        return BasePrice + Taxes;
    }
}

Lorsqu'une fonction contenant une expression est utilisée avec une propriété, la propriété est implémentée en tant que propriété de lecture seule.

Voir la démo


Indexeurs

public object this[string key] => dictionary[key];

Est équivalent à:

public object this[string key]
{
    get
    {
        return dictionary[key];
    }
}

Les méthodes

static int Multiply(int a, int b) => a * b;

Est équivalent à:

static int Multiply(int a, int b)
{
    return a * b;
}

Qui peut également être utilisé avec des méthodes void :

public void Dispose() => resource?.Dispose();

Un remplacement de ToString pourrait être ajouté à la classe Pair<T> :

public override string ToString() => $"{First}, {Second}";

En outre, cette approche simpliste fonctionne avec le mot-clé override :

public class Foo
{
    public int Bar { get; }

    public string override ToString() => $"Bar: {Bar}";
}

Les opérateurs

Cela peut également être utilisé par les opérateurs:

public class Land
{
    public double Area { get; set; }

    public static Land operator +(Land first, Land second) =>
        new Land { Area = first.Area + second.Area };
}

Limites

Les membres de la fonction avec expression ont certaines limitations. Ils ne peuvent contenir aucune instruction de bloc ni aucune autre instruction contenant des blocs: if , switch , for , foreach , while , do , try , etc.

Certains if les déclarations peuvent être remplacées par des opérateurs ternaires. Certaines instructions for et foreach peuvent être converties en requêtes LINQ, par exemple:

IEnumerable<string> Digits
{
    get
    {
        for (int i = 0; i < 10; i++)
            yield return i.ToString();
    }
}
IEnumerable<string> Digits => Enumerable.Range(0, 10).Select(i => i.ToString());

Dans tous les autres cas, l'ancienne syntaxe des membres de la fonction peut être utilisée.

Les membres de la fonction avec expression peuvent contenir async / await , mais ils sont souvent redondants:

async Task<int> Foo() => await Bar();  

Peut être remplacé par:

Task<int> Foo() => Bar();