It&#39;s a bug in the compiler - at least in Roslyn version 1.0.0.50618. From section 8.5.2 of the C# 5 specification:

&gt; A *local-constant-declaration* declares one or more local constants.
&gt;
&gt;  *local-constant-declaration*:  
&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;`const` *type* *constant-declarators*  
&gt; 
&gt; *constant-declarators*:  
&gt; &amp;nbsp;&amp;nbsp;*constant-declarator*  
&gt; &amp;nbsp;&amp;nbsp;*constant-declarators*   `,`   *constant-declarator*  
&gt;
&gt; *constant-declarator*:
&gt; &amp;nbsp;&amp;nbsp;*identifier*   `=`   *constant-expression*

As you can see, that grammar doesn&#39;t allow for `const const const bool flag = true;`.

I&#39;ve filed a [bug against Roslyn][1] so that it can get fixed.


  [1]: https://github.com/dotnet/roslyn/issues/6761

Similar to the MySQL `show variables` command that shows all variables and not just the ones defined in `my.ini`, I would like to see a list of **all** config variables in `git` **along with** their default values, and not just those defined in my `~/.gitconfig`. 

Is this possible?


git config: list all variables and their default values

I used `Sleep(500)` in my code and I used `getTickCount()` to test the timing. I found that it has a cost of about 515ms, more than 500. Does somebody know why that is?


Why does Sleep(500) cost more than 500ms?

I noticed that if I write something like:

    static void Main(string[] args)
    {
        const const const bool flag = true;
    }

The compiler doesn&#39;t warn me of the multiple `const`s. So this seems to mimic C modifiers, as they are idempotent.

However, if I write:

    private readonly readonly int a;

The compiler *does* warn me of the duplicated `readonly`.

So what&#39;s going on here? Are modifiers idempotent or not?

---

&lt;sup&gt;csc version 1.0.0.50618&lt;/sup&gt;


Idempotent modifiers in C#

I noticed that if I write something like:
<pre><code class="hljs language-c">static void Main(string[] args)
{
 const const const bool flag = true;
}
</code></pre>
The compiler doesn't warn me of the multiple <code>const</code>s. So this seems to mimic C modifiers, as they are idempotent.
However, if I write:
<pre><code class="hljs language-csharp">private readonly readonly int a;
</code></pre>
The compiler does warn me of the duplicated <code>readonly</code>.
So what's going on here? Are modifiers idempotent or not?
<hr>
csc version 1.0.0.50618

The new ASP.NET Core framework gives us ability to execute different html for different environments:

    &lt;environment names=&quot;Development&quot;&gt;
        &lt;link rel=&quot;stylesheet&quot; href=&quot;~/lib/material-design-lite/material.css&quot; /&gt;
        &lt;link rel=&quot;stylesheet&quot; href=&quot;~/css/site.css&quot; /&gt;
    &lt;/environment&gt;
    &lt;environment names=&quot;Staging,Production&quot;&gt;
        &lt;link rel=&quot;stylesheet&quot; href=&quot;https://ajax.aspnetcdn.com/ajax/bootstrap/3.0.0/css/bootstrap.min.css&quot;
              asp-fallback-href=&quot;~/lib/material-design-lite/material.min.css&quot;
              asp-fallback-test-class=&quot;hidden&quot; asp-fallback-test-property=&quot;visibility&quot; asp-fallback-test-value=&quot;hidden&quot;/&gt;
        &lt;link rel=&quot;stylesheet&quot; href=&quot;~/css/site.css&quot; asp-append-version=&quot;true&quot;/&gt;
    &lt;/environment&gt;

But **how can I determine and visualize the name of the current environment in the `_Layout.cshtml`** of an ASP.NET Core MVC web application?

For example I want to visualize the environment name (Production, Staging, Dev) as a HTML comment for debugging purposes:

    &lt;!-- Environment name: @......... --&gt;

Determine ASP.NET Core environment name in the views

## Background ##

We are currently developing a web application, which relies on ASP .NET MVC 5, Angular.JS 1.4, Web API 2 and Entity Framework 6. For scalability reasons, the web application heavility relies on the async/await pattern. Our domain requires some cpu-intensive calculations, which can takes some seconds (&lt;10s). In the past some team members used Task.Run, in order to speed up the calculations.Since starting an extra thread inside ASP .NET MVC or Web API controllers is considered a bad practise (the thread is not known by the IIS, so not considered on AppDomain Recycle =&gt; See [Stephen Cleary&#39;s blog post][1]), they used ConfigureAwait(false).

## Example ##
    public async Task CalculateAsync(double param1, double param2)
    {
        // CalculateSync is synchronous and cpu-intensive (&lt;10s)
        await Task.Run(() =&gt; this.CalculateSync(param1, param2))).ConfigureAwait(false);
    }

## Questions ##

 - Is there any performance benefit in using Task.Run in an async Web API Controller for cpu-bound operations? 
 - Does ConfigureAwait(false) really avoid the creation of an extra thread?
 
  [1]: http://blog.stephencleary.com/2013/11/taskrun-etiquette-examples-dont-use.html

Is Task.Run considered bad practice in an ASP .NET MVC Web Application?

Maybe I have a miss understanding of what &quot;.NET Core Library&quot; means, but when I try to add a .NET Core Library in a .NET 4.6 Assembly using Visual Studio 2015, I get the error:
&gt; A reference to &#39;...&#39; could not be added. 

Did I understand something wrong?

This is what I configured in project.json of the .NET Core assembly

    &quot;frameworks&quot;: {
       &quot;net451&quot;: { },
       &quot;dotnet5.4&quot;: {
         &quot;dependencies&quot;: {
         &quot;Microsoft.CSharp&quot;: &quot;4.0.1-beta-23516&quot;,
         &quot;System.Collections&quot;: &quot;4.0.11-beta-23516&quot;,
         &quot;System.Linq&quot;: &quot;4.0.1-beta-23516&quot;,
         &quot;System.Runtime&quot;: &quot;4.0.21-beta-23516&quot;,
         &quot;System.Threading&quot;: &quot;4.0.11-beta-23516&quot;
      }
    }

Reference a .NET Core Library in a .NET 4.6 project

Let’s consider this very simple async method:
	
	static async Task myMethodAsync() 
	{
		await Task.Delay(500);
	}

When I compile this with VS2013 (pre Roslyn compiler) the generated state-machine is a struct. 

	private struct &lt;myMethodAsync&gt;d__0 : IAsyncStateMachine
	{  
		...
	    void IAsyncStateMachine.MoveNext()
	    {
			...
	    }
	}

When I compile it with VS2015  (Roslyn) the generated code is this:

	private sealed class &lt;myMethodAsync&gt;d__1 : IAsyncStateMachine
	{
		...
		void IAsyncStateMachine.MoveNext()
		{
			...
		}
	}

As you can see Roslyn generates a class (and not a struct). If I remember correctly the first implementations of the async/await support in the old compiler (CTP2012 i guess) also generated classes and then it was changed to struct from performance reasons. (in some cases you can completely avoid boxing and heap allocation…) (See [this][1])

Does anyone know why this was changed again in Roslyn? (I don’t have any problem regarding this, I know that this change is transparent and does not change the behavior of any code, I’m just curious) 


  [1]: https://stackoverflow.com/questions/23609110/why-are-awaiters-async-await-structs-and-not-classes-can-classes-be-used

**Edit:**

The answer from @Damien_The_Unbeliever (and the source code :) ) imho explains everything. The described behaviour of Roslyn only applies for debug build (and that&#39;s needed because of the CLR limitation mentioned in the comment). In Release it also generates a struct (with all the benefits of that..). So this seems to be a very clever solution to support both Edit and Continue and better performance in production. Interesting stuff, thanks for everyone who participated! 

Why are async state machines classes (and not structs) in Roslyn?

I am writing some unit tests with NUnit 3.0 and, unlike v2.x, `ExpectedException()` has been removed from the library.

Based on [this](https://stackoverflow.com/questions/15014461/should-i-use-nunits-assert-throws-method-or-expected-exception-attribute) answer, I can definitely see the logic in trying to catch specifically where in the test one expects their system to throw an exception (rather than just saying &#39;anywhere in the test&#39;).

However, I tend to be very explicit about my Arrange, Act, and Assert steps and this makes it a challenge.

I used to do something like:

    [Test, ExpectedException(typeof(FormatException))]
    public void Should_not_convert_from_prinergy_date_time_sample1()
    {
    	//Arrange
    	string testDate = &quot;20121123120122&quot;;
    
    	//Act
    	testDate.FromPrinergyDateTime();
    
    	//Assert
    	Assert.Fail(&quot;FromPrinergyDateTime should throw an exception parsing invalid input.&quot;);
    }

Now I need to do something like:

    [Test]
    public void Should_not_convert_from_prinergy_date_time_sample2()
    {
    	//Arrange
    	string testDate = &quot;20121123120122&quot;;
    
    	//Act/Assert
    	Assert.Throws&lt;FormatException&gt;(() =&gt; testDate.FromPrinergyDateTime());
    }

This isn&#39;t terrible, but muddies the Act and Assert, in my opinion. (Obviously, for this simple test, it&#39;s not hard to follow, but might be more challenging in larger tests).

I&#39;ve had a colleague suggest I get rid of `Assert.Throws` altogether and just do something like:

    [Test]
    public void Should_not_convert_from_prinergy_date_time_sample3()
    {
    	//Arrange
    	int exceptions = 0;
    	string testDate = &quot;20121123120122&quot;;
    
    	//Act
    	try
    	{
    		testDate.FromPrinergyDateTime();
    	}
    	catch (FormatException) { exceptions++;}
    
    	//Assert
    	Assert.AreEqual(1, exceptions);
    }

Here, I stick with the strict AAA format, but at the expense of even more bloat.

So my question goes out to AAA-style testers: How would you do some sort of exception validation testing like I am trying to do here?

NUnit 3.0 and Assert.Throws

In old .NET we used to be able to run the `csc` compiler to compile a single .cs file or several files.

With .NET Core we have `dotnet build` that insists on having a proper project file. Is there a stand-alone  command line compiler that would allow to compile source code files without having a project (and listing referenced dependencies on the same command line)?

On Linux, when I have the old `csc` and the new .NET Core installed, I get these timings:

    [root@li1742-80 test]# time dotnet build
    Microsoft (R) Build Engine version 15.3.409.57025 for .NET Core
    Copyright (C) Microsoft Corporation. All rights reserved.

      test -&gt; /root/test/bin/Debug/netcoreapp2.0/test.dll

    Build succeeded.
        0 Warning(s)
        0 Error(s)

    Time Elapsed 00:00:03.94

    real    0m7.027s
    user    0m5.714s
    sys     0m0.838s

    [root@li1742-80 test]# time csc Program.cs
    Microsoft (R) Visual C# Compiler version 2.3.0.61801 (3722bb71)
    Copyright (C) Microsoft Corporation. All rights reserved.


    real    0m0.613s
    user    0m0.522s
    sys     0m0.071s
    [root@li1742-80 test]#

Note 7 seconds with .NET Core versus several hundred milliseconds with the old `csc` for the same file, `Program.cs`.

I&#39;d like to be able to compile as fast with .NET Core as I used to be able with `csc`.





Content Type	Original Author	Original Content on Stackoverflow
Question	xdevel2000	View Question on Stackoverflow
Solution 1 - C#	Jon Skeet	View Answer on Stackoverflow

Idempotent modifiers in C#

C# Problem Overview

C# Solutions

Solution 1 - C#

Why does Sleep(500) cost more than 500ms?

git config: list all variables and their default values

Attributions