`ConfigureAwait` only has effects on code running in the context of&#160;a `SynchronizationContext` which&#160;ASP.NET Core doesn&#39;t have (ASP.NET &quot;Legacy&quot; does).

General purpose code should still&#160;use it because it might be running&#160;with a `SynchronizationContext`.

[ASP.NET Core SynchronizationContext](http://blog.stephencleary.com/2017/03/aspnetcore-synchronization-context.html)

I am getting three warning messages when importing `request` in a barebone webpack project. A minimal example to reproduce the bug is available on [GitHub][2] (run `npm install` and `npm start`).

`Critical dependency: the request of a dependency is an expression`

How can I get rid of this warning?


----------
More information:

Webpack tries to resolve `require` calls statically to make a minimal bundle. When a library uses variables or expressions in a require call (such as `require(&#39;&#39; + &#39;nodent&#39;)` in [these lines][1] of `ajv`), Webpack cannot resolve them statically and imports the entire package.

My rationale is that this dynamic import is not desirable in production, and code is best kept warning-free. That means I want any solution that resolves the problem. E.g.:

 1. Manually configure webpack to import the required libraries and prevent the warnings from occurring.
 2. Adding a `hack.js` file to my project that overrides the require calls in some way.
 3. Upgrading my libraries. `ajv-5.0.1-beta.3` has a fix that silences the warnings. However, if I want to use it, I have to wait until it is released, and then until `har-validator` and `request` release subsequent updates. If there is a way to force `har-validator` to use the beta version of `ajv`, that would solve my problem.
 4. Other


  [1]: https://github.com/epoberezkin/ajv/blob/c19c02aa045f8d8fe55852b4303899f82e6de381/lib/async.js#L78
  [2]: https://github.com/Oduig/webpackfiddle

Webpack - Critical dependency: the request of a dependency is an expression

I have used `use_frameworks!` in CocoaPods `Podfile` many times. I just wonder why do we use it? I couldn&#39;t get the straight forward answer of it.

Example:

    platform :ios, &#39;8.0&#39;
    use_frameworks!
    
    target &quot;CityWhether&quot; do
        pod &#39;Alamofire&#39;
        pod &#39;SwiftyJSON&#39;
    end

Why do we use use_frameworks! in CocoaPods?

I stumbled on an issue (https://github.com/HTBox/allReady/issues/1313) at GitHub where they discussed about taking the `ConfigureAwait(false)` out of the code, claiming that, in **ASP.NET Core**
&gt;the call to `ConfigureAwait(false)` is redundant and does nothing

Best I could find here is a “side note” in an answer (from Stephen Cleary, https://stackoverflow.com/a/40220190/2805831) telling that 
&gt;ASP.NET Core no longer has a &quot;context&quot;


So, is `ConfigureAwait(false)` really unnecessary in **ASP.NET Core** (even if using full .Net Framework)? Does it have any real gain in performance in some cases or difference in the result/semantic?

**EDIT:** Is it different in this aspect if I am hosting it as a console application or in IIS?

ConfigureAwait(false) relevant in ASP.NET Core?

I stumbled on an issue (<a href="https://github.com/HTBox/allReady/issues/1313" target="_blank" rel="noopener noreferrer">https://github.com/HTBox/allReady/issues/1313</a>) at GitHub where they discussed about taking the <code>ConfigureAwait(false)</code> out of the code, claiming that, in ASP.NET Core
>the call to <code>ConfigureAwait(false)</code> is redundant and does nothing
Best I could find here is a “side note” in an answer (from Stephen Cleary, <a href="https://stackoverflow.com/a/40220190/2805831" target="_blank" rel="noopener noreferrer">https://stackoverflow.com/a/40220190/2805831</a>) telling that
>ASP.NET Core no longer has a "context"
So, is <code>ConfigureAwait(false)</code> really unnecessary in ASP.NET Core (even if using full .Net Framework)? Does it have any real gain in performance in some cases or difference in the result/semantic?
EDIT: Is it different in this aspect if I am hosting it as a console application or in IIS?

In C# setting a value to a variable is atomic as long as its size is at most `native int` (i.e. 4 bytes in a 32-bit runtime environment and 8 bytes on a 64-bit one).
In a 64-bit environment that includes all references types and most built-in value types (`byte`, `short`, `int`, `long`, etc.).

Setting a bigger value isn&#39;t atomic and can cause tearing where only part of the memory is updated.

`DateTime` is a struct that includes only a single `ulong` field containing all its data (`Ticks` and the `DateTimeKind`) and `ulong` by itself is atomic in a 64-bit environment.

Does that mean that `DateTime` is atomic as well? Or Can the following code lead to tearing at some point?

    static DateTime _value;
    static void Main()
    {
        for (int i = 0; i &lt; 10; i++)
        {
            new Thread(_ =&gt;
            {
                var random = new Random();
                while (true)
                {
                    _value = new DateTime((long)random.Next() &lt;&lt; 30 | (long)random.Next());
                }
            }).Start();
        }

        Console.ReadLine();
    }





Can DateTime tear in a 64 bit environment?

As I understand the `yield` keyword, if used from inside an iterator block, it returns flow of control to the calling code, and when the iterator is called again, it picks up where it left off.

Also, `await` not only waits for the callee, but it returns control to the caller, only to pick up where it left off when the caller `awaits` the method.

In other words-- [there is no thread](http://blog.stephencleary.com/2013/11/there-is-no-thread.html), and the &quot;concurrency&quot; of async and await is an illusion caused by clever flow of control, the details of which are concealed by the syntax.

Now, I&#39;m a former assembly programmer and I&#39;m very familiar with instruction pointers, stacks, etc. and I get how normal flows of control (subroutine, recursion, loops, branches) work.  But these new constructs-- I don&#39;t get them.

When an `await` is reached, how does the runtime know what piece of code should execute next?  How does it know when it can resume where it left off, and how does it remember where?  What happens to the current call stack, does it get saved somehow?  What if the calling method makes other method calls before it `await`s-- why doesn&#39;t the stack get overwritten?  And how on earth would the runtime work its way through all this in the case of an exception and a stack unwind?

When `yield` is reached, how does the runtime keep track of the point where things should be picked up?  How is iterator state preserved?

How do yield and await implement flow of control in .NET?

I&#39;m having major SQL performance problems when using async calls. I have created a small case to demonstrate the problem.

I have create a database on a SQL Server 2016 which resides in our LAN (so not a localDB).

In that database, I have a table `WorkingCopy` with 2 columns: 

    Id (nvarchar(255, PK))
    Value (nvarchar(max))

**DDL**

    CREATE TABLE [dbo].[Workingcopy]
    (
  	    [Id] [nvarchar](255) NOT NULL, 
 	    [Value] [nvarchar](max) NULL, 

	    CONSTRAINT [PK_Workingcopy] 
            PRIMARY KEY CLUSTERED ([Id] ASC)
	                    WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, 
                              IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, 
                              ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
    ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]

In that table, I have inserted a single record (`id`=&#39;PerfUnitTest&#39;, `Value` is a 1.5mb string (a zip of a larger JSON dataset)).

Now, if I execute the query in SSMS :

    SELECT [Value] 
    FROM [Workingcopy] 
    WHERE id = &#39;perfunittest&#39;

I immediately get the result, and I see in SQL Servre Profiler that the execution time was around 20 milliseconds. All normal.

When executing the query from .NET (4.6) code using a plain `SqlConnection` :

	// at this point, the connection is already open
	var command = new SqlCommand($&quot;SELECT Value FROM WorkingCopy WHERE Id = @Id&quot;, _connection);
	command.Parameters.Add(&quot;@Id&quot;, SqlDbType.NVarChar, 255).Value = key;

	string value = command.ExecuteScalar() as string;
			
The execution time for this is also around 20-30 milliseconds. 

But when changing it to async code : 

    string value = await command.ExecuteScalarAsync() as string;

The execution time is suddenly **1800 ms** ! Also in SQL Server Profiler, I see that the query execution duration is more than a second. Although the executed query reported by the profiler is exactly the same as the non-Async version.

But it gets worse. If I play around with the Packet Size in the connection string, I get the following results :

&gt; Packet size  32768 : [TIMING]: ExecuteScalarAsync in SqlValueStore -&gt;
&gt; elapsed time : 450 ms
&gt; 
&gt; Packet Size 4096 : [TIMING]: ExecuteScalarAsync in SqlValueStore -&gt;
&gt; elapsed time : 3667 ms
&gt; 
&gt; Packet size  512 : [TIMING]: ExecuteScalarAsync in SqlValueStore -&gt;
&gt; elapsed time : 30776 ms

**30,000 ms**!! That&#39;s over a 1000x slower than the non-async version. And SQL Server Profiler reports that the query execution took over 10 seconds. That doesn&#39;t even explain where the other 20 seconds are gone to!

Then I&#39;ve switched back to the sync version and also played around with the Packet Size, and although it did impact a little the execution time, it was nowhere as dramatic as with the async version.

As a sidenote, if it put just a small string (&lt; 100bytes) into the value, the async query execution is just as fast as the sync version (result in 1 or 2 ms).

I&#39;m really baffled by this, especially since I&#39;m using the built-in `SqlConnection`, not even an ORM. Also when searching around, I found nothing which could explain this behavior. Any ideas?

Horrible performance using SqlCommand Async methods with large data

I have a rather strange problem that is occurring.

This is my code:

    private async Task BreakExpectedLogic()
    {
        bool test = false;
        if (test == true)
        {
            Console.WriteLine(&quot;Hello!&quot;);
            throw new Exception(&quot;BAD HASH!&quot;);
        }
    }

Seems really simple, it shouldn&#39;t hit the `Console.WriteLine` or the `throw`.
For some reason it&#39;s always hitting the `throw`.

If I move the `throw` into its own method then it works fine. My question is how is it ignoring the `if` block and hitting the `throw new Exception`:


[![Here is some evidence][1]][1]


  [1]: https://i.stack.imgur.com/XpP8d.png

**EDIT 1:** I&#39;ve updated my code to include the signature, I&#39;ve removed everything not related to this problem and ran it, it still happens.

If (false == true) executes block when throwing exception is inside

I have a .Net Core project web project, and for various reasons want to convert it to a .Net Framework project.

Is there an easy way to do this, or do I have to start again and import the code from the previous projects

Convert .Net Core to .Net Framework

I recently installed VS 2017 RC and then automatically my dotnet version pointed to `1.0.0-preview4-004233`. Due to that whenever I create a new project using command `dotnet new -t Console` I cannot see `project.json` though I see `.csproj` file. 

When I check dotnet versions available on my machine at - `C:\Program Files\dotnet\sdk` I see multiple versions available. 

Is there any way to switch dotnet core back to an earlier version - `1.0.0-preview2-003133` from `1.0.0-preview4-004233` without uninstalling.

Switch between dotnet core SDK versions

I&#39;m trying to understand the proper way to do authentication in ASP.NET Core. I&#39;ve looked at several Resource (Most of which are out dated).  
   

 - [Simple-Implementation-Of-Microsoft-Identity](https://weblogs.asp.net/imranbaloch/a-simple-implementation-of-microsoft-aspnet-identity)
  
 -  [Introduction to Authentication with ASP.Core](https://andrewlock.net/introduction-to-authentication-with-asp-net-core/)

 -  [MSDNs Introduction to Identity](https://docs.microsoft.com/en-us/aspnet/core/security/authentication/identity)

Some people provide altenative solutions stating to use a cloud based solution such as Azure AD, or to Use IdentityServer4 and host my own Token Server.

In Older version Of .Net one of the simpler forms of authentication would be to create an Custom Iprinciple and store additional authentication user data inside.

    public interface ICustomPrincipal : System.Security.Principal.IPrincipal
    {
        string FirstName { get; set; }
 
        string LastName { get; set; }
    }
    
    public class CustomPrincipal : ICustomPrincipal
    {
        public IIdentity Identity { get; private set; }
 
        public CustomPrincipal(string username)
	    {
		    this.Identity = new GenericIdentity(username);
	    }
 
	    public bool IsInRole(string role)
	    {
		    return Identity != null &amp;&amp; Identity.IsAuthenticated &amp;&amp; 
		       !string.IsNullOrWhiteSpace(role) &amp;&amp; Roles.IsUserInRole(Identity.Name, role);
	    }

	    public string FirstName { get; set; }

	    public string LastName { get; set; }

	    public string FullName { get { return FirstName + &quot; &quot; + LastName; } }
    }

    public class CustomPrincipalSerializedModel
    {
        public int Id { get; set; }
 
        public string FirstName { get; set; }
 
        public string LastName { get; set; }
    }

Then you would Serialize your data into a cookie and return it back to the client.

    public void CreateAuthenticationTicket(string username) {     
 
        var authUser = Repository.Find(u =&gt; u.Username == username);  
        CustomPrincipalSerializedModel serializeModel = new CustomPrincipalSerializedModel();
      
        serializeModel.FirstName = authUser.FirstName;
        serializeModel.LastName = authUser.LastName;
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        string userData = serializer.Serialize(serializeModel);
      
        FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
        1,username,DateTime.Now,DateTime.Now.AddHours(8),false,userData);
        string encTicket = FormsAuthentication.Encrypt(authTicket);
        HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
        Response.Cookies.Add(faCookie);
    }


My questions are:

  1.  How can I authenticate similar to the way done in previous version&#39;s of .Net does the old way still work or is there a newer version.

  2.  What are the pros and cons of using your own token server verses creating your own custom principle?
    
  3.  When using a cloud based solution or a separate Token server how would you Integrate that with your current application, would I would still need a users table in my application how would you associate the two?
    
  4.  Being that there are so many different solutions how can I create an enterprise application, to allow Login through Gmail/Facebook while still being able to expand to other SSO&#39;s
  5.  What are some simple implementations of these technologies?

.NET Core Identity Server 4 Authentication VS Identity Authentication

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.



Enable OPTIONS header for CORS on .NET Core Web API

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

Finally `async`/`await` will be [supported][1] in all major browser soon except IE.
So now we can start writing more readable code with `async`/`await` but there is a catch. A lot of people use async await like this:

    const userResponse = await fetchUserAsync();
    const postsResponse = await fetchPostsAsync();

While this code is readable it has a problem, it runs the functions in series, it won&#39;t start fetching posts until the fetching of the user is finished. The solutions is simple, we need to fetch the resources in parallel.

So what I want to do is (in pseudo language): 


    fn task() {
      result-1 = doAsync();
      result-2 = doAsync();
      result-n = doLongAsync();
    
      // handle results together
      combinedResult = handleResults(result-1, result-2);

      lastResult = handleLastResult(result-n);
    }



  [1]: http://kangax.github.io/compat-table/es2016plus/#test-async_functions

How run async / await in parallel in Javascript

Is it safe to use async-await in Javascript instead of
generators-promises now, knowing that the syntax has not made yet and
will be coming with the release of ES8?

What browsers can I count on it being available, and how common are the browsers where this syntax is not available?  By Safe I mean without some transpilers like babel?

Is it safe to use async/await now?

[`asyncio.gather`][1] and [`asyncio.wait`][2] seem to have similar uses: I have a bunch of async things that I want to execute/wait for (not necessarily waiting for one to finish before the next one starts). They use a different syntax, and differ in some details, but it seems very un-pythonic to me to have 2 functions that have such a huge overlap in functionality. What am I missing?


  [1]: https://docs.python.org/3/library/asyncio-task.html#asyncio.gather
  [2]: https://docs.python.org/3/library/asyncio-task.html#asyncio.wait

Asyncio.gather vs asyncio.wait

I am struggling to figure out the issue with the following syntax:

    export const sendVerificationEmail = async () =&gt;
      (dispatch) =&gt; {
        try {
          dispatch({ type: EMAIL_FETCHING, payload: true });
          await Auth.sendEmailVerification();
          dispatch({ type: EMAIL_FETCHING, payload: false }))
        } catch (error) {
          dispatch({ type: EMAIL_FETCHING, payload: false });
          throw new Error(error);
        }
      };

I keep getting error saying:

&gt; await is a reserved word

...but isn&#39;t it legal within an async function?

The dispatch bit is coming from the [**react-thunk**][1] library.


  [1]: https://github.com/gaearon/redux-thunk

Content Type	Original Author	Original Content on Stackoverflow
Question	Pedro Lorentz	View Question on Stackoverflow
Solution 1 - .Net	Paulo Morgado	View Answer on Stackoverflow

ConfigureAwait(false) relevant in ASP.NET Core?

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

Why do we use use_frameworks! in CocoaPods?

Webpack - Critical dependency: the request of a dependency is an expression

Attributions