
Êtes-vous fatigué d'utiliser des instructions qui nécessitent d'indenter votre code? Vous pouvez maintenant écrire le code suivant, qui attache une déclaration à la portée du bloc d'instructions actuel, puis dispose de l'objet à la fin de celui-ci.
Code : | Sélectionner tout |
1 2 3 4 5 6 | static void Main(string[] args) { using var options = Parse(args); if (options["verbose"]) { WriteLine("Logging..."); } } // options disposed here |
Quiconque utilise C # aime probablement l’idée d’une instruction switch, mais pas la syntaxe. Le C # 8 introduit les expressions switch, qui activent les fonctions suivantes: la syntaxe terser, renvoie une valeur puisqu'il s'agit d'une expression et qu'il est entièrement intégré à la correspondance de modèle. Le mot clé switch est "infixe", ce qui signifie que le mot clé se situe entre la valeur testée (ici, c’est o) et la liste des cas, de la même manière que l’expression lambdas. Les exemples suivants utilisent la syntaxe lambda pour les méthodes, qui s’intègre bien avec les expressions switch mais n’est pas obligatoire.
Vous pouvez voir la syntaxe des expressions switch dans l'exemple suivant:
Code : | Sélectionner tout |
1 2 3 4 5 6 | static string Display(object o) => o switch { Point { X: 0, Y: 0 } => "origin", Point { X: var x, Y: var y } => $"({x}, {y})", _ => "unknown" }; |
Vous pouvez aller plus loin et vous fier à la déconstruction des tuples et à la position des paramètres, comme vous pouvez le constater dans l'exemple suivant:
Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 | static State ChangeState(State current, Transition transition, bool hasKey) => (current, transition) switch { (Opened, Close) => Closed, (Closed, Open) => Opened, (Closed, Lock) when hasKey => Locked, (Locked, Unlock) when hasKey => Closed, _ => throw new InvalidOperationException($"Invalid transition") }; |
Tous ces modèles vous permettent d'écrire un code déclaratif qui capture votre intention au lieu d'un code procédural implémentant des tests. Le compilateur devient responsable de la mise en œuvre de ce code de procédure ennuyeux et il est garanti qu'il le fera toujours correctement.
Il y aura toujours des cas où les instructions switch seront un meilleur choix que les expressions switch et les modèles peuvent être utilisés avec les deux styles de syntaxe.
Nouvelles API Math
- BitIncrement / BitDecrement : correspond aux opérations IEEE nextUp et nextDown. Elles renvoient le plus petit nombre à virgule flottante qui se compare plus ou moins à l'entrée (respectivement). Par exemple, Math.BitIncrement (0.0) renverrait double.Epsilon.
- MaxMagnitude / MinMagnitude : correspond aux opérations IEEE maxNumMag et minNumMag; elles renvoient la valeur supérieure ou inférieure en magnitude aux deux entrées (respectivement). Par exemple, Math.MaxMagnitude (2.0, -3.0) renverrait -3.0.
- ILogB : correspond à l'opération logB IEEE qui renvoie une valeur intégrale, elle renvoie le journal intégral en base 2 du paramètre d'entrée. C'est effectivement la même chose que floor (log2 (x)), mais avec un minimum d'erreur d'arrondi.
- ScaleB : correspond à l'opération scaleB IEEE qui prend une valeur intégrale, elle renvoie effectivement x * pow (2, n), mais avec une erreur d'arrondi minimale.
- Log2 : correspond à l'opération log2 IEEE, renvoie le logarithme en base 2. Cela minimise les erreurs d'arrondi.
- FusedMultiplyAdd : correspond à l'opération fma IEEE, il effectue une addition multipliée fusionnée. C'est-à-dire qu'il effectue (x * y) + z en une seule opération, minimisant ainsi l'erreur d'arrondi. Un exemple serait FusedMultiplyAdd (1e308, 2.0, -1e308) qui renvoie 1e308. La valeur régulière (1e308 * 2.0) - 1e308 renvoie double.PositiveInfinity.
- CopySign : correspond à l'opération copySign IEEE, il renvoie la valeur de x, mais avec le signe de y.
Utf8JsonWriter
Utf8JsonWriter fournit un moyen hautement performant, non mis en cache, d’écrire du texte JSON codé en UTF-8 à partir de types .NET courants tels que String, Int32 et DateTime. Comme le reader, le writer est un type fondamental, de bas niveau, qui peut être utilisé pour créer des sérialiseurs personnalisés. L'écriture d'une charge JSON à l'aide du nouvel utilitaire Utf8JsonWriter est 30 à 80% plus rapide que l'utilisation de l'enregistreur de Json.NET et ne l'alloue pas.
Voici un exemple d'utilisation de Utf8JsonWriter qui peut être utilisé comme point de départ:
Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | static int WriteJson(IBufferWriter<byte> output, long[] extraData) { var json = new Utf8JsonWriter(output, state: default); json.WriteStartObject(); json.WriteNumber("age", 15, escape: false); json.WriteString("date", DateTime.Now); json.WriteString("first", "John"); json.WriteString("last", "Smith"); json.WriteStartArray("phoneNumbers", escape: false); json.WriteStringValue("425-000-1212", escape: false); json.WriteStringValue("425-000-1213"); json.WriteEndArray(); json.WriteStartObject("address"); json.WriteString("street", "1 Microsoft Way"); json.WriteString("city", "Redmond"); json.WriteNumber("zip", 98052); json.WriteEndObject(); json.WriteStartArray("ExtraArray"); for (var i = 0; i < extraData.Length; i++) { json.WriteNumberValue(extraData[i]); } json.WriteEndArray(); json.WriteEndObject(); json.Flush(isFinalBlock: true); return (int)json.BytesWritten; } |
Vous pouvez vous inspirer de cet exemple d'implémentation de IBufferWriter <T>. Ce qui suit est une implémentation concrète d'un squelette d'interface basée sur un tableau :
Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | public class ArrayBufferWriter : IBufferWriter<byte>, IDisposable { private byte[] _rentedBuffer; private int _written; public ArrayBufferWriter(int initialCapacity) { // TODO: argument validation _rentedBuffer = ArrayPool<byte>.Shared.Rent(initialCapacity); _written = 0; } public void Advance(int count) { // TODO: check if disposed // TODO: argument validation _written += count; } public Memory<byte> GetMemory(int sizeHint = 0) { // TODO: check if disposed // TODO: argument validation // TODO: grow/resize the buffer as needed based on your resizing strategy return _rentedBuffer.AsMemory(_written); } public Span<byte> GetSpan(int sizeHint = 0) { // TODO: check if disposed // TODO: argument validation // TODO: grow/resize the buffer as needed based on your resizing strategy return _rentedBuffer.AsSpan(_written); } public void Dispose() { // return back to the pool } } |
Dans la Preview 2, Microsoft a également ajouté System.Text.Json.JsonDocument qui a été construit sur le lecteur Utf8JsonReader. JsonDocument permet d'analyser des données JSON et de créer un DOM (Document Object Model) en lecture seule pouvant être interrogé pour prendre en charge l'accès et l'énumération aléatoires. Les éléments JSON qui composent les données sont accessibles via le type JsonElement exposé par le JsonDocument en tant que propriété appelée RootElement. JsonElement contient les énumérateurs de tableau et d'objet JSON, ainsi que des API permettant de convertir du texte JSON en types .NET courants. L’analyse d’une charge JSON typique et l’accès à tous ses membres à l’aide de JsonDocument sont deux à trois fois plus rapides que Json.NET, avec très peu d’allocations pour des données de taille raisonnable (<1 Mo).
Voici un exemple d'utilisation de JsonDocument et de JsonElement pouvant être utilisé comme point de départ:
Code : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | static double ParseJson() { const string json = " [ { \"name\": \"John\" }, [ \"425-000-1212\", 15 ], { \"grades\": [ 90, 80, 100, 75 ] } ]"; double average = -1; using (JsonDocument doc = JsonDocument.Parse(json)) { JsonElement root = doc.RootElement; JsonElement info = root[1]; string phoneNumber = info[0].GetString(); int age = info[1].GetInt32(); JsonElement grades = root[2].GetProperty("grades"); double sum = 0; foreach (JsonElement grade in grades.EnumerateArray()) { sum += grade.GetInt32(); } int numberOfCourses = grades.GetArrayLength(); average = sum / numberOfCourses; } return average; } |
Voir aussi :


