# Fonctionnalités syntaxiques

## Inférence de type

C# supporte l'inférence de type pour les variables locales avec le mot clé `var`, exemple :

```csharp
var hello = "Hello world";

```

A utiliser uniquement lorsque le type est évident (constructor ou littéral).

## Interpolation de chaine

C# supporte l'interpolation de chaine avec `$`, exemple :

```csharp
var firstName = "John";
var lastName = "Shepard"
var fullName = $"{firstName} {lastName}";
Console.WriteLine(fullName); // Prints John Shepard

```

## Opérateurs `?` et `??`

### Nullabilité

Un type suivi de `?` signfie que le type est nullable. En cas d'assignation de `null` à un type qui n'est pas déclaré comme nullable, le compilateur produit un warning. Exemple :

```csharp

int nonNullableNumber= 42;
nonNullableNumber = null; // warning de compilation

int? nullableNumber = 42;
nullableNumber = null; // pas de warning de compilation

```

### Ternaires

```csharp
decimal ticketPrice = age >= 18 ? 10 : 6;

```

Equivalent :

```csharp
decimal ticketPrice;
if(age >= 18){
  ticketPrice = 10;
} else {
  ticketPrice = 6
}

```

### Accès conditionné par `null`

Permet de conditionner l'accès à un champs ou l'appel d'une méthode par la non présence d'une valeur `null` sur la référence sur laquelle on effecture l'appel. Exemple :

```csharp
User? user = GetUser();
string? name = user?.Name;

```

Equivalent :

```csharp
User? user = GetUser();
string? name;

if(user is not null){
	name = User.Name;
}

```

### `null`-coallescing

Valeur de repli en cas de valeur `null` :

```csharp
User user = GetUser() ?? new User("John Shepard");

```

Equivalent :

```csharp
User? temp = GetUser();

User user;
if(temp is not null){
	user = temp;
} else {
  	user = new User("John Shepard");
}

```

## Méthodes "Expression Body"

```csharp
public class Point2D {
	private int x;
    private int y;
    
    public Point2D(int x, int y){
    	this.x = x;
        this.y = y;
    }
    
    public Point Move(int distanceX, int distanceY) => new Point(x + distanceX, y + distanceY);
}


```

## Intialisation

### Propriétés d'objets

```csharp
var employee = new Employee{ FirstName = "John", LastName = "Shepard"};

```

Equivalent :

```csharp
var employee = new Employee();
employee.FirstName = "John";
employeeLastName = "Shepard";

```

### Collections

#### Listes / Tableaux

```csharp
var list = new List<string> { "Item1", "Item2", "Item3" }

```

#### Dictionnaires

```csharp
var map = new Dictionnary<int,string> { 
  [42] = "Item1", 
  [41] = "Item2", 
  [123] = "Item3" 
}

```

## Méthodes d'extensions

Les méthodes d'extensions permettent de rajouter des méthodes aux types qu'on ne controle pas (ex : classes de la Base Classes Library (BCL) ou des librairies qu'on utilise). Cela requiert de créer une classe `static`, et les méthodes d'exension doivent prendre en premier paramètre une argument du type étendu, avec le mot clé `this`. Exemple :

```csharp
public static class Extensions {
	public static void Multiply(this string stringToMultiply, int times){
    	return String.Concat(Enumerable.Repeat(stringToMultiply, times));
    }
}

```

## Surcharge d'opérateurs

En C#, les opérateurs du langage (`+`, `-`, `*`, etc...) peuvent être redéfinis :

```csharp
    public static Fraction operator +(Fraction a, Fraction b)
        => new Fraction(a.num * b.den + b.num * a.den, a.den * b.den);

```

<div class="page-content" dir="auto" id="bkmrk-"><div dir="auto"></div>---

</div>