Comment lire la chaîne de connexion dans .NET Core?

Je veux lire juste une chaîne de connexion à partir d'un fichier de configuration et pour cela ajouter un fichier avec le nom "appsettings.json" à mon projet et y ajouter ce contenu:

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

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

Sur ASP.NET, j'ai utilisé ceci:

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

Maintenant, comment puis-je lire "DefaultConnection" en C # et le stocker sur une variable de chaîne dans .NET Core?

Vous pouvez le faire avec la méthode d'extension GetConnectionString:

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

System.Console.WriteLine(conString);

ou avec une classe structurée pour DI:

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

Commencez:

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

Et puis dans le 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();
    }

avec ceci dans appsettings.json:

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

"Smtp": {
    "Server": "0.0.0.1",
    "User": "[email protected]",
    "Pass": "123456789",
    "Port": "25"
  }

La réponse publiée est correcte mais n'a pas répondu directement à la même question que j'avais sur la lecture dans une chaîne de connexion. Grâce à de nombreuses recherches, j'ai trouvé un moyen un peu plus simple de le faire.

Dans Startup.cs

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

Dans votre contrôleur, ajoutez un champ pour la configuration et un paramètre pour celle-ci sur un constructeur

private readonly IConfiguration configuration;

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

Maintenant, plus tard dans votre code de vue, vous pouvez y accéder comme:

connectionString = configuration.GetConnectionString("DefaultConnection");

Voir le lien pour plus d'informations: 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")));
}

EDIT: aspnetcore, à partir de 3.1: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1

La façon dont j'ai trouvé pour résoudre ce problème était d'utiliser AddJsonFile dans un constructeur au démarrage (ce qui lui permet de trouver la configuration stockée dans le fichier appsettings.json), puis de l'utiliser pour définir une variable _config privée

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

Et puis je pourrais définir la chaîne de configuration comme suit:

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

C'est sur dotnet core 1.1

ASP.NET Core ( dans mon cas 3.1 ) nous fournit des injections de constructeur dans les contrôleurs , vous pouvez donc simplement ajouter le constructeur suivant:

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

Voici à quoi peut ressembler appsettings.json:

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

Il existe une autre approche. Dans mon exemple, vous voyez une logique métier dans la classe de référentiel que j'utilise avec l'injection de dépendances dans ASP .NET MVC Core 3.1.

Et ici, je veux obtenir connectiongStringcette logique métier car un autre référentiel aura probablement accès à une autre base de données.

Ce modèle vous permet, dans le même référentiel de logique métier, d'accéder à différentes bases de données.

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

J'ai une bibliothèque d'accès aux données qui fonctionne à la fois avec .net core et .net framework.

l'astuce était dans les projets principaux .net de conserver les chaînes de connexion dans un fichier xml nommé "app.config" (également pour les projets Web), et de le marquer comme "copier dans le répertoire de sortie",

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

ConfigurationManager.ConnectionStrings - lira la chaîne de connexion.

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

Vous pouvez utiliser la méthode d'extension de configuration: getConnectionString ("DefaultConnection")

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