Passei pela documentação de configuração no núcleo do ASP.NET. A documentação diz que você pode acessar a configuração de qualquer lugar do aplicativo.
Abaixo está Startup.cs criado pelo modelo
public class Startup
{
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
if (env.IsEnvironment("Development"))
{
// This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
builder.AddApplicationInsightsSettings(developerMode: true);
}
builder.AddEnvironmentVariables();
Configuration = builder.Build();
}
public IConfigurationRoot Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddApplicationInsightsTelemetry(Configuration);
services.AddMvc();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseApplicationInsightsRequestTelemetry();
app.UseApplicationInsightsExceptionTelemetry();
app.UseMvc();
}
}
Portanto Startup.cs
, ao definir todas as configurações, o Startup.cs também possui uma propriedade chamadaConfiguration
O que não consigo entender como você acessa essa configuração no controlador ou em qualquer lugar do aplicativo? A Microsoft está recomendando o uso de padrão de opções, mas eu tenho apenas 4-5 pares de valores-chave, portanto, gostaria de não usar o padrão de opções. Eu só queria ter acesso à configuração no aplicativo. Como injeto em qualquer classe?
Respostas:
Atualizar
O uso do ASP.NET Core 2.0 adicionará automaticamente a
IConfiguration
instância do seu aplicativo no contêiner de injeção de dependência. Isso também funciona em conjunto comConfigureAppConfiguration
oWebHostBuilder
.Por exemplo:
É tão fácil quanto adicionar a
IConfiguration
instância à coleção de serviços como um objeto singleton emConfigureServices
:Onde
Configuration
está a instância na suaStartup
classe.Isso permite que você injete
IConfiguration
qualquer controlador ou serviço:fonte
IConfiguration
assim é muito gotejante. Muito melhor usar o padrão Opções .No .NET Core, você pode injetar o
IConfiguration
parâmetro como no construtor Class, e ele estará disponível.Agora, quando você deseja criar uma instância de sua classe, uma vez que sua classe é injetada
IConfiguration
, você não poderá fazer issonew MyClass()
, porque ela precisa de umIConfiguration
parâmetro injetado no construtor; portanto, será necessário injetar sua classe como bem à cadeia de injeção, o que significa duas etapas simples:1) Adicionar sua classe / es - onde você deseja usar o
IConfiguration
, aoIServiceCollection
noConfigureServices()
métodoStartup.cs
2) Defina uma instância - digamos no
Controller
, e injete-a usando o construtor:Agora você deve poder desfrutar
_myClass.configuration
livremente ...Se você ainda estiver procurando uma maneira de disponibilizá-lo sem precisar injetar as classes no controlador, poderá armazená-lo em um
static class
, que você configurará noStartup.cs
, algo como:E seu
Startup
construtor deve ficar assim:Em seguida, use
MyAppData.Configuration
em qualquer lugar do seu programa.Não me pergunte por que a primeira opção é o caminho certo, posso ver desenvolvedores experientes sempre evitarem dados de lixo ao longo do caminho e é bem compreendido que não é a melhor prática ter muitos dados disponíveis na memória o tempo todo, nem é bom para desempenho e nem para desenvolvimento, e talvez também seja mais seguro ter apenas com você o que você precisa.
fonte
System.Configuration
CORE de volta aos trilhos. Agora, você pode acessar seu bom e velho app.configs, como nos bons e velhos tempos. E eu não estou falando de controladores aqui. Estamos falando de componentes que têm suas próprias configuraçõesEu sei que isso é antigo, mas, devido aos padrões de IOptions, é relativamente simples de implementar:
Classe com propriedades públicas de obtenção / configuração que correspondem às configurações na configuração
registre suas configurações
injetar via IOptions
Não sei por que você não faria isso.
fonte
Microsoft.Extensions.Configuration
,Microsoft.Extensions.Configuration.Binder
eMicrosoft.Extensions.Configuration.Json
em seguida, você carregarappsettings.json
arquivos comovar config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
..e também você tem que certificar-se deappsettings.json
cópia ao diretório de saída está definido paracopy always
Há também uma opção para tornar
configuration
estática no startup.cs, para que você possa acessá-lo em qualquer lugar com facilidade, variáveis estáticas sejam convenientes, hein!Isso torna a configuração acessível em qualquer lugar usando
Startup.Configuration.GetSection...
O que pode dar errado?fonte
Estou fazendo assim no momento:
E então eu uso isso onde preciso obter os dados do arquivo appsettings.json:
fonte
Eu olhei para o exemplo de padrão de opções e vi o seguinte:
Ao adicionar Iconfiguration no construtor da minha classe, eu poderia acessar as opções de configuração através do DI.
Exemplo:
fonte
Eu sei que pode haver várias maneiras de fazer isso, estou usando o Core 3.1 e estava procurando a opção ideal / limpa e acabei fazendo o seguinte:
fonte
Em 8-2017, a Microsoft lançou o
System.Configuration
.NET CORE v4.4. Atualmente visualização v4.5 e v4.6.Para aqueles de nós que trabalham na transformação do .Net Framework para o CORE, isso é essencial. Permite manter e usar
app.config
arquivos atuais , que podem ser acessados a partir de qualquer montagem. Provavelmente é até uma alternativaappsettings.json
, já que a Microsoft percebeu a necessidade. Funciona da mesma forma que antes no FW. Há uma diferença:Nos aplicativos da web, [por exemplo, API do ASP.NET CORE WEB], é necessário usar
app.config
e não o web.config para o seuappSettings
ouconfigurationSection
. Pode ser necessário usá-lo,web.config
mas apenas se você estiver implantando seu site via IIS. Você coloca configurações específicas do IIS emweb.config
Eu testei com netstandard20 DLL e Asp.net Core Web Api e está tudo funcionando.
fonte
Usar o padrão Opções no ASP.NET Core é o caminho a seguir. Eu só quero adicionar, se você precisar acessar as opções no seu startup.cs , recomendo fazer o seguinte:
CosmosDbOptions.cs:
Startup.cs:
fonte
Eu tenho que ler os próprios parâmetros na inicialização.
Isso precisa estar lá antes que o WebHost seja iniciado (como eu preciso da URL / IP "to listen" e da porta do arquivo de parâmetro e aplique-o ao WebHost). Além disso, preciso das configurações públicas em todo o aplicativo.
Depois de pesquisar por um tempo (nenhum exemplo completo encontrado, apenas trechos) e depois de várias tentativas e erros, decidi fazê-lo da “maneira antiga” com um arquivo .ini.
Então, se você quiser usar o seu próprio arquivo .ini e / ou defina o "para escutar URL / IP" seu e / ou precise das configurações públicas, isto é para você ...
Exemplo completo, válido para o núcleo 2.1 (mvc):
Crie um arquivo .ini - exemplo:
em que o Dummyx é incluído apenas como exemplo para outros tipos de datas que não a string (e também para testar o caso "parâmetro errado" (consulte o código abaixo).
Adicionado um arquivo de código na raiz do projeto, para armazenar as variáveis globais:
O código foi alterado em program.cs (antes de CreateWebHostBuilder ()):
Deste jeito:
Se - por exemplo - um tipo errado estiver definido (por exemplo, * Dummy1 = gew7623 estiver ativado em vez de Dummy1 = true), o host mostrará vermelho as informações estão no console (incluindo a exceção) e posso reagir também no aplicativo (GV.bFehler_Ini está definido como true, se houver erros com o .ini)
fonte