Ospitare ASP.NET Core in un servizio WindowsHost ASP.NET Core in a Windows Service

Di Luke Latham e Tom DykstraBy Luke Latham and Tom Dykstra

È possibile ospitare un'app ASP.NET Core in Windows come servizio Windows senza usare IIS.An ASP.NET Core app can be hosted on Windows as a Windows Service without using IIS. Quando è ospitata come servizio di Windows, l'app viene avviata automaticamente dopo il riavvio del server.When hosted as a Windows Service, the app automatically starts after server reboots.

Visualizzare o scaricare il codice di esempio (procedura per il download)View or download sample code (how to download)

PrerequisitiPrerequisites

Modello di servizio di ruolo di lavoroWorker Service template

Il modello di servizio di ruolo di lavoro di ASP.NET Core rappresenta un punto di partenza per la scrittura di app di servizi a esecuzione prolungata.The ASP.NET Core Worker Service template provides a starting point for writing long running service apps. Per usare il modello come base per un'app di servizio Windows:To use the template as a basis for a Windows Service app:

  1. Creare un'app di servizio di ruolo di lavoro dal modello .NET Core.Create a Worker Service app from the .NET Core template.
  2. Seguire le indicazioni nella sezione Configurazione dell'app per aggiornare l'app di servizio di ruolo di lavoro affinché venga eseguita come servizio Windows.Follow the guidance in the App configuration section to update the Worker Service app so that it can run as a Windows Service.
  1. Creare un nuovo progetto.Create a new project.
  2. Selezionare Applicazione Web ASP.NET Core.Select ASP.NET Core Web Application. Scegliere Avanti.Select Next.
  3. Specificare il nome di un progetto nel campo Nome progetto oppure accettare il nome predefinito.Provide a project name in the Project name field or accept the default project name. Scegliere Crea.Select Create.
  4. Nella finestra di dialogo Crea una nuova applicazione Web ASP.NET Core verificare che siano selezionati .NET Core e ASP.NET Core 3.0.In the Create a new ASP.NET Core Web Application dialog, confirm that .NET Core and ASP.NET Core 3.0 are selected.
  5. Selezionare il modello del Servizio di ruolo di lavoro.Select the Worker Service template. Scegliere Crea.Select Create.

Configurazione dell'appApp configuration

IHostBuilder.UseWindowsService, fornito dal pacchetto Microsoft.Extensions.Hosting.WindowsServices, viene chiamato durante la creazione dell'host.IHostBuilder.UseWindowsService, provided by the Microsoft.Extensions.Hosting.WindowsServices package, is called when building the host. Se l'app è in esecuzione come servizio di Windows, il metodo:If the app is running as a Windows Service, the method:

  • Imposta la durata dell'host su WindowsServiceLifetime.Sets the host lifetime to WindowsServiceLifetime.
  • Imposta la radice del contenuto.Sets the content root.
  • Abilita la registrazione nel log eventi con il nome dell'applicazione come nome di origine predefinito.Enables logging to the event log with the application name as the default source name.
    • Il livello di registrazione può essere configurato con la chiave Logging:LogLevel:Default nel file appsettings.Production.json.The log level can be configured using the Logging:LogLevel:Default key in the appsettings.Production.json file.
    • Solo gli amministratori possono creare nuove origini eventi.Only administrators can create new event sources. Quando non è possibile creare un'origine evento usando il nome dell'applicazione, viene registrato un avviso nell'origine Applicazione e i log eventi vengono disabilitati.When an event source can't be created using the application name, a warning is logged to the Application source and event logs are disabled.
public class Program
{
    public static async Task Main(string[] args)
    {
        await CreateHostBuilder(args).Build().RunAsync();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseWindowsService()
            .ConfigureAppConfiguration((context, config) =>
            {
                // Configure the app here.
            })
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<ServiceA>();
                services.AddHostedService<ServiceB>();
            })
            // Only required if the service responds to requests.
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

L'app richiede i riferimenti ai pacchetti Microsoft.AspNetCore.Hosting.WindowsServices e Microsoft.Extensions.Logging.EventLog.The app requires package references for Microsoft.AspNetCore.Hosting.WindowsServices and Microsoft.Extensions.Logging.EventLog.

Per eseguire test e debug durante l'esecuzione all'esterno di un servizio, aggiungere il codice per determinare se l'app è in esecuzione come servizio o è un'app console.To test and debug when running outside of a service, add code to determine if the app is running as a service or a console app. Controllare se il debugger è collegato o se è presente un'opzione --console.Inspect if the debugger is attached or a --console switch is present. Se una delle due condizioni è vera (l'app non è eseguita come servizio), chiamare Run.If either condition is true (the app isn't run as a service), call Run. Se le condizioni sono false (l'app è eseguita come servizio):If the conditions are false (the app is run as a service):

Dato che il provider di configurazione della riga di comando richiede coppie nome-valore per gli argomenti della riga di comando, l'opzione --console viene rimossa dagli argomenti prima che CreateDefaultBuilder riceva gli argomenti.Because the Command-line Configuration Provider requires name-value pairs for command-line arguments, the --console switch is removed from the arguments before CreateDefaultBuilder receives the arguments.

Per scrivere nel registro eventi di Windows, aggiungere il provider EventLog a ConfigureLogging.To write to the Windows Event Log, add the EventLog provider to ConfigureLogging. Impostare il livello di registrazione con la chiave Logging:LogLevel:Default nel file appsettings.Production.json.Set the logging level with the Logging:LogLevel:Default key in the appsettings.Production.json file.

Nel seguente esempio dell'app di esempio, viene chiamato RunAsCustomService invece di RunAsService per gestire gli eventi di durata all'interno dell'app.In the following example from the sample app, RunAsCustomService is called instead of RunAsService in order to handle lifetime events within the app. Per altre informazioni, vedere la sezione Gestire gli eventi di avvio e arresto.For more information, see the Handle starting and stopping events section.

public class Program
{
    public static void Main(string[] args)
    {
        var isService = !(Debugger.IsAttached || args.Contains("--console"));
        
        if (isService)
        {
            var pathToExe = Process.GetCurrentProcess().MainModule.FileName;
            var pathToContentRoot = Path.GetDirectoryName(pathToExe);
            Directory.SetCurrentDirectory(pathToContentRoot);
        }

        var builder = CreateWebHostBuilder(
            args.Where(arg => arg != "--console").ToArray());

        var host = builder.Build();

        if (isService)
        {
            // To run the app without the CustomWebHostService change the
            // next line to host.RunAsService();
            host.RunAsCustomService();
        }
        else
        {
            host.Run();
        }
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .ConfigureLogging((hostingContext, logging) =>
            {
                logging.AddEventLog();
            })
            .ConfigureAppConfiguration((context, config) =>
            {
                // Configure the app here.
            })
            .UseStartup<Startup>();
}

Tipo di distribuzioneDeployment type

Per informazioni e consigli sugli scenari di distribuzione, vedere Distribuzione di applicazioni .NET Core.For information and advice on deployment scenarios, see .NET Core application deployment.

Distribuzione dipendente dal frameworkFramework-dependent deployment (FDD)

La distribuzione dipendente dal framework si basa sulla presenza di una versione condivisa a livello di sistema di .NET Core nel sistema di destinazione.Framework-dependent deployment (FDD) relies on the presence of a shared system-wide version of .NET Core on the target system. Quando lo scenario di distribuzione dipendente dal framework viene implementato in base alle indicazioni di questo articolo, l'SDK genera un file eseguibile (con estensione exe) detto eseguibile dipendente dal framework.When the FDD scenario is adopted following the guidance in this article, the SDK produces an executable (.exe), called a framework-dependent executable.

Aggiungere gli elementi di proprietà seguenti al file di progetto:Add the following property elements to the project file:

  • <OutputType> – Tipo di output dell'app (Exe per eseguibile).<OutputType> – The app's output type (Exe for executable).
  • <LangVersion> – Versione del linguaggio C# (latest o preview).<LangVersion> – The C# language version (latest or preview).

Un file web.config, che viene normalmente generato quando si pubblica un'app ASP.NET Core, non è necessario per un'app di servizi Windows.A web.config file, which is normally produced when publishing an ASP.NET Core app, is unnecessary for a Windows Services app. Per disabilitare la creazione del file web.config, aggiungere la proprietà <IsTransformWebConfigDisabled> impostata su true.To disable the creation of the web.config file, add the <IsTransformWebConfigDisabled> property set to true.

<PropertyGroup>
  <TargetFramework>netcoreapp3.0</TargetFramework>
  <OutputType>Exe</OutputType>
  <LangVersion>preview</LangVersion>
  <IsTransformWebConfigDisabled>true</IsTransformWebConfigDisabled>
</PropertyGroup>

L'identificatore di runtime (RID) di Windows (<RuntimeIdentifier>) contiene il framework di destinazione.The Windows Runtime Identifier (RID) (<RuntimeIdentifier>) contains the target framework. Nell'esempio seguente il RID è impostato su win7-x64.In the following example, the RID is set to win7-x64. La proprietà <SelfContained> è impostata su false.The <SelfContained> property is set to false. Queste proprietà indicano all'SDK di generare un file eseguibile (con estensione exe) per Windows e un'app che dipende dal framework .NET Core condiviso.These properties instruct the SDK to generate an executable (.exe) file for Windows and an app that depends on the shared .NET Core framework.

Un file web.config, che viene normalmente generato quando si pubblica un'app ASP.NET Core, non è necessario per un'app di servizi Windows.A web.config file, which is normally produced when publishing an ASP.NET Core app, is unnecessary for a Windows Services app. Per disabilitare la creazione del file web.config, aggiungere la proprietà <IsTransformWebConfigDisabled> impostata su true.To disable the creation of the web.config file, add the <IsTransformWebConfigDisabled> property set to true.

<PropertyGroup>
  <TargetFramework>netcoreapp2.2</TargetFramework>
  <RuntimeIdentifier>win7-x64</RuntimeIdentifier>
  <SelfContained>false</SelfContained>
  <IsTransformWebConfigDisabled>true</IsTransformWebConfigDisabled>
</PropertyGroup>

L'identificatore di runtime (RID) di Windows (<RuntimeIdentifier>) contiene il framework di destinazione.The Windows Runtime Identifier (RID) (<RuntimeIdentifier>) contains the target framework. Nell'esempio seguente il RID è impostato su win7-x64.In the following example, the RID is set to win7-x64. La proprietà <SelfContained> è impostata su false.The <SelfContained> property is set to false. Queste proprietà indicano all'SDK di generare un file eseguibile (con estensione exe) per Windows e un'app che dipende dal framework .NET Core condiviso.These properties instruct the SDK to generate an executable (.exe) file for Windows and an app that depends on the shared .NET Core framework.

La proprietà <UseAppHost> è impostata su true.The <UseAppHost> property is set to true. Questa proprietà fornisce il servizio con un percorso di attivazione (un file eseguibile, .exe) per una distribuzione dipendente dal framework.This property provides the service with an activation path (an executable, .exe) for an FDD.

Un file web.config, che viene normalmente generato quando si pubblica un'app ASP.NET Core, non è necessario per un'app di servizi Windows.A web.config file, which is normally produced when publishing an ASP.NET Core app, is unnecessary for a Windows Services app. Per disabilitare la creazione del file web.config, aggiungere la proprietà <IsTransformWebConfigDisabled> impostata su true.To disable the creation of the web.config file, add the <IsTransformWebConfigDisabled> property set to true.

<PropertyGroup>
  <TargetFramework>netcoreapp2.1</TargetFramework>
  <RuntimeIdentifier>win7-x64</RuntimeIdentifier>
  <UseAppHost>true</UseAppHost>
  <SelfContained>false</SelfContained>
  <IsTransformWebConfigDisabled>true</IsTransformWebConfigDisabled>
</PropertyGroup>

Distribuzione autonomaSelf-contained deployment (SCD)

Una distribuzione autonoma non si basa sulla presenza di un framework condiviso nel sistema host.Self-contained deployment (SCD) doesn't rely on the presence of a shared framework on the host system. Il runtime e le dipendenze dell'app vengono distribuiti con l'app.The runtime and the app's dependencies are deployed with the app.

Un identificatore di runtime (RID) di Windows viene incluso nel <PropertyGroup> che contiene il framework di destinazione:A Windows Runtime Identifier (RID) is included in the <PropertyGroup> that contains the target framework:

<RuntimeIdentifier>win7-x64</RuntimeIdentifier>

Per eseguire la pubblicazione per più identificatori di runtime:To publish for multiple RIDs:

  • Specificare gli identificatori di runtime in un elenco delimitato da punto e virgola.Provide the RIDs in a semicolon-delimited list.
  • Usare il nome di proprietà <RuntimeIdentifiers> (plurale).Use the property name <RuntimeIdentifiers> (plural).

Per altre informazioni, vedere il Catalogo RID di .NET Core.For more information, see .NET Core RID Catalog.

Una proprietà <SelfContained> è impostata su true:A <SelfContained> property is set to true:

<SelfContained>true</SelfContained>

Account utente del servizioService user account

Per creare un account utente per un servizio, usare il cmdlet New-LocalUser da una shell dei comandi di PowerShell 6 amministrativa.To create a user account for a service, use the New-LocalUser cmdlet from an administrative PowerShell 6 command shell.

In Aggiornamento di Windows 10 (ottobre 2018) (versione 1809/build 10.0.17763) o versioni successive:On Windows 10 October 2018 Update (version 1809/build 10.0.17763) or later:

New-LocalUser -Name {NAME}

In un sistema operativo Windows precedente ad Aggiornamento di Windows 10 (ottobre 2018) (versione 1809/build 10.0.17763):On Windows OS earlier than the Windows 10 October 2018 Update (version 1809/build 10.0.17763):

powershell -Command "New-LocalUser -Name {NAME}"

Fornire una password complessa quando richiesto.Provide a strong password when prompted.

Se non viene specificato il parametro -AccountExpires per il cmdlet New-LocalUser con un valore DateTime di scadenza, l'account non scade.Unless the -AccountExpires parameter is supplied to the New-LocalUser cmdlet with an expiration DateTime, the account doesn't expire.

Per altre informazioni, vedere Microsoft.PowerShell.LocalAccounts e Service User Accounts (Account utente di servizio).For more information, see Microsoft.PowerShell.LocalAccounts and Service User Accounts.

Un approccio alternativo per la gestione degli utenti quando si usa Active Directory consiste nell'usare account del servizio gestito.An alternative approach to managing users when using Active Directory is to use Managed Service Accounts. Per altre informazioni, vedere Panoramica degli account del servizio gestito del gruppo.For more information, see Group Managed Service Accounts Overview.

Diritti Accesso come servizioLog on as a service rights

Per stabilire i diritti Accesso come servizio per un account utente di servizio:To establish Log on as a service rights for a service user account:

  1. Aprire l'editor Criteri di sicurezza locali eseguendo secpol.msc.Open the Local Security Policy editor by running secpol.msc.
  2. Espandere il nodo Criteri locali e selezionare Assegnazione diritti utente.Expand the Local Policies node and select User Rights Assignment.
  3. Aprire il criterio Accesso come servizio.Open the Log on as a service policy.
  4. Selezionare Aggiungi utente o gruppo.Select Add User or Group.
  5. Specificare il nome oggetto (account utente) in uno dei modi seguenti:Provide the object name (user account) using either of the following approaches:
    1. Digitare l'account utente ({DOMAIN OR COMPUTER NAME\USER}) nel campo del nome oggetto e scegliere OK per aggiungere l'utente al criterio.Type the user account ({DOMAIN OR COMPUTER NAME\USER}) in the object name field and select OK to add the user to the policy.
    2. Selezionare Avanzate.Select Advanced. Selezionare Trova.Select Find Now. Selezionare l'account utente dall'elenco.Select the user account from the list. Scegliere OK.Select OK. Scegliere di nuovo OK per aggiungere l'utente al criterio.Select OK again to add the user to the policy.
  6. Scegliere OK o Applica per accettare le modifiche.Select OK or Apply to accept the changes.

Creare e gestire il servizio di WindowsCreate and manage the Windows Service

Creare un servizioCreate a service

Usare i comandi di PowerShell per registrare un servizio.Use PowerShell commands to register a service. Da una shell dei comandi di PowerShell 6 amministrativa eseguire i comandi seguenti:From an administrative PowerShell 6 command shell, execute the following commands:

$acl = Get-Acl "{EXE PATH}"
$aclRuleArgs = {DOMAIN OR COMPUTER NAME\USER}, "Read,Write,ReadAndExecute", "ContainerInherit,ObjectInherit", "None", "Allow"
$accessRule = New-Object System.Security.AccessControl.FileSystemAccessRule($aclRuleArgs)
$acl.SetAccessRule($accessRule)
$acl | Set-Acl "{EXE PATH}"

New-Service -Name {NAME} -BinaryPathName {EXE FILE PATH} -Credential {DOMAIN OR COMPUTER NAME\USER} -Description "{DESCRIPTION}" -DisplayName "{DISPLAY NAME}" -StartupType Automatic
  • {EXE PATH} – Percorso della cartella dell'app nell'host (ad esempio d:\myservice).{EXE PATH} – Path to the app's folder on the host (for example, d:\myservice). Non includere l'eseguibile dell'app nel percorso.Don't include the app's executable in the path. Non è necessario aggiungere una barra finale.A trailing slash isn't required.
  • {DOMAIN OR COMPUTER NAME\USER} – Account utente del servizio (ad esempio Contoso\ServiceUser).{DOMAIN OR COMPUTER NAME\USER} – Service user account (for example, Contoso\ServiceUser).
  • {NAME} – Nome del servizio (ad esempio MyService).{NAME} – Service name (for example, MyService).
  • {EXE FILE PATH} – Percorso dell'eseguibile dell'app (ad esempio d:\myservice\myservice.exe).{EXE FILE PATH} – The app's executable path (for example, d:\myservice\myservice.exe). Includere il nome del file eseguibile con l'estensione.Include the executable's file name with extension.
  • {DESCRIPTION} – Descrizione del servizio (ad esempio My sample service).{DESCRIPTION} – Service description (for example, My sample service).
  • {DISPLAY NAME} – Nome visualizzato del servizio (ad esempio My Service).{DISPLAY NAME} – Service display name (for example, My Service).

Avviare un servizioStart a service

Per avviare un servizio, usare il comando di PowerShell 6 seguente:Start a service with the following PowerShell 6 command:

Start-Service -Name {NAME}

L'avvio del servizio richiede alcuni secondi.The command takes a few seconds to start the service.

Determinare lo stato di un servizioDetermine a service's status

Per verificare lo stato di un servizio, usare il comando di PowerShell 6 seguente:To check the status of a service, use the following PowerShell 6 command:

Get-Service -Name {NAME}

Lo stato viene indicato con uno dei valori seguenti:The status is reported as one of the following values:

  • Starting
  • Running
  • Stopping
  • Stopped

Arrestare un servizioStop a service

Per arrestare un servizio, usare il comando di PowerShell 6 seguente:Stop a service with the following Powershell 6 command:

Stop-Service -Name {NAME}

Rimuovere un servizioRemove a service

Dopo il breve lasso di tempo necessario per arrestare un servizio, rimuovere il servizio con il comando di PowerShell 6 seguente:After a short delay to stop a service, remove a service with the following Powershell 6 command:

Remove-Service -Name {NAME}

Gestire gli eventi di avvio e arrestoHandle starting and stopping events

Per gestire gli eventi OnStarting, OnStarted e OnStopping:To handle OnStarting, OnStarted, and OnStopping events:

  1. Creare una classe che deriva da WebHostService con i metodi OnStarting, OnStarted e OnStopping:Create a class that derives from WebHostService with the OnStarting, OnStarted, and OnStopping methods:

    [DesignerCategory("Code")]
    internal class CustomWebHostService : WebHostService
    {
        private ILogger _logger;
    
        public CustomWebHostService(IWebHost host) : base(host)
        {
            _logger = host.Services
                .GetRequiredService<ILogger<CustomWebHostService>>();
        }
    
        protected override void OnStarting(string[] args)
        {
            _logger.LogInformation("OnStarting method called.");
            base.OnStarting(args);
        }
    
        protected override void OnStarted()
        {
            _logger.LogInformation("OnStarted method called.");
            base.OnStarted();
        }
    
        protected override void OnStopping()
        {
            _logger.LogInformation("OnStopping method called.");
            base.OnStopping();
        }
    }
    
  2. Creare un metodo di estensione per IWebHost che passa CustomWebHostService a Run:Create an extension method for IWebHost that passes the CustomWebHostService to Run:

    public static class WebHostServiceExtensions
    {
        public static void RunAsCustomService(this IWebHost host)
        {
            var webHostService = new CustomWebHostService(host);
            ServiceBase.Run(webHostService);
        }
    }
    
  3. In Program.Main chiamare il metodo di estensione RunAsCustomService invece di RunAsService:In Program.Main, call the RunAsCustomService extension method instead of RunAsService:

    host.RunAsCustomService();
    

    Per visualizzare il percorso di RunAsService in Program.Main, fare riferimento all'esempio di codice illustrato nella sezione Tipo di distribuzione.To see the location of RunAsService in Program.Main, refer to the code sample shown in the Deployment type section.

Scenari con server proxy e servizi di bilanciamento del caricoProxy server and load balancer scenarios

I servizi che interagiscono con le richieste da Internet o da una rete aziendale e si trovano dietro un proxy o un servizio di bilanciamento del carico potrebbero richiedere una configurazione aggiuntiva.Services that interact with requests from the Internet or a corporate network and are behind a proxy or load balancer might require additional configuration. Per altre informazioni, vedere Configurare ASP.NET Core per l'uso di server proxy e servizi di bilanciamento del carico.For more information, see Configurare ASP.NET Core per l'uso di server proxy e servizi di bilanciamento del carico.

Configurare HTTPSConfigure HTTPS

Per configurare un servizio con un endpoint sicuro:To configure a service with a secure endpoint:

  1. Creare un certificato X.509 per il sistema di hosting usando i meccanismi di acquisizione e distribuzione dei certificati della piattaforma.Create an X.509 certificate for the hosting system using your platform's certificate acquisition and deployment mechanisms.

  2. Specificare una configurazione dell'endpoint HTTPS del server Kestrel per usare il certificato.Specify a Kestrel server HTTPS endpoint configuration to use the certificate.

L'uso del certificato di sviluppo ASP.NET Core HTTPS per proteggere un endpoint del servizio non è supportato.Use of the ASP.NET Core HTTPS development certificate to secure a service endpoint isn't supported.

Directory corrente e radice del contenutoCurrent directory and content root

La directory di lavoro corrente restituita chiamando GetCurrentDirectory per un servizio Windows è la cartella C:\WINDOWS\system32.The current working directory returned by calling GetCurrentDirectory for a Windows Service is the C:\WINDOWS\system32 folder. La cartella system32 non è un percorso appropriato per archiviare i file di un servizio, ad esempio i file di impostazioni.The system32 folder isn't a suitable location to store a service's files (for example, settings files). Usare uno degli approcci seguenti per gestire e accedere agli asset e ai file di impostazioni di un servizio.Use one of the following approaches to maintain and access a service's assets and settings files.

Usare ContentRootPath o ContentRootFileProviderUse ContentRootPath or ContentRootFileProvider

Usare IHostEnvironment.ContentRootPath o ContentRootFileProvider per individuare le risorse di un'app.Use IHostEnvironment.ContentRootPath or ContentRootFileProvider to locate an app's resources.

Impostare il percorso radice del contenuto sulla cartella dell'appSet the content root path to the app's folder

ContentRootPath è lo stesso percorso fornito all'argomento binPath durante la creazione di un servizio.The ContentRootPath is the same path provided to the binPath argument when a service is created. Invece di chiamare GetCurrentDirectory per creare i percorsi dei file di impostazioni, chiamare SetCurrentDirectory con il percorso radice del contenuto dell'app.Instead of calling GetCurrentDirectory to create paths to settings files, call SetCurrentDirectory with the path to the app's content root.

In Program.Main, determinare il percorso della cartella dell'eseguibile del servizio e usare il percorso per stabilire la radice del contenuto dell'app:In Program.Main, determine the path to the folder of the service's executable and use the path to establish the app's content root:

var pathToExe = Process.GetCurrentProcess().MainModule.FileName;
var pathToContentRoot = Path.GetDirectoryName(pathToExe);
Directory.SetCurrentDirectory(pathToContentRoot);

CreateWebHostBuilder(args)
    .Build()
    .RunAsService();

Archiviare i file di un servizio in un percorso appropriato nel discoStore a service's files in a suitable location on disk

Specificare un percorso assoluto con SetBasePath quando si usa un IConfigurationBuilder per la cartella contenente i file.Specify an absolute path with SetBasePath when using an IConfigurationBuilder to the folder containing the files.

Risorse aggiuntiveAdditional resources