Vous présente des exemples de codes de fonctionnalités C#7

Vous présente des exemples de codes de fonctionnalité C#7 :

Type de valeur de tuple

.NET fournit un type tuple, mais son utilisation en C# pose divers problèmes. Étant donné que le type tuple est un type référence, vous pouvez probablement éviter la surcharge GC liée à son utilisation dans certains codes sensibles aux performances. Dans le même temps, les types de tuples sont immuables, et même si cela rend le partage entre threads plus sûr, cela signifie également qu'un nouvel objet doit être alloué à chaque fois qu'une modification est effectuée.

Pour résoudre ce problème, C# 7 fournira un tuple de types valeur. Il s'agit d'un type mutable, qui sera plus efficace pour le code qui valorise les performances. De plus, en tant que type valeur, il effectue une copie à chaque fois qu'il est alloué, il y a donc peu de risque de problèmes de multithread.

Vous pouvez créer un tuple avec la syntaxe suivante :

var result = (5, 20);

Vous pouvez également choisir de nommer les valeurs dans le tuple, ce qui n'est pas obligatoire mais rend simplement le code plus lisible.

var result = (count: 5, sum: 20);

Vous pensez peut-être : « Excellente fonctionnalité, mais je peux l'écrire moi-même ». Mais la fonctionnalité suivante est le point culminant.

Plusieurs valeurs de retour

Dans les langages de type C, renvoyer deux valeurs d'une fonction est toujours un problème. Vous pouvez uniquement choisir d'encapsuler le résultat dans une structure ou d'utiliser des paramètres de sortie. Comme beaucoup de langages de programmation fonctionnels, C# choisit la première façon de vous proposer cette fonctionnalité :

(int, int) Tally (IEnumerable<int> list)

Comme vous pouvez le voir, il y a un problème fondamental avec l'utilisation de tuples génériques ici : nous n'aurons aucun moyen de savoir ce que fait chaque champ. C# choisit donc de nommer le résultat via une astuce du compilateur :

(int Count, int Sum) Tally (IEnumerable<int> list)

Nous devons souligner un point ici : C# ne génère pas de nouveau type anonyme. Ce que vous obtenez est toujours un tuple, mais le compilateur supposera que ses propriétés sont Count et Sum au lieu de Item1 et Item2. Les lignes de code suivantes sont donc équivalentes :

var result = Tally(list);
Console.WriteLine(result.Item1);
Console.WriteLine(result.Count);

Veuillez noter que nous n'avons pas encore de syntaxe d'affectation multiple. Si cette syntaxe est finalement implémentée, son utilisation pourrait ressembler à ceci :

(count, sum) = Tally(list);

. En plus de fournir des fonctions fonctionnelles simples, l'utilité de plusieurs valeurs de retour se reflète également dans l'écriture de code asynchrone, car les paramètres out ne sont pas autorisés dans les fonctions asynchrones.

Correspondance de modèles : blocs de syntaxe Switch améliorés

La plainte la plus courante concernant C# de la part des programmeurs VB et fonctionnels est que l'instruction switch en C# a des fonctionnalités très limitées. Les développeurs VB veulent pouvoir effectuer une correspondance de plage, tandis que les développeurs habitués à F# ou Haskell veulent pouvoir utiliser la correspondance de modèles décomposés. C# a l'intention de fournir les deux fonctionnalités.

Lors de la correspondance d'un motif avec un type, vous pouvez créer une variable pour contenir le résultat de la conversion. Par exemple, lorsque vous utilisez l'instruction switch sur un System.Object, vous pouvez écrire le code suivant :

case int x:

Si l'objet est de type numérique, la variable x se verra attribuer une valeur. Sinon, le programme vérifiera le bloc d'instructions case suivant dans l'ordre de haut en bas. Si vous souhaitez être plus précis avec votre match, vous pouvez également utiliser une vérification de plage :

case int x when x > 0:
case int y:

Dans cet exemple, si l'objet est un entier positif, le bloc de code x sera exécuté. Si l'objet est 0 ou un entier négatif, le bloc de code y sera exécuté.

Si vous devez vérifier les valeurs nulles, utilisez simplement la syntaxe suivante :

case null;

Correspondance de motifs : décomposition

Jusqu'à présent, nous n'avons montré que quelques améliorations incrémentielles des fonctionnalités existantes dans VB. Le véritable pouvoir de la correspondance de modèles réside dans la décomposition, qui peut complètement démonter un objet :

if (person is Professor {Subject is var s, FirstName is "Scott"})

. Ce code accomplit deux choses :

1. Il crée une variable locale s et lui attribue la valeur ((Professeur)personne).Subject.

3. Il effectue un contrôle d'égalité ((Professeur)personne).FirstName == "Scott".

S'il est réécrit en code C# 6, il ressemblera à ceci :

var temp = person as Professor;
if (temp != null && temp.FirstName == "Scott")
{
    var s = temp.Subject

Dans la version finale, nous nous attendons à voir les deux améliorations des blocs de commutation.

Retour par référence

Le passage d'une grande structure de données par référence est beaucoup plus rapide que le passage par valeur, qui nécessite une copie de la structure entière. De même, renvoyer une référence à une structure de données volumineuse peut également améliorer la vitesse.

Dans des langages comme C, vous pouvez renvoyer une référence à une structure via un pointeur. Cette approche entraîne un problème courant : la mémoire pointée par le pointeur peut avoir été récupérée pour une raison quelconque.

C# évite ce problème en utilisant une référence, qui est un pointeur auquel sont attachées des règles. La règle la plus importante est que vous ne pouvez pas renvoyer une référence à une variable locale. Si vous essayez de faire cela, les informations de pile référencées par la variable deviendront inaccessibles au retour de la fonction.

在微软的展示代码中，它所返回的引用指向一个数组中的某个结构。由于它实质上是指向数组中某个元素的指针，因此随后可以对数组本身进行修改。举例来说：

var x = ref FirstElement(myArray)
x = 5; //MyArray[0] now equals 5

这一语法的用例是对性能高度敏感的代码，在大多数应用中都无需使用这一特性。

二进制字面值（Binary Literals）

此次发布还引入了一个小特性，即二进制字面值。这一语法只是一个简单的前缀而已，例如5可以表示为“0b0101”。这一特性的主要用例是设置基于flag的枚举，以及创建位掩码（bitmask），以用于与C风格语言的互操作。

本地函数

本地函数是指在另一个函数中所定义的函数。第一眼看来，本地函数似乎只是比匿名函数稍好的一种语法。但它实际上还存在几个优点：

• 首先，你无需为其分配一个委托以保存该函数。这不仅减少了内存压力，同时还允许编译器对该函数进行内联操作。

• 其次，在创建闭包时，也无需为其分配一个对象，因为它能够直接访问本地变量。这一点同样能够改善性能，因为它也减少了GC的压力。

按照第二条规则推算，你将无法创建一个指向本地函数的委托。这一点对于代码的组织其实是一个优点，因为你无需创建独立的函数，并且将现有函数的状态作为显式的参数进行传递。

部分类的改进

最后演示的特性是一种处理部分类的新方式。在过去，部分类的应用是基于代码生成优先的概念而出现的。所生成的代码将包含一系列部分方法，开发者可以选择实现这些方法，以调整类的行为。

通过新的“replace”语法，开发者就多了一种新选择，能够以最直接的方式编写代码，随后再引入代码生成器，并重写这些方法。以下将通过一个简单的示例表现开发者的代码编写方式：

public string FirstName {get; set;}

简单又清晰，但完全不符合XAML风格应用的写法。因此，代码生成器将生成如下代码：

private string m_FirstName;
static readonly PropertyChangedEventArgs s_FirstName_EventArgs =new PropertyChangedEventArgs("FirstName")

replace public string FirstName {
    get {
        return m_FirstName;
    }
    set {
        if (m_FirstName == value)
            return;
    m_FirstName = value;
    PropertyChanged?.Invoke(this, m_FirstName_EventArg);
}

通过“replace”关键字，所生成的代码将直接替换手写的代码，添加所缺失的功能。在这个示例中，我们甚至还能够处理一些开发者经常会忽略的麻烦的部分，例如对EventArgs对象进行缓存。

虽然这个官方示例仅用于属性变更通知，但这一技术还可用于各种“面向切面编程（AOP）”的场景，例如在代码中注入日志记录、安全检查、参数校验以及其他各种繁琐的样板式代码。

如果读者想实际了解一下这些特性，可以观赏Channel 9中的视频“The Future of C#”。

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!