## Method 

    System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform()

## Possible Argument

    OSPlatform.Windows
    OSPlatform.OSX
    OSPlatform.Linux

## Example 

    bool isWindows = System.Runtime.InteropServices.RuntimeInformation
                                                   .IsOSPlatform(OSPlatform.Windows);


## Update

Thanks to the comment by Oleksii Vynnychenko

You can get the operating systems name and version as a string using 

    var osNameAndVersion = System.Runtime.InteropServices.RuntimeInformation.OSDescription;

E.g. `osNameAndVersion` would be `Microsoft Windows 10.0.10586` 

`System.Environment.OSVersion.Platform` can be used in full .NET Framework and Mono but:

- Mac OS X detection almost never worked for me under Mono
- it is not implemented in .NET Core

`System.Runtime.InteropServices.RuntimeInformation` can be used in .NET Core but:

- it is not implemented in full .NET Framework and Mono
- it does not perform platform detection in runtime but **uses hardcoded information instead**  
(see [corefx issue #3032](https://github.com/dotnet/corefx/issues/3032) for more details)

You could pinvoke platform specific unmanaged functions such as `uname()` but:

- it may cause segmentation fault on unknown platforms
- is not allowed in some projects

So my suggested solution (see code bellow) may look sily at first but:

- it uses 100% managed code
- it works in .NET, Mono and .NET Core
- it works like a charm so far in [Pkcs11Interop](https://github.com/Pkcs11Interop/Pkcs11Interop/blob/3.2.0/src/Pkcs11Interop/Pkcs11Interop/Common/Platform.cs#L228-L254) library


&lt;!-- language: lang-cs --&gt;

    string windir = Environment.GetEnvironmentVariable(&quot;windir&quot;);
    if (!string.IsNullOrEmpty(windir) &amp;&amp; windir.Contains(@&quot;\&quot;) &amp;&amp; Directory.Exists(windir))
    {
    	_isWindows = true;
    }
    else if (File.Exists(@&quot;/proc/sys/kernel/ostype&quot;))
    {
    	string osType = File.ReadAllText(@&quot;/proc/sys/kernel/ostype&quot;);
    	if (osType.StartsWith(&quot;Linux&quot;, StringComparison.OrdinalIgnoreCase))
    	{
    		// Note: Android gets here too
    		_isLinux = true;
    	}
    	else
    	{
    		throw new UnsupportedPlatformException(osType);
    	}
    }
    else if (File.Exists(@&quot;/System/Library/CoreServices/SystemVersion.plist&quot;))
    {
    	// Note: iOS gets here too
    	_isMacOsX = true;
    }
    else
    {
    	throw new UnsupportedPlatformException();
    }



Check `System.OperatingSystem` class it has static methods for each OS i.e. IsMacOS(), IsWindows(), IsIOS() and so on.

I want to read just a connection string from a configuration file and for this add a file with the name &quot;appsettings.json&quot; to my project and add this content on it:

    {
    &quot;ConnectionStrings&quot;: {
      &quot;DefaultConnection&quot;: &quot;Server=(localdb)\\mssqllocaldb;Database=aspnet-

     WebApplica71d622;Trusted_Connection=True;MultipleActiveResultSets=true&quot;
      },
        &quot;Logging&quot;: {
        &quot;IncludeScopes&quot;: false,
        &quot;LogLevel&quot;: {
        &quot;Default&quot;: &quot;Debug&quot;,
        &quot;System&quot;: &quot;Information&quot;,
        &quot;Microsoft&quot;: &quot;Information&quot;
       }
     }
    }

On ASP.NET I used this:

     var temp=ConfigurationManager.ConnectionStrings[&quot;DefaultConnection&quot;].ConnectionString;

Now how can I read &quot;DefaultConnection&quot; in C# and store it on a string variable in .NET Core?


How to read connection string in .NET Core?

Is it possible to run react-native application on an iOS device directly from the command line like we do on simulator with `react-native run ios --simulator &quot;iPhone 5s&quot;`?

Run react-native application on iOS device directly from command line?

How can I determine which operating system my .NET Core app is running on?
In the past I could use `Environment.OSVersion`.

What is the current way to determine whether my app is running on Mac or Windows?

Determine Operating System in .NET Core

<p>How can I determine which operating system my .NET Core app is running on?
In the past I could use <code>Environment.OSVersion</code>.</p>
<p>What is the current way to determine whether my app is running on Mac or Windows?</p>


I have this exact code from the accepted answer in my project which I need to migrate into ASP.NET Core MVP.

https://stackoverflow.com/questions/14967457/how-to-extract-custom-header-value-in-web-api-message-handler

    var env = Request.Headers.GetValues(&quot;environment&quot;).First();

How can I implement this in .NET Core?

I hope this is not considered to be a duplicate question because I am trying to do this with the new system rather than the old one. I would also be fine if someone adds an answer to the link regarding the current version.

Edit: https://stackoverflow.com/questions/29706719/where-all-types-for-http-headers-gone-in-asp-net-5 I tried this link but API may have changed. I don&#39;t think this is a duplicate for that question either.

How to extract custom header value?

I am returning a file from a WebAPI controller. The Content-Disposition header value is automatically set to &quot;attachment&quot;. For example:

&gt; Disposition: attachment; filename=&quot;30956.pdf&quot;; filename*=UTF-8&#39;&#39;30956.pdf

When it is set to attachment the browser will ask to save file instead of opening it. I would like it to open it.

How can I set it to &quot;inline&quot; instead of &quot;attachment&quot;?

I am sending the file using this method:

&lt;!-- language: c# --&gt;

    public IActionResult GetDocument(int id)
    {
        var filename = $&quot;folder/{id}.pdf&quot;;
        var fileContentResult = new FileContentResult(File.ReadAllBytes(filename), &quot;application/pdf&quot;)
        {
            FileDownloadName = $&quot;{id}.pdf&quot;
        };
        // I need to delete file after me
        System.IO.File.Delete(filename);
    
        return fileContentResult;
    }

ASP.Net Core Content-Disposition attachment/inline

I am playing with [Azure Functions][1]. However, I feel like I&#39;m stumped on something pretty simple. I&#39;m trying to figure out how to return some basic JSON. I&#39;m not sure how to create some JSON and get it back to my request. 

Once upon a time,  I would create an object, populate its properties, and serialize it. So, I started down this path:

    #r &quot;Newtonsoft.Json&quot;
    
    using System.Net;
    
    public static async Task&lt;HttpResponseMessage&gt; Run(HttpRequestMessage req, TraceWriter log)
    {
        log.Info($&quot;Running Function&quot;);    
        try {      
          log.Info($&quot;Function ran&quot;);
    
          var myJSON = GetJson();
    
          // I want myJSON to look like:
          // {
          //   firstName:&#39;John&#39;,
          //   lastName: &#39;Doe&#39;,
          //   orders: [
          //     { id:1, description:&#39;...&#39; },
          //     ...
          //   ]
          // }
          return ?;
        } catch (Exception ex) {
            // TODO: Return/log exception
            return null;
        }
    }
    
    public static ? GetJson() 
    {
      var person = new Person();
      person.FirstName = &quot;John&quot;;
      person.LastName = &quot;Doe&quot;;

      person.Orders = new List&lt;Order&gt;();
      person.Orders.Add(new Order() { Id=1, Description=&quot;...&quot; });

      ?
    }

    public class Person 
    {
      public string FirstName { get; set; }
      public string LastName { get; set; }
      public List&lt;Order&gt; Orders { get; set; }
    }

    public class Order
    {
      public int Id { get; set; }
      public string Description { get; set; }
    }

However, I&#39;m totally stuck on the serialization and return process now.I guess I&#39;m used to returning JSON in ASP.NET MVC where everything is an Action


  [1]: https://azure.microsoft.com/en-us/services/functions/

How do I return JSON from an Azure Function

I&#39;m trying to generate classes from a database (EntityFramework&#39;s database first approach).

For convenience, I&#39;m more or less walking along with this tutorial:
[https://docs.efproject.net/en/latest/platforms/full-dotnet/existing-db.html][1]


  [1]: https://docs.efproject.net/en/latest/platforms/full-dotnet/existing-db.html

I&#39;m at a point where I am running the equivalent of this line of code in the Visual Studio Package Manager Console:

    Scaffold-DbContext &quot;Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True;&quot; Microsoft.EntityFrameworkCore.SqlServer -Verbose

This line of code is generating the error (with -Verbose mode on):

    Using startup project &#39;EFSandbox&#39;.
    Using project &#39;EntityFrameworkCore&#39;
    Build started...
    Build failed.

I see no other options that produce any meaningful output, and I see no documentation on this particular error. If it helps at all, this project does not have a project.json file, currently. Everything is in the .csproj file, which I have not manually edited.

&quot;Build failed&quot; on Database First Scaffold-DbContext

I&#39;m struggling with how to set up authentication in my web service. 
The service is build with the ASP.NET Core web api.

All my clients (WPF applications) should use the same credentials to call the web service operations. 

After some research, I came up with basic authentication - sending a username and password in the header of the HTTP request.
But after hours of research, it seems to me that basic authentication is not the way to go in ASP.NET Core.

Most of the resources I found are implementing authentication using OAuth or some other middleware. But that seems to be oversized for my scenario, as well as using the Identity part of ASP.NET Core. 

So what is the right way to achieve my goal - simple authentication with username and password in a ASP.NET Core web service?

Thanks in advance!

ASP.NET Core Web API Authentication

I have a .NET Core console application and have run `dotnet publish`. However, I can&#39;t figure out how to run the application from the command line. Any hints?

How to run .NET Core console application from the command line

The Azure error is:

&gt; .Net Core: Application startup exception:
&gt; System.IO.FileNotFoundException: The configuration file
&gt; &#39;appsettings.json&#39; was not found and is not optional.


So this is a bit vague. I can&#39;t seem to nail this down. I&#39;m trying to deploy a .Net Core Web API project to Azure, and I&#39;m getting this error:

&gt; :(  Oops. 500 Internal Server Error 
&gt; An error occurred while starting the application.

I&#39;ve deployed plain old .Net WebAPI&#39;s and they have worked. I&#39;ve followed online tutorials and they have worked. But somehow my project is broke. Enabling stdoutLogEnabled on Web.config and looking at the Azure Streaming Logs gives me this:


    2016-08-26T02:55:12  Welcome, you are now connected to log-streaming service.
    Application startup exception: System.IO.FileNotFoundException: The configuration file &#39;appsettings.json&#39; was not found and is not optional.
       at Microsoft.Extensions.Configuration.FileConfigurationProvider.Load(Boolean reload)
       at Microsoft.Extensions.Configuration.FileConfigurationProvider.Load()
       at Microsoft.Extensions.Configuration.ConfigurationRoot..ctor(IList`1 providers)
       at Microsoft.Extensions.Configuration.ConfigurationBuilder.Build()
       at Quanta.API.Startup..ctor(IHostingEnvironment env) in D:\Source\Workspaces\Quanta\src\Quanta.API\Startup.cs:line 50
    --- End of stack trace from previous location where exception was thrown ---
       at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()
       at Microsoft.Extensions.Internal.ActivatorUtilities.ConstructorMatcher.CreateInstance(IServiceProvider provider)
       at Microsoft.Extensions.Internal.ActivatorUtilities.CreateInstance(IServiceProvider provider, Type instanceType, Object[] parameters)
       at Microsoft.Extensions.Internal.ActivatorUtilities.GetServiceOrCreateInstance(IServiceProvider provider, Type type)
       at Microsoft.Extensions.DependencyInjection.ActivatorUtilities.GetServiceOrCreateInstance(IServiceProvider provider, Type type)
       at Microsoft.AspNetCore.Hosting.Internal.StartupLoader.LoadMethods(IServiceProvider services, Type startupType, String environmentName)
       at Microsoft.AspNetCore.Hosting.WebHostBuilderExtensions.&lt;&gt;c__DisplayClass1_0.&lt;UseStartup&gt;b__1(IServiceProvider sp)
       at Microsoft.Extensions.DependencyInjection.ServiceLookup.FactoryService.Invoke(ServiceProvider provider)
       at Microsoft.Extensions.DependencyInjection.ServiceProvider.ScopedCallSite.Invoke(ServiceProvider provider)
       at Microsoft.Extensions.DependencyInjection.ServiceProvider.SingletonCallSite.Invoke(ServiceProvider provider)
       at Microsoft.Extensions.DependencyInjection.ServiceProvider.&lt;&gt;c__DisplayClass12_0.&lt;RealizeService&gt;b__0(ServiceProvider provider)
       at Microsoft.Extensions.DependencyInjection.ServiceProvider.GetService(Type serviceType)
       at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType)
       at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService[T](IServiceProvider provider)
       at Microsoft.AspNetCore.Hosting.Internal.WebHost.EnsureStartup()
       at Microsoft.AspNetCore.Hosting.Internal.WebHost.EnsureApplicationServices()
       at Microsoft.AspNetCore.Hosting.Internal.WebHost.BuildApplication()
    Hosting environment: Production
    Content root path: D:\home\site\wwwroot
    Now listening on: http://localhost:30261
    Application started. Press Ctrl+C to shut down.

Ok, that seems simple. It can&#39;t find appsettings.json. Looking at my config ( startup.cs ) it seems very well defined. My Startup looks like this:

&lt;!-- language: c# --&gt;

    public class Startup
    {
        private static string _applicationPath = string.Empty;
        private static string _contentRootPath = string.Empty;
        public IConfigurationRoot Configuration { get; set; }
        public Startup(IHostingEnvironment env)
        {
            _applicationPath = env.WebRootPath;
            _contentRootPath = env.ContentRootPath;
            // Setup configuration sources.

            var builder = new ConfigurationBuilder()
                .SetBasePath(_contentRootPath)
                .AddJsonFile(&quot;appsettings.json&quot;)
                .AddJsonFile($&quot;appsettings.{env.EnvironmentName}.json&quot;, optional: true);

            if (env.IsDevelopment())
            {
                // This reads the configuration keys from the secret store.
                // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
                builder.AddUserSecrets();
            }

            builder.AddEnvironmentVariables();
            Configuration = builder.Build();
        }
        private string GetXmlCommentsPath()
        {
            var app = PlatformServices.Default.Application;
            return System.IO.Path.Combine(app.ApplicationBasePath, &quot;Quanta.API.xml&quot;);
        }

        // 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 http://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
            var pathToDoc = GetXmlCommentsPath();


            services.AddDbContext&lt;QuantaContext&gt;(options =&gt;
                options.UseSqlServer(Configuration[&quot;Data:DefaultConnection:ConnectionString&quot;],
                b =&gt; b.MigrationsAssembly(&quot;Quanta.API&quot;)));

            //Swagger
            services.AddSwaggerGen();
            services.ConfigureSwaggerGen(options =&gt;
            {
                options.SingleApiVersion(new Info
                {
                    Version = &quot;v1&quot;,
                    Title = &quot;Project Quanta API&quot;,
                    Description = &quot;Quant.API&quot;,
                    TermsOfService = &quot;None&quot;
                });
                options.IncludeXmlComments(pathToDoc);
                options.DescribeAllEnumsAsStrings();
            });

            // Repositories
            services.AddScoped&lt;ICheckListRepository, CheckListRepository&gt;();
            services.AddScoped&lt;ICheckListItemRepository, CheckListItemRepository&gt;();
            services.AddScoped&lt;IClientRepository, ClientRepository&gt;();
            services.AddScoped&lt;IDocumentRepository, DocumentRepository&gt;();
            services.AddScoped&lt;IDocumentTypeRepository, DocumentTypeRepository&gt;();
            services.AddScoped&lt;IProjectRepository, ProjectRepository&gt;();
            services.AddScoped&lt;IProtocolRepository, ProtocolRepository&gt;();
            services.AddScoped&lt;IReviewRecordRepository, ReviewRecordRepository&gt;();
            services.AddScoped&lt;IReviewSetRepository, ReviewSetRepository&gt;();
            services.AddScoped&lt;ISiteRepository, SiteRepository&gt;();

            // Automapper Configuration
            AutoMapperConfiguration.Configure();

            // Enable Cors
            services.AddCors();

            // Add MVC services to the services container.
            services.AddMvc()
                .AddJsonOptions(opts =&gt;
                {
                    // Force Camel Case to JSON
                    opts.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
                });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app)
        {
            app.UseStaticFiles();
            // Add MVC to the request pipeline.
            app.UseCors(builder =&gt;
                builder.AllowAnyOrigin()
                .AllowAnyHeader()
                .AllowAnyMethod());

            app.UseExceptionHandler(
              builder =&gt;
              {
                  builder.Run(
                    async context =&gt;
                    {
                        context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
                        context.Response.Headers.Add(&quot;Access-Control-Allow-Origin&quot;, &quot;*&quot;);

                        var error = context.Features.Get&lt;IExceptionHandlerFeature&gt;();
                        if (error != null)
                        {
                            context.Response.AddApplicationError(error.Error.Message);
                            await context.Response.WriteAsync(error.Error.Message).ConfigureAwait(false);
                        }
                    });
              });

            app.UseMvc(routes =&gt;
            {
                routes.MapRoute(
                    name: &quot;default&quot;,
                    template: &quot;{controller=Home}/{action=Index}/{id?}&quot;);

                // Uncomment the following line to add a route for porting Web API 2 controllers.
                //routes.MapWebApiRoute(&quot;DefaultApi&quot;, &quot;api/{controller}/{id?}&quot;);
            });


            //Ensure DB is created, and latest migration applied. Then seed.
            using (var serviceScope = app.ApplicationServices
              .GetRequiredService&lt;IServiceScopeFactory&gt;()
              .CreateScope())
            {
                QuantaContext dbContext = serviceScope.ServiceProvider.GetService&lt;QuantaContext&gt;();
                dbContext.Database.Migrate();
                QuantaDbInitializer.Initialize(dbContext);
            }


            app.UseSwagger();
            app.UseSwaggerUi();


        }
    }

This works fine locally. But once we publish to Azure, this fails. I&#39;m at a loss. I&#39;ve created new .Net core project that deploy to Azure just find. But this one project, that I put all my time into to, seems to fail. I&#39;m about ready to copy and paste code out of the project that fails to run and into a new project, but i&#39;m really curious on what&#39;s breaking this.

Any ideas?


EDIT:
So my Program.cs was:

&lt;!-- language: c# --&gt;

    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Threading.Tasks;
    using Microsoft.AspNetCore.Hosting;
    
    namespace Quanta.API
    {
        public class Program
        {
            public static void Main(string[] args)
            {
                var host = new WebHostBuilder()
                    .UseKestrel()
                    .UseContentRoot(Directory.GetCurrentDirectory())
                    .UseIISIntegration()
                    .UseStartup&lt;Startup&gt;()
                    .Build();
    
                host.Run();
            }
        }
    }


Edit2:
Per Frans, I checked the publishOptions. It was:

    &quot;publishOptions&quot;: {
    &quot;include&quot;: [
      &quot;wwwroot&quot;,
      &quot;web.config&quot;
    ]

I took a publishOptions from a working project and changed it to:

     &quot;publishOptions&quot;: {
      &quot;include&quot;: [
        &quot;wwwroot&quot;,
        &quot;Views&quot;,
        &quot;Areas/**/Views&quot;,
        &quot;appsettings.json&quot;,
        &quot;web.config&quot;
      ]
      },

It still gave a 500 error, but it didn&#39;t give a stack trace saying it coulding load appsettings.json. Now it was complaining about a connection to SQL. I noticed that my SQL connection string code is mentioned in a lot of RC1 blog posts. RC2 of .Net Core changed it. So I updated it to:

      &quot;Data&quot;: {
        &quot;ConnectionStrings&quot;: {
          &quot;DefaultConnection&quot;: &quot;Server=(localdb)\\MSSQLLocalDB;Database=QuantaDb;Trusted_Connection=True;MultipleActiveResultSets=true&quot;
        }
      },

And changed my startup to:

&lt;!-- language: c# --&gt;

     services.AddDbContext&lt;QuantaContext&gt;(options =&gt;
            options.UseSqlServer(Configuration.GetConnectionString(&quot;DefaultConnection&quot;),
            b =&gt; b.MigrationsAssembly(&quot;Quanta.API&quot;)));

Finally, it worked. 

I must have followed an older RC1 example and not realized it.



The configuration file &#39;appsettings.json&#39; was not found and is not optional

I have an appsettings.json file which looks like this:

    {
        &quot;someSetting&quot;: {
            &quot;subSettings&quot;: [
                &quot;one&quot;,
                &quot;two&quot;,
                &quot;three&quot;
             ]
        }
    }

When I build my configuration root, and do something like `config[&quot;someSetting:subSettings&quot;]` it returns null and the actual settings available are something like this:

`config[&quot;someSettings:subSettings:0&quot;]`

Is there a better way of retrieving the contents of `someSettings:subSettings` as a list?

How to extract a list from appsettings.json in .net core

I have ASP.NET Core application (Web Api). The documentation has explained [working with multiple environments][1], however it failed to explain how to set `aspnetcore_environment` when publishing the web site.     

So lets say if i have 3 environments `Development`, `Staging` and `Production`   

  1. In classic ASP.NET Web Application i used to create 3 build configurations. `Development`, `Staging` and `Production` ( Like shown in picture below).  and then 3 `.pubxml` files, one for each configuration. Do i need to use the same approach for `ASP.NET Core` application as well?

  2. How do i set `aspnetcore_environment` in `.pubxml` file?  

  3. If the approach specified in Question 1 is obsolete, then what&#39;s the alternate approach? ( I use Jenkins for CI)

[![enter image description here][2]][2]
    
**Update 1**
 
I understand that I have to set `ASPNETCORE_ENVIRONMENT` however I am not able to understand where do we set this? During development I can set this in profile in `launchSettings.json`, however question was how do we set this when publishing to staging or production? do we set environment variable on the target server itself? 

[![enter image description here][3]][3]

**Update 2**  
I found article [here][4] that explains different ways of setting environment variable. This partially answered my question. However when I publish the application, the publish process does not honor the environment variable while publishing `appsettings.{env.EnvironmentName}.json`  
I have created separate [post][5] for that question


  [1]: https://docs.asp.net/en/latest/fundamentals/environments.html
  [2]: http://i.stack.imgur.com/8K8Zs.png
  [3]: http://i.stack.imgur.com/55kOO.png
  [4]: http://andrewlock.net/how-to-set-the-hosting-environment-in-asp-net-core/
  [5]: https://stackoverflow.com/questions/39256057/how-to-publish-environment-specific-appsettings-in-net-core-app

Content Type	Original Author	Original Content on Stackoverflow
Question	dknaack	View Question on Stackoverflow
Solution 1 - C#	dknaack	View Answer on Stackoverflow
Solution 2 - C#	jariq	View Answer on Stackoverflow
Solution 3 - C#	Sameer Vartak	View Answer on Stackoverflow

Determine Operating System in .NET Core

C# Problem Overview

C# Solutions

Solution 1 - C#

Method

Possible Argument

Example

Update

Solution 2 - C#

Solution 3 - C#

Run react-native application on iOS device directly from command line?

How to read connection string in .NET Core?

Attributions