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 :

.NET Core 3.0 est disponible


Sujet :

Dotnet

  1. #61
    Expert éminent
    Avatar de StringBuilder
    Homme Profil pro
    Chef de projets
    Inscrit en
    février 2010
    Messages
    3 695
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Chef de projets
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : février 2010
    Messages : 3 695
    Points : 6 328
    Points
    6 328
    Billets dans le blog
    1
    Par défaut
    Donc on est d'accord

    Sinon, quand je parle de lynchage, je parle du dégénéré prépubère qui me colle des "-1" à chaque poste, sans jamais prendre la peine d'exprimer en quoi il est en désaccord avec mon opinion
    On ne jouit bien que de ce qu’on partage.

  2. #62
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    4 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : mars 2013
    Messages : 4 723
    Points : 122 954
    Points
    122 954
    Par défaut Microsoft annonce la disponibilité de .NET Core 3 Preview 2 et apporte les expressions switch avec C# 8,
    Microsoft annonce la disponibilité de .NET Core 3 Preview 2 et apporte les expressions switch avec C# 8,
    ainsi que d'autres améliorations

    Utiliser les déclarations

    Ê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 - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    static void Main(string[] args)
    {
        using var options = Parse(args);
        if (options["verbose"]) { WriteLine("Logging..."); }
     
    } // options disposed here
    Les expressions Switch

    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 - Visualiser dans une fenêtre à part
    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"
    };
    Il y a deux modèles en jeu dans cet exemple. o correspond d’abord au modèle de type Point, puis au modèle de propriété à l’intérieur des {accolades}. Le _ décrit le modèle de suppression, qui est identique à celui par défaut pour les instructions switch.

    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 - Visualiser dans une fenêtre à part
    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")
        };
    Dans cet exemple, vous pouvez constater qu'il n'est pas nécessaire de définir une variable ou un type explicite pour chacun des cas. Au lieu de cela, le compilateur peut faire correspondre le tuple à tester avec les n-uplets définis pour chacun des cas.

    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.


    Nom : wpf-core-500x282.png
Affichages : 2390
Taille : 49,8 Ko

    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 - 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
    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;
    }
    Utf8JsonWriter accepte IBufferWriter <octet> comme emplacement de sortie dans lequel les données JSON doivent être écrites de manière synchrone et vous, en tant qu’appelant, devez fournir une implémentation concrète. La plateforme n'inclut pas actuellement d'implémentation de cette interface, mais Microsoft prévoit d'en fournir une qui s'appuie sur un tableau d'octets redimensionnable. Cette implémentation permettrait des écritures synchrones, qui pourraient ensuite être copiées dans n’importe quel flux (de manière synchrone ou asynchrone). Si vous écrivez du JSON sur le réseau et que vous incluez le package System.IO.Pipelines, vous pouvez utiliser l'implémentation basée sur Pipe de l'interface appelée PipeWriter pour éviter de copier le JSON d'un tampon intermédiaire dans la sortie réelle.

    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 - 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
    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
        }
    }
    JsonDocument

    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 - 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
    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;
    }
    Source : Microsoft

    Voir aussi :

    De .NET Core 1 à .NET Core 3.0, retour sur l'évolution du Framework open source et multiplateforme de Microsoft
    ASP.NET Core 2.2 est disponible en version stable avec un nouveau module d'hébergement dans IIS et une nouvelle API pour suivre l'état des apps
    La version 2.2 du framework .Net Core est disponible avec l'ajout de sécurité pour les connexions avec SQL Server et un meilleur suivi des services
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  3. #63
    Chroniqueur Actualités

    Homme Profil pro
    Webmaster
    Inscrit en
    janvier 2014
    Messages
    904
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webmaster
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : janvier 2014
    Messages : 904
    Points : 22 624
    Points
    22 624
    Par défaut La seconde préversion du framework ASP.Net Core 3 est disponible
    La seconde préversion du framework ASP.Net Core 3 est disponible
    avec la prise en charge de Razor Components et l’intégration du streaming client-serveur avec SignalR

    Depuis quelques jours, Microsoft a annoncé la disponibilité de la seconde préversion de ASP.Net Core 3.0. Dans cette nouvelle mouture du framework modulaire, Microsoft met en avant des changements notables et des améliorations.

    Dans ASP.Net Core 3 Preview 2, Microsoft a souhaité faire le nettoyage de son framework partagé. Cela a conduit les mainteneurs du projet à expurger le framework de certaines fonctionnalités. Parmi le lot des changements apportés, nous avons Json.Net qui est en train d’être supprimé du framework partagé. Pour permettre à ASP.Net de prendre en charge le framework JSON pour .Net dans les projetst, il va falloir ajouter Json.Net comme un package indépendant. Toujours sur cette même lancée, l’équipe de Microsoft a décidé de supprimer la prise en charge de la compilation au moment de l’exécution des pages et des vues. Ce changement a été opéré afin de ne plus dépendre du compilateur Roslyn. Pour remédier au délestage du compilateur Roslyn, la compilation des pages et des vues est effectuée au moment de la construction. Dans une prochaine mise à jour, Microsoft annonce qu’elle fournira des packages NuGet pour éventuellement activer le support de la compilation à l'exécution dans les applications.

    Razor Components, que retenir ?

    Du côté des améliorations, nous avons cette seconde préversion de ASP.Net Core 3.0 qui prend en charge Razor Components. Pour les développeurs qui n’ont pas suivi l’évolution du projet Blazor, il faut savoir que Razor Components représente l’intégration du modèle de Blazor Components dans ASP.NET Core ainsi que le modèle d’hébergement Blazor côté serveur. Autrement dit, la fonctionnalité Razor Components s’exécute côté serveur dans ASP.NET Core, tandis que Blazor (Razor qui s’exécute côté client) est un framework Web .NET expérimental utilisant C#/Razor et HTML qui exécute Razor Components directement dans le navigateur à l’aide d’un environnement d’exécution .NET basé sur WebAssembly. Pour mieux se représenter l’idée de ces composants Razor, Microsoft explique que ce sont des fragments d’interface utilisateur tels qu’une page, une boite de dialogue ou un formulaire qui peuvent être utilisés comme un nouveau moyen de créer une interface utilisateur Web interactive côté client avec ASP.NET Core sans pour autant avoir besoin d’écrire du code JavaScript. En outre, les composants Razor sont également des classes .NET normales qui définissent la logique de rendu de l'interface utilisateur et des gestionnaires d'évènements côté client.

    Hébergement de Razor Components

    Étant donné que Razor Components dissocie la logique de rendu d'un composant de la manière dont les mises à jour de l'interface utilisateur sont appliquées, la manière dont les composants Razor peuvent être hébergés est très flexible. ASP.NET Core Razor Components dans .NET Core 3.0 ajoute la prise en charge de l'hébergement de composants Razor sur le serveur dans une application ASP.NET Core où toutes les mises à jour de l'interface utilisateur sont gérées via une connexion SignalR. Le moteur d'exécution envoie les évènements d'interface utilisateur du navigateur au serveur, puis applique les mises à jour d'interface utilisateur envoyées par le serveur au navigateur après l'exécution des composants. La même connexion est également utilisée pour gérer les appels JavaScript interop. À noter que les composants Razor peuvent également utiliser du code JavaScript côté client si nécessaire. De même, à partir d’un composant Razor, il est possible de faire appel à n'importe quelle API du navigateur ou à une bibliothèque JavaScript existante exécutée dans le navigateur.

    Nom : aspnet-core-razor-components.png
Affichages : 4174
Taille : 30,9 Ko

    Compatibilité assurée avec les applications MVC existantes en utilisant Razor Components

    Pour ceux qui craignent une réécriture complète du code de leur application en souhaitant utiliser Razor Components, Microsoft rassure que les composants Razor peuvent être utilisés avec vos applications MVC et pages Razor existantes. Il n'est pas nécessaire de réécrire les vues ou les pages existantes pour utiliser les composants Razor. Et pour ceux qui ont déjà commencé à utiliser la préversion de l’EDI Visual Studio 2019, une prise en charge de Razor Components a été intégrée dans l’environnement de développement. Pour ce qui concerne Visual Studio pour Mac et Visual Studio Code, il va falloir patienter encore un peu pour voir la fonctionnalité Razor Components être supportée.

    Le streaming client-serveur avec SignalR

    Comme autres améliorations dans ASP.Net Core Preview 2, une prise en charge du streaming client-serveur a été ajoutée avec ASP.NET Core SignalR afin de permettre la transmission en continu des valeurs de retour à partir de méthodes côté serveur. Ceci est utile lorsque des fragments de données arrivent sur une période de temps.

    API System.IO.Pipelines sur HttpContext

    Microsoft informe que son équipe travaille actuellement dans ASP.NET Core 3.0 pour consommer l'API System.IO.Pipelines et l'exposer afin de permettre aux développeurs d'écrire des applications plus performantes.

    Hôte générique dans les modèles

    Les modèles ont été mis à jour pour utiliser l'hôte générique au lieu de WebHostBuilder comme cela se faisait dans le passé.

    En dehors de ces améliorations, l'ajout de plusieurs nouvelles fonctionnalités a été effectué dans cette version de ASP.Net Core 3 Preview 2.

    Source : Microsoft

    Et vous ?

    Quel est votre avis sur la nouvelle implémentation de ASP.Net Core 3 ?

    Les nouveautés annoncées sont-elles en phase avec vos attentes ?

    Voir aussi

    ASP.NET Core 2.2 est disponible en version stable avec un nouveau module d'hébergement dans IIS et une nouvelle API pour suivre l'état des apps
    Apprendre à créer une application CRUD avec ASP.NET Core Razor Pages sous Visual Studio Code et Entity Framework Core, un tutoriel d'Hinault Romaric
    Apprendre à déployer une application ASP.NET Core avec un conteneur Docker, un billet d'Hinault Romaric
    .NET Core ou .NET Framework ? Quelle implémentation adopter pour son projet ? Par Hinault Romaric
    ASP.NET 5 devient ASP.NET Core 1 et .Net Core 5 est maintenant appelé .NET Core 1.0 pour mieux se démarquer des anciens frameworks
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  4. #64
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    juin 2016
    Messages
    877
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Bénin

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : juin 2016
    Messages : 877
    Points : 24 734
    Points
    24 734
    Par défaut ASP.NET Core est le 3e serveur Web le plus rapide, répondant à 7 millions de requêtes HTTP/s
    ASP.NET Core est le 3e serveur Web le plus rapide, répondant à 7 millions de requêtes HTTP/s
    selon un test de TechEmpower

    ASP.NET Core est un framework .NET open source et multiplateforme permettant de créer des applications Web modernes en nuage sous Windows, Mac ou Linux. C'est un framework bâti sur les bases suivantes : multiplateforme, participation de la communauté, performance, modularité, souplesse, etc. Avec ASP.NET Core, il existe désormais deux déclinaisons de la plateforme .NET. Chacune disposant de son propre cycle de développement et les deux bénéficient du support de Microsoft. Bien qu’il s’agisse d’un framework construit sur une nouvelle pile Web, il présente un degré élevé de compatibilité conceptuelle avec ASP.NET MVC.

    De ce fait, quelle différence note-t-on entre .NET Core et son homologue .NET Framework ? Contrairement à .NET Framework qui fonctionne uniquement sur Windows ou Windows Server, .NET Core peut être utilisé aussi bien sur Windows que sur Linux et OS X. La conséquence de cette ouverture est le manque de support d’applications qui reposent sur des technologies Microsoft comme WPF, WinForms ou encore ASP.NET WebForms. .NET Core est développé en open source avec la contribution de la communauté. Ce qui n’est pas le cas pour le .NET Framework.

    .NET Core implémente de nombreuses API communes avec le Framework .NET. en plus des API qui sont spécifiques à Unix, Linux et OS X. Les API communes sont regroupées dans .NET Standard, qui est implémenté à la fois par .NET Core et .NET Framework. Ce qui signifie que tout code qui cible .NET Standard, peut s’exécuter sur .NET Core et .NET Framework. Cela rend assez simple le partage de code entre les deux plateformes. La dernière version stable du framework, la version 2.2 a été rendue disponible le 4 décembre passé. La version 3.0 quant à elle, est encore en développement. Mais en attendant, une version Preview 2 est disponible avec quelques changements notables tels que la prise en charge des flux asynchrones, la prise en charge des API de port pour Linux, un support pour ARM64 pour Linux, etc.

    Pour permettre à ASP.NET de prendre en charge le framework JSON pour .NET dans les projets, il va falloir ajouter Json.NET comme un package indépendant. Toujours sur cette même lancée, l’équipe de Microsoft a décidé de supprimer la prise en charge de la compilation au moment de l’exécution des pages et des vues. Ce changement a été opéré afin de ne plus dépendre du compilateur Roslyn. Après ces mises à jour répétitives qu’a subi le .NET Core, Microsoft a fourni une synthèse sur ses deux outils à savoir le .NET Core et le .NET Framework, qui montre que .NET Core est plus performant que le .NET Framework.

    Nom : asp-net-core-techempower-plaintext-top10.png
Affichages : 14173
Taille : 16,9 Ko

    À la vue de cela, un internaute explique que Microsoft a beaucoup travaillé pour améliorer les performances du .NET Core par rapport à .NET Framework. Pour lui, certains sujets restent encore à la traîne, mais d’autres par contre, ont été revus en profondeur. LINQ est devenu omniprésent ces dernières années, dit-il. La sérialisation, la compression, le networking, etc. dans les Web API sont bien plus rapides dans .NET Core que dans .NET Framework.
    Ainsi, TechEmpower (un framework d’applications Web qui compare les projets offrant des services de conception, de stratégie, de gestion, de systèmes et de graphisme) a réalisé récemment une comparaison entre la version stable 2.2 de .NET Core avec plusieurs autres frameworks d’applications Web, d'infrastructures full-stack et micro-frameworks. Les résultats placent ASP.NET Core comme 3e serveur le plus rapide. Il est capable de répondre à 7 millions de requêtes HTTP en seulement une seconde.

    Ces résultats concernent le serveur Web et le testeur de charge s’exécutant dans des conteneurs Docker, sur deux machines Linux physiques différentes connectées à un réseau de 10GbE, a écrit Ben Adams de Age of Ascent, qui rapporte les différents résultats des tests. « C'est aussi une quantité extraordinaire de bande passante ; assez pour saturer en permanence un lien de 10 Go/s », a-t-il estimé. Selon lui, ASP.NET Core serait très rapide sur toutes les plateformes et l’est plus encore lorsqu’il s’agit de Linux. Dans la comparaison avec d’autres serveurs bien connus, les résultats montrent qu’il est 1,78 fois plus rapide que nginx ; 2,93 fois plus rapide que le servlet de Java ( 7,76 fois plus rapide que le servlet sur Tomcat) ; 7,36 fois plus rapide que le package “net/HTTP” de Golang ; 8,06 fois plus rapide que node.js fonctionnant en cluster de 28 processus (car node.js est à thread unique).

    Nom : asp-net-core-techempower-other-servers.png
Affichages : 13849
Taille : 16,4 Ko

    Dans ce dernier cas, certains internautes indiquent que Node.js est totalement dépassé par les performances de ASP.NET Core et cela, quels que soient l’OS, le type de machine et le nombre de cœurs. Ils soulignent notamment les performances remarquables du framework sur Linux. La petite surprise, disent-ils, c’est les bons chiffres sur Ubuntu et ses pairs. On sent que la firme de Redmond a vraiment travaillé sur l’implémentation du .NET Core sur Linux, disent-ils. Néanmoins, ils soulignent quelques imperfections, rien n’étant jamais parfaite à 100 %. « Après, même si cela n’apparaît pas dans les chiffres, il y a tout de même quelques bémols. En effet, sans la désactivation des logs, les performances d'une ’application Web ASP.NET Core sont divisées par environ 5. Ce qui, lors des tests sur Windows, causait des erreurs sur 1 à 2 % des requêtes. Or, une application sans log n’est pas très réaliste en production », ont-ils déclaré.

    Ils conseillent donc de préférer les fonctions qui facilitent le développement comme le nouveau concept de Middleware et de Pipeline. D’autres tests réalisés pour examiner les performances de ces outils sur une base de données montrent que ASP.NET Core peut fonctionner avec de nombreuses bases de données (Postgres, MySQL, etc.) avec des performances très remarquables. Il existe d’autres résultats des tests que vous pouvez visualiser sur le site Age of Ascent. D’après Adams, .NET et ASP.NET ont toujours été très productifs et l’avenir avec ASP.NET Core et .NET Core sera aussi productif que rapide.

    Sources : Age of Ascent, TechEmpower

    Et vous ?

    Que pensez-vous des résultats de ce test ?
    ASP.NET Core est-il vraiment meilleur que les autres serveurs Web courants, selon vous ? Pourquoi ?
    Quel est votre serveur Web préféré et pourquoi ?
    Quelles expériences avez-vous faites d'ASP.NET Core ?

    Voir aussi

    .NET Core ou .NET Framework ? Quelle implémentation adopter pour son projet ?

    ASP.NET Core 2.2 est disponible en version stable avec un nouveau module d'hébergement dans IIS et une nouvelle API pour suivre l'état des apps

    ASP.Net Core 3 Preview 2 est disponible avec la prise en charge de Razor Components et l'intégration du streaming client-serveur avec SignalR

    Apprendre à créer une application CRUD avec ASP.NET Core Razor Pages sous Visual Studio Code et Entity Framework Core, un tutoriel d'Hinault Romaric

    Apprendre à déployer une application ASP.NET Core avec un conteneur Docker, un billet d'Hinault Romaric
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  5. #65
    Membre confirmé Avatar de rt15
    Homme Profil pro
    Développeur informatique
    Inscrit en
    octobre 2005
    Messages
    242
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : octobre 2005
    Messages : 242
    Points : 606
    Points
    606
    Par défaut
    Pardon mais en première lecture j'ai trouvé ces résultats suffisamment surprenant pour me demander si c'était pas pondu par une boîte, comment dire, légèrement influencée par M$.
    Genre une boîte qui vend des produits basés sur ASP.NET et qui est toute contente d'avoir comme par hasard choisi la meilleur technologie.

    Pour remettre dans le contexte, il y a quelques années, je me suis un peu intéressé à nodejs.
    Avant cette étude, j'imaginais qu'un serveur en nodejs devais être au mieux 20 ou 30% plus lent qu'un serveur en C, C++ ou en Java.
    Généralement le javascript peut difficilement espérer faire mieux, même exécuté par le V8 de Google qui est utilisé par nodejs.

    Je me disais que les utilisateurs de nodejs acceptaient cette perte de performance.
    Mais en fait pas du tout.
    L'architecture d'un serveur nodejs est bien différente de la plupart des serveurs de l'époque.
    Alors que beaucoup utilisaient (et utilisent encore) un thread par requête HTTP et parallélisaient les traitements sur différents coeurs, nodejs utilise un seul thread (du point de vue du développeur JS) et se base sur les entrées sorties asynchrones.

    Le coeur de nodejs, c'est libuv, une bibliothèque écrite en C par le créateur de nodejs.
    Cette librairie permet avant tout de faire en asynchrone les I/O sur les sockets et les disques.

    En gros le thread principal ne fait que soumettre des demandes de "tâches" au système d'exploitation, du genre écrit moi ça sur telle socket.
    Mais le thread n'attends pas la fin de la lecture ou de l'écriture : la demande de l'exécution d'une tâche n'est pas bloquante.
    Au lieu de cela, le thread principal se met en attente sur un ensemble d’évènements tels que "fin de l'écriture" ou "il y a quelque chose à lire sur tel socket".
    Le système réalise les tâches en arrière plan et notifie quand elles sont terminées.
    Dès qu'un événement se déclenche, le thread principal va le traiter, généralement en soumettant de nouvelles tâches d'entrée/sortie, puis se remettre en attente d'un nouvel évènement.
    De cette manière le thread principal a "très peu" de travail et peut gérer des quantités astronomiques de connections et de lectures/écritures sur disque.
    Le fait d'avoir peu de threads est très avantageux par rapport à un serveur classique car quand le processeur change de thread, il faut qu'il remplace son contexte d'exécution et ça prend un certain temps.
    Ce contexte et la pile associée au thread prend aussi de la place en mémoire.
    Par contre le désavantage d'avoir un seul thread principal est que si on a besoin de faire une tâche gourmande en CPU et qu'on l'a fait en JS, ça va bloquer le thread principal et le serveur ne fera rien d'autre : il ne sera pas à l'écoute des évènements pendant ce temps là.

    Le résultat c'est que pour certaines applications, un serveur nodejs ne vas pas être 20 ou 30% plus lent qu'une appli JEE. Le serveur nodejs peut battre le JEE à plate couture.
    Mais ce n'est pas JS qui est plus rapide que le Java. C'est la librairie C libuv qui bat l'archi JEE.

    Donc sachant la qualité de l'approche et de l'implémentation de nodejs dans ce domaine, j'ai été surpris que aspcore puisse écraser nodejs sur un "Best plaintext responses per second".

    Qu'est ce qui peut expliquer une telle différence ?
    En y regardant de plus près, a priori, le serveur web utilisé par ASP.NET Core dans ce benchmark s'appelle Kestrel (c'est celui par défaut).
    https://github.com/TechEmpower/Frame...rks/Program.vb
    (à noter qu'ils ont implémentés le benchmark en VB, pas en C#!)

    Et devinez sur quoi est basé Kestrel à la base ? Sur libuv...

    Depuis l'utilisation de libuv a été supprimé mais en fin de compte la nouvelle implémentation se base certainement sur epoll sous Linux et les Overlapped I/O sous Windows.
    Kestrel s'appuie donc sur les mêmes fonctions systèmes que libuv.

    En tout cas chapeau aux développeurs C/C++ de M$ pour leur résultat sur ce bench.

  6. #66
    Nouveau membre du Club

    Homme Profil pro
    Analyse système
    Inscrit en
    juillet 2003
    Messages
    30
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Analyse système

    Informations forums :
    Inscription : juillet 2003
    Messages : 30
    Points : 32
    Points
    32
    Par défaut
    En effet, dire que libUV est plus rapide sur aspcore que sur nodejs semble étrange... Mais bon, c'est un bench l'interprétation reste humaine. Si je regarde la même source, je peux conclure que PHP est plus rapide que aspcore pour sérialiser du json et que sur les 100 premiers du test « fortunes » les deux seuls qui génèrent des erreurs sont sur aspcore. De là à dire que aspcore est lent et buggé, il n'y a qu'un pas ... de troll.
    Cordialement, Renaud

    https://www.ezbastion.com

  7. #67
    Membre actif
    Avatar de ryankarl65
    Homme Profil pro
    Etudiant en Informatique | Freelance
    Inscrit en
    juillet 2013
    Messages
    101
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Etudiant en Informatique | Freelance

    Informations forums :
    Inscription : juillet 2013
    Messages : 101
    Points : 233
    Points
    233
    Par défaut
    J'aurais bien aime avoir un comparatif avec les solutions existantes.
    Merci pour cette article.
    Shakespeare: "Je me sens toujours heureux, vous savez pourquoi...?
    Parce que je n'attends rien de personne... Les attentes font toujours mal, la vie est courte. Aimez votre vie, soyez heureux, gardez le sourire et souvenez vous: Avant de parler écoutez, Avant d'écrire réfléchissez, Avant de prier pardonnez, Avant de blesser considérez l'autre, Avant de déteste aimez... Et avant de mourir vivez"

  8. #68
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    4 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : mars 2013
    Messages : 4 723
    Points : 122 954
    Points
    122 954
    Par défaut .NET Core 3.0 Preview 4 s'accompagne d'une MàJ de la compilation hiérarchisée
    Microsoft annonce la disponibilité de .NET Core 3.0 Preview 4 qui s'accompagne d'une MàJ de la compilation hiérarchisée,
    et du contrôle WinForms Chart

    Microsoft a annoncé la disponibilité de .NET Core 3.0 Preview 4. Il inclut un contrôle de graphique pour Windows Forms, une prise en charge HTTP / 2, des mises à jour du GC permettant d’utiliser moins de mémoire, une prise en charge des limites de CPU avec Docker, l’ajout de PowerShell dans les images de conteneur Docker du SDK .NET Core, et bien d’autres améliorations encore.

    Le contrôle WinForms Chart est maintenant disponible pour .NET Core

    Richard de Microsoft a avancé que :

    « Nous avons entendu dire que certains développeurs n'étaient pas en mesure de migrer leurs applications .NET Framework existantes vers .NET Core, car ils dépendaient du contrôle Chart. Nous avons résolu ce problème pour vous!

    « Le package System.Windows.Forms.DataVisualization (qui inclut le contrôle de graphique) est désormais disponible sur NuGet, pour .NET Core. Vous pouvez maintenant inclure ce contrôle dans vos applications .NET Core WinForms! »

    Nom : 1.png
Affichages : 8251
Taille : 125,2 Ko

    Microsoft a porté la bibliothèque System.Windows.Forms.DataVisualization sur .NET Core au cours des derniers sprints. La source du contrôle de graphique est disponible à l'adresse dotnet / winforms-datavisualization, sur GitHub. Le contrôle a été migré pour faciliter le portage vers .NET Core 3, mais Microsoft précise qu'il ne s'agit pas là d'un composant sur lequel l'entreprise a l'intention d'innover. Pour des scénarios de visualisation des données plus avancés, l'éditeur recommande de consulter Power BI.

    Microsoft pense que le meilleur moyen de vous familiariser avec le contrôle des graphiques est de jeter un coup d'œil à son projet ChartSamples. Il contient tous les types de graphiques existants et peut vous guider à chaque étape.

    Nom : 2.png
Affichages : 5335
Taille : 245,8 Ko

    Activation du contrôle Chart dans votre projet .NET

    Pour utiliser le contrôle Chart dans votre projet WinForms Core, ajoutez une référence au package System.Windows.Forms.DataVisualization NuGet. Vous pouvez le faire en recherchant System.Windows.Forms.DataVisualization dans le gestionnaire de paquets de NuGet (n’oubliez pas de cocher la case Inclure la version préliminaire) ou en ajoutant les lignes suivantes dans votre fichier .csproj.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    <ItemGroup>
        <PackageReference Include="System.Windows.Forms.DataVisualization" Version="1.0.0-prerelease.19212.2"/>
    </ItemGroup>
    Remarque: le concepteur WinForms est en cours de développement et vous ne pourrez pas configurer le contrôle à partir de ce dernier. Pour l'instant, vous pouvez utiliser une approche code d'abord ou créer et configurer le contrôle dans une application .NET Framework à l'aide du concepteur, puis transférer votre projet vers .NET Core.

    WPF

    L’équipe WPF a publié davantage de composants pour dotnet / wpf entre les versions Preview 3 et Preview 4.

    Les composants suivants sont maintenant disponibles en tant que source:
    • Microsoft.NET.Sdk.WindowsDesktop - il s'agit du SDK MSBuild (comme dans le “SDK style project”) pour les applications desktop Windows.
    • Microsoft.Dotnet.Wpf.ProjectTemplates - ce sont les modèles de projet pour WPF.
    • PresentationBuildTasks - ce sont les tâches utilisées pour compiler Xaml.


    Amélioration des API de la version .NET Core

    Microsoft a amélioré les API de la version .NET Core dans .NET Core 3.0. Elles renvoient maintenant les informations de version attendues : « Ces modifications, même si elles sont objectivement meilleures, sont techniquement révolutionnaires et peuvent perturber les applications qui reposent sur des API de version pour diverses informations ».

    Vous pouvez maintenant accéder aux informations suivantes via les API existantes:

    C:\testapps\versioninfo>dotnet run
    .NET Core version:
    Environment.Version: 3.0.0
    RuntimeInformation.FrameworkDescription: .NET Core 3.0.0-preview4.19113.15
    CoreFX Build: 3.0.0-preview4.19113.15
    CoreFX Hash: add4cacbfb7f7d3f5f07630d10b24e38da4ad027
    Le code pour produire cette sortie est le suivant:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    WriteLine(".NET Core version:");
    WriteLine($"Environment.Version: {Environment.Version}");
    WriteLine($"RuntimeInformation.FrameworkDescription: {RuntimeInformation.FrameworkDescription}");
    WriteLine($"CoreCLR Build: {((AssemblyInformationalVersionAttribute[])typeof(object).Assembly.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute),false))[0].InformationalVersion.Split('+')[0]}");
    WriteLine($"CoreCLR Hash: {((AssemblyInformationalVersionAttribute[])typeof(object).Assembly.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false))[0].InformationalVersion.Split('+')[1]}");
    WriteLine($"CoreFX Build: {((AssemblyInformationalVersionAttribute[])typeof(Uri).Assembly.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute),false))[0].InformationalVersion.Split('+')[0]}");
    WriteLine($"CoreFX Hash: {((AssemblyInformationalVersionAttribute[])typeof(Uri).Assembly.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false))[0].InformationalVersion.Split('+')[1]}");
    Mise à jour de la compilation par niveaux (TC - Tiered Compilation)

    La compilation hiérarchisée (TC) est une fonctionnalité d'exécution capable de contrôler la vitesse de compilation et la qualité du JIT afin d'obtenir différents résultats en termes de performances. Elle est activée par défaut dans les versions .NET Core 3.0.

    L’avantage fondamental de TC est de permettre des méthodes de (ré) jitting avec un code lent mais plus rapide à produire ou de meilleure qualité mais plus lent à produire afin d’améliorer les performances d’une application au cours des différentes étapes d’exécution, du démarrage à son état stationnaire. Cela contraste avec l'approche non-TC, dans laquelle chaque méthode est compilée d'une seule manière (comme pour le niveau de qualité supérieure), qui privilégie l'état stationnaire au démarrage.

    Nom : core.PNG
Affichages : 5245
Taille : 12,4 Ko

    « Nous réfléchissons à ce que la configuration par défaut de TC devrait être pour la version 3.0 finale. Nous avons étudié l’impact (positif et / ou négatif) sur les performances de nombreux scénarios d’application, avec pour objectif de sélectionner un paramètre par défaut qui convient à tous les scénarios et de fournir des commutateurs de configuration permettant aux développeurs de sélectionner leurs paramètres de configuration.

    « TC reste activé dans la préversion 4, mais nous avons modifié la fonctionnalité activée par défaut. Nous recherchons des commentaires et des données supplémentaires pour nous aider à décider si cette nouvelle configuration est la meilleure ou si nous devons apporter d'autres modifications. Notre objectif est de sélectionner la meilleure valeur globale par défaut, puis de fournir un ou plusieurs commutateurs de configuration afin d'activer d'autres comportements de participation ».

    Prise en charge HTTP/2

    Microsoft a apporté un support pour HTTP/2 dans HttpClient. Le nouveau protocole est obligatoire pour certaines API, telles que gRPC et le service de notification Apple Push. L'éditeur prévoit que davantage de services nécessiteront HTTP/2 à l'avenir.

    ASP.NET prend également en charge HTTP/2, mais il s'agit d'une implémentation indépendante optimisée pour la mise à l'échelle.

    Dans la préversion 4, HTTP/2 n'est pas activé par défaut, mais peut être activé avec l'une des méthodes suivantes:
    • Définissez AppContext.SetSwitch ("System.Net.Http.SocketsHttpHandler.Http2Support", true); réglage du contexte de l'application
    • Définissez la variable d'environnement DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2SUPPORT sur true

    Ces configurations (l'une ou l'autre) doivent être définies avant d'utiliser HttpClient si vous avez l'intention d'utiliser HTTP/2.

    Remarque: la version de protocole HTTP préférée sera négociée via TLS/ALPN et HTTP/2 ne sera utilisé que si le serveur choisit de l'utiliser.

    Les images SDK Docker contiennent PowerShell Core

    PowerShell Core a été ajouté aux images de conteneur Docker du SDK .NET Core SDK, à la demande de la communauté. PowerShell Core est un outil / framework d'automatisation et de configuration multiplate-forme (Windows, Linux et macOS) qui fonctionne bien avec vos outils existants et qui est optimisé pour traiter les données structurées (JSON, CSV, XML, etc.) et les API REST. et modèles d'objet. Il comprend un shell de ligne de commande, un langage de script associé et un framework pour le traitement des cmdlets.

    Vous pouvez essayer PowerShell Core, en tant qu'élément de l'image du conteneur du Kit de développement .NET Core SDK, en exécutant la commande Docker suivante:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    docker run --rm mcr.microsoft.com/dotnet/core/sdk:3.0 pwsh -c Write-Host "Hello Powershell"
    L’intégration de PowerShell dans l’image de conteneur .NET Core SDK permet à PowerShell de réaliser deux scénarios principaux, ce qui était impossible autrement:
    • Rédiger des fichiers Docker de l'application .NET Core avec la syntaxe PowerShell pour tout système d'exploitation.
    • Écrire une logique de construction d’application / bibliothèque .NET Core qui puisse être facilement conteneurisée.

    Exemple de syntaxe de lancement de PowerShell pour une construction conteneurisée (montée sur volume):
    • docker run -it -v c: \ myrepo: / myrepo -w / myrepo mcr.microsoft.com/dotnet/core/sdk:3.0 pwsh build.ps1
    • docker run -it -v c: \ myrepo: / myrepo -w / myrepo mcr.microsoft.com/dotnet/core/sdk:3.0 ./build.ps1

    Source : Microsoft
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  9. #69
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    4 723
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : mars 2013
    Messages : 4 723
    Points : 122 954
    Points
    122 954
    Par défaut Microsoft confirme que la version générale de .NET Core 3.0 sera disponible durant la .NET Conf 2019
    Microsoft confirme que la version générale de .NET Core 3.0 sera disponible durant la .NET Conf 2019,
    et en profite pour publier .NET Core 3.0 RC1

    Microsoft a annoncé la disponibilité de la RC1 de .NET Core 3.0. .NET Core est pour rappel le « reboot » complet de l’environnement .NET. Entièrement open source (licence MIT), il en est une version modulaire distribuée via NuGet.

    Dans son billet parlant de .NET Core 3.0 Preview 9, Microsoft avait déclaré que la Preview 9 serait la dernière version avant la disponibilité générale de .NET Core 3.0. « Nous, ou du moins l'auteur infatigable de ces billets de blogs, nous sommes trompés », a noté Richard de Microsoft (qui est celui qui rédige les billets sur les Preview de .NET Core 3.0).

    Cette fois-ci, il s'est contenté de dire que la disponibilité générale approche à grands pas puisqu'elle est prévue pour le 23 septembre à l'occasion de la .NET Conf, un événement gratuit de trois jours autour des plateformes .NET (qui va donc s'achever le 25 septembre).

    Voici son explication :

    « Pour des raisons techniques et historiques, l'ensemble d'outils .NET (compilateurs, client NuGet, MSBuild,…) est dupliqué entre Visual Studio et le Kit de développement logiciel (SDK) .NET. Des modifications importantes ont été apportées à la boîte à outils dans Visual Studio 2019 16.3 Preview 4, également publié aujourd'hui. Il est essentiel que la version du Kit de développement .NET Core SDK faisant partie de toute version de Visual Studio inclue le même jeu d'outils afin de fournir une expérience compatible dans tous les scénarios.

    « Nous aurions dû nous rendre compte qu'il était très probable que nous devions publier des modifications pour prendre en charge une autre préversion de Visual Studio. Faire des corrections dans les outils .NET comme ceci est une procédure d’exploitation standard. Nous aurions pu publier un nouveau SDK .NET Core et le livrer uniquement via Visual Studio. Cependant, nous avons déjà déboussolé des personnes dans un passé (maintenant lointain) avec cette approche. Par conséquent, lorsque nous publions un nouveau kit de développement .NET Core SDK, nous le rendons disponible pour tous, partout ».

    Nom : dot.png
Affichages : 3829
Taille : 90,6 Ko

    Prise en charge de Visual Studio

    .NET Core 3.0 est pris en charge avec Visual Studio 2019 16.3 Preview 4 et Visual Studio pour Mac 8.3, également disponibles aujourd'hui. Effectuez une mise à niveau pour bénéficier de la meilleure expérience (et prise en charge) avec .NET Core 3.0 Preview RC1.

    Le code C# Extension pour Visual Studio est toujours mis à jour pour prendre en charge les nouvelles versions de .NET Core. Assurez-vous d'avoir la dernière version de l'extension C# installée.

    .NET Core 3.0

    Les évolutions ont été abordées au fil des Preview. Par exemple, .NET Core 3.0 Preview 4 inclut un contrôle de graphique pour Windows Forms, une prise en charge HTTP / 2, des mises à jour du GC permettant d’utiliser moins de mémoire, une prise en charge des limites de CPU avec Docker, l’ajout de PowerShell dans les images de conteneur Docker du SDK .NET Core, et bien d’autres améliorations encore.

    Contrôle WinForms Chart

    Richard de Microsoft avait avancé que :

    « Nous avons entendu dire que certains développeurs n'étaient pas en mesure de migrer leurs applications .NET Framework existantes vers .NET Core, car ils dépendaient du contrôle Chart. Nous avons résolu ce problème pour vous!

    « Le package System.Windows.Forms.DataVisualization (qui inclut le contrôle de graphique) est désormais disponible sur NuGet, pour .NET Core. Vous pouvez maintenant inclure ce contrôle dans vos applications .NET Core WinForms! »

    Nom : win.png
Affichages : 1506
Taille : 125,2 Ko

    Microsoft a porté la bibliothèque System.Windows.Forms.DataVisualization sur .NET Core au cours des derniers sprints. La source du contrôle de graphique est disponible à l'adresse dotnet / winforms-datavisualization, sur GitHub. Le contrôle a été migré pour faciliter le portage vers .NET Core 3, mais Microsoft précise qu'il ne s'agit pas là d'un composant sur lequel l'entreprise a l'intention d'innover. Pour des scénarios de visualisation des données plus avancés, l'éditeur recommande de consulter Power BI.

    Mise à jour de la compilation par niveaux (TC - Tiered Compilation)

    La compilation hiérarchisée (TC) est une fonctionnalité d'exécution capable de contrôler la vitesse de compilation et la qualité du JIT afin d'obtenir différents résultats en termes de performances. Elle est activée par défaut dans les versions .NET Core 3.0.

    L’avantage fondamental de TC est de permettre des méthodes de (ré) jitting avec un code lent mais plus rapide à produire ou de meilleure qualité mais plus lent à produire afin d’améliorer les performances d’une application au cours des différentes étapes d’exécution, du démarrage à son état stationnaire. Cela contraste avec l'approche non-TC, dans laquelle chaque méthode est compilée d'une seule manière (comme pour le niveau de qualité supérieure), qui privilégie l'état stationnaire au démarrage.

    « Nous réfléchissons à ce que la configuration par défaut de TC devrait être pour la version 3.0 finale. Nous avons étudié l’impact (positif et / ou négatif) sur les performances de nombreux scénarios d’application, avec pour objectif de sélectionner un paramètre par défaut qui convient à tous les scénarios et de fournir des commutateurs de configuration permettant aux développeurs de sélectionner leurs paramètres de configuration.

    « TC reste activé dans la préversion 4, mais nous avons modifié la fonctionnalité activée par défaut. Nous recherchons des commentaires et des données supplémentaires pour nous aider à décider si cette nouvelle configuration est la meilleure ou si nous devons apporter d'autres modifications. Notre objectif est de sélectionner la meilleure valeur globale par défaut, puis de fournir un ou plusieurs commutateurs de configuration afin d'activer d'autres comportements de participation ».

    Prise en charge HTTP/2

    Microsoft a apporté un support pour HTTP/2 dans HttpClient. Le nouveau protocole est obligatoire pour certaines API, telles que gRPC et le service de notification Apple Push. L'éditeur prévoit que davantage de services nécessiteront HTTP/2 à l'avenir.

    ASP.NET prend également en charge HTTP/2, mais il s'agit d'une implémentation indépendante optimisée pour la mise à l'échelle.

    Dans la préversion 4, HTTP/2 n'est pas activé par défaut, mais peut être activé avec l'une des méthodes suivantes:
    • Définissez AppContext.SetSwitch ("System.Net.Http.SocketsHttpHandler.Http2Support", true); réglage du contexte de l'application
    • Définissez la variable d'environnement DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2SUPPORT sur true

    Ces configurations (l'une ou l'autre) doivent être définies avant d'utiliser HttpClient si vous avez l'intention d'utiliser HTTP/2.

    Remarque: la version de protocole HTTP préférée sera négociée via TLS/ALPN et HTTP/2 ne sera utilisé que si le serveur choisit de l'utiliser.

    En somme, voici quelques-unes des principales fonctionnalités de .NET Core 3 :
    • Windows Desktop, WPF et support de winforms dans .NET Core
    • Prise en charge de la dernière version de C# (8.0)
    • Déploiement MSIX et exécutable EXE autonome
    • Prise en charge de .Net Standard 2.1
    • Winforms avec haute DPI
    • Prise en charge JSON intégrée rapide
    • Support HTTP/2
    • Prise en charge des chiffrements cryptographiques AES-GCM et AES-CCM
    • Compilation à plusieurs niveaux
    • Amélioration des performances

    Télécharger .NET Core 3.0 RC1 (sur Windows, macOS et Linux)

    Source : Microsoft

    Voir aussi :

    Bing.com tourne désormais sur .NET Core 2.1, un choix technique qui lui a permis de gagner en performance, mais aussi en agilité
    Microsoft annonce la diffusion de mises à jour cumulatives pour .NET Framework à compter de la mise à jour Windows 10 octobre 2018
    PowerShell Core 6.1 est disponible : support de .NET Core 2.1, compatibilité avec les modules Windows, cmdlets et rendu Markdown et plus

    Visual Studio 2019 version 16.2 Preview 2 est disponible en téléchargement, et apporte des améliorations à la productivité .NET
    Avec .NET 5, Microsoft voudrait produire un environnement d'exécution .NET unique et une infrastructure utilisable partout
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  10. #70
    Chroniqueur Actualités
    Avatar de Michael Guilloux
    Homme Profil pro
    Consultant
    Inscrit en
    juillet 2013
    Messages
    2 274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Consultant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2013
    Messages : 2 274
    Points : 74 128
    Points
    74 128
    Billets dans le blog
    2
    Par défaut .NET Core 3.0 est disponible
    .NET Core 3.0 est disponible avec le support du développement d'applications Windows Desktop
    C# 8.0, ARM64, une prise en charge JSON intégrée rapide et de nombreuses autres améliorations

    Microsoft vient d’annoncer la publication de .NET Core 3.0. Cette tant attendue nouvelle version majeure de la variante open source et multiplateforme de .NET Framework comprend de nombreuses améliorations, notamment l'ajout de Windows Forms et de Windows Presentation Foundation (WPF). Elle introduit aussi de nouvelles API JSON, la prise en charge d’ARM64 et des améliorations de performance générales. Notons également qu'elle embarque C# 8.0, entre de nombreuses autres nouveautés que nous ne pourrons présenter ici de manière exhaustive.

    WPF et Windows Forms

    Une des principales nouveautés de cette version est la prise en charge des applications desktop. Vous pouvez maintenant créer des applications Windows Forms et WPF avec .NET Core, sous Windows. Précisons que pour les applications de bureau de .NET Framework existantes, Microsoft a également veillé à faciliter leur migration vers .NET Core.


    Une application .NET Core Windows Forms

    Visual Studio 2019 16.3 prend en charge la création d'applications WPF qui ciblent .NET Core. Cela inclut de nouveaux templates, un concepteur XAML (similaire au concepteur XAML existant qui cible .NET Framework) et XAML Hot Reload. Le concepteur Windows Forms est quant à lui toujours en préversion et disponible en téléchargement séparé, en tant qu'extension Visual Studio. Il sera ajouté à Visual Studio dans une version ultérieure. Il ne prend actuellement en charge que les contrôles et les fonctionnalités de bas niveau les plus couramment utilisés. Microsoft ne recommande donc pas de porter vos applications Windows Forms vers .NET Core, en particulier si vous comptez sur le concepteur. Les développeurs sont plus invités à le tester afin de partager leurs avis... Soulignons que vous pouvez également créer et générer des applications de bureau en utilisant la CLI .NET.


    Une application WPF affichée dans le nouveau concepteur

    En plus de Windows Forms et WPF, le package System.Windows.Forms.DataVisualization (qui inclut le contrôle permettant de générer des graphiques) est disponible pour .NET Core. Vous pouvez donc maintenant inclure ce contrôle dans vos applications .NET Core WinForms.

    Support de C# 8.0

    Livré avec .NET Core 3.0, C# 8.0 apporte de nombreuses améliorations. Parmi les plus notables, on peut citer les types de référence nullables. Désormais, toute variable d'un type référence est considérée comme un type référence n'acceptant pas la valeur Null. Autrement dit, par défaut, ces types seront non nullables ! Mais vous pouvez faire en sorte que le type de la variable soit nullable en ajoutant "?" au nom de type pour le déclarer comme type de référence nullable. Le but de cette fonctionnalité est d'en finir avec les exceptions de référence null très fréquentes.

    C# 8.0 vient également avec les types Index et Range qui offrent une syntaxe concise pour spécifier des sous-plages dans un tableau, Span<T> ou ReadOnlySpan<T>. Un type Index peut être utilisé pour l’indexation. Vous pouvez en créer un à partir d'un intqui permet de compter depuis le début, ou avec un opérateur de préfixe ^ qui permet de compter depuis la fin.

    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    Index i1 = 3;  // number 3 from beginning
    Index i2 = ^4; // number 4 from end
    int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    Console.WriteLine($"{a[i1]}, {a[i2]}"); // "3, 6"

    Un type Range est quant à lui composé de deux index, un pour le début et un pour la fin, et il peut être écrit avec une expression de plage (C#) x..y.

    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    var slice = a[i1..i2]; // { 3, 4, 5 }

    C# 8.0 inclut bien d'autres fonctionnalités comme les flux asynchrones, les déclarations using, les expressions Switch, les modèles récursifs (les modèles contenant d'autres modèles), l'implémentation par défaut des membres d'une interface, etc.

    Prise en charge JSON intégrée rapide

    Les utilisateurs de .NET se sont largement appuyés sur Json.NET et d’autres bibliothèques JSON populaires. Mais .NET Core 3.0 inclut une nouvelle famille d’API JSON permettant des scénarios de lecture/écriture (Utf8JsonReader et Utf8JsonWriter), l’accès aléatoire avec un modèle objet document (JsonDocument) et un sérialiseur (JsonSerializer). Les nouvelles API sont conçues pour répondre à de nombreux scénarios identiques, mais avec moins de mémoire et une exécution plus rapide. Microsoft souhaitait en effet créer une nouvelle API JSON qui tirait parti de toutes les nouvelles fonctionnalités de performance de .NET Core et qui offrait des performances appropriées. Mais il n’était pas possible de faire cela dans une base de code existante telle que Json.NET tout en maintenant la compatibilité.

    Un nouveau SqlClient

    SqlClient est le fournisseur de données que vous utilisez pour accéder à Microsoft SQL Server et à Azure SQL Database. Il va maintenant être publié et mis à jour en tant que package NuGet Microsoft.Data.SqlClient, et pris en charge à la fois pour les applications .NET Framework et .NET Core. En utilisant NuGet, il sera plus facile pour l’équipe SQL de fournir des mises à jour aux utilisateurs .NET Framework et .NET Core.

    Support ARM et IoT

    Microsoft a ajouté la prise en charge de Linux ARM64 dans cette version, après l’ajout de la prise en charge d’ARM32 pour Linux et Windows dans les versions .NET Core 2.1 et 2.2, respectivement. Raspberry Pi et les puces ARM sont désormais prises en charge pour permettre le développement IoT, y compris avec le débogueur Visual Studio distant. Vous pouvez déployer des applications qui écoutent des capteurs et afficher des messages ou des images sur un écran, le tout à l'aide des nouvelles API GPIO. ASP.NET peut être utilisé pour exposer des données en tant qu'API ou en tant que site permettant de configurer un périphérique IoT.

    Compilation hiérarchisée

    La compilation hiérarchisée est activée par défaut avec .NET Core 3.0. Cette fonctionnalité permet au runtime d’utiliser de manière plus adaptative le compilateur JIT pour obtenir de meilleures performances. Son principal avantage est d’autoriser les méthodes JIT avec un niveau de moins bonne qualité, mais plus rapide, ou avec un niveau de meilleure qualité, mais plus lent. Cela permet d’améliorer les performances d’une application quand elle passe par les différents stades de l’exécution, du démarrage à l’état stable.

    Autres améliorations

    On peut encore citer parmi les améliorations les plus importantes :
    • le support de HTTP/2 dans HttpClient ;
    • les applications .NET Core ont maintenant des exécutables par défaut : dans les versions précédentes, les applications devaient être lancées via la commande dotnet ;
    • la taille de tas par défaut du récupérateur de mémoire a été réduite, aboutissant à une diminution de la quantité de mémoire utilisée par .NET Core. Le récupérateur de mémoire a également été mis à jour afin de mieux utiliser un grand nombre de cœurs sur des machines de plus de 64 cœurs ;
    • .NET Core fonctionne mieux avec Docker, le ramasse-miettes et le pool de threads ont été mis à jour pour fonctionner beaucoup mieux lorsqu'un conteneur a été configuré pour une mémoire ou un processeur limité. Les images docker .NET Core également sont plus petites, en particulier celles du SDK ;
    • etc.

    Il est important de mentionner que Visual Studio 2019 16.3 et Visual Studio pour Mac 8.3 ont également été publiés et que ce sont les versions requises pour utiliser .NET Core 3.0 avec Visual Studio.

    Télécharger .NET Core 3.0 pour Windows, macOS ou Linux

    Source : Microsoft

    Voir aussi :

    Bing.com tourne désormais sur .NET Core 2.1, un choix technique qui lui a permis de gagner en performance, mais aussi en agilité
    Microsoft annonce la diffusion de mises à jour cumulatives pour .NET Framework à compter de la mise à jour Windows 10 octobre 2018
    PowerShell Core 6.1 est disponible : support de .NET Core 2.1, compatibilité avec les modules Windows, cmdlets et rendu Markdown et plus
    Visual Studio 2019 version 16.2 Preview 2 est disponible en téléchargement, et apporte des améliorations à la productivité .NET
    Avec .NET 5, Microsoft voudrait produire un environnement d'exécution .NET unique et une infrastructure utilisable partout
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  11. #71
    Membre éclairé
    Homme Profil pro
    Architecte de système d'information
    Inscrit en
    août 2014
    Messages
    432
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Ain (Rhône Alpes)

    Informations professionnelles :
    Activité : Architecte de système d'information

    Informations forums :
    Inscription : août 2014
    Messages : 432
    Points : 840
    Points
    840
    Par défaut
    Ca n'aura de reel interet que le jour ou ca ne fonctionnera pas QUE sous windows (WPF/Winforms j'entends). Le reste c'est du detail.

  12. #72
    Membre confirmé Avatar de FatAgnus
    Homme Profil pro
    Trouffion de base
    Inscrit en
    août 2015
    Messages
    135
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Trouffion de base

    Informations forums :
    Inscription : août 2015
    Messages : 135
    Points : 582
    Points
    582
    Par défaut
    Citation Envoyé par kilroyFR Voir le message
    Ca n'aura de réel intérêt que le jour ou ca ne fonctionnera pas QUE sous Windows (WPF/WinForms j'entends). Le reste c'est du détail.
    Microsoft ne veut pas pas d'une implémentation multiplate-formes de Windows Forms ou WPF, c'est eux même qui l'écrivent sur la page Contributing Guide : « Nous n'avons pas non plus l'intention d'accepter des contributions qui fournissent des implémentations multiplate-formes pour Windows Forms ou WPF. ».

  13. #73
    Membre confirmé
    Inscrit en
    juin 2010
    Messages
    609
    Détails du profil
    Informations forums :
    Inscription : juin 2010
    Messages : 609
    Points : 622
    Points
    622
    Par défaut
    Citation Envoyé par kilroyFR Voir le message
    Ca n'aura de reel interet que le jour ou ca ne fonctionnera pas QUE sous windows (WPF/Winforms j'entends). Le reste c'est du detail.
    Déjà winform ne fonctionnera jamais en dehors de Windows, et Wpf non plus. L'un est une flat api par dessus win32 le second utilise massivement directX.

    Il a des mots clefs dans ces technologies comme Windows ou Win32... Ce qui laisse peu de doute concernant la portabilité.

    Votre commentaire montre que vous ne semblez pas comprendre le fonctionnement des apis que utilisez ce qui est extrêmement inquiétant si vous êtes un professionnel.

  14. #74
    Membre confirmé
    Inscrit en
    juin 2010
    Messages
    609
    Détails du profil
    Informations forums :
    Inscription : juin 2010
    Messages : 609
    Points : 622
    Points
    622
    Par défaut
    Citation Envoyé par FatAgnus Voir le message
    Microsoft ne veut pas pas d'une implémentation multiplate-formes de Windows Forms ou WPF, c'est eux même qui l'écrivent sur la page Contributing Guide : « Nous n'avons pas non plus l'intention d'accepter des contributions qui fournissent des implémentations multiplate-formes pour Windows Forms ou WPF. ».
    Ils ont parfaitement raison ce sont deux technos liés à Windows il ne peut y avoir de version portable. Il ne peut y avoir que du code qui n'a strictement aucun rapport et qui propose des apis ressemblantes.

  15. #75
    Membre expérimenté Avatar de dfiad77pro
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    décembre 2008
    Messages
    462
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : FrancesƆ

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2008
    Messages : 462
    Points : 1 350
    Points
    1 350
    Par défaut
    Et à l'heure du tout web pour la portabilité,
    je doute que Microsoft investisse dans la création d'un Framework multi-plateforme…

    Ils auraient du le faire il y'a 10 ans, maintenant c'est trop tard.

  16. #76
    Expert confirmé
    Homme Profil pro
    Développeur .NET
    Inscrit en
    novembre 2009
    Messages
    1 640
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : novembre 2009
    Messages : 1 640
    Points : 4 109
    Points
    4 109
    Par défaut
    Citation Envoyé par dfiad77pro Voir le message
    je doute que Microsoft investisse dans la création d'un Framework multi-plateforme…
    En fait si, il y a Xamarin pour du multi-plateforme utile : le mobile.
    Les IHM sur du linux desktop ca touche tellement peu de cas que c'est s'attirer beaucoup d’emmerde pour pas grand chose.

  17. #77
    Membre du Club
    Profil pro
    Inscrit en
    octobre 2003
    Messages
    26
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : octobre 2003
    Messages : 26
    Points : 42
    Points
    42
    Par défaut
    Xamarin.Forms est multiplateforme : Windows UWP, IOS, Android mais aussi (en preview pour le moment) Linux (GTK), MacOs et Windows desktop (WPF) :
    https://docs.microsoft.com/en-us/xam...latform/other/
    It's time to kickass nvidia and chew 3dfx/ati bubblegum !

  18. #78
    Expert éminent
    Avatar de StringBuilder
    Homme Profil pro
    Chef de projets
    Inscrit en
    février 2010
    Messages
    3 695
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Chef de projets
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : février 2010
    Messages : 3 695
    Points : 6 328
    Points
    6 328
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par micka132 Voir le message
    Les IHM sur du linux desktop ca touche tellement peu de cas que c'est s'attirer beaucoup d’emmerde pour pas grand chose.
    Oui et non.

    En portant son SGBD SQL Server sous Linux, ainsi que son framework de développement .NET sous Linux, Microsoft s'ouvre clairement la voie vers ce système.
    A ça, on combine le sous-système Linux pour Windows, et on en arrive à se demander quand des outils tels que Microsoft Office, qui sont déjà portés sous Mac OS... qui n'est qu'un Linux après-tout, seront enfin portés sous Linux.

    Si je ne m'abuse, Visual Studio Code tourne sous Linux... pour quelle sombre raison SQL Server Management Studio, actuellement développé en .NET, ne serait pas porté sous Linux lui aussi ? C'est juste logique d'offrir un environnement complet de développement et d'administration SQL sous Linux.

    Bref, si Microsoft ne se lance pas ouvertement dans le développement de logiciels grand public sous Linux, le simple fait d'avoir mis de côté le projet Mono au profit de .NET Core montre que Microsoft se recentre clairement sur Linux, et que l'objectif est bel et bien de ne pas seulement faire tourner ses langages sous Linux, mais bien de s'approprier Linux et devenir une plateforme de choix, y compris pour des projets 100% Linux. A partir de là, que ce soit Windows.Forms, WPF, UWP ou n'importe quoi de nouveau, Microsoft finira bien par se lancer dans les IHM multiplateforme.

    Le simple fait que Microsoft développe en masse pour Android (qui, rappelons le, est basé sur Linux) montre bien cette volonté de ne plus devenir un choix des "windowsiens qui essaient de faire marcher leurs trucs ailleurs que sous Windows", mais bien une alternative réelle à Java... qui dispose d'IHM sur toutes les plateformes depuis toujours.
    Actuellement, l'absence d'IHM portable est la seule réelle tare que traîne .NET face à Java.
    On ne jouit bien que de ce qu’on partage.

  19. #79
    Membre confirmé Avatar de rt15
    Homme Profil pro
    Développeur informatique
    Inscrit en
    octobre 2005
    Messages
    242
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : octobre 2005
    Messages : 242
    Points : 606
    Points
    606
    Par défaut
    Bof. Désolé, je partage pas du tout cette analyse.

    Alors déjà Mac OS ce n'est pas un Linux c'est un UNIX.
    Donc en gros le point commun entre Linux et Mac ça devrait être quasiment que les appels systèmes tels que open/write/fork/mmap...
    Ce qu'on peut faire avec ces fonctions reste très limité : on ne peut pas faire d'interface graphique par exemple.
    Sous Mac OS, Microsoft Office s'appuie sur Cocoa pour l'interface graphique. Supporter Linux impliquerai un portage vers GTK, QT ou encore wxWidgets. Ça serait assez lourd.

    Visual Studio Code est en TypeScript et s'appuie sur Electron. C'est portable par essence. Technologiquement SQL Server Management Studio en .NET n'a rien à voir.

    Mettre de côté Mono c'est pas vraiment se recentrer sur Linux car Mono tentait justement entre autre de rendre disponible les WinForms et WPF sous Linux.
    À l'inverse .NET Core n'a pas du tout cet objectif, en tout cas pas pour le moment.

    Microsoft développe en masse pour Android ? Je suis pas au courant. Avec quels technos ?
    En tout cas je pense pas que Xamarin va écraser ses nombreux concurrents dans le domaine des applis mobiles portables : Flutter, react native et leurs ennemis.
    Sans compter que les applis natives sur mobile, ça reste quand même le must pour avoir de la qualité et des perfs.
    Accessoirement il me semble que le Java est complètement has been sur mobile (bouffé par javascript, Dart, Kotlin...) et de toute façon pour les interfaces graphiques, les librairies historiques portables Swing et JavaFX sont pas utilisées sur mobile.

    Les applications desktop ça devient de plus en plus has been aussi, tout se fait de plus en plus dans le navigateur.
    Par exemple pour Office, plutôt qu'un portage Linux, M$ a fait un portage (partiel) sur le web en proposant "Office Online"/"Office Web Apps"/"Office for the web"/"Office in a browser".

    Le combat Java vs C# (pas seulement niveau appli desktop où ils n'ont jamais vraiment percé) va pas perdurer bien longtemps s'ils se font complètement démonter par pléthore de nouvelles technos (node.js...) et autres langages (Go...) qui sont vachement hypés.

  20. #80
    Membre expérimenté Avatar de dfiad77pro
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    décembre 2008
    Messages
    462
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : FrancesƆ

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2008
    Messages : 462
    Points : 1 350
    Points
    1 350
    Par défaut
    pour les databases Microsoft à un logiciel electron basé sur vscode (mais vraiment différent), ça ne remplace pas le management studio mais c'est un bon début.
    https://github.com/microsoft/azuredatastudio

Discussions similaires

  1. Réponses: 0
    Dernier message: 23/08/2017, 02h14
  2. Réponses: 1
    Dernier message: 12/05/2017, 17h04
  3. Réponses: 1
    Dernier message: 05/09/2016, 01h52
  4. Réponses: 1
    Dernier message: 10/05/2016, 09h28
  5. Réponses: 9
    Dernier message: 24/03/2011, 15h33

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