.NET Core-alkalmazások üzembe helyezése a Visual Studióval

  • Cikk

A .NET Core-alkalmazásokat keretrendszerfüggő üzembe helyezésként is üzembe helyezheti, amely magában foglalja az alkalmazás bináris fájljait, de függ a .NET Core a célrendszeren való jelenlététől, vagy önálló üzembe helyezésként, amely magában foglalja az alkalmazást és a .NET Core bináris fájljait is. A .NET Core-alkalmazások üzembe helyezésének áttekintéséért tekintse meg a .NET Core-alkalmazások üzembe helyezését ismertető témakört.

Az alábbi szakaszok bemutatják, hogyan hozhat létre a Microsoft Visual Studiót a következő típusú üzemelő példányok létrehozásához:

  • Keretrendszerfüggő üzembe helyezés
  • Keretrendszerfüggő üzembe helyezés külső függőségekkel
  • Önálló üzembe helyezés
  • Önálló üzembe helyezés külső függőségekkel

A Visual Studio .NET Core-alkalmazások fejlesztésére való használatával kapcsolatos információkért tekintse meg a .NET Core-függőségeket és -követelményeket.

Keretrendszerfüggő üzembe helyezés

A keretrendszerfüggő üzembe helyezés külső függőségek nélkül történő üzembe helyezése egyszerűen magában foglalja az alkalmazás kiépítését, tesztelését és közzétételét. A folyamatot egy egyszerű, C# nyelven írt példa szemlélteti.

  1. Hozza létre a projektet.

    Válassza a File (Fájl)>New (Új)>Project (Projekt) lehetőséget. Az Új projekt párbeszédpanelen bontsa ki a nyelv (C# vagy Visual Basic) projektkategóriáit a Telepített projekttípusok panelen, válassza a .NET Core lehetőséget, majd válassza a konzolalkalmazás (.NET Core) sablont a középső panelen. A Név szövegmezőbe írjon be egy projektnevet (például "FDD"). Kattintson az OK gombra.

  2. Adja hozzá az alkalmazás forráskódját.

    Nyissa meg a Program.cs vagy Program.vb fájlt a szerkesztőben, és cserélje le az automatikusan létrehozott kódot a következő kódra. Arra kéri a felhasználót, hogy írja be a szöveget, és megjeleníti a felhasználó által beírt egyes szavakat. A reguláris kifejezéssel \w+ választja el a bemeneti szövegben lévő szavakat.

    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. Hozzon létre egy hibakeresési buildet az alkalmazásból.

    Válassza a Build Solution (Buildmegoldás létrehozása)>lehetőséget. Az alkalmazás hibakeresési buildjének fordításához és futtatásához válassza a Hibakeresés>indítása hibakeresés lehetőséget.

  4. Az alkalmazás üzembe helyezése.

    A program hibakeresése és tesztelése után hozza létre az alkalmazással üzembe helyezendő fájlokat. A Visual Studióból való közzétételhez tegye a következőket:

    1. Módosítsa a megoldás konfigurációját hibakeresésről kiadásra az eszköztáron az alkalmazás kiadási (nem hibakeresési) verziójának létrehozásához.

    2. Kattintson a jobb gombbal a projektre (nem a megoldásra) a Megoldáskezelő, és válassza a Közzététel lehetőséget.

    3. A Közzététel lapon válassza a Közzététel lehetőséget. A Visual Studio az alkalmazást alkotó fájlokat a helyi fájlrendszerbe írja.

    4. A Közzététel lapon mostantól egyetlen profil látható, a FolderProfile. A profil konfigurációs beállításai a lap Összegzés szakaszában jelennek meg.

    Az eredményül kapott fájlok egy Windows és publish Unix rendszerű könyvtárba Publish kerülnek, amely a projekt .\bin\release\netcoreapp2.1 alkönyvtárának alkönyvtárában található.

Az alkalmazás fájljai mellett a közzétételi folyamat egy programadatbázist (.pdb) bocsát ki, amely hibakeresési információkat tartalmaz az alkalmazásról. A fájl elsősorban a kivételek hibakereséséhez hasznos. Dönthet úgy, hogy nem csomagolja be az alkalmazás fájljaival. Mentse azonban abban az esetben, ha hibakeresést szeretne végezni az alkalmazás kiadási buildjében.

Helyezze üzembe az alkalmazásfájlok teljes készletét tetszőleges módon. Csomagolhatja őket például zip-fájlba, használhat egy egyszerű copy parancsot, vagy üzembe helyezheti őket bármilyen tetszőleges telepítési csomaggal. A telepítés után a felhasználók végrehajthatják az alkalmazást a dotnet parancs használatával, és megadhatja az alkalmazás fájlnevét, például dotnet fdd.dll.

Az alkalmazás bináris fájljain kívül a telepítőnek csomagolnia kell a megosztott keretrendszer-telepítőt is, vagy az alkalmazástelepítés részeként előfeltételként kell ellenőriznie. A megosztott keretrendszer telepítéséhez Rendszergazda istrator/root hozzáférésre van szükség, mivel gépi szintű.

Keretrendszerfüggő üzembe helyezés külső függőségekkel

A keretrendszerfüggő üzembe helyezés egy vagy több külső függőséggel való üzembe helyezéséhez minden függőségnek elérhetővé kell lennie a projekt számára. Az alkalmazás létrehozásához a következő további lépések szükségesek:

  1. A NuGet Csomagkezelő használatával adjon hozzá egy NuGet-csomagra mutató hivatkozást a projekthez, és ha a csomag még nem érhető el a rendszeren, telepítse. A csomagkezelő megnyitásához válassza a Tools>NuGet Csomagkezelő> Manage NuGet Packages for Solution lehetőséget.

  2. Győződjön meg arról, Newtonsoft.Jsonhogy a külső függőségek (például ) telepítve vannak a rendszeren, és ha nem, telepítse őket. A Telepített lap felsorolja a rendszeren telepített NuGet-csomagokat. Ha Newtonsoft.Json nem szerepel a listában, válassza a Tallózás lapot, és írja be a "Newtonsoft.Json" kifejezést a keresőmezőbe. Válassza kiNewtonsoft.Json, majd a jobb oldali panelen válassza ki a projektet, mielőtt a Telepítés lehetőséget választja.

  3. Ha Newtonsoft.Json már telepítve van a rendszeren, adja hozzá a projekthez a megoldáscsomagok kezelése lap jobb oldali paneljén található projekt kiválasztásával.

A külső függőségekkel rendelkező keretrendszerfüggő üzembe helyezés csak olyan hordozható, mint a külső függőségei. Ha például egy külső kódtár csak a macOS-t támogatja, az alkalmazás nem hordozható Windows-rendszerekre. Ez akkor fordul elő, ha maga a külső függőség a natív kódtól függ. Erre jó példa a Kestrel-kiszolgáló, amely natív függőséget igényel a libuvtól. Ha egy ilyen típusú külső függőséggel rendelkező alkalmazáshoz létrehoz egy FDD-t, a közzétett kimenet minden olyan futtatókörnyezet-azonosítóhoz (RID) tartalmaz egy mappát, amelyet a natív függőség támogat (és amely a NuGet-csomagban létezik).

Önálló üzembe helyezés külső függőségek nélkül

Az önálló, külső függőségek nélküli üzembe helyezés magában foglalja a projekt létrehozását, a csproj-fájl módosítását, az alkalmazás létrehozását, tesztelését és közzétételét. A folyamatot egy egyszerű, C# nyelven írt példa szemlélteti. A projekt létrehozása, kódolása és tesztelése ugyanúgy kezdődik, mint egy keretrendszerfüggő üzembe helyezés:

  1. Hozza létre a projektet.

    Válassza a File (Fájl)>New (Új)>Project (Projekt) lehetőséget. Az Új projekt párbeszédpanelen bontsa ki a nyelv (C# vagy Visual Basic) projektkategóriáit a Telepített projekttípusok panelen, válassza a .NET Core lehetőséget, majd válassza a konzolalkalmazás (.NET Core) sablont a középső panelen. A Név szövegmezőbe írjon be egy projektnevet (például "SCD"), és válassza az OK gombot.

  2. Adja hozzá az alkalmazás forráskódját.

    Nyissa meg a Program.cs vagy Program.vb fájlt a szerkesztőben, és cserélje le az automatikusan létrehozott kódot a következő kódra. Arra kéri a felhasználót, hogy írja be a szöveget, és megjeleníti a felhasználó által beírt egyes szavakat. A reguláris kifejezéssel \w+ választja el a bemeneti szövegben lévő szavakat.

    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. Határozza meg, hogy a globalizáció invariáns módját szeretné-e használni.

    Különösen akkor, ha az alkalmazás Linuxot céloz meg, csökkentheti az üzembe helyezés teljes méretét a globalizáció invariáns módjának kihasználásával. A globalizációs invariáns mód olyan alkalmazások esetében hasznos, amelyek nincsenek globálisan tisztában, és használhatják az invariáns kultúra formázási konvencióit, casing konvencióit, sztringek összehasonlítását és rendezési sorrendjét.

    Az invariáns mód engedélyezéséhez kattintson a jobb gombbal a projektre (nem a megoldásra) a Megoldáskezelő, és válassza az SCD.csproj szerkesztése vagy az SCD.vbproj szerkesztése lehetőséget. Ezután adja hozzá a következő kiemelt sorokat a fájlhoz:

    <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. Hozzon létre egy hibakeresési buildet az alkalmazásból.

    Válassza a Build Solution (Buildmegoldás létrehozása)>lehetőséget. Az alkalmazás hibakeresési buildjének fordításához és futtatásához válassza a Hibakeresés>indítása hibakeresés lehetőséget. Ezzel a hibakeresési lépéssel azonosíthatja az alkalmazással kapcsolatos problémákat, amikor az a gazdaplatformon fut. Továbbra is tesztelnie kell az egyes célplatformokon.

    Ha engedélyezte a globalizációs invariáns módot, különösen ügyeljen arra, hogy tesztelje, hogy a kulturális szempontból érzékeny adatok hiánya alkalmas-e az alkalmazás számára.

Miután végzett a hibakereséssel, közzéteheti a saját telepítést:

A program hibakeresése és tesztelése után hozza létre az alkalmazással üzembe helyezendő fájlokat minden olyan platformhoz, amelyet megcélzott.

Az alkalmazás Visual Studióban való közzétételéhez tegye a következőket:

  1. Határozza meg az alkalmazás által megcélzott platformokat.

    1. Kattintson a jobb gombbal a projektre (nem a megoldásra) a Megoldáskezelő, és válassza az SCD.csproj szerkesztése lehetőséget.

    2. Hozzon létre egy címkét <RuntimeIdentifiers> a <PropertyGroup> csproj-fájl azon szakaszában, amely meghatározza az alkalmazás által célként megadott platformokat, és adja meg az egyes megcélzott platformok futtatókörnyezet-azonosítóját (RID). Pontosvesszőt is hozzá kell adnia a RID-k elválasztásához. A futtatókörnyezet-azonosítók listáját a futtatókörnyezet-azonosítókat tartalmazó katalógusban találja.

    Az alábbi példa például azt jelzi, hogy az alkalmazás 64 bites Windows operációs rendszereken és a 64 bites OS X operációs rendszeren fut.

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

    Az <RuntimeIdentifiers> elem a csproj-fájlban található bármely <PropertyGroup> elembe bekerülhet. Ebben a szakaszban egy teljes csproj-mintafájl jelenik meg.

  2. Az alkalmazás közzététele.

    A program hibakeresése és tesztelése után hozza létre az alkalmazással üzembe helyezendő fájlokat minden olyan platformhoz, amelyet megcélzott.

    Az alkalmazás Visual Studióban való közzétételéhez tegye a következőket:

    1. Módosítsa a megoldás konfigurációját hibakeresésről kiadásra az eszköztáron az alkalmazás kiadási (nem hibakeresési) verziójának létrehozásához.

    2. Kattintson a jobb gombbal a projektre (nem a megoldásra) a Megoldáskezelő, és válassza a Közzététel lehetőséget.

    3. A Közzététel lapon válassza a Közzététel lehetőséget. A Visual Studio az alkalmazást alkotó fájlokat a helyi fájlrendszerbe írja.

    4. A Közzététel lapon mostantól egyetlen profil látható, a FolderProfile. A profil konfigurációs beállításai a lap Összegzés szakaszában jelennek meg. A cél futtatókörnyezet azonosítja, hogy melyik futtatókörnyezet lett közzétéve, a célhely pedig azt határozza meg, hogy hol írták a saját telepítés fájljait.

    5. A Visual Studio alapértelmezés szerint egyetlen könyvtárba írja az összes közzétett fájlt. A kényelem érdekében érdemes külön profilokat létrehozni minden cél futtatókörnyezethez, és a közzétett fájlokat egy platformspecifikus könyvtárban elhelyezni. Ez magában foglalja egy külön közzétételi profil létrehozását minden célplatformhoz. Így most újraépítheti az alkalmazást az egyes platformokhoz az alábbiak végrehajtásával:

      1. Válassza az Új profil létrehozása lehetőséget a Közzététel párbeszédpanelen.

      2. A Közzétételi cél kiválasztása párbeszédpanelen módosítsa a Mappa kiválasztása helyet bin\Release\PublishOutput\win-x64 értékre. Kattintson az OK gombra.

      3. Válassza ki az új profilt (FolderProfile1) a profilok listájában, és győződjön meg arról, hogy a cél futtatókörnyezet is.win-x64 Ha nem, válassza a Gépház. A Profil Gépház párbeszédpanelen módosítsa a cél futtatókörnyezetet a Mentés gombra win-x64. Ellenkező esetben válassza a Mégse lehetőséget.

      4. Válassza a Közzététel lehetőséget az alkalmazás 64 bites Windows 10-platformokon való közzétételéhez.

      5. Az előző lépéseket követve hozzon létre profilt a osx-x64 platformhoz. A célhely a bin\Release\PublishOutput\osx-x64, a cél futtatókörnyezet pedig a osx-x64. A Visual Studio által ehhez a profilhoz hozzárendelt név a FolderProfile2.

    Minden célhely tartalmazza az alkalmazás elindításához szükséges teljes fájlkészletet (mind az alkalmazásfájlokat, mind az összes .NET Core-fájlt).

Az alkalmazás fájljai mellett a közzétételi folyamat egy programadatbázist (.pdb) bocsát ki, amely hibakeresési információkat tartalmaz az alkalmazásról. A fájl elsősorban a kivételek hibakereséséhez hasznos. Dönthet úgy, hogy nem csomagolja be az alkalmazás fájljaival. Mentse azonban abban az esetben, ha hibakeresést szeretne végezni az alkalmazás kiadási buildjében.

A közzétett fájlokat tetszés szerint helyezheti üzembe. Csomagolhatja őket például zip-fájlba, használhat egy egyszerű copy parancsot, vagy üzembe helyezheti őket bármilyen tetszőleges telepítési csomaggal.

Az alábbiakban a projekt teljes csproj-fájlja található.

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

Önálló üzembe helyezés külső függőségekkel

Egy önálló üzembe helyezés üzembe helyezése egy vagy több külső függőséggel magában foglalja a függőségek hozzáadását. Az alkalmazás létrehozásához a következő további lépések szükségesek:

  1. A NuGet Csomagkezelő használatával adjon hozzá egy NuGet-csomagra mutató hivatkozást a projekthez, és ha a csomag még nem érhető el a rendszeren, telepítse. A csomagkezelő megnyitásához válassza a Tools>NuGet Csomagkezelő> Manage NuGet Packages for Solution lehetőséget.

  2. Győződjön meg arról, Newtonsoft.Jsonhogy a külső függőségek (például ) telepítve vannak a rendszeren, és ha nem, telepítse őket. A Telepített lap felsorolja a rendszeren telepített NuGet-csomagokat. Ha Newtonsoft.Json nem szerepel a listában, válassza a Tallózás lapot, és írja be a "Newtonsoft.Json" kifejezést a keresőmezőbe. Válassza kiNewtonsoft.Json, majd a jobb oldali panelen válassza ki a projektet, mielőtt a Telepítés lehetőséget választja.

  3. Ha Newtonsoft.Json már telepítve van a rendszeren, adja hozzá a projekthez a megoldáscsomagok kezelése lap jobb oldali paneljén található projekt kiválasztásával.

A projekt teljes csproj-fájlja a következő:

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

Az alkalmazás üzembe helyezésekor az alkalmazásban használt külső függőségeket az alkalmazásfájljai is tartalmazzák. A külső kódtárak nem szükségesek azon a rendszeren, amelyen az alkalmazás fut.

Csak az adott tár által támogatott platformokon helyezhet üzembe önálló üzembe helyezést külső tárral. Ez hasonló ahhoz, hogy a keretrendszer-függő üzemelő példányban a külső függőségek natív függőségekkel rendelkeznek, ahol a natív függőségek csak akkor léteznek a célplatformon, ha korábban ott voltak telepítve.

Lásd még