Wie lese ich eine Verbindungszeichenfolge in .NET Core?

Ich möchte nur eine Verbindungszeichenfolge aus einer Konfigurationsdatei lesen und dazu eine Datei mit dem Namen "appsettings.json" zu meinem Projekt hinzufügen und diesen Inhalt hinzufügen:

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

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

Unter ASP.NET habe ich Folgendes verwendet:

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

Wie kann ich nun "DefaultConnection" in C # lesen und in einer Zeichenfolgenvariablen in .NET Core speichern?

Sie können dies mit der GetConnectionString-Erweiterungsmethode tun:

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

System.Console.WriteLine(conString);

oder mit einer strukturierten Klasse für DI:

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

Anfang:

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"));

Und dann im Home-Controller:

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();
    }

mit diesem in appsettings.json:

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

Die gepostete Antwort ist in Ordnung, hat aber nicht direkt die gleiche Frage beantwortet, die ich zum Lesen einer Verbindungszeichenfolge hatte. Durch viel Suchen fand ich einen etwas einfacheren Weg, dies zu tun.

In Startup.cs

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

Fügen Sie in Ihrem Controller ein Feld für die Konfiguration und einen Parameter dafür in einem Konstruktor hinzu

private readonly IConfiguration configuration;

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

Jetzt später in Ihrem Ansichtscode können Sie wie folgt darauf zugreifen:

connectionString = configuration.GetConnectionString("DefaultConnection");

Weitere Informationen finden Sie unter dem Link: 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")));
}

BEARBEITEN: aspnetcore, ab 3.1: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1

Um dies zu beheben, habe ich AddJsonFile in einem Builder beim Start verwendet (wodurch die in der Datei appsettings.json gespeicherte Konfiguration gefunden werden kann) und anschließend eine private Variable _config festgelegt

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();
    }

Und dann könnte ich die Konfigurationszeichenfolge wie folgt einstellen:

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

Dies ist auf Dotnet Core 1.1

ASP.NET Core ( in meinem Fall 3.1 ) bietet uns Konstruktorinjektionen in Controller , sodass Sie einfach den folgenden Konstruktor hinzufügen können:

[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")
    }
}

So könnte appsettings.json aussehen:

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

Es gibt einen anderen Ansatz. In meinem Beispiel sehen Sie eine Geschäftslogik in der Repository-Klasse, die ich mit der Abhängigkeitsinjektion in ASP .NET MVC Core 3.1 verwende.

Und hier möchte ich connectiongStringauf diese Geschäftslogik eingehen, da wahrscheinlich ein anderes Repository überhaupt Zugriff auf eine andere Datenbank hat.

Mit diesem Muster haben Sie im selben Geschäftslogik-Repository Zugriff auf verschiedene Datenbanken.

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

Ich habe eine Datenzugriffsbibliothek, die sowohl mit .net Core als auch .net Framework funktioniert.

In .net-Kernprojekten bestand der Trick darin, die Verbindungszeichenfolgen in einer XML-Datei mit dem Namen "app.config" (auch für Webprojekte) zu speichern und als "In Ausgabeverzeichnis kopieren" zu markieren.

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

ConfigurationManager.ConnectionStrings - liest die Verbindungszeichenfolge.

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

Sie können die Konfigurationserweiterungsmethode verwenden: getConnectionString ("DefaultConnection")

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