By Oluwafemi


2015-07-16 11:57:11 8 Comments

I have setup my AppSettings data in appsettings/Config .json like this:

{
  "AppSettings": {
        "token": "1234"
    }
}

I have searched online on how to read AppSettings values from .json file, but I could not get anything useful.

I tried:

var configuration = new Configuration();
var appSettings = configuration.Get("AppSettings"); // null
var token = configuration.Get("token"); // null

I know with ASP.NET 4.0 you can do this:

System.Configuration.ConfigurationManager.AppSettings["token"];

But how do I do this in ASP.NET Core?

16 comments

@Gregory 2019-09-13 10:46:15

.NET Core 2.1.0

  1. Create the .json file on the root directory
  2. On your code:
var builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); 
var config = builder.Build();

3. Install the following dependencies:

Microsoft.Extensions.Configuration
Microsoft.Extensions.Configuration.json

4. Then, IMPORTANT: Right-click on the appsettings.json file -> click on Properties -> select Copy if newer: enter image description here

  1. Finally, you can do:

    config["key1"]

Considering that my config file will look like this:

{
    "ConnectionStrings": "myconnection string here",
    "key1": "value here"
}

@jishan siddique 2019-06-27 12:47:59

You can try below code. this is working for me.

public class Settings
    {
        private static IHttpContextAccessor _HttpContextAccessor;
        public Settings(IHttpContextAccessor httpContextAccessor)
        {
            _HttpContextAccessor = httpContextAccessor;
        }
        public static void Configure(IHttpContextAccessor httpContextAccessor)
        {
            _HttpContextAccessor = httpContextAccessor;
        }
        public static IConfigurationBuilder Getbuilder()
        {
            var builder = new ConfigurationBuilder()
              .SetBasePath(Directory.GetCurrentDirectory())
              .AddJsonFile("appsettings.json");
            return builder;
        }

        public static string GetAppSetting(string key)
        {
            //return Convert.ToString(ConfigurationManager.AppSettings[key]);
            var builder = Getbuilder();
            var GetAppStringData = builder.Build().GetValue<string>("AppSettings:" + key);
            return GetAppStringData;
        }

        public static string GetConnectionString(string key="DefaultName")
        {
            var builder = Getbuilder();
            var ConnectionString = builder.Build().GetValue<string>("ConnectionStrings:"+key);
            return ConnectionString;
        }
    }

Here I have created one class to get connection string and app settings.

I Startup.cs file you need to register class as below.

public class Startup
{      

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {           

        var httpContextAccessor = app.ApplicationServices.GetRequiredService<IHttpContextAccessor>();
        Settings.Configure(httpContextAccessor);
    }
}

@Lapenkov Vladimir 2019-06-21 08:05:49

Get it inside controller as object via call Get<YourType>()

public IActionResult Index([FromServices] IConfiguration config) { BillModel model= config.GetSection("Yst.Requisites").Get<BillModel>(); return View(model); }

@Eric Milliot-Martinez 2018-04-11 01:39:42

I doubt this is good practice but it's working locally. I'll update this if it fails when I publish/deploy (to an IIS web service).

Step 1 - Add this assembly to the top of your class (in my case, controller class):

using Microsoft.Extensions.Configuration;

Step 2 - Add this or something like it:

var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json").Build();

Step 3 - Call your key's value by doing this (returns string):

config["NameOfYourKey"]

@tnJed 2019-04-22 21:12:51

With Core 2.2, and in the simplest way possible...

public IActionResult Index([FromServices] IConfiguration config) 
{
    var myValue = config.GetValue<string>("MyKey");
}

appsettings.json is automatically loaded and available thru either constructor or action injection, and there's a GetSection method on IConfiguration as well. No need to alter Startup.cs or Program.cs if all you need is appsettings.json.

@Chris Halcrow 2018-06-26 22:17:12

For .NET Core 2.0, you can simply:

Declare your key/value pairs in appsettings.json:

{
  "MyKey": "MyValue"
}

Inject the configuration service in startup.cs, and get the value using the service

using Microsoft.Extensions.Configuration;

public class Startup
{
    public void Configure(IConfiguration configuration,
                          ... other injected services
                          )
    {
        app.Run(async (context) =>
        {
            string myValue = configuration["MyKey"];
            await context.Response.WriteAsync(myValue);
        });

@Alper Ebicoglu 2019-02-19 08:05:22

Here's the full use-case for ASP.NET Core!

articles.json

{
  "shownArticlesCount": 3,
  "articles": [
    {
      "title": "My Title 1",
      "thumbnailLink": "example.com/img1.png",
      "authorProfileLink": "example.com/@@alper",
      "authorName": "Alper Ebicoglu",
      "publishDate": "2018-04-17",
      "text": "...",
      "link": "..."
    },
    {
      "title": "My Title 2",
      "thumbnailLink": "example.com/img2.png",
      "authorProfileLink": "example.com/@@alper",
      "authorName": "Alper Ebicoglu",
      "publishDate": "2018-04-17",
      "text": "...",
      "link": "..."
    },
  ]
}

ArticleContainer.cs

public class ArticleContainer
{
    public int ShownArticlesCount { get; set; }

    public List<Article> Articles { get; set; }
}

public class Article
{
    public string Title { get; set; }

    public string ThumbnailLink { get; set; }

    public string AuthorName { get; set; }

    public string AuthorProfileLink { get; set; }

    public DateTime PublishDate { get; set; }

    public string Text { get; set; }

    public string Link { get; set; } 
}

Startup.cs

public class Startup
{
    public IConfigurationRoot ArticleConfiguration { get; set; }

    public Startup(IHostingEnvironment env)
    {
        ArticleConfiguration = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("articles.json")
            .Build();
    }

    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services.AddOptions();

        services.Configure<ArticleContainer>(ArticleConfiguration);
    }
}

Index.cshtml.cs

public class IndexModel : PageModel
{
    public ArticleContainer ArticleContainer { get;set; }

    private readonly IOptions<ArticleContainer> _articleContainer;

    public IndexModel(IOptions<ArticleContainer> articleContainer)
    {
        _articleContainer = articleContainer;
    }

    public void OnGet()
    {
        ArticleContainer = _articleContainer.Value;
    }
}

Index.cshtml.cs

<h1>@Model.ArticleContainer.ShownArticlesCount</h1>

@Alex Herman 2018-10-20 07:02:20

In addition to existing answers I'd like to mention that sometimes it might be useful to have extension methods for IConfiguration for simplicity's sake.

I keep JWT config in appsettings.json so my extension methods class looks as follows:

public static class ConfigurationExtensions
{
    public static string GetIssuerSigningKey(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:SecurityKey");
        return result;
    }

    public static string GetValidIssuer(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:Issuer");
        return result;
    }

    public static string GetValidAudience(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:Audience");
        return result;
    }

    public static string GetDefaultPolicy(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Policies:Default");
        return result;
    }

    public static SymmetricSecurityKey GetSymmetricSecurityKey(this IConfiguration configuration)
    {
        var issuerSigningKey = configuration.GetIssuerSigningKey();
        var data = Encoding.UTF8.GetBytes(issuerSigningKey);
        var result = new SymmetricSecurityKey(data);
        return result;
    }

    public static string[] GetCorsOrigins(this IConfiguration configuration)
    {
        string[] result =
            configuration.GetValue<string>("App:CorsOrigins")
            .Split(",", StringSplitOptions.RemoveEmptyEntries)
            .ToArray();

        return result;
    }
}

It saves you a lot of lines and you just write clean and minimal code:

...
x.TokenValidationParameters = new TokenValidationParameters()
{
    ValidateIssuerSigningKey = true,
    ValidateLifetime = true,
    IssuerSigningKey = _configuration.GetSymmetricSecurityKey(),
    ValidAudience = _configuration.GetValidAudience(),
    ValidIssuer = _configuration.GetValidIssuer()
};

It's also possible to register IConfiguration instance as singleton and inject it wherever you need - I use Autofac container here's how you do it:

var appConfiguration = AppConfigurations.Get(WebContentDirectoryFinder.CalculateContentRootFolder());
builder.Register(c => appConfiguration).As<IConfigurationRoot>().SingleInstance();

You can do the same with MS Dependency Injection:

services.AddSingleton<IConfigurationRoot>(appConfiguration);

@Yuval Itzchakov 2015-07-16 12:05:06

This has had a few twists and turns. I've modified this answer to be up to date with ASP.NET Core 2.0 (as of 26/02/2018).

This is mostly taken from the official documentation:

To work with settings in your ASP.NET application, it is recommended that you only instantiate a Configuration in your application’s Startup class. Then, use the Options pattern to access individual settings. Let's say we have an appsettings.json file that looks like this:

{
  "MyConfig": {
   "ApplicationName": "MyApp",
   "Version": "1.0.0"
   }

}

And we have a POCO object representing the configuration:

public class MyConfig
{
    public string ApplicationName { get; set; }
    public int Version { get; set; }
}

Now we build the configuration in Startup.cs:

public class Startup 
{
    public IConfigurationRoot Configuration { get; set; }

    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

        Configuration = builder.Build();
    }
}

Note that appsettings.json will be registered by default in .NET Core 2.0. We can also register an appsettings.{Environment}.json config file per environment if needed.

If we want to inject our configuration to our controllers, we'll need to register it with the runtime. We do so via Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    // Add functionality to inject IOptions<T>
    services.AddOptions();

    // Add our Config object so it can be injected
    services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
}

And we inject it like this:

public class HomeController : Controller
{
    private readonly IOptions<MyConfig> config;

    public HomeController(IOptions<MyConfig> config)
    {
        this.config = config;
    }

    // GET: /<controller>/
    public IActionResult Index() => View(config.Value);
}

The full Startup class:

public class Startup 
{
    public IConfigurationRoot Configuration { get; set; }

    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

        Configuration = builder.Build();
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc();

        // Add functionality to inject IOptions<T>
        services.AddOptions();

        // Add our Config object so it can be injected
        services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
    }
}

@Oluwafemi 2015-07-16 12:09:21

I am getting this compile time error: Configuration does not contain a definition for 'AddJsonFile'.... How do I resolve that?

@Yuval Itzchakov 2015-07-16 12:11:57

@Oluwafemi See my edit.

@Oluwafemi 2015-07-16 12:15:45

Am getting this error after adding it to project.json: Dependency Microsoft.Framework.ConfigurationModel.Json >= 1.0.0-alpha4 could not be resolved.

@Yuval Itzchakov 2015-07-16 12:17:05

@Oluwafemi Did you get the package from nuget?

@Oluwafemi 2015-07-16 12:20:58

version "1.0.0-beta4" works on mine not "1.0.0-alpha4". Thanks a lot!

@Yuval Itzchakov 2015-07-16 12:21:51

@Oluwafemi Yes I've updated that to be beta as it should. :)

@dnxit 2015-08-18 20:28:57

now it gives me InvalidOperationException: Unable to resolve path 'config.json'; construct this IConfigurationSourceRoot with a non-null BasePath. on config.AddJsonFile("config.json"); I need to read AppSettings in a static class instead of controller

@Yuval Itzchakov 2015-08-18 20:32:09

@Lucky See this. Ill update my answer. You'll need IApplicationEnvironment to get the base path.

@dnxit 2015-08-18 20:52:02

I need to pass a setting to another layer from a utility class so I need something like this public static string GetConnectionString() { if (string.IsNullOrEmpty(connectionString)) { var builder = new ConfigurationBuilder() .AddJsonFile("config.json"); Configuration = builder.Build(); connectionString = Configuration.Get("Data:DefaultConnection:ConnectionString")‌​; } } return connectionString; }

@dnxit 2015-08-18 20:57:03

And then query the data: var token = configuration.Get<string>("AppSettings:token"); how to instantiate configuration in my utility class ???

@Yuval Itzchakov 2016-09-15 17:30:21

@downvoter I got your flag, I've updated the answer :)

@Vedant 2016-11-07 16:21:45

I have created a new .Net Core project. It does have Startup.cs and project.json but there is no appsetting.json. It needs to be created manually after the creation of the project or it is created with the project and I have mistakenly deleted it? And if it is to be created manually then where should it be placed? In the same the folder as project.json?

@Yuval Itzchakov 2016-11-07 17:00:02

appsetting.json is just an example. You can have a barnes.json file and map it via AddJsonFile.

@Peter 2018-04-20 20:23:52

I get Argument 2: cannot convert from 'Microsoft.Extensions.Configuration.IConfigurationSection' to 'System.Action<....Settings>'

@Yuval Itzchakov 2018-04-20 20:45:45

@Peter Where do you get that?

@Peter 2018-04-20 20:55:06

@YuvalItzchakov on the following line .Configure<Settings>(Configuration.GetSection("Settings"))

@Peter 2018-04-20 22:19:03

After adding the nuget Microsoft.Extensions.Options.ConfigurationExtensions it worked as expected.

@Vasil Valchev 2018-09-28 16:00:10

this code vs old xml > how many of you have time for this, just to save a string?

@Bozhidar Stoyneff 2019-02-12 09:21:08

Nice explanation of the config process logic, but it misses a major point: SetBasePath() and AddJsonFile() are extension methods, berried deeply in the framework in separate assemblies. So in order to get started, one needs to install Microsoft.Extensions.Configuration.FileExtensions and Microsoft.Extensions.Configuration.Json in addition to Microsoft.Extensions.Configuration.

@Prachi 2019-02-28 14:49:04

@YuvalItzchakov how can I read list of objects rather than object using this? services.Configure<List<MappingList>>(Configuration.GetSecti‌​on("MyConfig"));

@user2173353 2019-03-27 08:01:31

This injects IOptions<MyConfig> in a controller. What if you need to read the settings inside the ConfigureServices() method and configure things according to the settings? Is there a way to resolve the settings object manually inside ConfigureServices()?

@ryanwebjackson 2019-04-10 17:02:19

Is there a way to get only the settings for a specific ConfigurationProvider?

@Teoman shipahi 2018-09-19 16:14:11

Following works for Console Apps;

1- install following nuget packages (.csproj);

<ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.2.0-preview2-35157" />
    <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="2.2.0-preview2-35157" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0-preview2-35157" />
  </ItemGroup>

2- Create appsettings.json at root level. Right click on it and "Copy to Output Directory" as "Copy if newer".

3- Sample config file:

{
  "AppConfig": {
    "FilePath": "C:\\temp\\logs\\output.txt"
  }
}

4- Program.cs

configurationSection.Key and configurationSection.Value will have config properties.

static void Main(string[] args)
{
    try
    {

        IConfigurationBuilder builder = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

        IConfigurationRoot configuration = builder.Build();
        // configurationSection.Key => FilePath
        // configurationSection.Value => C:\\temp\\logs\\output.txt
        IConfigurationSection configurationSection = configuration.GetSection("AppConfig").GetSection("FilePath");  

    }
    catch (Exception e)
    {
        Console.WriteLine(e);
    }
}

@Brian Moore 2018-07-25 21:43:42

Was this "cheating"? I just made my Configuration in the Startup class static, and then I can access it from anywhere else:

public class Startup
{
    // This method gets called by the runtime. Use this method to add services to the container.
    // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
    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();

        Configuration = builder.Build();
    }

    public static IConfiguration Configuration { get; set; }

@Monolithcode 2016-06-03 23:20:56

They just keep changing things – having just updated VS and had the whole project bomb, on the road to recovery and the new way looks like this:

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.IsDevelopment())
    {
        // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
        builder.AddUserSecrets();
    }

    builder.AddEnvironmentVariables();
    Configuration = builder.Build();
}

I kept missing this line!

.SetBasePath(env.ContentRootPath)

@S.Siva 2016-09-30 10:40:03

How can we get the AppSettings values in Test Projects using the same approach?

@Tiago Barroso 2018-04-14 03:30:51

Just to complement the Yuval Itzchakov answer.

You can load configuration without builder function, you can just inject it.

public IConfiguration Configuration { get; set; }

public Startup(IConfiguration configuration)
{
   Configuration = configuration;
}

@hug 2015-09-23 15:27:55

First off: The assembly name and namespace of Microsoft.Framework.ConfigurationModel has changed to Microsoft.Framework.Configuration. So you should use: e.g.

"Microsoft.Framework.Configuration.Json": "1.0.0-beta7"

as a dependency in project.json. Use beta5 or 6 if you don't have 7 installed. Then you can do something like this in Startup.cs.

public IConfiguration Configuration { get; set; }

public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
     var configurationBuilder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
        .AddJsonFile("config.json")
        .AddEnvironmentVariables();
     Configuration = configurationBuilder.Build();
}

If you then want to retrieve a variable from the config.json you can get it right away using:

public void Configure(IApplicationBuilder app)
    {
        // Add .Value to get the token string
        var token = Configuration.GetSection("AppSettings:token");
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync("This is a token with key (" + token.Key + ") " + token.Value);
        });
    }

or you can create a class called AppSettings like this:

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

and configure the services like this:

public void ConfigureServices(IServiceCollection services)
{       
    services.AddMvc();

    services.Configure<MvcOptions>(options =>
    {
        //mvc options
    });

    services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
}

and then access it through e.g. a controller like this:

public class HomeController : Controller
{
    private string _token;

    public HomeController(IOptions<AppSettings> settings)
    {
        _token = settings.Options.token;
    }
}

@Ankit Mori 2018-05-02 13:18:18

can you please share configuration json for "AppSettings" for reference

@Nilay 2018-07-31 01:06:59

I need entire appSettings.json configs in class, for this, I have designed class as per JSON and use Configuration.Get<AppSettings>() to deserialize entire file instead of a specific section.

@MDMoore313 2017-11-19 11:45:18

For .NET Core 2.0, things have changed a little bit. The startup constructor takes a Configuration object as a parameter, So using the ConfigurationBuilder is not required. Here is mine:

public Startup(IConfiguration configuration)
{
    Configuration = configuration;
}

public IConfiguration Configuration { get; }

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.Configure<StorageOptions>(Configuration.GetSection("AzureStorageConfig"));
}

My POCO is the StorageOptions object mentioned at the top:

namespace Brazzers.Models
{
    public class StorageOptions
    {
        public String StorageConnectionString { get; set; }
        public String AccountName { get; set; }
        public String AccountKey { get; set; }
        public String DefaultEndpointsProtocol { get; set; }
        public String EndpointSuffix { get; set; }

        public StorageOptions() { }
    }
}

And the configuration is actually a subsection of my appsettings.json file, named AzureStorageConfig:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;",
    "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=brazzerswebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  },

  "AzureStorageConfig": {
    "AccountName": "brazzerswebapp",
    "AccountKey": "Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==",
    "DefaultEndpointsProtocol": "https",
    "EndpointSuffix": "core.windows.net",
    "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=brazzerswebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
  }
}

The only thing I'll add is that, since the constructor has changed, I haven't tested whether something extra needs to be done for it to load appsettings.<environmentname>.json as opposed to appsettings.json.

@Ivan Juarez 2017-12-16 19:10:07

Soo cool you work for brazzers!!

@Eric 2018-03-12 17:06:51

Just a note that you still need to toss .AddJsonFile("yourfile.json") to ConfigConfiguration. IE, you need to tell it where the file is. Didn't see that in the answer.

@MDMoore313 2018-03-12 17:31:18

Eric I will retest that, I don't remember adding that line; Could it be necessary only if the name of the json file isn't the default name?

@Sat Thiru 2018-03-26 04:47:41

Per MSDN, it is not required for ASPNETCORE 2.0, although it doesnt appear to work for me either. docs.microsoft.com/en-us/dotnet/api/…

@Sat Thiru 2018-03-26 05:05:26

I can confirm that I had to build a ConfigurationBuilder() object and call AddJSONFile() to load the appSettings.json files into the config dictionary. This is ASP.NET Core 2.0. Is this a bug as it runs contrary to what MSDN says?

@Jpsy 2018-05-03 09:21:38

Can you give an example how you inject StorageOptions into your controllers? If I use hug's approach of using dependency injection with public HomeController(IOptions<StorageOptions> settings), I get this error message: Model bound complex types must not be abstract or value types and must have a parameterless constructor.

@Thang Pham 2018-06-06 04:05:03

Can configure for a list of StorageOptions? Like services.Configure<List<StorageOptions>>. I got an error.

@kodebot 2017-07-03 11:59:12

If you just want to get the value of the token then use

Configuration["AppSettings:token"]

@Ashok kumar 2019-09-10 09:23:26

Excellent answer, thank you.

Related Questions

Sponsored Content

28 Answered Questions

[SOLVED] Get int value from enum in C#

  • 2009-06-03 06:46:39
  • jim
  • 1365382 View
  • 1644 Score
  • 28 Answer
  • Tags:   c# enums casting int

21 Answered Questions

[SOLVED] How do you give a C# Auto-Property a default value?

3 Answered Questions

6 Answered Questions

[SOLVED] Load appsettings.{envName}.json file in ASP.NET Core 2.1

21 Answered Questions

[SOLVED] File Upload ASP.NET MVC 3.0

5 Answered Questions

[SOLVED] Read and parse a Json File in C#

42 Answered Questions

[SOLVED] How do I create an Excel (.XLS and .XLSX) file in C# without installing Microsoft Office?

  • 2008-09-29 22:30:28
  • mistrmark
  • 1027316 View
  • 1776 Score
  • 42 Answer
  • Tags:   c# .net excel file-io

5 Answered Questions

[SOLVED] Token Based Authentication in ASP.NET Core (refreshed)

1 Answered Questions

[SOLVED] Serilog asp.net core appsettings config for syslog

1 Answered Questions

[SOLVED] reading appSettings from asp.net core webapi

Sponsored Content