.NET Core

Fin prochaine du support de .NET Core 3.1

Soumis par fredericmazue le

Microsoft a publié le framework .NET Core en version 3.1 en 2019. Cette mouture a bénéficié d'un support à long terme qui arrive à sa fin.

Ainsi, .NET Core 3.1 ne sera plus pris en charge le 13 décembre 2022. Après cette date, Microsoft ne fournira plus de mises à jour de maintenance ni de support technique pour .NET Core 3.1. Microsoft recommande à tous  ceux qui utilisent encore cette version du framewrok de passer à .NET 6 ou .NET 7, tout en précisant qu'après le 13 décembre 2022 les applications qui s'appuient sur .NET Core 3.1 continueront toutefois à fonctionner, mais en devenant vulnérables au fil du temps.

.NET Core Uninstall Tool : un outil pour faire le ménage dans les SDK et runtime .NET Core

Soumis par fredericmazue le

Si à partir de Visual Studio 2019 version 16.3, Visual Studio gère les versions du SDK et du runtime .NET Core qu'il installe, dans les versions précédentes de VS, ceux-ci étaient laissés à niveau au cas où ces versions seraient ciblées. 

De ce fait, votre machine peut être encombrée de nombreux SDK et runtime devenus inutiles pour vous. Pour vous aider à faire le ménage, Microsoft vient d'annoncer la disponibilité de l'outil .NET Core Uninstall Tool

Il s'agit d'un outil puissant et il est facile de se tromper. Mais ne vous inquiétez pas… explique Microsoft, vous pouvez toujours exécuter une réparation sur Visual Studio ou réinstaller à partir de l'archive .NET Core.

Étant donné que cet outil est basé sur des programmes d'installation, il ne fonctionne que sur Windows et Mac et non sur Linux.

.NET Core Uninstall Tool peut être téléchargé ici.

Fin de vie pour .NET Core 3.0

Soumis par fredericmazue le

Microsoft rappelle que la plate-forme .NET Core 3.0 arrivera en fin de vie demain 3 mars 2020.

.NET Core 3.0 est remplacé par .NET Core 3.1 qui est sorti le 3 décembre 2019.

A partir du 3 mars, les correctifs .NET Core ne contiendront plus de package pour .NET Core 3.0. Il est à noter que .NET Core 3.1 est une version LTS, c'est-à-dire avec un support à long terme, en l'occurrence pendant au moins trois ans.

Microsoft recommande très vivement de migrer dès maintenant les applications vers .NET Core 3.1. Une mise à niveau facile dans la plupart des cas, souligne Redmond.

Utiliser WebAssembly depuis le framework .NET Core avec Wamstime

Soumis par fredericmazue le

Récemment, la Bytecode Alliance a ajouté une une API pour .NET Core dans le moteur d'exécution WebAssembly. Cette API est en préversion au moment où nous écrivons ces lignes. Cette API permet aux développeurs de charger et d'exécuter du code WebAssembly par programmation directement à partir de leurs applications .NET.

Pourquoi faire ? A chacun de laisser libre cours à son imagination :-) Mozilla suggère par exemple que c'est un bon moyen d'isoler du code non sûr, WebAssembly se comportant comme un bac-à-sable (sandbox)

Comment procéder ? Un très intéressant billet donne la réponse sous la forme d'un didacticiel.

L'exemple s'intéresse à l'utilisation d’une bibliothèque Rust compilée dans WebAssembly à partir de .NET avec l’API Wasmtime for .NET.

Un didacticiel à lire absolument par tous ceux que le sujet intéresse. Le billet de Mozilla est ici.

Sortie de .NET Core 3.1 avec support LTS

Soumis par fredericmazue le

.NET Core 3.0 est sorti début octobre seulement et déjà Microsoft annonce la disponibilité de .NET Core 3.1.

Il ne s'agit donc pas d'une mouture majeure mais d’un petit ensemble de corrections et d’améliorations par rapport à .NET Core 3.0.

Le plus important, ainsi que le souligne Microsoft, est que .NET Core 3.1 bénéficiera d'un support à long terme (LTS), en l'occurrence un support d'une durée de trois ans. Microsoft indique avoir tiré profit des deux mois passés depuis la publication de .NET Core 3.0 pour sélectionner et mettre en œuvre le bon ensemble d’améliorations aboutissant à la présente version.

ASP.NET Core et EF Core sont également publiés dans la foulée.

En ce qui concerne le cycle de vie de .NET Core, Microsoft fait le rappel suivant :

  • .NET Core 3.0 arrivera en fin de vie dans trois mois, concrètement le 3 mars 2020.
  • .NET Core 2.2 arrivera en fin de vie le 23 décembre 2019.
  • .NET Core 2.1 sera pris en charge jusqu'en août 2021 il s'agit également d'une version LTS).

.NET Core 3.1 peut être téléchargé ici.

Créer des applications cloud modernes à l'aide de Pulumi et de .NET Core

Soumis par fredericmazue le

Pulumi est une infrastructure as code qui aide les développeurs et les équipes d'infrastructure à mieux collaborer pour créer, déployer et gérer des applications cloud dans leurs langages préférées. Dans ce billet, Microsoft annonce le support de .NET Core pour Pulumi.

Grâce à ce support, vous pouvez utiliser vos outils .NET préférés, tels que les éditeurs, les gestionnaires de packages, les systèmes de construction et les infrastructures de test, pour créer, déployer et gérer des infrastructures sur n’importe quel cloud, notamment Azure, AWS et Google Cloud. Ceci avec les langages C #, VB.NET ou F #.

Par exemple, ce code C # crée une base de données Azure CosmosDB avec une FunctionApp Azure AppService sans serveur qui s'adapte automatiquement à la base de données:

using System;
using System.Collections.Generic;
using Pulumi;
using Pulumi.Azure.AppService;
using Pulumi.Azure.Core;
using Pulumi.Azure.CosmosDB;

class Program
{
    static Task<int> Main(string[] args)
    {
        return Deployment.RunAsync(() => {
            var locations = new[] { "WestUS", "WestEurope", "SouthEastAsia" };
            var rg = new ResourceGroup("myapp-rg", new ResourceGroupArgs {
                Location = locations[0],
            });

            var app = new CosmosApp("myapp", new CosmosAppArgs {
                 ResourceGroup = resourceGroup,
                 Locations = locations,
                 DatabaseName = "pricedb",
                 ContainerName = "prices",
                 Factory = (location, db) => {
                     var func = new ArchiveFunctionApp("myapp-func",
                          new ArchiveFunctionAppArgs {
                              Location = location,
                              Archive = new FileArchive("app"),
                              AppSettings = new Dictionary<string, string> {
                                  ["COSMOSDB_ENDPOINT"] = db.Endpoint,
                              },
                          },
                      );
                      return func.App.ID;
                 },
            });
        });
    }

    // Definitions of CosmosApp and ArchiveFunctionApp elided for brevity.
    // Actual runtime application code is stored in the "app" directory.
    // See link to the full example at the end of this article.
}

Après avoir écrit ce code, vous exécutez la CLI de Pulumi avec la commande pulumi up. Celle-ci vous montrera d'abord un aperçu des ressources d'infrastructure qu'il prévoit de créer. Après confirmation, il déploiera l'ensemble de votre application et l'infrastructure requise en quelques minutes seulement.

Par la suite, si vous devez apporter des modifications, il vous suffit de modifier votre programme, de réexécuter la CLI, qui apportera les modifications incrémentielles nécessaires pour mettre à jour votre infrastructure en conséquence. Un historique complet de vos déploiements est enregistré afin que vous puissiez facilement voir quelles modifications ont été apportées.

Site : www.pulumi.com/docs/intro/languages/dotnet/

Microsoft a terminé le portage de l'API .Net Framework vers .NET Core 3.0 qu'elle considère être l'avenir de .NET

Soumis par fredericmazue le

A ses débuts .NET Core comprenait un ensemble minimal de .NET Framework. Après quoi Microsoft s'en attachée à rendre beaucoup plus viable le partage de code entre .NET Framework, .NET Core et Xamarin, ce qui a abouti à la création d'environ 38 000 API .NET Framework pour .NET Core 2.0 et à la création du Windows Compatibility Pack qui a apporté presque 60 000 API supplémentaires. Dans .NET Core 3.0, qui est sorti au début de ce mois, Microsoft a ajouté WPF et WinForms, ce qui a porté le nombre d'API .NET Framework portées à .NET Core à plus de 120 000, soit plus de la moitié de toutes les API .NET Framework.

Parallèlement, Microsoft a ajouté à .NET Core 62 000 API qui n'existent pas dans .NET Framework. En comparant le nombre total des API des deux frameworks, il apparaît que .NET Core possède environ 80% de la surface de l'API de .NET Framework.

Désormais, Microsoft ne prévoit plus de passer des technologies existantes de .NET Framework à .NET Core, considère que son travail de portage est terminé, et que l'avenir de .NET sera basé sur .NET Core.

Microsoft en fait l'annonce dans un billet publié sur GitHub, précisant : Avec .NET Core 3.0, nous avons atteint le stade où nous avons porté toutes les technologies requises pour les charges de travail modernes, qu’elles soient des applications de bureau, des applications mobiles, des applications de console, des sites Web ou des services de cloud. Cela ne veut pas dire que nous n'avons pas de lacunes ni d'opportunités pour les nouvelles technologies, mais nous pensons généralement que nous ne les trouverons plus dans la base de code .NET Framework. À l'avenir, nous concentrons nos ressources sur l'intégration de nouvelles technologies.

Par ailleurs, Microsoft envisage de publier davantage de code .NET Framework sous la licence MIT sur GitHub 

Utiliser la préversion du nouveau concepteur Windows Forms de .NET Core 3.0

Soumis par fredericmazue le
IDE

Avec .NET Core 3.0 qui est sorti récemment, Microsoft a introduit un nouveau concepteur Windows Forms, qui est actuellement à l'état de préversion.

Ce concepteur aura à terme le même aspect que le concepteur de formulaires du framework Windows .NET. Microsoft souligne qu'arriver à cela était un véritable défi technique, qui a nécessité de repenser l'architecture de Visual Studio en ce qui concerne la communication de l'EDI avec ce concepteur.

Ce concepteur étant pour le moment en préversion, il ne fait pas partie de Visual Studio. Mais cela ne signifie par pour autant qu'il n'est pas intéressant de le tester, bien au contraire.

Pour cela vous devez le télécharger sous la forme d'une extension Visual Studio («VSIX»). Ce téléchargement est ici. Une fois que vous avez installé ce concepteur (.NET Core Designer), Visual Studio choisit automatiquement le concepteur approprié (.NET Core ou .NET Framework) en fonction de la structure cible du projet sur lequel vous travaillez. Vous pouvez supprimer le concepteur de Visual Studio à tout moment.

Microsoft souligne que .NET Core Designer ne prend pas encore en charge tous les contrôles que l'on peut trouver dans le concepteur du framework Windows .NET. Pour cette raison, il est déconseillé de tenter de porter des applications Windows Forms vers .NET Core.

.NET Core 1.0 et 1.1 : fin de vie dès le 27 juin

Soumis par francoistonic le

Microsoft vient d’annoncer la fin de vie des versions 1.0 et 1.1 de son .NET Core. Ces versions étaient sorties en 2016. L’éditeur met en avant le support 3 ans d’un programme LTS classique (support long terme). Le 27 juin prochain marquera la fin du support officiel et de l’arrêt des mises à jour et patchs. 

En attendant la v3, toujours en développement, vous devrez migrer sur la la version 2.1 ou 2.2. 

A noter que certaines versions sont dites LTS et d’autres non ! Ainsi .Net Core 2.0 n’est pas LTS et son support a été limité : sortie en août 2017, fin de vie octobre 2018. La v2.1 est LTS mais pas la 2.2 qui aura un support durant 3 mois après la version de la prochaine version. 

Le guide de migration officiel : https://docs.microsoft.com/en-us/dotnet/core/migration/20-21

François Tonic

.NET Core 3 preview 2

Soumis par fredericmazue le

Microsoft a annoncé la disponibilité de la deuxième préversion de .NET Core 3 : .NET Core 3 preview 2.

On y remarque un sucre syntaxique :-)  à l'attention des paresseux (en informatique la paresse est souvent une vertu ;-) Si vous êtes fatigué d'utiliser des instructions qui nécessitent d'indenter votre code, vous pouvez maintenant écrire le code suivant, qui attache une déclaration using à la portée du bloc d'instructions actuel, puis dispose de l'objet à la fin de celui-ci.

static void Main(string[] args)
{
    using var options = Parse(args);

    if (options["verbose"]) { WriteLine("Logging..."); }
} // options disposed here

C#8 enrichit les correspondances de motifs (pattern matching) de C#7 aux motifs récursifs et apporte l'expression switch. Avec elle, switch devient un opérateur infoxe, pour une syntaxe simplifiée et plus claire. Par exemple :

static string Display(object o) => o switch
{
    Point { X: 0, Y: 0 }         => "origin",
    Point { X: var x, Y: var y } => $"({x}, {y})",
    _                            => "unknown"
};

Autre exemple, avec tests de postions des paramètres et déconstructions de tuples :

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")
    };

A remarquer encore, l'outil de flux Utf8JsonWriter qui permet décrire des types .NET dans du texdte JSON encodé en UTF-8. Par exemple :

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

.NET Core 3 preview 2 peut être téléchargé ici. https://dotnet.microsoft.com/download/dotnet-core/3.0