Getting a Configuration Value in ASP.NET 5 (vNext)

Question

I am struggling with some concepts in ASP.NET 5 (vNext).

One of those is the Dependency Injection approach used for configuration. It seems like I have to pass a parameter all the way through the stack. I'm probably misunderstanding something or doing it wrong.

Imagine I have a config property named "contactEmailAddress". I'll use that config property to send an email when a new order is placed. With that scenario in mind, my ASP.NET 5 stack will look like this:

Startup.cs

public class Startup
{        
  public IConfiguration Configuration { get; set; }
  public Startup(IHostingEnvironment environment)
  {
    var configuration = new Configuration().AddJsonFile("config.json");
    Configuration = configuration;
  }

  public void ConfigureServices(IServiceCollection services)
  {
    services.Configure<AppSettings>(Configuration.GetSubKey("AppSettings"));
    services.AddMvc();
  }

  public void Configure(IApplicationBuilder app)
  {
    app.UseErrorPage();
    app.UseMvc(routes =>
      {
        routes.MapRoute("default",
          "{controller}/{action}/{id}",
          defaults: new { controller = "Home", action = "Index" });
      }
    );
    app.UseWelcomePage();
  }

AppSettings.cs

public class AppSettings
{
 public string ContactEmailAddress { get; set; }
}

config.json

{
  "AppSettings": {
    "ContactEmailAddress":"[email protected]"  
  }
}

OrderController.cs

[Route("orders")]
public class OrdersController : Controller
{    
  private IOptions<AppSettings> AppSettings { get; set; }

  public OrdersController(IOptions<AppSettings> appSettings)
  {
    AppSettings = appSettings;
  }

  [HttpGet("new-order")]
  public IActionResult OrderCreate()
  {
    var viewModel = new OrderViewModel();
    return View(viewModel);
  }

  [HttpPost("new-order")]
  public IActionResult OrderCreate(OrderViewModel viewModel)
  {

    return new HttpStatusCodeResult(200);
  } 
}

Order.cs

public class Order()
{
  public void Save(IOptions<AppSettings> appSettings)
  {
    // Send email to address in appSettings
  }

  public static List<Order> FindAll(IOptions<AppSettings> appSettings)
  {
    // Send report email to address in appSettings
    return new List<Order>();
  }
}

As the example above shows, I'm passing AppSettings through the entire stack. This does not feel correct. To further my worries, this approach will not work if I'm attempt to use a third-party library that needs to access configuration settings. How can a third-party library access configuration settings? Am I misunderstanding something? Is there a better way to do this?

Will this be only one email address or multiple addresses ?

Mairaj Ahmad
– Mairaj Ahmad

2015-05-28 04:12:20 +00:00
Commented May 28, 2015 at 4:12 — Mairaj Ahmad
– Mairaj Ahmad, Commented May 28, 2015 at 4:12

Dave Alperovich · Accepted Answer · 2015-05-28 06:50:33Z

11

+250

You are entangling 2 different run time resource provider, AppSettings and Dependency Injection.

AppSettings, provides run-time access to Application specific values like UICulture strings, Contact Email, etc.

DI Containers are factories that Manage access to Services and their lifetime scopes. For example, If a MVC Controller needed access to your EmailService, you would configure

   public void ConfigureServices(IServiceCollection services)
   {
      // Add all dependencies needed by Mvc.
      services.AddMvc();

      // Add EmailService to the collection. When an instance is needed,
      // the framework injects this instance to the objects that needs it
      services.AddSingleton<IEmailService, EmailService>();
   }

Then, if our Home Controller needs access to your EmailService, we add a dependency on it's Interface by adding it as a parameter to the Controller constructor

public class HomeController : Controller
{
   private readonly IEmailService _emailService;
   private readonly string _emailContact;

  /// The framework will inject an instance of an IEmailService implementation.
   public HomeController(IEmailService emailService)
   {
      _emailService = emailService;
      _emailContact = System.Configuration.ConfigurationManager.
                   AppSettings.Get("ContactEmail");
   }

   [HttpPost]
   public void EmailSupport([FromBody] string message)
   {
      if (!ModelState.IsValid)
      {
         Context.Response.StatusCode = 400;
      }
      else
      {
         _emailService.Send(_emailContact, message);

The purpose of Dependancy Injection is to manage access and lifetimes of services.

In the previous example, in our Application Startup, we configured the DI Factory to associate application requests for IEmailService with EmailService. So when our Controllers are instantiate by the MVC Framework, the framework notices that our Home Controller expects IEmailService, the framework checks our Application Services Collection. It finds mapping instructions and Inject a Singleton EmailService (a descendant of the occupying Interface) into our Home Controller.

Super Polymorphic Factorific - alodocious!

Why is this important?

If your contact email changes, you change the AppSetting value and are done. All requests for "ContactEmail" from ConfigurationManager are Globally changed. Strings are easy. No need for Injection when we can just hash.

If your Repository, Email Service, Logging Service, etc changes, you want a Global way to change all references to this service. Service reference aren't as easily transferred as immutable string literals. Service instantiation should be handled by a factory to configure the Service's settings and dependencies.

So, in a year you develop a RobustMailService:

Class RobustMailService : IEmailService
{

....

}

As long as your new RobustMailService inherits and implements the IEmailService Interface, you can substitute all references to your mail service Globally by changing :

   public void ConfigureServices(IServiceCollection services)
   {
      // Add all dependencies needed by Mvc.
      services.AddMvc();

      // Add RobustMailService to the collection. When an instance is needed,
      // the framework injects this instance to the objects that needs it 
      services.AddSingleton<IEmailService, RobustMailService>();
   }

edited May 28, 2015 at 6:50

answered May 28, 2015 at 6:17

Dave Alperovich

32.6k8 gold badges82 silver badges101 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

czioutas Over a year ago

although your answer is very detailed @DavidMoores answer is actually the correct one, as he specifies how to pass configuration down to Services that need them all the way from the Startup.cs

Dave Alperovich Over a year ago

@Drakoumel, I honestly don't know what you want me to say. I don't agree, and 12 other ppl don't agree with your assessment. Further, I make a point of not responding to vague criticisms of my answers. You haven't made a detailed critique, and I can't be certain that you understand either question or my answer.

czioutas Over a year ago

I didnt mean to offend you, I am commenting as I had the same question as the OP and it seems your answer is obsolete. Why? Well as I said David's solution explains how to set the IOptions Models in order to pass specific chunks of the config file into Services. You completely ignore that part. You specify how to define a correct MVC & service layer but not how to create Settings Models as David does.

czioutas Over a year ago

I honestly wont continue this conversation as you appear to be quite aggressive for no reason and well I cant do anything about that. Have a good day.

Keith Over a year ago

@DaveAlperovich could you clarify something? In this answer you're quite clear about the config (in this case the email) being applied where the service is consumed - which makes sense. How would you apply settings required to initialise the service? So in this email case the SMTP server and suchlike? Obviously in appsettings where they can be easily changed, but where should those settings be read? The RobustMailService constructor? That seems the wrong place to me, Startup.ConfigureServices makes more sense, but aren't you describing that as a misuse of the DI?

|

David Moores · Accepted Answer · 2016-08-15 17:59:07Z

This can be achieved using IOptions assessor service as it seems you were trying.

We can begin by creating a class with all of the variables that your controller needs from configuration.

public class VariablesNeeded
{
    public string Foo1{ get; set; }        
    public int Foo2{ get; set; }
}

public class OtherVariablesNeeded
{
    public string Foo1{ get; set; }        
    public int Foo2{ get; set; }
}

We now need to tell the middleware that the controller needs this class in the constructor of the controller using dependency injection, we do this using IOptions accessor service.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;

public class MyController: Controller{    
    private readonly VariablesNeeded _variablesNeeded;

    public MyController(IOptions<VariablesNeeded> variablesNeeded) {
        _variablesNeeded= variablesNeeded.Value;
    }

    public ActionResult TestVariables() {
        return Content(_variablesNeeded.Foo1 + _variablesNeeded.Foo2);
    }
}

To get the variables from your configuration files, we create a constructor for the startup class, and a configuration property.

public IConfigurationRoot Configuration { get; }

public Startup(IHostingEnvironment env)
{
    /* This is the fairly standard procedure now for configuration builders which will pull from appsettings (potentially with an environmental suffix), and environment variables. */
    var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)    
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            .AddEnvironmentVariables();
    Configuration = builder.Build();
}

Now we need to make sure the pipeline actually supplies the controller with this service.

In your ConfigureServices method in your Startup class, you want to use the Options middleware, and inject an object of type VariablesNeeded in to the pipeline.

public void ConfigureServices(IServiceCollection services)
{
   // Tells the pipeline we want to use IOption Assessor Services
   services.AddOptions();

   // Injects the object VariablesNeeded in to the pipeline with our desired variables
   services.Configure<VariablesNeeded>(x =>
   {
       x.Foo1 = Configuration["KeyInAppSettings"]
       x.Foo2 = Convert.ToInt32(Configuration["KeyParentName:KeyInAppSettings"])
   });

   //You may want another set of options for another controller, or perhaps to pass both to our "MyController" if so, you just add it to the pipeline    
   services.Configure<OtherVariablesNeeded>(x =>
   {
       x.Foo1 = "Other Test String",
       x.Foo2 = 2
   });

   //The rest of your configure services...
}

For more information see the chapter on Using Options and configuration objects in the ASPCore Docs

Collectives™ on Stack Overflow

Getting a Configuration Value in ASP.NET 5 (vNext)

2 Answers 2

9 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

9 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related