Compartir a través de

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

Puede implementar una aplicación de .NET Core como una implementación dependiente del marco, 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 tanto la aplicación como los archivos binarios de .NET Core. Para obtener información general sobre la implementación de aplicaciones de .NET Core, consulte Implementación de aplicaciones de .NET Core.

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

  • Despliegue dependiente del marco
  • Implementación dependiente del marco con dependencias de terceros
  • Implementación autocontenida
  • Implementación independiente con dependencias de terceros

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

Despliegue dependiente del marco

La implementación de una implementación dependiente del marco sin dependencias de terceros simplemente implica compilar, probar y publicar la aplicación. Un ejemplo sencillo escrito en C# muestra 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 Tipos de proyecto instalados , elija .NET Core y, a continuación, 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 . Selecciona el botón Aceptar.

  2. Agregue 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 código siguiente. Pide al usuario que escriba texto y muestre las palabras individuales escritas por el usuario. Usa la expresión \w+ regular para separar las palabras del 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>solución de compilación. También puede compilar y ejecutar la compilació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, haga lo siguiente:

    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 ahora muestra un único 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 llamado Publish en Windows y publish en Unix que se encuentra en un subdirectorio del .\bin de su proyecto\release\netcoreapp2.1.

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 optar por 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 aplicación de cualquier manera que desee. Por ejemplo, puede empaquetarlos en un archivo Zip, usar un comando simple copy o implementarlos con cualquier paquete de instalación que prefiera. Una vez instalado, los usuarios pueden ejecutar la aplicación mediante el dotnet comando y proporcionar el nombre de archivo de la aplicación, 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 de administrador o raíz, ya que está en toda la máquina.

Implementación dependiente del marco con dependencias de terceros

La implementación de una implementación dependiente del marco con una o varias dependencias de terceros requiere que las dependencias estén disponibles para el proyecto. Se requieren los siguientes pasos adicionales para poder compilar la aplicación:

  1. Use el Administrador de paquetes NuGet para agregar una referencia a un paquete NuGet al proyecto; y si el paquete aún 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 lo son, instálelas. En la pestaña Instalado se enumeran los paquetes 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 seleccionar 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 es portátil para los sistemas Windows. Esto sucede si la propia dependencia de terceros depende del código nativo. Un buen ejemplo de esto es el servidor Kestrel, que requiere una dependencia nativa en libuv. Cuando se crea un FDD para una aplicación con este tipo de dependencia de terceros, la salida publicada contiene una carpeta para cada identificador en tiempo de ejecución (RID) que admite la dependencia nativa (y que existe en su paquete 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 , compilar, probar y publicar la aplicación. Un ejemplo sencillo escrito en C# muestra el proceso. Para empezar, cree, codifique y pruebe el proyecto como lo haría con una implementación dependiente del marco:

  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 Tipos de proyecto instalados , elija .NET Core y, a continuación, 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 seleccione el botón Aceptar .

  2. Agregue 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 código siguiente. Pide al usuario que escriba texto y muestre las palabras individuales escritas por el usuario. Usa la expresión \w+ regular para separar las palabras del 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 desea usar el modo invariable de globalización.

    Especialmente si la aplicación tiene como destino Linux, puede reducir el tamaño total de la implementación aprovechando el modo invariable de globalización. 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. A continuación, 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>solución de compilación. También puede compilar y ejecutar la compilación de depuración de la aplicación seleccionando Depurar>Iniciar depuración. Este paso de depuración le permite identificar problemas con la aplicación cuando se ejecuta en la plataforma host. Pero, aun así, tiene que probarla en cada una de las plataformas de destino.

    Si ha habilitado el modo invariante de globalización, asegúrese especialmente de probar si la ausencia de datos sensibles a la cultura es adecuada para su aplicación.

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

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, haga lo siguiente:

  1. Defina las plataformas a las que se dirige 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 <RuntimeIdentifiers> etiqueta en la <PropertyGroup> sección del archivo csproj que defina las plataformas que tiene como destino la aplicación y especifique el identificador en tiempo de ejecución (RID) de cada plataforma de destino. También debe agregar un punto y coma para separar los RID. Consulte el Catálogo de identificadores de tiempo de ejecución para obtener una lista de identificadores de tiempo de ejecución.

    Por ejemplo, en el ejemplo siguiente se indica que la aplicación se ejecuta en sistemas operativos Windows de 64 bits y en el sistema operativo 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. Aparece un archivo csproj de ejemplo completo más adelante en esta sección.

  2. Publicar 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, haga lo siguiente:

    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 ahora muestra un único 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 escribieron los archivos de la implementación autocontenida.

    5. Visual Studio escribe de forma predeterminada todos los archivos publicados en un único directorio. Para mayor comodidad, es mejor crear perfiles independientes para cada tiempo de ejecución de destino y colocar 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 lo tanto, vuelva a generar la aplicación para cada plataforma haciendo lo siguiente:

      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 opción Elegir una ubicación de carpeta a bin\Release\PublishOutput\win-x64. Selecciona Aceptar.

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

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

      5. Siga los pasos anteriores de nuevo para crear un perfil para la osx-x64 plataforma. La ubicación de destino es bin\Release\PublishOutput\osx-x64 y el runtime 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 (tanto los archivos de la 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 optar por 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 cualquier manera que desee. Por ejemplo, puede empaquetarlos en un archivo Zip, usar un comando simple copy o implementarlos con cualquier 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>

Implementación independiente con dependencias de terceros

Desplegar un sistema autocontenido con una o varias dependencias de terceros implica agregar las dependencias. Se requieren los siguientes pasos adicionales para poder compilar la aplicación:

  1. Use el Administrador de paquetes NuGet para agregar una referencia a un paquete NuGet al proyecto; y si el paquete aún 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 lo son, instálelas. En la pestaña Instalado se enumeran los paquetes 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 seleccionar 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 para 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>

Al implementar la aplicación, las dependencias de terceros que se usan en la aplicación también se incluyen en los archivos de la aplicación. Las bibliotecas de terceros no son necesarias 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 del marco, donde las dependencias nativas no existirán en la plataforma de destino a menos que se instalaran anteriormente allí.

Consulte también