IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Dotnet Discussion :

Microsoft publie .NET 7 Preview 7, le dernier aperçu de la nouvelle version du framework


Sujet :

Dotnet

  1. #1
    Chroniqueur Actualités
    Avatar de Bruno
    Homme Profil pro
    Rédacteur technique
    Inscrit en
    mai 2019
    Messages
    922
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Rédacteur technique
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : mai 2019
    Messages : 922
    Points : 18 847
    Points
    18 847
    Par défaut Microsoft publie .NET 7 Preview 7, le dernier aperçu de la nouvelle version du framework
    Microsoft annonce .NET 7 Preview 6, la version du framework pour la création des applications,
    améliore les convertisseurs de type, personnalise des contrats JSON

    Microsoft a annoncé en début d’année la disponibilité de la Preview 1 de .NET 7. Le 12 juillet, Jon Douglas, Directeur de programme senior, NuGet, annonce la sortie de .NET 7 Preview 6. « Aujourd'hui, nous avons publié la Preview 6 de .NET 7. Cette Preview de .NET 7 comprend des améliorations des convertisseurs de type, la personnalisation des contrats JSON, des mises à jour de l'API System.Formats.Tar, des contraintes pour la création de modèles .NET et des améliorations des performances dans le domaine de CodeGen », déclare Jeremy Likness, Directeur de programme principal chez Microsoft.


    « .NET 7 s'appuie sur la base établie par .NET 6, qui comprend un ensemble unifié de bibliothèques de base, de runtime et de SDK, une expérience de développement simplifiée et une productivité accrue des développeurs. Les principaux domaines d'intérêt de .NET 7 comprennent une meilleure prise en en charge des scénarios cloud native, des outils facilitant la mise à niveau des projets existants et la simplification de l'expérience du développeur en facilitant le travail avec les conteneurs », a écrit Jeremy Likness de l'équipe .NET à propos de cette version. En gros, .NET 7 vise à faciliter le développement d'applications cloud natives et la conteneurisation.

    Nom : donet.png
Affichages : 18305
Taille : 1,3 Ko

    .NET 7 Preview 6 a été testé avec Visual Studio 17.3 Preview 3. Il est recommandé d'utiliser les builds du canal Preview ppour l’essai de .NET 7 avec les produits de la famille Visual Studio. Sous macOS, il est recommandé d'utiliser la dernière version de Visual Studio 2022 pour Mac. Voici, ci-dessous, les nouvelles fonctionnalités qu’apporte la Preview 6 de .NET 7.

    Convertisseurs de type

    Il existe maintenant des convertisseurs de type exposés pour les nouveaux types primitifs DateOnly, TimeOnly, Int128, UInt128 et Half.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    namespace System.ComponentModel
    {
        public class DateOnlyConverter : System.ComponentModel.TypeConverter
        {
            public DateOnlyConverter() { }
        }
        public class TimeOnlyConverter : System.ComponentModel.TypeConverter
        {
            public TimeOnlyConverter() { }
        }
     
        public class Int128Converter : System.ComponentModel.BaseNumberConverter
        {
            public Int128Converter() { }
        }
     
        public class UInt128Converter : System.ComponentModel.BaseNumberConverter
        {
            public UInt128Converter() { }
        }
     
        public class HalfConverter : System.ComponentModel.BaseNumberConverter
        {
            public HalfConverter() { }
        }
    }

    Personnalisation du contrat JSON

    Dans certaines situations, les développeurs qui sérialisent ou désérialisent JSON constatent qu'ils ne veulent pas ou ne peuvent pas changer les types, soit parce qu'ils proviennent d'une bibliothèque externe, soit parce que cela polluerait grandement le code, mais qu'ils ont besoin d'effectuer certains changements qui influencent la sérialisation, comme la suppression d'une propriété, la modification de la façon dont les nombres sont sérialisés, la façon dont les objets sont créés, etc. Ils sont souvent obligés d'écrire des wrappers ou des convertisseurs personnalisés, ce qui est non seulement fastidieux mais rend également la sérialisation plus lente.

    La personnalisation du contrat JSON permet à l'utilisateur d'avoir un meilleur contrôle sur les types qui sont sérialisés ou désérialisés et sur la manière dont ils le sont.

    Se lancer dans la personnalisation

    Il y a deux façons de base pour les développeurs de « se brancher » sur la personnalisation, elles aboutissent toutes deux à l'attribution de JsonSerializerOptions.TypeInfoResolver et nécessitent l'attribution de resolver :

    • Le développeur peut utiliser DefaultJsonTypeInfoResolver et ajouter son modificateur, tous les modificateurs seront appelés en série :

      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      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
      JsonSerializerOptions options = new()
      {
          TypeInfoResolver = new DefaultJsonTypeInfoResolver()
          {
              Modifiers =
              {
                  (JsonTypeInfo jsonTypeInfo) =>
                  {
                      // your modifications here, i.e.:
                      if (jsonTypeInfo.Type == typeof(int))
                      {
                          jsonTypeInfo.NumberHandling = JsonNumberHandling.AllowReadingFromString;
                      }
                  }
              }
          }
      };
       
      Point point = JsonSerializer.Deserialize<Point>(@"{""X"":""12"",""Y"":""3""}", options);
      Console.WriteLine($"({point.X},{point.Y})"); // (12,3)
       
      public class Point
      {
          public int X { get; set; }
          public int Y { get; set; }
      }
    • Écrire son propre résolveur personnalisé en implémentant ;
    • System.Text.Json.Serialization.Metadata.IJsonTypeInfoResolver ;
    • Lorsque le type n'est pas géré, le code doit retourner null ;
    • IJsonTypeInfoResolver peut être combiné avec d'autres pour former un résolveur efficace qui retournera la première réponse non nulle. Par exemple, JsonTypeInfoResolver.Combine(new MyResolver(), new DefaultJsonTypeInfoResolver()).

    Personnalisations

    La fonctionde IJsonTypeInfoResolver est de fournir JsonTypeInfo pour toute demande de sérialiseur de type, cela ne se produira qu'une fois par type et par option. JsonTypeInfo.Kind déterminera quels boutons le développeur peut changer et est déterminé en fonction du convertisseur qui est déterminé en fonction des convertisseurs fournis aux options. Par exemple, JsonTypeInfoKind.Object signifie que des propriétés peuvent être ajoutées/modifiées tandis que JsonTypeInfoKind.None signifie qu'aucun des boutons n'est garanti d'être utilisé cela peut arriver quand le type a un convertisseur personnalisé.

    JsonTypeInfo est soit créé par DefaultJsonTypeInfoResolver avec des boutons pré-remplis provenant par exemple d'attributs personnalisés, soit peut être créé de toutes pièces par l'utilisateur : JsonTypeInfo.CreateJsonTypeInfo, la création à partir de zéro signifie que l'utilisateur devra également définir JsonTypeInfo.CreateObject.

    Personnalisation des propriétés

    Les propriétés ne sont pertinentes que lorsque JsonTypeInfo.Kind == JsonTypeInfoKind.Object et, dans le cas de DefaultJsonTypeInfoResolver, elles seront préremplies. Elles peuvent être modifiées ou créées à l'aide de JsonTypeInfo.CreateJsonPropertyInfo et ajoutées à la liste des propriétés, par exemple, si vous obtenez une classe d'une autre bibliothèque dont les API sont bizarrement conçues et que vous ne pouvez pas les modifier :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class MyClass
    {
        private string _name = string.Empty;
        public string LastName { get; set; }
     
        public string GetName() => _name;
        public void SetName(string name)
        {
            _name = name;
        }
    }

    Avant que cette fonctionnalité n'existe, il faut créer son propre convertisseur personnalisé pour ce type.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    JsonSerializerOptions options = new()
    {
        TypeInfoResolver = new DefaultJsonTypeInfoResolver()
        {
            Modifiers = { ModifyTypeInfo }
        }
    };
     
    MyClass obj = new()
    {
        LastName = "Doe"
    };
     
    obj.SetName("John");
     
    string serialized = JsonSerializer.Serialize(obj, options); // {"LastName":"Doe","Name":"John"}
     
    static void ModifyTypeInfo(JsonTypeInfo ti)
    {
        if (ti.Type != typeof(MyClass))
            return;
     
        JsonPropertyInfo property = ti.CreateJsonPropertyInfo(typeof(string), "Name");
        property.Get = (obj) =>
        {
            MyClass myClass = (MyClass)obj;
            return myClass.GetName();
        };
     
        property.Set = (obj, val) =>
        {
            MyClass myClass = (MyClass)obj;
            string value = (string)val;
            myClass.SetName(value);
        };
     
        ti.Properties.Add(property);
    }

    Sérialisation conditionnelle des propriétés

    Dans certains scénarios d'utilisation, il est nécessaire que certaines valeurs par défaut ne soient pas sérialisées. Par exemple, vous ne voulez pas que 0 apparaisse dans le JSON pour certaines propriétés. Il était possible de faire fonctionner ce scénario auparavant en utilisant JsonIgnoreAttribute avec JsonIgnoreCondition.WhenWritingDefault. Le problème se pose lorsque la valeur par défaut n'est pas 0 mais quelque chose de différent, par exemple -1, ou qu'elle dépend d'un paramètre externe.

    Il est maintenant possible de définir son propre prédicat ShouldSerialize avec la condition de votre choix. Par exemple, disons qu'il esxite une propriété string et que vous voulez que N/A n'apparaisse pas dans le JSON :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // string property you'd like to customize
    JsonPropertyInfo property = ...;
     
    property.ShouldSerialize = (obj, val) =>
    {
        // in this specific example we don't use parent but it's available if needed
        MyClass parentObj = (MyClass)obj;
        string value = (string)val;
        return value != "N/A";
    };

    Ignorer les propriétés ayant un nom ou un type spécifique

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    var modifier = new IgnorePropertiesWithNameOrType();
    modifier.IgnorePropertyWithType(typeof(SecretHolder));
    modifier.IgnorePropertyWithName("IrrelevantDetail");
     
    JsonSerializerOptions options = new()
    {
        TypeInfoResolver = new DefaultJsonTypeInfoResolver()
        {
            Modifiers = { modifier.ModifyTypeInfo }
        }
    };
     
    ExampleClass obj = new()
    {
        Name = "Test",
        Secret = new SecretHolder() { Value = "MySecret" },
        IrrelevantDetail = 15,
    };
     
    string output = JsonSerializer.Serialize(obj, options); // {"Name":"Test"}
     
    class ExampleClass
    {
        public string Name { get; set; }
        public SecretHolder Secret { get; set; }
        public int IrrelevantDetail { get; set; }
    }
     
    class SecretHolder
    {
        public string Value { get; set; }
    }
     
    class IgnorePropertiesWithNameOrType
    {
        private List<Type> _ignoredTypes = new List<Type>();
        private List<string> _ignoredNames = new List<string>();
     
        public void IgnorePropertyWithType(Type type)
        {
            _ignoredTypes.Add(type);
        }
     
        public void IgnorePropertyWithName(string name)
        {
            _ignoredNames.Add(name);
        }
     
        public void ModifyTypeInfo(JsonTypeInfo ti)
        {
            JsonPropertyInfo[] props = ti.Properties.Where((pi) => !_ignoredTypes.Contains(pi.PropertyType) && !_ignoredNames.Contains(pi.Name)).ToArray();
            ti.Properties.Clear();
     
            foreach (var pi in props)
            {
                ti.Properties.Add(pi);
            }
        }
    }

    Mises à jour de l'API System.Formats.Tar

    Dans la Preview 4, l'assemblage System.Formats.Tar a été introduit. Elle offre des API pour la manipulation des archives TAR. Dans la Preview 6, quelques modifications ont été apportées pour couvrir quelques cas particuliers :

    Classe spécialisée Global Extended Attributes

    La conception initiale supposait que seules les archives TAR PAX pouvaient contenir une seule entrée GEA (Global Extended Attributes) en première position, mais il a été découvert que les archives TAR peuvent contenir plusieurs entrées GEA, qui peuvent affecter toutes les entrées suivantes jusqu'à ce qu'elles rencontrent une nouvelle entrée GEA ou la fin de l'archive.

    Il a également été découvert que les entrées GEA ne doivent pas être attendues uniquement dans les archives contenant exclusivement des entrées PAX : elles peuvent apparaître dans des archives qui mélangent des entrées de différents formats. Une nouvelle classe a donc été ajoutée pour décrire une entrée GEA :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    + public sealed partial class PaxGlobalExtendedAttributesTarEntry : PosixTarEntry
    + {
    +     public PaxGlobalExtendedAttributesTarEntry(IEnumerable<KeyValuePair<string, string>> globalExtendedAttributes) { }
    +     public IReadOnlyDictionary<string, string> GlobalExtendedAttributes { get { throw null; } }
    + }

    Format d'entrée, pas format d'archive

    Puisqu'il a également été découvert que des entrées de différents formats peuvent être mélangées dans une seule archive TAR, l'enum TarFormat a été renommé TarEntryFormat :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    -public enum TarFormat
    +public enum TarEntryFormat
    {
        ...
    }

    Et une nouvelle propriété a été ajoutée à TarEntry pour exposer le format de l'entrée :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    public abstract partial class TarEntry
    {
        ...
    +    public TarEntryFormat Format { get { throw null; } }
        ...
    }

    Changements en écriture et en lecture

    La propriété Format a été supprimée de TarReader car aucune archive n'est censée avoir toutes ses entrées dans un format unique. Étant donné que les entrées GEA sont maintenant décrites avec leur propre classe spécialisée, et que plusieurs entrées de ce type peuvent être trouvées dans une seule archive, la propriété dictionnaire du TarReader a également été supprimée :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    public sealed partial class TarReader : IDisposable
    {
        ...
    -    public TarFormat Format { get { throw null; } }
    -    public IReadOnlyDictionary<string, string>? GlobalExtendedAttributes { get { throw null; } }
        ...
    }

    L'ajout de la classe GEA spécialisée a également affecté TarWriter :

    • le constructeur qui prenait le dictionnaire pour une seule entrée GEA en première position a été supprimé ;
    • un nouveau constructeur qui ne prend que le flux et le booléen leaveOpen a été ajouté ;
    • le constructeur qui prend le TarFormat a été conservé, mais l'énumération a été renommée, et une valeur par défaut a été fixée à Pax. La documentation de la méthode a été modifiée pour expliquer que le paramètre format spécifié s'applique uniquement à la méthode TarWriter.WriteEntry qui ajoute une entrée à partir d'un fichier.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public sealed partial class TarWriter : IDisposable
    {
        ...
    -    public TarWriter(Stream archiveStream, IEnumerable<KeyValuePair<string, string>>? globalExtendedAttributes = null, bool leaveOpen = false) { }
    +    public TarWriter(Stream archiveStream, bool leaveOpen = false) { }
    -    public TarWriter(Stream archiveStream, TarFormat archiveFormat, bool leaveOpen = false) { }
    +    public TarWriter(Stream archiveStream, TarEntryFormat format = TarEntryFormat.Pax, bool leaveOpen = false) { }
         public void WriteEntry(string fileName, string? entryName) { }
        ...
    }

    Création de modèles

    Contraintes

    La Preview 6 introduit le concept de contraintes dans les modèles .NET. Les contraintes permettent de définir le contexte dans lequel les modèles sont autorisés. Ce qui peut aider le moteur de modèles à déterminer quels modèles il doit afficher dans des commandes comme dotnet new list. Dans cette version, Microsoft a ajouté la prise en charge de trois types de contraintes :

    • Système d'exploitation : qui limite les modèles en fonction du système d'exploitation de l'utilisateur ;
    • Template Engine Host : qui limite les modèles en fonction de l'hôte qui exécute le Template Engine. Il s'agit généralement du .NET CLI lui-même, ou de scénarios intégrés comme la boîte de dialogue Nouveau projet dans Visual Studio/Visual Studio pour Mac ;
    • Charges de travail installées : exige que la charge de travail .NET SDK spécifiée soit installée avant que le modèle ne soit disponible.

    Dans tous les cas, la description de ces contraintes est aussi simple que l'ajout d'une nouvelle section de contraintes au fichier de configuration du modèle :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    "constraints": {
           "web-assembly": {
               "type": "workload",
               "args": "wasm-tools"
           },
       }

    Actuellement, ces contraintes sont prises en charge dans le .NET CLI, et l'éauipe .NET travaille des équipes Visual Studio pour les intégrer dans les expériences de création de projets et d'éléments déjà existant.

    Cette fonctionnalité poura permettre aux utilisateurs du SDK de bénéficier d'une expérience plus cohérente, quel que soit leur choix d'éditeur, Microsft espère qu'elle facilitera le pilotage des utilisateurs vers les prérequis des modèles et qu'elle aidera à désencombrer la liste des modèles pour les scénarios courants tels que dotnet new list. Dans les futures versions de .NET 7.

    Paramètres multi-choix

    La Preview 6 ajoute également une nouvelle capacité pour les paramètres de choix ; la possibilité pour un utilisateur de spécifier plus d'une valeur dans une seule sélection. Cette fonctionnalité peut être utilisée de la même manière qu'un enum de type Flags. Voici des exemples courants de ce type de paramètre :

    • choix de plusieurs formes d'authentification sur le modèle web ;
    • choix de plusieurs plateformes cibles (ios, android, web) à la fois dans les templates maui.

    Pour adopter ce comportement, il suffit d'ajouter allowMultipleValues : true à la définition du paramètre dans la configuration du modèle. Ceci donne alors accès à un certain nombre de fonctions d'aide à utiliser dans le contenu du modèle pour détecter les valeurs spécifiques choisies par l'utilisateur.

    Unification des codes de sortie et rapports

    La Preview 6 a également unifié les codes de sortie signalés par le moteur de modèles. Cela devrait permettre aux utilisateurs qui utilisent des scripts dans leur shell de prédilection de bénéficier d'une gestion des erreurs plus cohérente. En outre, les erreurs signalées par le .NET CLI comprennent désormais un lien permettant de trouver des informations détaillées sur chaque code de sortie.

    Source : Microsoft

    Et vous ?

    Que pensez-vous des changements et des nouveautés introduits par la Preview 6 de .NET 7 ?

    Voir aussi :

    Microsoft annonce .NET 7 Preview 3, la version du framework pour la création des applications, apporte une amélioration du temps de démarrage avec la fonction Write-Xor-Execute activée de 10 à 15 %

    Microsoft annonce .NET 7 Preview 4, la version du framework pour la création des applications, elle corrige les bogues et comprend des MAJ

    Microsoft publie le premier aperçu de .NET 7 avec des optimisations continues du compilateur JIT, de nouvelles API et la prise en charge de plus de scénarios de rechargement à chaud
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

  2. #2
    Chroniqueur Actualités

    Homme Profil pro
    Dirigeant
    Inscrit en
    juin 2016
    Messages
    2 544
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Bénin

    Informations professionnelles :
    Activité : Dirigeant
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : juin 2016
    Messages : 2 544
    Points : 55 672
    Points
    55 672
    Par défaut Microsoft publie .NET 7 Preview 7, le dernier aperçu de la nouvelle version du framework
    Microsoft publie .NET 7 Preview 7, le dernier aperçu de la nouvelle version du framework avant la sortie de la première version candidate
    cet aperçu apporte de nouvelles améliorations au framework

    Microsoft a publié mardi .NET 7 Preview 7. L'entreprise a annoncé qu'il s'agit du dernier aperçu de .NET 7 et que la prochaine version sera la première release candidate (RC). Cet aperçu de .NET 7 comprend des améliorations de System.LINQ, des permissions de fichiers Unix, des structures de bas niveau, de la génération de sources p/Invoke, de la génération de code et des websockets. L'aperçu 7 a été testé avec Visual Studio 17.4 Preview 1, qui a également été publié mardi en même temps que la version finale Visual Studio v17.3. Le lancement de la version stable de .NET 7 est prévu pour le 10 novembre 2022.

    Lorsque le développement de .NET 7 a commencé, Microsoft a expliqué à la communauté que cette nouvelle version unifiera enfin tous les composants disparates des outils de développement .NET, permettant aux développeurs de créer tous les types d'applications - bureautiques, mobiles, Web et autres - sur la même bibliothèque de classes de base (BCL), le même moteur d'exécution et les mêmes compilateurs. C'était en fait l'objectif de .NET 5 - qui succède aux offres .NET Core - lorsqu'il a fait ses débuts en novembre 2020. Mais des problèmes de développement exacerbés par la pandémie n'ont pas permis d'atteindre cet objectif.

    En effet, tous les éléments prévus n'ont pas été intégrés à .NET 5 et ont été reportés jusqu'à l'arrivée de .NET 6 en novembre 2021 en tant que version LTS (Long Term Support). Mais même à ce moment-là, l'effort d'unification global de Microsoft était incomplet, car certains composants, tels que .NET Multi-platform App UI (.NET MAUI), n'ont pas respecté le calendrier. .NET MAUI a depuis atteint la disponibilité générale, et l'unification complète est désormais attendue pour novembre. Lors de la célébration des 20 ans de .NET en février dernier, Microsoft a réitéré son intention d'unifier tous les composants du framework à partir de .NET 7.

    Nom : images.png
Affichages : 1192
Taille : 50,0 Ko

    « .NET 7 s'appuie sur la base établie par .NET 6, qui comprend un ensemble unifié de bibliothèques de base, de runtime et de SDK, une expérience de développement simplifiée et une productivité accrue des développeurs. Les principaux domaines d'intérêt de .NET 7 comprennent une meilleure prise en en charge des scénarios cloud native, des outils facilitant la mise à niveau des projets existants et la simplification de l'expérience du développeur en facilitant le travail avec les conteneurs », a écrit Jeremy Likness de l'équipe .NET à propos de cette version. En gros, .NET 7 vise à faciliter le développement d'applications cloud natives et la conteneurisation.

    Dans le cadre de l'aperçu 7, Likness a déclaré mardi que l'équipe de développement s'est concentrée sur l'amélioration de System.LINQ, des permissions de fichiers Unix, des structures de bas niveau, de la génération de sources p/Invoke, de la génération de code et des websockets. Tous ces éléments spécifiques relèvent des conseils généraux fournis sur le site Themes of .NET. Voici ci-dessous les points forts de .NET 7 Preview 7 :

    Commande simplifiée avec System.LINQ

    System.Linq comprend maintenant de nouvelles méthodes, Order et OrderDescending, qui sont utilisées pour commander un IEnumerable en fonction de T. IQueryable supporte également ces méthodes maintenant.

    Avant le changement

    Auparavant, vous deviez appeler OrderBy/OrderByDescending en faisant référence à la valeur propre.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    var data = new[] { 2, 1, 3 };
    var sorted = data.OrderBy(static e => e);
    var sortedDesc = data.OrderByDescending(static e => e);

    Après le changement

    Maintenant, vous pouvez écrire :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    var data = new[] { 2, 1, 3 };
    var sorted = data.Order();
    var sortedDesc = data.OrderByDescending();

    Prise en charge des modes de fichiers Unix

    Auparavant, .NET ne disposait d'aucun support intégré pour l'obtention et la définition des autorisations de fichiers Unix, qui contrôlent les utilisateurs autorisés à lire, écrire et exécuter des fichiers et des répertoires. Il n'est pas toujours facile d'invoquer manuellement les syscalls, car certains sont exposés différemment selon les distributions. Par exemple, sur Ubuntu, vous pouvez avoir à pinvoke à __xstat, sur RedHat à stat, et ainsi de suite. Selon l'équipe, c'est la raison pour laquelle il est important de disposer d'une API .NET de première classe. Dans l'aperçu 7, l'équipe a introduit un nouveau type enum :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    public enum UnixFileMode
    {
        None,
        OtherExecute, OtherWrite, OtherRead,
        GroupExecute, GroupWrite, GroupRead,
        UserExecute, UserWrite, UserRead,
         ...
    }

    Elle a également ajouté les API File.GetUnixFileMode et File.SetUnixFileMode qui permettent d'obtenir et de définir le mode de fichier sur un chemin ou un handle (descripteurs de fichiers). Ainsi qu'une nouvelle propriété sur FileInfo et DirectoryInfo nommée UnixFileMode. Il existe également une nouvelle surcharge de Directory.CreateDirectory et une nouvelle propriété sur FileStreamOptions pour vous permettre de créer un répertoire ou un fichier avec un mode particulier en une seule fois.

    Selon l'équipe, lorsque vous les utilisez, umask est toujours appliqué, comme si vous aviez créé le répertoire ou le fichier dans votre Shell. Voici un exemple :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    // Create a new directory with specific permissions
    Directory.CreateDirectory("myDirectory", UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
     
    // Create a new file with specific permissions
    FileStreamOptions options = new()
    {
        Access = FileAccess.Write,
        Mode = FileMode.Create,
        UnixCreateMode =  UnixFileMode.UserRead | UnixFileMode.UserWrite,
    };
    using FileStream myFile = new FileStream("myFile", options);
     
    // Get the mode of an existing file
    UnixFileMode mode = File.GetUnixFileMode("myFile");
     
    // Set the mode of an existing file
    File.SetUnixFileMode("myFile", UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);

    Améliorations des structures de bas niveau : prise en charge du champ ref

    Les moteurs d'exécution .NET 7 prennent désormais pleinement en charge les champs ref dans les types ByRefLike (c'est-à-dire les structures ref). Grâce à cette fonctionnalité, les types qui nécessitaient auparavant une gestion spécialisée dans les moteurs d'exécution (par exemple, Span<T> et ReadOnlySpan<T>) peuvent désormais être entièrement implémentés en C#.

    Générateur de sources LibraryImport P/Invoke

    Le générateur de sources LibraryImport est désormais disponible de manière supportée pour tous les utilisateurs. Fruit de plus de 18 mois de travail, ce générateur de sources est conçu pour remplacer directement la majorité des utilisations de DllImport, tant dans le produit d'exécution que dans le code utilisateur. L'équipe indique que les bibliothèques .NET ont toutes adopté LibraryImport et sont livrées avec du code de marshalling généré par les sources depuis .NET 7 Preview 1.

    Le générateur source est livré avec le TFM (target framework moniker) .NET 7 et est facilement disponible pour la consommation. Pour bénéficier de la mise en correspondance générée par les sources, remplacez l'utilisation de DllImport par LibraryImport. Il existe des analyseurs et des correcteurs qui peuvent vous aider dans ce processus. Voici un exemple :

    Avant la prise en charge de LibraryImport

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    public static class Native
    {
        [DllImport(nameof(Native), CharSet = CharSet.Unicode)]
        public extern static string ToLower(string str);
    }

    Avec la prise en charge de LibraryImport

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    public static class Native
    {
        [LibraryImport(nameof(Native), StringMarshalling = StringMarshalling.Utf16)]
        public static partial string ToLower(string str);
    }

    L'équipe a indiqué qu'il existe un analyseur et un correcteur de code pour convertir automatiquement vos attributs DllImport en LibraryImport. Pour l'aperçu 7, il s'agit d'un opt-in. Ajoutez dotnet_diagnostic.SYSLIB1054.severity = suggestion à votre fichier EditorConfig pour activer l'analyseur de conversion en tant que diagnostic.

    Amélioration du comportement de ClientWebSocket

    Auparavant, ClientWebSocket ne fournissait aucun détail sur la réponse de mise à niveau. Cependant, les informations sur les en-têtes de réponse et le code d'état peuvent être importantes dans les scénarios d'échec et de réussite. En cas d'échec, le code d'état peut aider à faire la distinction entre les erreurs récupérables et non récupérables (le serveur ne prend pas du tout en charge les websockets ou il s'agit simplement d'une petite erreur transitoire).

    Les en-têtes peuvent aussi contenir des informations supplémentaires sur la manière de gérer la situation. Les en-têtes sont également utiles même en cas de connexion réussie d'un websocket. ils peuvent contenir un jeton lié à une session, des informations relatives à la version du sous-protocole, etc.

    Support

    .NET 7 est une version de support à court terme (Short Term Support - STS), ce qui signifie qu'elle bénéficiera d'un support et de correctifs gratuits pendant 18 mois à compter de sa date de sortie. L'équipe indique que la qualité de toutes les versions est la même. La seule différence est la durée de l'assistance. Enfin, l'équipe explique que .NET 7 Preview 7 a été testé avec Visual Studio 17.4 Preview 1.

    Elle recommande d'utiliser les builds du canal preview si vous voulez essayer .NET 7 avec les produits de la famille Visual Studio. Si vous êtes sur macOS, elle recommande d'utiliser la dernière version de Visual Studio 2022 pour Mac. Microsoft prévoit de lancer .NET 7 lors d'un événement qui se tiendra du 8 au 10 novembre 2022.

    Source : .NET 7 Preview 7

    Et vous ?

    Que pensez-vous des nouveautés et améliorations introduites par .NET 7 Preview 7 ?

    Voir aussi

    Microsoft annonce .NET 7 Preview 6, la version du framework pour la création des applications, améliore les convertisseurs de type, personnalise des contrats JSON

    Microsoft annonce .NET 7 Preview 4, la version du framework pour la création des applications, elle corrige les bogues et comprend des MAJ

    Microsoft annonce .NET 7 Preview 3, la version du framework pour la création des applications, apporte une amélioration du temps de démarrage avec la fonction Write-Xor-Execute activée de 10 à 15 %

    Microsoft publie le premier aperçu de .NET 7 avec des optimisations continues du compilateur JIT, de nouvelles API et la prise en charge de plus de scénarios de rechargement à chaud

    Microsoft célèbre les 20 ans de .NET, son Framework de développement, les dépôts .NET seraient dans le top 30 des projets open source à plus haute vélocité sur GitHub depuis 2017
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

Discussions similaires

  1. Réponses: 2
    Dernier message: 13/05/2022, 14h22
  2. Réponses: 0
    Dernier message: 14/04/2022, 04h51
  3. Réponses: 0
    Dernier message: 18/06/2021, 14h42
  4. Réponses: 0
    Dernier message: 14/06/2018, 20h59
  5. Réponses: 0
    Dernier message: 20/02/2015, 10h19

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo