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>net8.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:

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

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

<?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:

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

<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