Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Microsoft annonce la disponibilité de .NET Core 3 Preview 2 et apporte les expressions switch avec C# 8
Ainsi que d'autres améliorations

Le , par Stéphane le calme

204PARTAGES

13  0 
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
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
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
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.



Utf8JsonWriter

Utf8JsonWriter fournit un moyen hautement performant, non mis en cache, d’écrire du texte JSON codé en UTF-8 à partir de types .NET courants tels que String, Int32 et DateTime. Comme le reader, le writer est un type fondamental, de bas niveau, qui peut être utilisé pour créer des sérialiseurs personnalisés. L'écriture d'une charge JSON à l'aide du nouvel utilitaire Utf8JsonWriter est 30 à 80% plus rapide que l'utilisation de l'enregistreur de Json.NET et ne l'alloue pas.

Voici un exemple d'utilisation de Utf8JsonWriter qui peut être utilisé comme point de départ:

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
static int WriteJson(IBufferWriter<byte> output, long[] extraData)
{
    var json = new Utf8JsonWriter(output, state: default);
 
    json.WriteStartObject();
 
    json.WriteNumber("age", 15, escape: false);
    json.WriteString("date", DateTime.Now);
    json.WriteString("first", "John");
    json.WriteString("last", "Smith");
 
    json.WriteStartArray("phoneNumbers", escape: false);
    json.WriteStringValue("425-000-1212", escape: false);
    json.WriteStringValue("425-000-1213");
    json.WriteEndArray();
 
    json.WriteStartObject("address");
    json.WriteString("street", "1 Microsoft Way");
    json.WriteString("city", "Redmond");
    json.WriteNumber("zip", 98052);
    json.WriteEndObject();
 
    json.WriteStartArray("ExtraArray");
    for (var i = 0; i < extraData.Length; i++)
    {
        json.WriteNumberValue(extraData[i]);
    }
    json.WriteEndArray();
 
    json.WriteEndObject();
 
    json.Flush(isFinalBlock: true);
 
    return (int)json.BytesWritten;
}
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
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
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

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de micka132
Expert confirmé https://www.developpez.com
Le 30/09/2019 à 12:27
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.
2  0 
Avatar de freesket
Membre du Club https://www.developpez.com
Le 01/10/2019 à 8:03
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/
2  0 
Avatar de sergio_is_back
Membre émérite https://www.developpez.com
Le 17/10/2019 à 16:57
Citation Envoyé par denisys Voir le message
Etant déçus des résultat de .Net Core 3.0 , je préfère continuer a utiliser mono , pour le portage des applications WinForm , sur linux et mac .
https://www.mono-project.com/
Ce serai bien que tu développe un peu, ça pourrai toujours être intéressant de savoir pourquoi...
2  0 
Avatar de rt15
Membre confirmé https://www.developpez.com
Le 11/02/2019 à 17:40
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.
1  0 
Avatar de FatAgnus
Membre confirmé https://www.developpez.com
Le 26/09/2019 à 21:16
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. ».
2  1 
Avatar de redcurve
Membre confirmé https://www.developpez.com
Le 27/09/2019 à 21:01
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.
2  1 
Avatar de StringBuilder
Expert éminent https://www.developpez.com
Le 01/10/2019 à 21:46
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.
1  0 
Avatar de dfiad77pro
Membre expérimenté https://www.developpez.com
Le 02/10/2019 à 4:29
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
1  0 
Avatar de xarkam
Membre confirmé https://www.developpez.com
Le 03/10/2019 à 20:32
Citation Envoyé par rt15 Voir le message
Bof. Désolé, je partage pas du tout cette analyse.

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.
Dart transpilé en java, Kotlin qui n'est qu'une surcouche pour apporter de la modernité à java.
Malgré que java passe pour un hasbeen sur mobile, sauf cordova, (il me semble que le reste transpile en java ou mettent un interpréteur), java sous android reste le best en terme de perf.

Citation Envoyé par rt15 Voir le message
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".
Mais bien sur. Pour des besoins ultra simple c'est ok, sinon office web ca vaut pas la peine. C'est plus un viewer web qu'autre chose.
Un exemple récent (avant hier), j'ai fait une présentation powerpoint via teams et j'ai eu besoin de faire une modification et ensuite grouper les éléments. Ca n'est pas dispo dans la version web.
Je pourrais dresser une liste assez longue de ce qui n'est pas dans les version web.
Quant à electron, prévoyons des machines dans le future avec 128gb ram vu comment sa prend des ressources.

Citation Envoyé par rt15 Voir le message
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.
Alors, pour ce qui est de la france, en dehors de php et java, nulle espoir. D'ailleurs en france on forme des dev php à tour de bras.
Dans le reste du monde, les dev c# sont hyper courtisés justement depuis le renouvellement de c#
(ma femme et moi sommes des dev c# et nous pourrions changer de boite tout les mois. Ca en devient lassant ces relances pour bosser chez l'un et l'autre)

Pour moi la guerre java vs c# n'existe plus depuis belle lurette. C# apporte plein de modernité dans le langage que n'a pas java.
Pourtant, java rattrape doucement son retard, mais les applications métiers restent encore sur java 8.

Blazor quant à lui apporte une manière de coder à la react. J'ai vu dernièrement une vidéo montrant du débug de code c# directement dans les devtools de edge chromium. Bluffant.
1  0 
Avatar de rt15
Membre confirmé https://www.developpez.com
Le 04/10/2019 à 15:28
Dart peut être transpilé vers javascript ou être exécuté par sa propre VM. Il n'y a pas de lien technique entre Dart et Java.

Kotlin dépend de la JVM, pas du langage Java. Le lien entre Kotlin et Java est techniquement le même qu'entre C# et VB.NET.

Java reste très utilisé et ne va pas disparaître du jour au lendemain. Mais il me semble sur le début de la pente du déclin. Côté mobile il n'est plus poussé par Google. Côté serveur, les grosses boîtes osent démarrer des nouveaux projets en nodejs. Et la politique d'Oracle vis à vis de Java est désespérante, mais c'est un autre sujet.

Pour le best en terme de perf à l'exécution sous Android il faut certainement oublier Java et se tourner vers le NDK.

Office dans le navigateur, c'est bien de la merde, on est d'accord. Je suis obligé d'utiliser de temps en temps Excel dans le navigateur et c'est très pénible car l'édition est très lente .
Mais c'est pas moi qui le pousse. C'est Microsoft :
Office Online is Now Simply Office
Why you should use Office for the web

Sauf grande surprise, Office (sans Wine) sous Linux, c'est pas pour demain.
De toute façon sous Linux les applis Desktop, c'est un peu la merde à développer. Trop de distributions. Une appli GTK dans un environnement de bureau KDE ou une appli QT dans un environnement GNOME, c'est réputé hideux...
Electron idem, ce n'est pas moi qui ait poussé Microsoft à le choisir pour Visual Studio Code.
Le choix d'architecture est très osé de se basé sur Electron donc Chromium, donc du Google, donc du concurrent.
D'un côté cela montre une ouverture de M$, d'un autre côté, ça leur fait un peu perdre en crédibilité de ne pas faire du Dogfooding.
Mais bon au moins ils ont utilisé leur TypeScript.
C'est comme le choix d'utiliser Chromium dans Edge. Économiquement à court terme, c'est efficace. Stratégiquement, sur le long terme, ça me paraît complètement foireux.

Bref, ils auraient pu faire un portage au moins partiel de XAML/WPF sous Linux (en partant de Mono ?) et faire Visual Studio Code en .NET.
Mais ce n'est pas du tout ce qu'ils ont fait.
Quoiqu'il en soit pas mal de développeurs semblent s'être tourné vers Visual Studio Code, le produit est loin d'être un échec niveau adoption.

Pour ce qui est de Blazor, ce sera plus intéressant quand le code que l'on écrit sera compilé directement vers WebAssembly. Parce que là, du code intermédiaire (.NET) exécuté par une runtime en code intermédiaire (wasm), c'est un peu lourd...

En fait peut être que Blazor sera une solution proposé par M$ pour les applis de bureau portables en .NET.
Ce serait bien plus logique que VSCode soit basé sur C#/Blazor et pas sur TypeScript. Mais bien sûr quand ils ont commencé à développer VSCode, WebAssembly n'était pas vraiment une option...

Certains prédisent que WebAssembly va beaucoup diminuer l'utilisation de javascript dans les SPA. J'imagine que oui et que c'est une bonne chose (meilleure perf à l'exécution, possibilité de choisir le langage de développement de son choix compilant vers wasm), mais pour le moment ça patine... Peut être le temps que les outils type Blazor soient bien au point.

D'autres prédisent que WebAssembly sera utilisé pour faire des applications desktop portable (et donc qu'il va tuer au moins Electron, à part si Electron devient l'hôte standard des applis wasm). Là j'en sais trop rien.
1  0