On peut déclarer des fonctions à l’intérieur d’autres fonctions.

Avant C# 7.0, on pouvait utiliser des expressions lambda, par exemple:

IEnumerable<int> GetPositiveNumber(IEnumerable<int> numbers, bool strictComparison) 
{ 
  var isPositive => n => { 
    if (strictComparison) 
      return n > 0; 
    else 
      return n >= 0; 
    } 

  return numbers.Where(n => isPositive(n)); 
} 

A partir de C# 7.0, on peut déclarer une fonction directement dans le corps d’une autre fonction:

IEnumerable<int> GetPositiveNumber(IEnumerable<int> numbers, bool strictComparison) 
{ 
  return numbers.Where(n => isPositive(n)); 

  bool isPositive(int number) 
  { 
    if (strictComparison) 
      return number > 0; 
    else 
      return number >= 0; 
  } 
} 

La fonction locale fait partie du contexte de sa fonction parente, il est donc possible d’accéder dans la fonction locale aux arguments et variables locales de la fonction parente.

Avant C# 7.0, pour utiliser le mot-clé out dans les arguments d’une méthode, il fallait déclarer le paramètre avant l’appel à la méthode:

public static bool TryFindFirstPositiveNumber(IEnumerable<int> numbers, out firstPositiveNumber) 
{ 
  var positiveNumbers = numbers.Where(n => n > 0); 
  if (positiveNumbers.Any()) 
  { 
    firstPositiveNumber = positiveNumbers.First(); 
    return true; 
  } 
  else 
  { 
    firstPositiveNumber = 0; 
    return false; 
  } 
} 

Avant C# 7.0, l’appel est du type:

int[] numbers = {-1, -2, 0, 5, 8}; 
int firstPositiveNumber; 
 
if (TryFindFirstPositiveNumber(numbers, out firstPositiveNumber)) 
{ 
  Console.WriteLine(firstPositiveNumber); 
} 

A partir de C# 7.0, on peut déclarer la variable directement lors de l’appel avec out:

if (TryFindFirstPositiveNumber(numbers, out int firstPositiveNumber)) 
{ 
  Console.WriteLine(firstPositiveNumber); 
} 

Dans le cas de cette fonction, le scope de la variable firstPositiveNumber déclarée avec out est le même que si la variable est déclarée en dehors de l’appel.

Certaines syntaxes imposent de devoir définir des variables même si on ne souhaite pas s’en servir par la suite, par exemple si on utilise un méthode avec un argument out et qu’on ne souhaite pas utiliser cet argument:

string valueAsString = "6" 
if (int.TryParse(valueAsString, out int valueAsInt)) 
  Console.WriteLine("Value is an integer."); 

Dans cet exemple valueAsInt ne sert pas, toutefois on est obligé de le déclarer à cause de la signature de la fonction. A partir de C# 7.0, il est possible d’ignorer l’argument en utilisant le caractère _ de façon à alléger la syntaxe:

if (int.TryParse(valueAsString, out _)) 
  Console.WriteLine("Value is an integer."); 

D’autres cas de figure permettent d’ignorer une variable:

• Lors de la déconstruction d’un tuple:

  var tuple = (6, "6", 6.0f); 
  var (ValueAsInt, ValueAsString, ValueAsFloat) = tuple; // Déconstruction du tuple 
  Console.WriteLine($"Int value is {ValueAsInt}."); // ValueAsString et ValueAsFloat sont inutiles 
  

  On peut ignorer de déclarer des variables inutilement lors de la déconstruction:

  var (ValueAsInt, _, _) = tuple; // Déconstruction 
  Console.WriteLine($"Int value is {ValueAsInt}."); 
  

• Pour une variable locale (possible mais pas très utile):

  Par exemple si on considère le code suivant:

  private static async Task UselessTask() 
  { 
    await Task.Delay(10000); 
    Console.WriteLine("Completed"); 
  } 
  
  static void Main() 
  { 
    UselessTask(); // WARNING: CS4014
    Console.ReadLine(); 
  } 
  

  Ce code n’attends pas la fin de l’exécution de la task asynchrone exécutée dans UselessTask(). A la compilation, il entraîne le message de Warning:

  Warning CS4014: Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the ‘await’ operator to the result of the call. 
  

  Si on souhaite éviter le message de warning et ne pas attendre l’exécution de la tâche, on peut ignorer le retour de la fonction:

  static void Main() 
  { 
    _ = UselessTask(); // Pas de warning 
    Console.ReadLine(); 
  } 
  

  Il est possible d’utiliser _ en tant que nom de variable. Toutefois si _ est utilisé pour désigner une variable, il ne sera plus possible d’utiliser ce caractère pour indiquer une variable:

  var _ = 5; // OK
  
  _ = UselessTask(); // ERROR: cette ligne est considéré comme étant une affectation. 
  // _ est de type int, l'affectation n'est pas possible.
  

• Avec is:
  L’opérateur is permet de tester si une expression correspond à un type, par exemple si on considère la classe suivante:

  class Square 
  { 
    public int Size; 
  } 
  

  is permet de tester si l’objet squareAsObj est de type Square:

  object squareAsObj = new Square { Size = 6 }; 
  if (squareAsObj is Square) // permet de tester le type de squareAsObj 
  { 
    Square typedSquare = squareAsObj as Square; 
    Console.WriteLine($"{nameof(squareAsObj)} is a square of size {typedSquare.Size}."); 
  } 
  

  A partir de C# 7.0, il est possible de simplifier l’utilisation de is et as en une seule ligne:

  if (squareAsObj is Square typedSquare) // permet de tester le type et d'initialiser la variable typée typedSquare 
    Console.WriteLine($"{nameof(squareAsObj)} is a square of size {typedSquare.Size}."); 
  

  Par suite, on peut ignorer la création d’une variable avec _:

  if (squareAsObj is Square _) // La création de la variable est ignorée 
    Console.WriteLine($"{nameof(squareAsObj)} is a square."); 
  

  L’exemple précédent complexifie inutilement la syntaxe puisqu’il suffirait d’écrire if (squareAsObj is Square) pour obtenir le même résultat. L’intérêt de cette syntaxe est de simplifier l’écriture avec switch (point suivant).

• Avec switch...case:
  A partir de C# 7.0, il est possible d’utiliser switch...case pour tester le type d’une variable, par exemple (la classe Square est déclarée plus haut):

  object squareAsObj = new Square { Size = 6 }; 
  switch (squareAsObj) 
  { 
    case Square typedSquare: // permet de tester le type et d'initialiser la variable typée typedSquare 
      Console.WriteLine($"{nameof(squareAsObj)} is a square of size {typedSquare.Size}."); 
      break; 
    default: 
      Console.WriteLine($"{nameof(squareAsObj)} is not a square."); 
      break; 
  } 
  

  case Square typedSquare est équivalent à if (squareAsObj is Square typedSquare). De la même façon que is, il est possible d’ignorer la création d’une variable en utilisant _:

  switch (squareAsObj) 
  { 
    case Square _: // permet de seulement tester le type 
      Console.WriteLine($"{nameof(squareAsObj)} is a square."); 
      break; 
    default: 
      Console.WriteLine($"{nameof(squareAsObj)} is not a square."); 
      break; 
  } 
  

Avant C# 7.1, quand la méthode Main() d’une application appelait une méthode async, on devait utiliser une syntaxe similaire à celle-ci:

class Program 
{ 
  static void Main(string[] args) 
  { 
    UselessTask().GetAwaiter().GetResult(); 
    // ou 
    UselessTask().Wait(); 
    // ou 
    int result = UselessTaskWithResult().GetAwaiter().GetResult(); 
    // ou 
    int result = UselessTaskWithResult().Result; 
  } 
 
  private static async Task UselessTask() 
  { 
    await Task.Delay(10000); 
    Console.WriteLine("Completed"); 
  } 

  private static async Task<int> UselessTaskWithResult() 
  { 
    await Task.Delay(10000); 
    Console.WriteLine("Completed"); 
    return 0; 
  } 
} 

A partir de C# 7.1, la fonction Main() supporte la notation async/await, il est possible d’utiliser une syntaxe plus simple:

static async Task Main(string[] args) 
{ 
  await UselessTask(); 
} 

ou

static async Task<int> Main(string[] args) 
{ 
  return await UselessTaskWithResult(); 
} 

D’autres syntaxes pour définir la fonction Main() sont possibles:

static void Main(string[] args)
static int Main(string[] args)
static void Main()
static int Main()

static async Task Main(string[] args)
static Task Main(string[] args)
static async Task<T> Main(string[] args)
static Task<T> Main(string[] args)

static async Task Main()
static Task Main()
static async Task<T> Main()
static Task<T> Main()

A partir de C# 7.1, on peut simplifier la syntaxe default(T) par default. default et default(T) permettent au compilateur de produire une valeur par défaut suivant le type voulu obtenu par déduction:

• Pour les types références, la valeur par défaut sera null.
• Les chaînes de caractères bien qu’étant des objets de type référence, ont pour valeur par défaut une chaîne vide (i.e. string.Empty);
• Les types valeurs usuels ont pour valeur par défaut la valeur 0 correspondant au type exact: 0 pour int, uint, long ou ulong; 0f pour float; 0m pour decimal; 0d pour double; false pour bool etc…

Par exemple:

int intValue = default; // 0 même comportement que default(int).
float floatValue = default; // 0f ATTENTION à la comparaison entre un flottant et 0
string strValue = default; // Chaîne vide (string.Empty)

Dans le cas d’un objet de type référence, la valeur par défaut est null:

class EmptyClass {}

EmptyClass instance = default; // null

Dans le cas d’une structure, la valeur par défaut n’est pas null mais une instance dans laquelle les membres ont une valeur par défaut:

struct SimpleStruct
{
  public int InnerMember;
}

// ...
SimpleStruct instance = default; // N’est pas égal à null
Console.WriteLine(instance.InnerMember); // 0

default ou default(T) peuvent être utilisés en dehors de l’initialisation comme par exemple dans une comparaison:

Console.WriteLine(default == 0); // true. C’est le compilateur qui déduit la valeur de default en fonction de 0

Un des intérêts de default ou default(T) est de pouvoir utiliser une valeur par défaut quand l’utilisation de type générique ne permet pas de déterminer le type exact, par exemple:

T GetValue<T>()
{
  return default; // Le type réel de T n’est pas connu
}

A partir de C# 7.2, l’opérateur de portée private protected a été rajouté, si un membre est décoré de cet opérateur dans une classe, il ne sera accessible que par les membres et les classes dérivant de cette classe se trouvant dans la même assembly.

Pour résumer:

• protected internal: l’accès est limité aux objets de l’assembly courante ou aux classes dérivant de la classe où se trouve l’opérateur (les classes dérivées peuvent se trouver dans une autre assembly).
• private protected: l’accès est limité aux classes dérivant de la classe où se trouve l’opérateur. Les classes dérivées doivent se trouver obligatoirement dans la même assembly.

C# 7 a permis d’étendre l’utilisation des expressions à d’autres types d’instructions comme le constructeur, les propriétés en écriture ou les exceptions lancées avec throw.

On peut utiliser des expressions avec une syntaxe réduite directement pour:

• Propriété en écriture:
  La syntaxe permet d’utiliser des expressions directement dans des propriétés, par exemple:

  public int InnerVariable
  {
    get => this.innerVariable; // En lecture, pas d’accolade et return est omis
    set => this.innerVariable = value; // En écriture, la valeur à paramétrer est dans value
  }
  

• Constructeur:

  public class Circle
  {
    private int Radius;
  
    public Circle(int radius) => this.Radius = radius; // Les accolades sont omises
  }
  

• Destructeur:
  Même syntaxe que pour le constructeur:

  public class Circle
  {
    private int Radius;
  
    ~Circle() => this.Radius = 0;
  }
  

• Index:
  Les surcharges d’index sur un objet peuvent aussi utiliser une syntaxe sous la forme d’expressions en lecture/écriture:

  public class Séquence
  {
    private readonly List<int> sequence = new List<int> {
      0, 1, 1, 2, 3, 5, 8, 13, 21, 34
    }
  
    public int this[int i]
    {
      get => this.sequence[i];
      set => this.sequence[i] = value;
    }
  }
  

Auparavant throw <exception> n’était pas considéré comme une expression (c’est-à-dire qu’on ne peut pas extraire de l’instruction throw <exception> une valeur assignable). Il n’était donc possible d’utiliser throw <exception> que dans un bloc de code:

int uselessValue = -1;
if (uselessValue < 0)
  throw new InvalidOperationException(); // Dans un bloc de code particulier

throw <exception> ne pouvait pas être utilisé en tant qu’expression, par exemple dans une expression ternaire:

// Avant C# 7.0, cette syntaxe n’est pas possible
  int newValue = uselessValue > 0 ? uselessValue : throw new InvalidOperationException();

A partir de C# 7.0, le compilateur traite throw <exception> comme une expression de façon à ne pas avoir d’erreur de syntaxe à la compilation quand on l’utilise en tant qu’expression.

Par exemple:

• Quand on définit une expression lambda:

  Func<float, int> convertToInt = (number) => throw new NotImplementedException();
  

• Dans un constructeur:

  public class Circle
  {
    private int Radius;
  
    public Circle(int radius) => throw new NotImplementedException();
  }
  

  Cette syntaxe est possible pour tous les exemples d’utilisation de syntaxe réduite du corps d’une expression présentés plus haut.

• Si on utilise une expression ternaire:

  bool intValue = 1;
  string exitCode = intValue > 0 ? "OK" : throw new InvalidOperationException();
  

• etc…

A partir de C# 7.3, il est possible d’implémenter la déclaration de variables avec out var <variable> directement dans la version réduite du corps d’une expression.

Par exemple, si on considère la fonction suivante:

public static bool CanExtractIntIfOdd(string inputStr, out int extractedNumber)
{
  return int.TryParse(inputStr, out extractedNumber)
    && extractedNumber % 2 != 0;
}

Il est possible d’utiliser la construction out var <variable> dans une des formes réduites utilisées plus haut, par exemple dans le constructeur:

public class Test
{
  private readonly bool isNumberOddAndPositive;

  public Test(string intAsString) => this.isNumberOffAndPositive = CanExtractIntIfOdd(intAsString, out int extractedNumber)
    && extractedNumber > 0;
}