Pour avoir plus de détails sur la version du langage par rapport aux versions de framework, se reporter à Versions des composants .NET.
C# 6.0 |
Visual Studio 2015
- Version implémentée avec Roslyn.
- Initialiseurs pour implémenter automatiquement les propriétés:
public class ItemId
{
public Guid Id { get; } = Guid.NewGuid();
}
- Utiliser des directives
using static pour importer des membres statiques:
using static System.Console;
public class Driver
{
public static void Main()
{
WriteLine("Hello, World!");
}
}
- Filtres d’exceptions:
try
{
...
}
catch (Exception ex) if (ex.Message.Contains("Invalid Operation Exception"))
{
...
}
try
{
...
}
catch (Exception ex) when (ex.Message.Contains("Invalid Operation Exception"))
{
...
}
- Interpolation de chaines de caractères:
En plus de la syntaxe utilisant string.Format() comme:
class dto
{
public const string StringMember = "des mots";
public const int IntMember = 34;
public const bool BoolMember = false;
}
string s = string.Format("Chaine de caractères contenant {0} puis {1} et {2}.",
dto.StringMember, dto.IntMember, dto.BoolMember);
On peut dorénavant utiliser une syntaxe plus claire:
string s = $"Chaine de caractères contenant {dto.StringMember} puis {dto.IntMember} et {dto.BoolMember}.";
- Initialisation indexée de membres:
var indexedMemberDict = new Dictionary<string, string>()
{
["apple"] = "pomme",
["tomato"] = "tomate",
["water"] = "eau"
};
- Possibilité d’utiliser
await dans un bloc catch et finally ,
- Opérateur
nameof : il permet de retourner le nom d’une variable ou d’une méthode sous forme de chaîne de caractères:
Si on considère la classe:
class SimpleClass
{
public static string SimpleMember { get; set; }
public static int SimpleMethod { return -1; }
}
On peut obtenir directement le nom du membre SimpleMember en faisant:
string memberName = nameof(SimpleClass.SimpleMember); // Retourne "SimpleMember"
string methodName = nameof(SimpleClass.SimpleMethod); // Retourne "SimpleMethod"
- Opérateur
?. :
Cet opérateur est un équivalent de:
string value = person != null ? person.Name : null;
On peut dorénavant utiliser la syntaxe:
string value = person?.person.Name;
|
C# 5.0 |
Visual Studio 2012
- Programmation asynchrone plus facile avec les mot-clés
async et await ,
- Attribut permettant de connaître l’appelant:
public void DoProcessing()
{
TraceMessage("Something happened.");
}
public void TraceMessage(string message,
[CallerMemberName] string memberName = "",
[CallerFilePath] string sourceFilePath = "",
[CallerLineNumber] int sourceLineNumber = 0)
{ ... }
|
C# 4.0 |
|
C# 3.0 |
Visual Studio 2008
- Ajout des mot-clés
select, from et where pour la fonctionnalité LinQ,
- Expressions Lambda:
Action<int> deletePerson = (id) => { ... };
Func<int, int, int> addNumbers = (a, b) => a + b;
- Méthodes d’extension:
public static class ListExtensionMethods
{
public static string GetString(this List<int> items)
{ ... }
}
// Utilisation de la méthode d'extension:
List<int> items = new <int>();
string listAsString = items.GetString();
- Arbres d’expressions ("expression trees"):
// Création d'un arbre d'expressions
Expression<Func<int, bool>> exprTree = num => num < 5;
- Type implicite avec
var : var idList = new List(); .
|
C# 2.0 |
Visual Studio 2005
- Types génériques:
public class CustomList<TItem>
{...}
- Méthodes anonymes:
// Création d'un délégué
delegate void AddNumbers(int x, int y);
// Instantiation du délégué en utilisant une méthode anonyme
AddNumbers d = delegate(int i, int j) { ... };
- Types nullables:
int? = null;
- Nouvel itérateur avec le mot-clé
yield .
|