.NET Core'da bağlantı dizesi nasıl okunur?

Bir yapılandırma dosyasından yalnızca bir bağlantı dizesi okumak ve bunun için projeme "appsettings.json" adında bir dosya eklemek ve bu içeriği ona eklemek istiyorum:

{
"ConnectionStrings": {
  "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=aspnet-

 WebApplica71d622;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
    "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
    "Default": "Debug",
    "System": "Information",
    "Microsoft": "Information"
   }
 }
}

ASP.NET üzerinde şunu kullandım:

 var temp=ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;

Şimdi C # 'da "DefaultConnection" ı nasıl okuyabilirim ve .NET Core'da bir dize değişkeninde saklayabilirim?

Bunu GetConnectionString uzantı yöntemiyle yapabilirsiniz:

string conString = Microsoft
   .Extensions
   .Configuration
   .ConfigurationExtensions
   .GetConnectionString(this.Configuration, "DefaultConnection");

System.Console.WriteLine(conString);

veya DI için yapılandırılmış bir sınıfla:

public class SmtpConfig
{
    public string Server { get; set; }
    public string User { get; set; }
    public string Pass { get; set; }
    public int Port { get; set; }
}

Başlamak:

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)
{
    // http://developer.telerik.com/featured/new-configuration-model-asp-net-core/
    // services.Configure<SmtpConfig>(Configuration.GetSection("Smtp"));
    Microsoft.Extensions.DependencyInjection.OptionsConfigurationServiceCollectionExtensions.Configure<SmtpConfig>(services, Configuration.GetSection("Smtp"));

Ve sonra ev kumandasında:

public class HomeController : Controller
{

    public SmtpConfig SmtpConfig { get; }
    public HomeController(Microsoft.Extensions.Options.IOptions<SmtpConfig> smtpConfig)
    {
        SmtpConfig = smtpConfig.Value;
    } //Action Controller


    public IActionResult Index()
    {
        System.Console.WriteLine(SmtpConfig);
        return View();
    }

bununla appsettings.json içinde:

"ConnectionStrings": {
"DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=aspnet-WebApplica71d622;Trusted_Connection=True;MultipleActiveResultSets=true"
},

"Smtp": {
    "Server": "0.0.0.1",
    "User": "user@company.com",
    "Pass": "123456789",
    "Port": "25"
  }

Gönderilen cevap iyidir, ancak bir bağlantı dizesinde okumakla ilgili sorduğum soruyu doğrudan cevaplamadı. Çok fazla arama yaparak bunu yapmanın biraz daha basit bir yolunu buldum.

Startup.cs içinde

public void ConfigureServices(IServiceCollection services)
{
    ...
    // Add the whole configuration object here.
    services.AddSingleton<IConfiguration>(Configuration);
}

Denetleyicinize yapılandırma için bir alan ve kurucuda bunun için bir parametre ekleyin

private readonly IConfiguration configuration;

public HomeController(IConfiguration config) 
{
    configuration = config;
}

Şimdi daha sonra görünüm kodunuzda aşağıdaki gibi erişebilirsiniz:

connectionString = configuration.GetConnectionString("DefaultConnection");

Daha fazla bilgi için bağlantıya bakın: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-strings

JSON

    {
      "ConnectionStrings": {
        "BloggingDatabase": "Server=(localdb)\\mssqllocaldb;Database=EFGetStarted.ConsoleApp.NewDb;Trusted_Connection=True;"
      },
    }

C # Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<BloggingContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("BloggingDatabase")));
}

DÜZENLEME: aspnetcore, 3.1'den itibaren: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1

Bunu çözmek için bulduğum yol, Başlangıçta bir oluşturucuda AddJsonFile kullanmaktı (bu, appsettings.json dosyasında depolanan yapılandırmayı bulmasına izin verir) ve ardından bunu özel bir _config değişkeni ayarlamak için kullanmaktı.

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)
            .AddEnvironmentVariables();
        _config = builder.Build();
    }

Ve sonra yapılandırma dizesini aşağıdaki gibi ayarlayabilirim:

var connectionString = _config.GetConnectionString("DbContextSettings:ConnectionString"); 

Bu dotnet core 1.1 üzerindedir

ASP.NET Core ( benim durumumda 3.1 ) bize Denetleyicilere Yapıcı enjeksiyonları sağlar , bu nedenle aşağıdaki kurucuyu ekleyebilirsiniz:

[Route("api/[controller]")]
[ApiController]
public class TestController : ControllerBase
{
    private readonly IConfiguration m_config;

    public TestController(IConfiguration config)
    {
        m_config = config;
    }

    [HttpGet]
    public string Get()
    {
        //you can get connection string as follows
        string connectionString = m_config.GetConnectionString("Default")
    }
}

Appsettings.json nasıl görünebilir:

{
    "ConnectionStrings": {
        "Default": "YOUR_CONNECTION_STRING"
        }
}

Başka bir yaklaşım var. Örneğimde, ASP .NET MVC Core 3.1'de bağımlılık enjeksiyonu ile kullandığım depo sınıfında bazı iş mantığı görüyorsunuz.

Ve burada connectiongStringbu iş mantığına ulaşmak istiyorum çünkü muhtemelen başka bir havuzun başka bir veritabanına erişimi olacaktır.

Bu model, aynı iş mantığı havuzunda farklı veritabanlarına erişmenize izin verir.

C #

public interface IStatsRepository
{
            IEnumerable<FederalDistrict> FederalDistricts();
}

class StatsRepository : IStatsRepository
{
   private readonly DbContextOptionsBuilder<EFCoreTestContext>
                optionsBuilder = new DbContextOptionsBuilder<EFCoreTestContext>();
   private readonly IConfigurationRoot configurationRoot;

   public StatsRepository()
   {
       IConfigurationBuilder configurationBuilder = new ConfigurationBuilder().SetBasePath(Environment.CurrentDirectory)
           .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
       configurationRoot = configurationBuilder.Build();
   }

   public IEnumerable<FederalDistrict> FederalDistricts()
   {
        var conn = configurationRoot.GetConnectionString("EFCoreTestContext");
        optionsBuilder.UseSqlServer(conn);

        using (var ctx = new EFCoreTestContext(optionsBuilder.Options))
        { 
            return ctx.FederalDistricts.Include(x => x.FederalSubjects).ToList();
        }
    }
}

appsettings.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "EFCoreTestContext": "Data Source=DESKTOP-GNJKL2V\\MSSQLSERVER2014;Database=Test;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

Hem .net çekirdeği hem de .net çerçevesi ile çalışan bir veri erişim kitaplığım var.

hile, bağlantı dizelerini "app.config" adlı bir xml dosyasında (ayrıca web projeleri için) tutmak ve "çıktı dizinine kopyala" olarak işaretlemek için .net çekirdek projelerindeydi,

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <add name="conn1" connectionString="...." providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>

ConfigurationManager.ConnectionStrings - bağlantı dizesini okur.

    var conn1 = ConfigurationManager.ConnectionStrings["conn1"].ConnectionString;

Yapılandırma uzantısı yöntemini kullanabilirsiniz: getConnectionString ("DefaultConnection")

https://docs.asp.net/projects/api/en/latest/autoapi/Microsoft/Extensions/Configuration/ConfigurationExtensions/index.html#Microsoft.Extensions.Configuration.ConfigurationExtensions.GetConnectionString