I&#39;m using Auth0 to handle authentication in my web app. I&#39;m using ASP.NET Core v1.0.0 and Angular 2 rc5 and I don&#39;t know much about authentication/security in general.

In the [Auth0 docs for ASP.NET Core Web Api][1], there are two choices for the JWT algorithm being RS256 and HS256. This may be a dumb question but:

**What&#39;s the difference between RS256 and HS256? What are some use cases (if applicable)?**


  [1]: https://auth0.com/docs/quickstart/backend/aspnet-core-webapi/01-authorization

RS256 vs HS256: What&#39;s the difference?

I&#39;m looking for the correct way to return JSON with a HTTP status code in my .NET Core Web API controller. I use to use it like this:

    public IHttpActionResult GetResourceData()
    {
        return this.Content(HttpStatusCode.OK, new { response = &quot;Hello&quot;});
    }

This was in a 4.6 MVC application but now with .NET Core I don&#39;t seem to have this `IHttpActionResult` I have `ActionResult` and using like this:

    public ActionResult IsAuthenticated()
    {
        return Ok(Json(&quot;123&quot;));
    }

But the response from the server is weird, as in the image below:

[![enter image description here][1]][1]

I just want the Web API controller to return JSON with a HTTP status code like I did in Web API 2.

  [1]: https://i.stack.imgur.com/DpSlo.png

ASP.NET Core return JSON with status code

## Problem
I want to return a file in my ASP.Net Web API Controller, but all my approaches return the `HttpResponseMessage` as JSON.

## Code so far

    public async Task&lt;HttpResponseMessage&gt; DownloadAsync(string id)
    {
        var response = new HttpResponseMessage(HttpStatusCode.OK);
        response.Content = new StreamContent({{__insert_stream_here__}});
        response.Content.Headers.ContentType = new MediaTypeHeaderValue(&quot;application/octet-stream&quot;);
        return response;
    }

When I call this endpoint in my browser, the Web API returns the `HttpResponseMessage` as JSON with the HTTP Content Header set to ``application/json``.

Return file in ASP.Net Core Web API

I want the example controller below to return a status code 418 with no contents. Setting the status code is easy enough but then it seems like there is something that needs to be done to signal the end of the request. In MVC prior to ASP.NET Core or in WebForms that might be a call to `Response.End()` but how does it work in ASP.NET Core where `Response.End` does not exist?

    public class ExampleController : Controller
    {
        [HttpGet][Route(&quot;/example/main&quot;)]
        public IActionResult Main()
        {
            this.HttpContext.Response.StatusCode = 418; // I&#39;m a teapot
            // How to end the request?
            // I don&#39;t actually want to return a view but perhaps the next
            // line is required anyway?
            return View();   
        }
    }

How to return a specific status code and no contents from Controller?

I am porting my API from Web API 2 to ASP.NET Core Web API.  I used to be able to add a custom header in the following manner:

      HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
      response.Headers.Add(&quot;X-Total-Count&quot;, count.ToString());
      return ResponseMessage(response);

How does one add a custom header in ASP.NET Core Web API?

How to add custom header to ASP.NET Core Web API response

ASP.NET Core API controllers typically return explicit types (and do so by default if you create a new project), something like:

    [Route(&quot;api/[controller]&quot;)]
    public class ThingsController : Controller
    {
        // GET api/things
        [HttpGet]
        public async Task&lt;IEnumerable&lt;Thing&gt;&gt; GetAsync()
        {
            //...
        }

        // GET api/things/5
        [HttpGet(&quot;{id}&quot;)]
        public async Task&lt;Thing&gt; GetAsync(int id)
        {
            Thing thingFromDB = await GetThingFromDBAsync();
            if(thingFromDB == null)
                return null; // This returns HTTP 204

            // Process thingFromDB, blah blah blah
            return thing;
        }

        // POST api/things
        [HttpPost]
        public void Post([FromBody]Thing thing)
        {
            //..
        }

        //... and so on...
    }

The problem is that `return null;` - it returns an HTTP `204`: success, no content.

This is then regarded by a lot of client side Javascript components as success, so there&#39;s code like:

    const response = await fetch(&#39;.../api/things/5&#39;, {method: &#39;GET&#39; ...});
    if(response.ok)
        return await response.json(); // Error, no content!

A search online (such as [this question][1] and [this answer][2]) points to helpful `return NotFound();` extension methods for the controller, but all these return `IActionResult`, which isn&#39;t compatible with my `Task&lt;Thing&gt;` return type. That design pattern looks like this:

    // GET api/things/5
    [HttpGet(&quot;{id}&quot;)]
    public async Task&lt;IActionResult&gt; GetAsync(int id)
    {
        var thingFromDB = await GetThingFromDBAsync();
        if (thingFromDB == null)
            return NotFound();
    
        // Process thingFromDB, blah blah blah
        return Ok(thing);
    }

That works, but to use it the return type of `GetAsync` must be changed to `Task&lt;IActionResult&gt;` - the explicit typing is lost, and either all the return types on the controller have to change (i.e. not use explicit typing at all) or there will be a mix where some actions deal with explicit types while others. In addition unit tests now need to make assumptions about the serialisation and explicitly deserialise the content of the `IActionResult` where before they had a concrete type.

There are loads of ways around this, but it appears to be a confusing mishmash that could easily be designed out, so the real question is: **what is the correct way intended by the ASP.NET Core designers?**

It seems that the possible options are:

1. Have a weird (messy to test) mix of explicit types and `IActionResult` depending on expected type.
2. Forget about explicit types, they&#39;re not really supported by Core MVC, _always_ use `IActionResult` (in which case why are they present at all?)
3. Write an implementation of `HttpResponseException` and use it like `ArgumentOutOfRangeException` (see [this answer][3] for an implementation). However, that does require using exceptions for program flow, which is generally a bad idea and also [deprecated by the MVC Core team][4].
4. Write an implementation of `HttpNoContentOutputFormatter` that returns `404` for GET requests.
5. Something else I&#39;m missing in how Core MVC is supposed to work?
6. Or is there a reason why `204` is correct and `404` wrong for a failed GET request?

These all involve compromises and refactoring that lose something or add what seems to be unnecessary complexity at odds with the design of MVC Core. Which compromise is the correct one and why?


  [1]: https://stackoverflow.com/questions/37793418/how-to-return-http-500-from-asp-net-core-rc2-web-api
  [2]: https://stackoverflow.com/a/41465343
  [3]: https://stackoverflow.com/a/41484262/905
  [4]: https://github.com/aspnet/Mvc/issues/4311#issuecomment-198324107

Returning a 404 from an explicitly typed ASP.NET Core API controller (not IActionResult)

I&#39;m in the process of building an ASP.NET Core WebAPI and I&#39;m attempting to write unit tests for the controllers.  Most examples I&#39;ve found are from the older WebAPI/WebAPI2 platforms and don&#39;t seem to correlate with the new Core controllers.

My controller methods are returning `IActionResults`.  However, the `IActionResult` object only has a `ExecuteResultAsync()` method which requires a controller context.  I&#39;m instantiating the controller manually, so the controller context in this instance is null, which causes an exception when calling `ExecuteResultAsync`.  Essentially this is leading me down a very hacky path to get these unit tests to successfully complete and is very messy. I&#39;m left wondering that there must be a more simple/correct way of testing API controllers.

Also, my controllers are NOT using async/await if that makes a difference.

Simple example of what I&#39;m trying to achieve:

Controller method:

    [HttpGet(Name = &quot;GetOrdersRoute&quot;)]
    public IActionResult GetOrders([FromQuery]int page = 0)
    {
         try
         {
            var query = _repository.GetAll().ToList();
            
            int totalCount = query.Count;
            int totalPages = (int)Math.Ceiling((double)totalCount / pageSize) - 1;
            var orders = query.Skip(pageSize * page).Take(pageSize);

            return Ok(new
            {
               TotalCount = totalCount,
               TotalPages = totalPages,

               Orders = orders
            });
         }
         catch (Exception ex)
         {
            return BadRequest(ex);
         }
    }

Unit test:

	[Fact]
    public void GetOrders_WithOrdersInRepo_ReturnsOk()
    {
         // arrange
         var controller = new OrdersController(new MockRepository());

         // act
         IActionResult result = controller.GetOrders();
         
         // assert
         Assert.Equal(HttpStatusCode.OK, ????);
    }

Unit testing controller methods which return IActionResult

It might have been asked before but I cannot find even in the official site why I should use MediatR and what problems it solves?  


 - Is it because I can pass a single object in my constructor rather than a multitude of Interfaces?

 - Is it a replacement or competitor of ServicesBus etc...

 - Basically what are the benefit and what problem does it solve

I want to buy into it but its not clear to me why I should use it.

many thanks



MediatR when and why I should use it?

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&#39;m developing an ASP.Net Core web application where I need to create a kind of &quot;authentication proxy&quot; to another (external) web service.

What I mean by authentication proxy is that I will receive requests through a specific path of my web app and will have to check the headers of those requests for an authentication token that I&#39;ll have issued earlier, and then redirect all the requests with the same request string / content to an external web API which my app will authenticate with through HTTP Basic auth.

Here&#39;s the whole process in pseudo-code

 - Client requests a token by making a POST to a unique URL that I sent him earlier
 - My app sends him a unique token in response to this POST
 - Client makes a GET request to a specific URL of my app, say `/extapi` and adds the auth-token in the HTTP header
 - My app gets the request, checks that the auth-token is present and valid
 - My app does the same request to the external web API and authenticates the request using BASIC authentication
 - My app receives the result from the request and sends it back to the client

Here&#39;s what I have for now. It seems to be working fine, but I&#39;m wondering if it&#39;s really the way this should be done or if there isn&#39;t a more elegant or better solution to this? Could that solution create issues in the long run for scaling the application?

    [HttpGet]
    public async Task GetStatement()
    {
        //TODO check for token presence and reject if issue

        var queryString = Request.QueryString;
        var response = await _httpClient.GetAsync(queryString.Value);
        var content = await response.Content.ReadAsStringAsync();

        Response.StatusCode = (int)response.StatusCode;
        Response.ContentType = response.Content.Headers.ContentType.ToString();
        Response.ContentLength = response.Content.Headers.ContentLength;

        await Response.WriteAsync(content);
    }

    [HttpPost]
    public async Task PostStatement()
    {
        using (var streamContent = new StreamContent(Request.Body))
        {
            //TODO check for token presence and reject if issue

            var response = await _httpClient.PostAsync(string.Empty, streamContent);
            var content = await response.Content.ReadAsStringAsync();

            Response.StatusCode = (int)response.StatusCode;

            Response.ContentType = response.Content.Headers.ContentType?.ToString();
            Response.ContentLength = response.Content.Headers.ContentLength;
                
            await Response.WriteAsync(content);
        }
    }

`_httpClient` being a `HttpClient` class instantiated somewhere else and being a singleton and with a `BaseAddress`of `http://someexternalapp.com/api/`

Also, is there a simpler approach for the token creation / token check than doing it manually?

Creating a proxy to another web api with Asp.net core

Using **asp.net core web api**, I want to have my controller action method to return an **jpeg image stream**. &lt;br&gt;
In my current implementation, browser **displays only a json string**.
My expectation is to see the image in the  browser.

While debugging using chrome developer tools I found that the content type is still

`Content-Type:application/json; charset=utf-8` 

 returned in the response header, even though in my code I manually set the content type to &quot;image/jpeg&quot;.

**Looking for a solution**  My Web API is as below

    [HttpGet]
    public async Task&lt;HttpResponseMessage&gt; Get()
    {
        var image = System.IO.File.OpenRead(&quot;C:\\test\random_image.jpeg&quot;);
        var stream = new MemoryStream();

        image.CopyTo(stream);
        stream.Position = 0;            
        result.Content = new StreamContent(image);
        result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue(&quot;attachment&quot;);
        result.Content.Headers.ContentDisposition.FileName = &quot;random_image.jpeg&quot;;
        result.Content.Headers.ContentType = new MediaTypeHeaderValue(&quot;image/jpeg&quot;);
        result.Content.Headers.ContentLength = stream.Length;
         
        return result;
    }

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/bMt50.png

Return jpeg image from Asp.Net Core WebAPI

After a lot of struggling (and a lot of tuturials, guides, etc) I managed to setup a small .NET Core REST Web API with an Auth Controller issuing JWT tokens when stored username and password are valid.

The token stores the user id as sub claim.

I also managed to setup the Web API to validate those tokens when a method uses the Authorize annotation.

&lt;pre&gt; app.UseJwtBearerAuthentication(...)&lt;/pre&gt;

Now my question:
How do I read the user id (stored in the subject claim) in my controllers (in a Web API)?

It is basically this question ([How do I get current user in ASP .NET Core][1]) but I need an answer for a web api. And I do not have a UserManager. So I need to read the subject claim from somewhere.


  [1]: https://stackoverflow.com/questions/36641338/how-get-current-user-in-asp-net-core%20

How do I get current user in .NET Core Web API (from JWT Token)

I want to send data of object to my Web API. The API accepts a parameter of class, which properties are type of int and string.

This is my class:

    public class deneme
    {
       public int ID { get; set; }
       public int sayi { get; set; }
       public int reqem { get; set; }
       public string yazi { get; set; }
    }

This is my JSON object:

    {
       &quot;id&quot;:0,
       &quot;sayi&quot;:&quot;9&quot;,
       &quot;reqem&quot;:8,
       &quot;yazi&quot;:&quot;sss&quot;
    }



I want the api read the property &quot;sayi&quot; as integer.
but because it cant, it gives the error: 

    The JSON value could not be converted to System.Int32. Path: $.sayi

How could I solve this problem?

The JSON value could not be converted to System.Int32

We have an **ASP.NET Core 2.0** web site that also presents a couple of simple **Web API** methods for UI enhancement purposes.

The **Web API** calls work as expected when running locally under **IIS Express**, but when we deploy to our **IIS 8.5** production web server, we get the following error when making HTTP `DELETE` and `PUT` requests...

    405 Method Not Allowed

After some web searching, we have found several posts suggesting the removal of the IIS **WebDAV** module.  We have disabled this in IIS (it is our server), and we have also tried the following:

 - Disabled _WebDAV_
 - Enabled _WebDev_ and set `Allow verb filtering = False`
 - Set the _Hander Mappings_ to allow _All Verbs_ in the _Request Restrictions_ settings for: `aspNetCore`, `WebDAV` and `ExtensionlessUrlHandler-Integrated-4.0`

None of the above steps have resolved our problem.

Any advice/direction would be much appreciated.

ASP.NET Core with IIS - HTTP Verb Not Allowed

I want to debug an empty WebApi Project based on .NET Core 2.2.

I installed the &quot;Core 2.2 SDK x86&quot; and changed the target framework to 2.2:

```
&lt;Project Sdk=&quot;Microsoft.NET.Sdk.Web&quot;&gt;
  &lt;PropertyGroup&gt;
    &lt;TargetFramework&gt;netcoreapp2.2&lt;/TargetFramework&gt;
  &lt;/PropertyGroup&gt;
```

When I started to debug this project, IIS starts, but in the route `api/values` I see nothing (it loads forever) and I get this error:

&gt; The target process exited without raising a CoreCLR started event.Ensure that the target process is configured to use .NET Core. This may be expected if the target process did not run on .NET Core

In my solution WPF and Class Library projects exist. I wanted to make a WebApi for it. Like I said, it&#39;s an empty base project generated by Visual Studio 2019. I just installed Core 2.2. Why do I get that error and what am I doing wrong?

[![][1]][1]


  [1]: https://i.stack.imgur.com/gt8jT.png


The target process exited without raising CoreCLR started event error with .NET Core 2.2

I am developing some Web API with .NET Core 3.0 and want to integrate it with SwashBuckle.Swagger.
It is working fine, but when I add JWT authentication, it does not work as I expect.
To do that, I added the code below:

&lt;!-- language: lang-cs --&gt;

    services.AddSwaggerGen(c =&gt;
        {
            c.SwaggerDoc(&quot;v1&quot;, new Microsoft.OpenApi.Models.OpenApiInfo { Title = &quot;My Web API&quot;, Version = &quot;v1&quot; });
            c.AddSecurityDefinition(&quot;Bearer&quot;, new OpenApiSecurityScheme
            {
                Description = &quot;JWT Authorization header using the Bearer scheme. Example: \&quot;Authorization: Bearer {token}\&quot;&quot;,
                Name = &quot;Authorization&quot;,
                In = ParameterLocation.Header,
                Type = SecuritySchemeType.ApiKey
            });
        });

After adding `AddSecurityDefinition` function, I can see the Authorize button and when I click it, I see the form below:
[![enter image description here][1]][1]

Then I type `Bearer WhatEverApiKeyIsfgdgdgdg845734987fgdhgiher635kjh`. After doing it, I expect to see `authorization: Bearer WhatEverApiKeyIsfgdgdgdg845734987fgdhgiher635kjh` in the request&#39;s header when I send a request to the Web API from Swagger, but authorization is not added to the request header. I am using SwashBuckle.Swagger(5.0.0-rc3). Please note there are many samples which work fine on .NET Core 2.0, but Swashbuckle swagger functions has changed on the latest version so I cannot use those samples.


  [1]: https://i.stack.imgur.com/gNgds.png


JWT Authentication and Swagger with .NET Core 3.0

I have a method to get header value using `IHttpContextAccessor`

    public class HeaderConfiguration : IHeaderConfiguration
    {
        public HeaderConfiguration()
        {
           
        }

        public string GetTenantId(IHttpContextAccessor httpContextAccessor)
        {
            return httpContextAccessor.HttpContext.Request.Headers[&quot;Tenant-ID&quot;].ToString();
        }
    }

I am testing `GetBookByBookId` method

Let&#39;s say the method looks like this:
  
    public class Book
    {
        private readonly IHttpContextAccessor _httpContextAccessor;
        private IHeaderConfiguration _headerConfiguration;
        private string _tenantID;

        public Book(IHeaderConfiguration headerConfiguration, IHttpContextAccessor httpContextAccessor){
            var headerConfig = new HeaderConfiguration();
            _httpContextAccessor = httpContextAccessor;
            _tenantID = headerConfig.GetTenantId(_httpContextAccessor);
        }

        public Task&lt;List&lt;BookModel&gt;&gt; GetBookByBookId(string id){
        	//do something with the _tenantId
        	//...
        }
    }

Here&#39;s my unit test for `GetBookByBookId` method

    [Fact]
    public void test_GetBookByBookId()
    {
        //Arrange

        //Mock IHttpContextAccessor
        var mockHttpContextAccessor = new Mock&lt;IHttpContextAccessor&gt;();

        mockHttpContextAccessor.Setup(req =&gt; req.HttpContext.Request.Headers[&quot;Tenant-ID&quot;].ToString()).Returns(It.IsAny&lt;string&gt;());
        //Mock HeaderConfiguration
        var mockHeaderConfiguration = new Mock&lt;IHeaderConfiguration&gt;();
        mockHeaderConfiguration.Setup(x =&gt; x.GetTenantId(mockHttpContextAccessor.Object)).Returns(It.IsAny&lt;string&gt;());

        var book = new Book( mockHttpContextAccessor.Object, mockHeaderConfiguration.Object);

        var bookId = &quot;100&quot;;

        //Act
        var result = book.GetBookByBookId(bookId);

        //Assert
        result.Result.Should().NotBeNull().And.
            BeOfType&lt;List&lt;BookModel&gt;&gt;();
    }

But for this line:

    mockHttpContextAccessor.Setup(req =&gt; req.HttpContext.Request.Headers[&quot;Tenant-ID&quot;].ToString()).Returns(It.IsAny&lt;string&gt;());

It says 

&gt; System.NotSupportedException: &#39;Type to mock must be an interface or an abstract or non-sealed class. &#39;

I was wondering what&#39;s the proper way to mock `IHttpContextAccessor` with header value?





Mock IHttpContextAccessor in Unit Tests

Is this a good practice to always add CancellationToken in my actions no matter if operation is long or not?

I&#39;m currently adding it to every action and I don&#39;t know if it&#39;s right or wrong.

    [ApiController]
    [Route(&quot;api/[controller]&quot;)]
    public class DummiesController : ControllerBase
    {
        private readonly AppDbContext _dbContext;
    
        public DummyController(AppDbContext dbContext)
        {
            _dbContext = dbContext;
        }
    
        [HttpGet(&quot;{id}&quot;)]
        public async Task&lt;ActionResult&lt;Dummy&gt;&gt; GetAsync(int id, CancellationToken ct) // &lt;&lt;----- should I always do this?
        {
            var dummy = await _dbContext.Dummies.AsNoTracking().SingleOrDefaultAsync(e=&gt;e.Id == id, ct);
            if (dummy == null) return NotFound();
            return dummy;
        }
    }

Also is adding `CancellationToken ct = default(CancellationToken)` necessary?

Should I always add CancellationToken to my controller actions?

I&#39;m using ASP.NET Core 2.0 application (Web API) as a JWT issuer to generate a token consumable by a mobile app. Unfortunately, this token couldn&#39;t be validated by one controller while can be validated by another (using the same validation setting within the same asp.net core 2.0 app).

So I have a token which is valid and could be decoded, has all the required claims and timestamps. But one endpoint accepts it, while another gives me 401 error and debug output: 

&gt; Microsoft.AspNetCore.Authorization.DefaultAuthorizationService:Information:
&gt; Authorization failed for user: (null).


    [40m[32minfo[39m[22m[49m: Microsoft.AspNetCore.Authorization.DefaultAuthorizationService[2]
          Authorization failed for user: (null).
    Microsoft.AspNetCore.Authorization.DefaultAuthorizationService:Information: Authorization failed for user: (null).
    [40m[32minfo[39m[22m[49m: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[3]
          Authorization failed for the request at filter &#39;Microsoft.AspNetCore.Mvc.Authorization.AuthorizeFilter&#39;.
    Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker:Information: Authorization failed for the request at filter &#39;Microsoft.AspNetCore.Mvc.Authorization.AuthorizeFilter&#39;.
    Microsoft.AspNetCore.Mvc.ChallengeResult:Information: Executing ChallengeResult with authentication schemes ().
    [40m[32minfo[39m[22m[49m: Microsoft.AspNetCore.Mvc.ChallengeResult[1]
          Executing ChallengeResult with authentication schemes ().
    [40m[32minfo[39m[22m[49m: Microsoft.AspNetCore.Authentication.JwtBearer.JwtBearerHandler[12]
          AuthenticationScheme: Bearer was challenged.
    Microsoft.AspNetCore.Authentication.JwtBearer.JwtBearerHandler:Information: AuthenticationScheme: Bearer was challenged.
    [40m[32minfo[39m[22m[49m: Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker[2]
          Executed action MyController.Get (WebApi) in 72.105ms
    Microsoft.AspNetCore.Mvc.Internal.ControllerActionInvoker:Information: Executed action MyController.Get (WebApi) in 72.105ms
    Microsoft.AspNetCore.Hosting.Internal.WebHost:Information: Request finished in 271.077ms 401 
    [40m[32minfo[39m[22m[49m: Microsoft.AspNetCore.Hosting.Internal.WebHost[2]
          Request finished in 271.077ms 401 



My validation setup is below:

    var secretKey = Configuration[&quot;Authentication:OAuth:IssuerSigningKey&quot;];
    var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(secretKey));
    var tokenValidationParameters = new TokenValidationParameters
    {
       ValidateIssuerSigningKey = true,
       IssuerSigningKey = signingKey,
       ValidateIssuer = true,
       ValidIssuer = Configuration[&quot;Authentication:OAuth:Issuer&quot;],
       ValidateAudience = true,
       ValidAudience = Configuration[&quot;Authentication:OAuth:Audience&quot;],
       ValidateLifetime = true,
       ClockSkew = TimeSpan.Zero,
    };
    
    services.AddAuthentication(options =&gt;
    {
       options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
       options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
       options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    }).AddJwtBearer(options =&gt;
    {
        options.RequireHttpsMetadata = false;
        options.TokenValidationParameters = tokenValidationParameters;
    });

These two endpoints are identical, just live in different controllers, both marked with the `Authorize` attribute.

How is that possible?

ASP.NET Core 2.0 JWT Validation fails with `Authorization failed for user: (null)` error

I solved this problem after not finding the solution on Stackoverflow, so I am sharing my problem here and the solution in an answer.

After enabling a cross domain policy in my .NET Core Web Api application with AddCors, it still does not work from browsers. This is because browsers, including Chrome and Firefox, will first send an OPTIONS request and my application just responds with 204 No Content.



All asp.net Core-Webapi Solutions on Gang of Coders

Total of 20 asp.net Core-Webapi Solutions

RS256 vs HS256: What's the difference?