Implementación de aplicaciones de .NET Core con Visual Studio

Puede implementar una aplicación de .NET Core como una implementación dependiente de la plataforma, que incluye los archivos binarios de la aplicación pero depende de la presencia de .NET Core en el sistema de destino, o como una implementación independiente, que incluye la aplicación y los archivos binarios de .NET Core. Para obtener información general sobre la implementación de aplicaciones de NET Core, vea Implementación de aplicaciones .NET Core.

En las secciones siguientes se muestra cómo usar Microsoft Visual Studio para crear los siguientes tipos de implementaciones:

• Implementación dependiente de marco de trabajo
• Implementación dependiente de marco de trabajo con dependencias de terceros
• Implementación autocontenida
• Implementación autocontenida con dependencias de terceros

Para obtener información sobre el uso de Visual Studio para desarrollar aplicaciones de .NET Core, vea Dependencias y requisitos de .NET Core .

Implementación dependiente de marco de trabajo

La implementación de una implementación dependiente del marco sin dependencias de terceros implica simplemente la compilación, la prueba y la publicación de la aplicación. Un sencillo ejemplo escrito en C# ilustra el proceso.

1. Crear el proyecto.

   Seleccione Archivo>Nuevo>Proyecto. En el cuadro de diálogo Nuevo proyecto, expanda las categorías de proyecto del lenguaje (C# o Visual Basic) en el panel de tipos de proyecto instalados, elija .NET Core y luego seleccione la plantilla Aplicación de consola (.NET Core) en el panel central. Escriba un nombre de proyecto, como "FDD", en el cuadro de texto Nombre. Seleccione el botón Aceptar.

2. Agregar el código fuente de la aplicación.

   Abra el archivo Program.cs o Program.vb en el editor y reemplace el código generado automáticamente por el siguiente. Pide al usuario que escriba texto y muestra las palabras individuales escritas por el usuario. Se usa la expresión regular \w+ para separar las palabras en el texto de entrada.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Crear una versión de depuración de la aplicación.

   Seleccione Compilar>Compilar solución. También puede compilar y ejecutar la versión de depuración de la aplicación seleccionando Depurar>Iniciar depuración.

4. Implementar la aplicación.

   Después de depurar y probar el programa, cree los archivos que se implementarán con la aplicación. Para publicar desde Visual Studio, siga estos pasos:

   1. Cambie la configuración de la solución de Depurar a Versión en la barra de herramientas para compilar una compilación de versión (en lugar de depuración) de la aplicación.

   2. Haga clic con el botón derecho en el proyecto (no en la solución) en el Explorador de soluciones y seleccione Publicar.

   3. En la pestaña Publicar, seleccione Publicar. Visual Studio escribe los archivos que componen la aplicación en el sistema de archivos local.

   4. La pestaña Publicar muestra ahora un solo perfil, FolderProfile. Los valores de configuración del perfil se muestran en la sección Resumen de la pestaña.

   Los archivos resultantes se colocan en un directorio denominado Publish en Windows y publish en sistemas Unix que está en un subdirectorio del subdirectorio .\bin\release\netcoreapp2.1 del proyecto.

Junto con los archivos de la aplicación, el proceso de publicación emite un archivo de base de datos de programa (.pdb) que contiene información de depuración sobre la aplicación. El archivo es útil principalmente para depurar excepciones. Puede decidir no empaquetarlo con los archivos de la aplicación. Pero se debe guardar en caso de que se quiera depurar la compilación de versión de la aplicación.

Implemente el conjunto completo de archivos de la aplicación del modo que quiera. Por ejemplo, puede empaquetarlos en un archivo ZIP, usar un simple comando copy o implementarlos con el paquete de instalación que prefiera. Una vez instalados, los usuarios pueden ejecutar la aplicación mediante el comando dotnet y proporcionando el nombre de archivo, como dotnet fdd.dll.

Además de los archivos binarios de la aplicación, el instalador también debe empaquetar el instalador de marco compartido o buscarlo como requisito previo como parte de la instalación de la aplicación. La instalación del marco compartido requiere acceso raíz o de administrador dado que implica a toda la máquina.

Implementación dependiente de marco de trabajo con dependencias de terceros

La implementación de una implementación dependiente de la plataforma con una o más dependencias de terceros requiere que todas las dependencias estén disponibles para el proyecto. Se requieren los pasos adicionales siguientes antes de poder compilar la aplicación:

1. Use el Administrador de paquetes NuGet para agregar una referencia a un paquete de NuGet para el proyecto y, si el paquete todavía no está disponible en el sistema, instálelo. Para abrir el administrador de paquetes, seleccione Herramientas>Administrador de paquetes NuGet>Administrar paquetes NuGet para la solución.

2. Confirme que las dependencias de terceros (por ejemplo, Newtonsoft.Json) están instaladas en el sistema y, si no es así, instálelas. La pestaña Instalado enumera los paquetes de NuGet instalados en el sistema. Si Newtonsoft.Json no aparece ahí, seleccione la pestaña Examinar y escriba "Newtonsoft.Json" en el cuadro de búsqueda. Seleccione Newtonsoft.Json y, en el panel derecho, seleccione el proyecto antes de hacer clic en Instalar.

3. Si Newtonsoft.Json ya está instalado en el sistema, agréguelo al proyecto seleccionando el proyecto en el panel derecho de la pestaña Administrar paquetes para la solución.

Una implementación dependiente del marco con dependencias de terceros solo es tan portátil como sus dependencias de terceros. Por ejemplo, si una biblioteca de terceros solo admite macOS, la aplicación no se puede portar a sistemas Windows. Esto ocurre si la dependencia de terceros propiamente dicha depende del código nativo. Un buen ejemplo de esto es el servidor Kestrel, que requiere una dependencia nativa de libuv. Cuando se crea una FDD para una aplicación con esta clase de dependencia de terceros, el resultado publicado contiene una carpeta para cada identificador en tiempo de ejecución (RID) que admita la dependencia nativa (y que exista en su paquete de NuGet).

Implementación independiente sin dependencias de terceros

La implementación de una implementación independiente sin dependencias de terceros implica crear el proyecto, modificar el archivo csproj y compilar, probar y publicar la aplicación. Un sencillo ejemplo escrito en C# ilustra el proceso. Empiece por crear, codificar y probar el proyecto, como haría en el caso de una implementación dependiente del marco de trabajo:

1. Crear el proyecto.

   Seleccione Archivo>Nuevo>Proyecto. En el cuadro de diálogo Nuevo proyecto, expanda las categorías de proyecto del lenguaje (C# o Visual Basic) en el panel de tipos de proyecto instalados, elija .NET Core y luego seleccione la plantilla Aplicación de consola (.NET Core) en el panel central. Escriba un nombre de proyecto, como "SCD", en el cuadro de texto Nombre y pulse el botón Aceptar.

2. Agregar el código fuente de la aplicación.

   Abra el archivo Program.cs o Program.vb en el editor y reemplace el código generado automáticamente por el siguiente. Pide al usuario que escriba texto y muestra las palabras individuales escritas por el usuario. Se usa la expresión regular \w+ para separar las palabras en el texto de entrada.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Determine si quiere usar el modo de globalización invariable.

   Especialmente si la aplicación es para Linux, puede reducir el tamaño total de la implementación si aprovecha las ventajas del modo de globalización invariable. El modo de globalización invariable es útil para aquellas aplicaciones que no son globales y que pueden usar las convenciones de formato, las convenciones de mayúsculas y minúsculas y el criterio de ordenación y la comparación de cadenas de la referencia cultural invariable.

   Para habilitar el modo invariable, haga clic con el botón derecho en el proyecto (no en la solución) en el Explorador de soluciones y seleccione Editar SCD.csproj o Editar SCD.vbproj. Luego agregue las siguientes líneas resaltadas al archivo:

   <Project Sdk="Microsoft.NET.Sdk">
   
     <PropertyGroup>
       <TargetFramework>net6.0</TargetFramework>
       <Nullable>enable</Nullable>
     </PropertyGroup>
   
     <ItemGroup>
       <RuntimeHostConfigurationOption Include="System.Globalization.Invariant" Value="true" />
     </ItemGroup> 
   
   </Project>
   

4. Cree una compilación de depuración de la aplicación.

   Seleccione Compilar>Compilar solución. También puede compilar y ejecutar la versión de depuración de la aplicación seleccionando Depurar>Iniciar depuración. Este paso de depuración permite identificar problemas con la aplicación cuando se ejecuta en la plataforma de host. Pero, aun así, tiene que probarla en cada una de las plataformas de destino.

   Si ha habilitado el modo de globalización invariable, asegúrese especialmente de probar si la ausencia de datos dependientes de la referencia cultural es adecuada para la aplicación.

Una vez que haya terminado de depurar, puede publicar la implementación independiente:

Visual Studio 15.6 y anterior

Después de depurar y probar el programa, cree los archivos que se implementarán con la aplicación para cada una de las plataformas de destino.

Para publicar la aplicación desde Visual Studio, siga estos pasos:

1. Definir las plataformas de destino de la aplicación.

   1. Haga clic con el botón derecho en el proyecto (no en la solución) en el Explorador de soluciones y seleccione Editar SCD.csproj.

   2. Cree una etiqueta <RuntimeIdentifiers> en la sección <PropertyGroup> del archivo csproj que defina las plataformas a las que se destina la aplicación y especifique el identificador en tiempo de ejecución (RID) de cada una. También debe agregar un punto y coma para separar los RID. Para ver una lista de identificadores de tiempo de ejecución, consulte el catálogo de identificadores de tiempo de ejecución.

   Por ejemplo, el ejemplo siguiente indica que la aplicación se ejecuta en sistemas operativos Windows de 64 bits y OS X de 64 bits.

   <PropertyGroup>
      <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
   </PropertyGroup>
   

   El elemento <RuntimeIdentifiers> puede ir en cualquier <PropertyGroup> que tenga en el archivo csproj. Más adelante en esta sección aparece un ejemplo completo del archivo csproj.

2. Publique la aplicación.

   Después de depurar y probar el programa, cree los archivos que se implementarán con la aplicación para cada una de las plataformas de destino.

   Para publicar la aplicación desde Visual Studio, siga estos pasos:

   1. Cambie la configuración de la solución de Depurar a Versión en la barra de herramientas para compilar una compilación de versión (en lugar de depuración) de la aplicación.

   2. Haga clic con el botón derecho en el proyecto (no en la solución) en el Explorador de soluciones y seleccione Publicar.

   3. En la pestaña Publicar, seleccione Publicar. Visual Studio escribe los archivos que componen la aplicación en el sistema de archivos local.

   4. La pestaña Publicar muestra ahora un solo perfil, FolderProfile. Los valores de configuración del perfil se muestran en la sección Resumen de la pestaña. Tiempo de ejecución de destino identifica qué tiempo de ejecución se ha publicado, y Ubicación de destino identifica dónde se escriben los archivos de la implementación independiente.

   5. De forma predeterminada, Visual Studio escribe todos los archivos publicados en un único directorio. Para mayor comodidad, es mejor crear perfiles distintos para cada tiempo de ejecución de destino y colocar los archivos publicados en un directorio específico de la plataforma. Esto implica la creación de un perfil de publicación independiente para cada plataforma de destino. Por tanto, vuelva a compilar la aplicación para cada plataforma siguiendo estos pasos:

      1. Seleccione Crear nuevo perfil en el cuadro de diálogo Publicar.

      2. En el cuadro de diálogo Elegir un destino de publicación, cambie la ubicación Elegir una carpeta a bin\Release\PublishOutput\win-x64. Seleccione Aceptar.

      3. Seleccione el nuevo perfil (FolderProfile1) en la lista de perfiles y asegúrese de que el Tiempo de ejecución de destino es win-x64. Si no lo es, seleccione Configuración. En el cuadro de diálogo Configuración de perfil, cambie Tiempo de ejecución de destino por win-x64 y haga clic en Guardar. En caso contrario, haga clic en Cancelar.

      4. Seleccione Publicar para publicar la aplicación para las plataformas de 64 bits de Windows 10.

      5. Siga los pasos anteriores de nuevo para crear un perfil para la plataforma osx-x64. La Ubicación de destino es bin\Release\PublishOutput\osx-x64 y el Tiempo de ejecución de destino es osx-x64. El nombre que Visual Studio asigna a este perfil es FolderProfile2.

   Cada ubicación de destino contiene el conjunto completo de archivos (los archivos de aplicación y todos los archivos de .NET Core) necesarios para iniciar la aplicación.

Junto con los archivos de la aplicación, el proceso de publicación emite un archivo de base de datos de programa (.pdb) que contiene información de depuración sobre la aplicación. El archivo es útil principalmente para depurar excepciones. Puede decidir no empaquetarlo con los archivos de la aplicación. Pero se debe guardar en caso de que se quiera depurar la compilación de versión de la aplicación.

Implemente los archivos publicados de la forma que quiera. Por ejemplo, puede empaquetarlos en un archivo ZIP, usar un simple comando copy o implementarlos con el paquete de instalación que prefiera.

A continuación se muestra el archivo csproj completo para este proyecto.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
</Project>

Visual Studio 15.7 y posterior

Después de depurar y probar el programa, cree los archivos que se implementarán con la aplicación para cada una de las plataformas de destino. Esto implica la creación de un perfil independiente para cada plataforma de destino.

Haga lo siguiente para cada plataforma que sea destino de la aplicación:

1. Cree un perfil para la plataforma de destino.

   Si este es el primer perfil que ha creado, haga clic con el botón derecho en el proyecto (no en la solución) en el Explorador de soluciones y seleccione Publicar.

   Si ya ha creado un perfil, haga clic con el botón derecho en el proyecto para abrir el cuadro de diálogo Publicar, si aún no está abierto. Luego seleccione Nuevo perfil.

   Se abre el cuadro de diálogo Elegir un destino de publicación.

2. Seleccione la ubicación en la que Visual Studio publica la aplicación.

   Si solo se va a publicar en una plataforma, se puede aceptar el valor predeterminado del cuadro de texto Elegir una carpeta; así, se publica la implementación dependiente del marco de la aplicación en el directorio <directorio-del-proyecto>\bin\Release\netcoreapp2.1\publish.

   Si va a publicar en más de una plataforma, anexe una cadena que identifique a la plataforma de destino. Por ejemplo, si anexa la cadena "linux" a la ruta de acceso de archivo, Visual Studio publica la implementación dependiente del marco de la aplicación en el directorio <directorio-del-proyecto>\bin\Release\netcoreapp2.1\publish\linux.

3. Para crear el perfil, seleccione el icono de lista desplegable situado junto al botón Publicar y luego Crear perfil. Después, seleccione el botón Crear perfil para crear el perfil.

4. Indique que va a publicar una implementación independiente y defina una plataforma como destino de la aplicación.

   1. En el cuadro de diálogo Publicar, seleccione el vínculo Configurar para abrir el cuadro de diálogo Configuración del perfil.

   2. Seleccione Independiente en el cuadro de lista Modo de implementación.

   3. En el cuadro de lista Tiempo de ejecución de destino, seleccione una de las plataformas de destino de la aplicación.

   4. Seleccione Guardar para aceptar los cambios y cerrar el cuadro de diálogo.

5. Asigne un nombre al perfil.

   1. Seleccione Acciones>Cambiar nombre de perfil apara asignar el nombre al perfil.

   2. Asigne al perfil un nombre que identifique a la plataforma de destino y luego seleccione *Guardar.

Repita estos pasos para definir las plataformas de destino adicionales de la aplicación.

Ha configurado los perfiles y ahora está listo para publicar la aplicación. Para hacerlo:

1. Si la ventana Publicar no está abierta, haga clic con el botón derecho en el proyecto (no en la solución) en el Explorador de soluciones y seleccione Publicar.

2. Seleccione el perfil que quiere publicar y luego Publicar. Realice este procedimiento para cada perfil que se vaya a publicar.

Cada ubicación de destino (en el caso de nuestro ejemplo, bin\release\netcoreapp2.1\publish\profile-name) contiene el conjunto completo de archivos (tanto los archivos de aplicación como todos los archivos de .NET Core) necesarios para iniciar la aplicación.

Junto con los archivos de la aplicación, el proceso de publicación emite un archivo de base de datos de programa (.pdb) que contiene información de depuración sobre la aplicación. El archivo es útil principalmente para depurar excepciones. Puede decidir no empaquetarlo con los archivos de la aplicación. Pero se debe guardar en caso de que se quiera depurar la compilación de versión de la aplicación.

Implemente los archivos publicados de la forma que quiera. Por ejemplo, puede empaquetarlos en un archivo ZIP, usar un simple comando copy o implementarlos con el paquete de instalación que prefiera.

A continuación se muestra el archivo csproj completo para este proyecto.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
</Project>

Además, Visual Studio crea un perfil de publicación independiente (*.pubxml) para cada plataforma que elija como destino. Por ejemplo, el archivo para nuestro perfil de Linux (linux.pubxml) aparece así:

<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <PublishProtocol>FileSystem</PublishProtocol>
    <Configuration>Release</Configuration>
    <Platform>Any CPU</Platform>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <PublishDir>bin\Release\netcoreapp2.1\publish\linux</PublishDir>
    <RuntimeIdentifier>win-x86</RuntimeIdentifier>
    <SelfContained>true</SelfContained>
    <_IsPortable>false</_IsPortable>
  </PropertyGroup>
</Project>

Implementación autocontenida con dependencias de terceros

Implementar una implementación independiente con una o varias dependencias de terceros implica agregar las dependencias. Se requieren los pasos adicionales siguientes antes de poder compilar la aplicación:

1. Use el Administrador de paquetes NuGet para agregar una referencia a un paquete de NuGet para el proyecto y, si el paquete todavía no está disponible en el sistema, instálelo. Para abrir el administrador de paquetes, seleccione Herramientas>Administrador de paquetes NuGet>Administrar paquetes NuGet para la solución.

2. Confirme que las dependencias de terceros (por ejemplo, Newtonsoft.Json) están instaladas en el sistema y, si no es así, instálelas. La pestaña Instalado enumera los paquetes de NuGet instalados en el sistema. Si Newtonsoft.Json no aparece ahí, seleccione la pestaña Examinar y escriba "Newtonsoft.Json" en el cuadro de búsqueda. Seleccione Newtonsoft.Json y, en el panel derecho, seleccione el proyecto antes de hacer clic en Instalar.

3. Si Newtonsoft.Json ya está instalado en el sistema, agréguelo al proyecto seleccionando el proyecto en el panel derecho de la pestaña Administrar paquetes para la solución.

A continuación se muestra el archivo csproj completo de este proyecto:

Visual Studio 15.6 y anterior

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

Visual Studio 15.7 y posterior

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

Al implementar la aplicación, los archivos de aplicación también contienen las dependencias de terceros usadas en la aplicación. No se requieren las bibliotecas de terceros en el sistema en el que se ejecuta la aplicación.

Solo puede implementar una implementación autocontenida con una biblioteca de terceros en plataformas compatibles con esa biblioteca. Esto es similar a tener dependencias de terceros con dependencias nativas en la implementación dependiente de la plataforma, donde las dependencias nativas no existirán en la plataforma de destino a menos que se hayan instalado allí previamente.

Vea también

• Implementación de aplicaciones .NET Core
• Catálogo de identificadores de entorno de ejecución (RID) de .NET Core