The other answers suggesting starting a new thread are a bad idea - there&#39;s no need to do that at all. Part of the point of `async`/`await` is to *reduce* the number of threads your application needs.

You should instead use [`Task.Delay`][1] which *doesn&#39;t* require a new thread, and was designed precisely for this purpose:

    // Execution of the async method will continue one second later, but without
    // blocking.
    await Task.Delay(1000);

This solution also has the advantage of [allowing cancellation][2], if a cancellation token is provided. Example:

	public async Task DoWork(CancellationToken token)
	{
		await Task.Delay(1000, token);
	}


  [1]: http://msdn.microsoft.com/en-us/library/system.threading.tasks.task.delay.aspx
  [2]: https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.delay?view=net-6.0#system-threading-tasks-task-delay(system-int32-system-threading-cancellationtoken)

Say I have an array `a`:

    a = np.array([[1,2,3], [4,5,6]])
    
    array([[1, 2, 3],
           [4, 5, 6]])

I would like to convert it to a 1D array (i.e. a column vector):

    b = np.reshape(a, (1,np.product(a.shape)))

but this returns

    array([[1, 2, 3, 4, 5, 6]])

which is not the same as:

    array([1, 2, 3, 4, 5, 6])


I can take the first element of this array to manually convert it to a 1D array:
    
    b = np.reshape(a, (1,np.product(a.shape)))[0]

but this requires me to know how many dimensions the original array has (and concatenate [0]&#39;s when working with higher dimensions)

Is there a dimensions-independent way of getting a column/row vector from an arbitrary ndarray?




From ND to 1D arrays

In my app iPhone app I have a Tab Bar Controller with 4 relationships to 4 different Table View Controllers. Is there a way to rearrange the order of the relationship in the StoryBoard graphically? I can&#39;t find a way to do this and I&#39;m sure I must be missing something!

Rearranging Tab Bar Controller Order in StoryBoard

I&#39;m writing a network-bound application based on await/sleep paradigm. 

Sometimes, connection errors happen, and in my experience it pays to wait for some time and then retry operation again.

The problem is that if I use Thread.Sleep or another similar blocking operation in await/async, it blocks all activity in the caller thread.

What should I replace Thread.Sleep(10000) with to achieve the same effect as 

    await Thread.SleepAsync(10000)

?

**UPDATE**

I&#39;ll prefer an answer which does this without creating any additional thread

How to get awaitable Thread.Sleep?

I'm writing a network-bound application based on await/sleep paradigm.
Sometimes, connection errors happen, and in my experience it pays to wait for some time and then retry operation again.
The problem is that if I use Thread.Sleep or another similar blocking operation in await/async, it blocks all activity in the caller thread.
What should I replace Thread.Sleep(10000) with to achieve the same effect as
<pre><code class="hljs language-csharp">await Thread.SleepAsync(10000)
</code></pre>
?
UPDATE
I'll prefer an answer which does this without creating any additional thread

For example

    List&lt;string&gt; name_list1 = new List&lt;string&gt;();
    List&lt;string&gt; name_list2 = new List&lt;string&gt;();

later in the code:

    name_list1.Add(&quot;McDonald&quot;);
    name_list1.Add(&quot;Harveys&quot;);
    name_list1.Add(&quot;Wendys&quot;);
    
    name_list2 = name_list1; // I make a copy of namelist1 to namelist2

So, from this point I would like to keep adding element or making changes in name_list2  without affecting name_list1. How do I do that?



How to assign List&lt;T&gt; without it being a reference to the original List&lt;T&gt;?

I have following code for specifying parameters for SQL query. I am getting following exception when I use `Code 1`; but works fine when I use `Code 2`. In `Code 2` we have a check for null and hence a `if..else` block. 

Exception:  

&gt; *The parameterized query &#39;(@application\_ex\_id nvarchar(4000))SELECT  E.application\_ex\_id A&#39; expects the parameter &#39;@application\_ex\_id&#39;, which was not supplied.*

**Code 1**:

    command.Parameters.AddWithValue(&quot;@application_ex_id&quot;, logSearch.LogID);

**Code 2**:

    if (logSearch.LogID != null)
    {
             command.Parameters.AddWithValue(&quot;@application_ex_id&quot;, logSearch.LogID);
    }
    else
    {
            command.Parameters.AddWithValue(&quot;@application_ex_id&quot;, DBNull.Value );
    }


**QUESTION**

1. Can you please explain why it is unable to take NULL from logSearch.LogID value in Code 1 (but able to accept DBNull)? 

2. Is there a better code to handle this?


**Reference**:

1.  https://stackoverflow.com/questions/4555935/how-to-assign-null-to-a-sqlparameter
2. https://stackoverflow.com/questions/13306275/datatype-returned-varies-based-on-data-in-table
3. https://stackoverflow.com/questions/13265704/conversion-error-from-database-smallint-into-c-sharp-nullable-int?lq=1
4. https://stackoverflow.com/questions/4488727/what-is-the-point-of-dbnull/9632050#9632050  
 
CODE

        public Collection&lt;Log&gt; GetLogs(LogSearch logSearch)
        {
            Collection&lt;Log&gt; logs = new Collection&lt;Log&gt;();

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();

                string commandText = @&quot;SELECT  *
                    FROM Application_Ex E 
                    WHERE  (E.application_ex_id = @application_ex_id OR @application_ex_id IS NULL)&quot;;
                    
                using (SqlCommand command = new SqlCommand(commandText, connection))
                {
                    command.CommandType = System.Data.CommandType.Text;

                    //Parameter value setting
                    //command.Parameters.AddWithValue(&quot;@application_ex_id&quot;, logSearch.LogID);
                    if (logSearch.LogID != null)
                    {
                        command.Parameters.AddWithValue(&quot;@application_ex_id&quot;, logSearch.LogID);
                    }
                    else
                    {
                        command.Parameters.AddWithValue(&quot;@application_ex_id&quot;, DBNull.Value );
                    }

                    using (SqlDataReader reader = command.ExecuteReader())
                    {
                        if (reader.HasRows)
                        {
                            Collection&lt;Object&gt; entityList = new Collection&lt;Object&gt;();
                            entityList.Add(new Log());

                            ArrayList records = EntityDataMappingHelper.SelectRecords(entityList, reader);

                            for (int i = 0; i &lt; records.Count; i++)
                            {
                                Log log = new Log();
                                Dictionary&lt;string, object&gt; currentRecord = (Dictionary&lt;string, object&gt;)records[i];
                                EntityDataMappingHelper.FillEntityFromRecord(log, currentRecord);
                                logs.Add(log);
                            }
                        }

                        //reader.Close();
                    }
                }
            }

            return logs;
        }

Exception when AddWithValue parameter is NULL

This is my `web.config` mail settings:

    &lt;system.net&gt;
        &lt;mailSettings&gt;
          &lt;smtp deliveryMethod=&quot;Network&quot; from=&quot;smthg@smthg.net&quot;&gt;
            &lt;network defaultCredentials=&quot;true&quot; host=&quot;localhost&quot; port=&quot;587&quot; userName=&quot;smthg@smthg.net&quot; password=&quot;123456&quot;/&gt;
          &lt;/smtp&gt;
        &lt;/mailSettings&gt;
      &lt;/system.net&gt;

and here&#39;s how I try to read the values from `web.config`

     var smtp = new System.Net.Mail.SmtpClient();
     var credential = new System.Net.Configuration.SmtpSection().Network;
                    
     string strHost = smtp.Host;
     int port = smtp.Port;
     string strUserName = credential.UserName;
     string strFromPass = credential.Password;

But credentials are always null. How can i access these values?


How to read system.net/mailSettings/smtp from Web.config

I got a problem when I try to modify the value of an item because its only a read only field.

    KeyValuePair&lt;Tkey, Tvalue&gt;

I&#39;ve tried different alternatives like:

    Dictionary&lt;Tkey, Tvalue&gt;

but there I have the same problem. Is there a way to set the value field to an new value?

How to modify a KeyValuePair value?

It&#39;s recently been pointed out to me that various Linq extension methods (such as `Where`, `Select`, etc) return an &lt;code&gt;IEnumerable&amp;lt;T&amp;gt;&lt;/code&gt; that also happens to be &lt;code&gt;IDisposable&lt;/code&gt;. The following evaluates to &lt;code&gt;True&lt;/code&gt;

    new int[2] {0,1}.Select(x =&gt; x*2) is IDisposable

Do I need to dispose of the results of a &lt;code&gt;Where&lt;/code&gt; expression? 

Whenever I call a method returning `IEnumerable&lt;T&gt;`, am I (potentially) accepting responsibility for calling dispose when I&#39;ve finished with it? 



Do I need to consider disposing of any IEnumerable&lt;T&gt; I use?

Every time that I create a non-nullable datetime in my mvc3 application it defaults to now(), where now is current date with current time.  I would like to default it to today&#39;s date with 12am as the time.

I&#39;m trying to default the time in my mvc...but...the following isn&#39;t setting to todays date @12am.  Instead it defaults to now with current date and time.

    private DateTime _Begin = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 12, 0, 0);
    public DateTime Begin { get { return _Begin; } set { _Begin = value; } } 

How can I set to 12am for the current date for non-nullable datetime?

How to set time to midnight for current day?

How do I enable Entity Framework 5 (version 5.0.0) migrations for multiple DB contexts in the same project, where each context corresponds to its own database? When I run `Enable-Migrations` in the PM console (Visual Studio 2012), there&#39;s an error because of there being multiple contexts:

    PM&gt; Enable-Migrations
    More than one context type was found in the assembly &#39;DatabaseService&#39;.
    To enable migrations for DatabaseService.Models.Product1DbContext, use Enable-Migrations -ContextTypeName DatabaseService.Models.Product1DbContext.
    To enable migrations for DatabaseService.Models.Product2DbContext, use Enable-Migrations -ContextTypeName DatabaseService.Models.Product2DbContext.

If I run `Enable-Migrations -ContextTypeName DatabaseService.Models.Product1DbContext` I&#39;m not allowed to run `Enable-Migrations -ContextTypeName DatabaseService.Models.Product2DbContext` because a migration already exists: `Migrations have already been enabled in project &#39;DatabaseService&#39;. To overwrite the existing migrations configuration, use the -Force parameter.`

How do I enable EF migrations for multiple contexts to separate databases?

I have the case where I want to map an entity to a viewmodel and back. I have to specify the mapping explicitly with `ForMember()` because their properties do not share the exact same names. Here is a short example of how my classes look like:

    public class PartTwo {
        public int Integer { get; set; }
    }

    public class PartTwoViewModel {
        public int PartInteger { get; set; }
    }

And I want to use them this way:

    Mapper.CreateMap&lt;PartTwo, PartTwoViewModel&gt;()
        .ForMember(dst =&gt; dst.PartInteger, opt =&gt; opt.MapFrom(src =&gt; src.Integer))
        .ReverseMap();

    var partTwoViewModel = new PartTwoViewModel() { PartInteger = 42 };
    var partTwo = Mapper.Map&lt;PartTwoViewModel, PartTwo&gt;(partTwoViewModel);
    Assert.AreEqual(partTwoViewModel.PartInteger, partTwo.Integer);

But it does not match the property `PartInteger` to `Integer`. (`Integer` is `0`.)

Is there a way to make this work? (When the properties of both classes have the same names it works.) Do I have to set some kind of option in the method `ForMember()`?


Automapper: bidirectional mapping with ReverseMap() and ForMember()

As per [Understanding the node.js event loop][1], node.js supports a single thread model. That means if I make multiple requests to a node.js server, it won&#39;t spawn a new thread for each request but will execute each request one by one.  It means if I do the following for the first request in my node.js code, and meanwhile a new request comes in on node, the second request has to wait until the first request completes, including 5 second sleep time.  Right?

	var sleep = require(&#39;sleep&#39;);
        sleep.sleep(5)//sleep for 5 seconds

Is there a way that node.js can spawn a new thread for each request so that the second request does not have to wait for the first request to complete, or can I call sleep on specific thread only?

 [1]: http://blog.mixu.net/2011/02/01/understanding-the-node-js-event-loop/

How to sleep the thread in node.js without affecting other threads?

I&#39;m designing a class that I wish to make readonly after a main thread is done configuring it, i.e. &quot;freeze&quot; it. Eric Lippert calls this [popsicle][1] immutability. After it is frozen, it can be accessed by multiple threads concurrently for reading.

My question is how to write this in a thread safe way that is *realistically* efficient, i.e. without trying to be unnecessarily *clever*.

**Attempt 1:**

    public class Foobar
    {
       private Boolean _isFrozen;
       
       public void Freeze() { _isFrozen = true; }
    
       // Only intended to be called by main thread, so checks if class is frozen. If it is the operation is invalid.
       public void WriteValue(Object val)
       {
          if (_isFrozen)
             throw new InvalidOperationException();
             
          // write ...
       }
       
       public Object ReadSomething()
       {
          return it;
       }
    }

Eric Lippert seems to suggest this would be OK in [this][2] post.
I know writes have release semantics, but as far as I understand this only pertains to *ordering*, and it doesn&#39;t necessarily mean that all threads will see the value immediately after the write. Can anyone confirm this? This would mean this solution is not thread safe (this may not be the only reason of course).

**Attempt 2:**

The above, but using `Interlocked.Exchange` to ensure the value is actually published:

    public class Foobar
    {
       private Int32 _isFrozen;
       
       public void Freeze() { Interlocked.Exchange(ref _isFrozen, 1); }
    
       public void WriteValue(Object val)
       {
          if (_isFrozen == 1)
             throw new InvalidOperationException();
             
          // write ...
       }
    }

Advantage here would be that we ensure the value is published without suffering the overhead on every read. If none of the reads are moved before the write to _isFrozen as the Interlocked method uses a full memory barrier I would guess this is thread safe. However, who knows what the compiler will do (and according to section 3.10 of the C# spec that seems like quite a lot), so I don&#39;t know if this is threadsafe.

**Attempt 3:**

Also do the read using `Interlocked`.

    public class Foobar
    {
       private Int32 _isFrozen;
       
       public void Freeze() { Interlocked.Exchange(ref _isFrozen, 1); }
    
       public void WriteValue(Object val)
       {
          if (Interlocked.CompareExchange(ref _isFrozen, 0, 0) == 1)
             throw new InvalidOperationException();
             
          // write ...
       }
    }

Definitely thread safe, but it seems a little wasteful to have to do the compare exchange for every read. I know this overhead is probably minimal, but I&#39;m looking for a *reasonably* efficient method (although perhaps this is it).

**Attempt 4:**

Using `volatile`:

    public class Foobar
    {
       private volatile Boolean _isFrozen;
       
       public void Freeze() { _isFrozen = true; }
    
       public void WriteValue(Object val)
       {
          if (_isFrozen)
             throw new InvalidOperationException();
             
          // write ...
       }
    }

But Joe Duffy declared &quot;[sayonara volatile][3]&quot;, so I won&#39;t consider this a solution.

**Attempt 5:**

Lock everything, seems a bit overkill:

    public class Foobar
    {
       private readonly Object _syncRoot = new Object();
       private Boolean _isFrozen;
       
       public void Freeze() { lock(_syncRoot) _isFrozen = true; }
    
       public void WriteValue(Object val)
       {
          lock(_syncRoot) // as above we could include an attempt that reads *without* this lock
             if (_isFrozen)
                throw new InvalidOperationException();
             
          // write ...
       }
    }

Also seems definitely thread safe, but has more overhead than using the Interlocked approach above, so I would favour attempt 3 over this one.

And then I can come up with at least some more (I&#39;m sure there are many more):

**Attempt 6:** use `Thread.VolatileWrite` and `Thread.VolatileRead`, but these are supposedly a little on the heavy side.

**Attempt 7:** use `Thread.MemoryBarrier`, seems a little too *internal*.

**Attempt 8:** create an immutable copy - don&#39;t want to do this

Summarising:

- which attempt would you use and why (or how would you do it if entirely different)? (i.e. what is the best way for publishing a value once that is then read concurrently, while being reasonably efficient without being overly &quot;clever&quot;?)
- does .NET&#39;s memory model &quot;release&quot; semantics of writes imply that all other threads see updates (cache coherency etc.)? I generally don&#39;t want to think too much about this, but it&#39;s nice to have an understanding.

EDIT:

Perhaps my question wasn&#39;t clear, but I am looking in particular for reasons as to why the above attempts are good or bad. Note that I am talking here about a scenario of one single writer that writes then freezes before any concurrent reads. I believe attempt 1 is OK but I&#39;d like to know exactly why (as I wonder if reads could be optimized away somehow, for example).
I care less about whether or not this is good design practice but more about the actual threading aspect of it.


  [1]: http://blogs.msdn.com/b/ericlippert/archive/2011/05/23/read-only-and-threadsafe-are-different.aspx
  [2]: http://blogs.msdn.com/b/ericlippert/archive/2011/05/23/read-only-and-threadsafe-are-different.aspx
  [3]: http://www.bluebytesoftware.com/blog/2010/12/04/SayonaraVolatile.aspx

---

Many thanks for the response the question received, but I have chosen to mark this as an answer myself because I feel that the answers given do not *quite* answer my question and I do not want to give the impression to anyone visiting the site that the marked answer is correct simply because it was automatically marked as such due to the bounty expiring.
Furthermore I do not think the answer with the highest number of votes was overwhelmingly voted for, not enough to mark it automatically as an answer.

I am still leaning to attempt #1 being correct, however, I would have liked some authoritative answers. I understand x86 has a strong model, but I don&#39;t want to (and shouldn&#39;t) code for a particular architecture, after all that&#39;s one of the nice things about .NET.

If you are in doubt about the answer, go for one of the locking approaches, perhaps with the optimizations shown here to avoid a lot of contention on the lock.

How to freeze a popsicle in .NET (make a class immutable)

So, my app needs to perform an action almost continuously (with a pause of 10 seconds or so between each run) for as long as the app is running or a cancellation is requested. The work it needs to do has the possibility of taking up to 30 seconds.

Is it better to use a System.Timers.Timer and use AutoReset to make sure it doesn&#39;t perform the action before the previous &quot;tick&quot; has completed.

Or should I use a general Task in LongRunning mode with a cancellation token, and have a regular infinite while loop inside it calling the action doing the work with a 10 second Thread.Sleep between calls? As for the async/await model, I&#39;m not sure it would be appropriate here as I don&#39;t have any return values from the work. 

    CancellationTokenSource wtoken;
    Task task;
    
    void StopWork()
    {
        wtoken.Cancel();
    
        try 
        {
            task.Wait();
        } catch(AggregateException) { }
    }
    
    void StartWork()
    {
        wtoken = new CancellationTokenSource();
    
        task = Task.Factory.StartNew(() =&gt;
        {
            while (true)
            {
                wtoken.Token.ThrowIfCancellationRequested();
                DoWork();
                Thread.Sleep(10000);
            }
        }, wtoken, TaskCreationOptions.LongRunning);
    }
    
    void DoWork()
    {
        // Some work that takes up to 30 seconds but isn&#39;t returning anything.
    }

or just use a simple timer while using its AutoReset property, and call .Stop() to cancel it?



Proper way to implement a never ending task. (Timers vs Task)

I have 3 questions that I need help with.

1. What are the correct objects/references to be passed as `lock` statement parameter? I&#39;ve seen a lot of sample codes and I noticed that the objects/references passed in could possibly be non related to the current class or any other class in the program as long as the access modifier `static` is non public? E.g.:

        private Object anyObj = new Object();
        lock(anyObj){.....}

        private static readonly object Locker = new object();
        lock(Locker){.....}

    It just doesn&#39;t make sense to me.

2. I found a sample code in MSDN about multi threading that uses `lock` statements too. In the sample there are two `try`/`catch` blocks with the `Monitor.Wait()` within it. If I understand the logic correctly, the `readerFlag` will forbid the program to ever enter the `try`/`catch` block at all.&lt;br/&gt;The code is example 2 from here:&lt;br/&gt;
http://msdn.microsoft.com/en-us/library/aa645740(v=vs.71).aspx

3. How do I run a thread that runs in the background as long as the Windows Form is active?

C# lock statement, what object to lock on?

I have been doing some research on this but I am still VERY confused to say the least.

Can anyone give me a concrete example of when to use `Task` and when to use `Platform.runLater(Runnable);`? What exactly is the difference? Is there a golden rule to when to use any of these?

Also correct me if I&#39;m wrong but aren&#39;t these two &quot;Objects&quot; a way of creating another thread inside the main thread in a GUI (used for updating the GUI)?

Platform.runLater and Task in JavaFX

When you have server-side code (i.e. some `ApiController`) and your functions are asynchronous - so they return `Task&lt;SomeObject&gt;` - is it considered best practice that any time you await functions that you call `ConfigureAwait(false)`?

I had read that it is more performant since it doesn&#39;t have to switch thread contexts back to the original thread context.  However, with ASP.NET Web Api, if your request is coming in on one thread, and you await some function and call `ConfigureAwait(false)` that could potentially put you on a different thread when you are returning the final result of your `ApiController` function.

I&#39;ve typed up an example of what I am talking about below:

    public class CustomerController : ApiController
    {
        public async Task&lt;Customer&gt; Get(int id)
        {
            // you are on a particular thread here
            var customer = await GetCustomerAsync(id).ConfigureAwait(false);
            
            // now you are on a different thread!  will that cause problems?
            return customer;
        }
    }

Best practice to call ConfigureAwait for all server-side code

I&#39;m trying to integrate `async`/`await` into our service bus.
I implemented a `SingleThreadSynchronizationContext` based on this example http://blogs.msdn.com/b/pfxteam/archive/2012/01/20/10259049.aspx.

And it works fine, except for one thing: `TransactionScope`. I await for stuff inside the `TransactionScope` and it breaks the `TransactionScope`.

`TransactionScope` doesn&#39;t seem to play nice with `async`/`await`, certainly because it stores things in the thread using `ThreadStaticAttribute`. I get this exception: 
&gt; &quot;TransactionScope nested incorrectly.&quot;.

I tried to save `TransactionScope` data before queuing the task and restore it before running it, but it doesn&#39;t seem to change a thing. And `TransactionScope` code is a mess, so it&#39;s really hard to understand what&#39;s going on there.

Is there a way to make it work? Is there some alternative to `TransactionScope`?

Get TransactionScope to work with async / await

I have an application.  This application uses an interface to access the database. This interface can be implemented by many classes.  For example, one uses EF 4.4, but other classes can use EF5 that is more efficient.  In the future perhaps I will use EF6 because it uses async methods. In this example all the methods use EF, but perhaps other options can be use other ways.

The application is coded once, using the interface, and according to the config file, use one implementation or the other, so I only need to modify the code in one place, the constructor, to add the new option in the instantiation of the class that is assigned to the interface.

At the moment all the methods of the classes are not `async`, but in the future if I use EF6 I would like to use the async methods, so I don&#39;t know if it is possible that the class that use EF6 and implements the interface can use the `async` methods.

For the async methods of EF6, I would use the async/awiat pattern, so in the method of my class I need to use the async attribute. This lets me use the `await` keyword when I call to the async method of EF6.

But this class can implement the interface that in a first time is for synchronous methods?

Is there some way that in the main application I can use many implementations without the need to modify the code? Some implementations will use async methods while others will be synchronous.

Interfaces and async methods

It&#39;s clear why stack traces are affected with Microsoft&#39;s new programming paradigm. We now have a semantic stack and a couple of physical ones (my choice of words).

What I get to see is an exception&#39;s `StackTrace` property (and in the debugger) is the physical ones, concatenated:

    private async Task CheckFooAndBar()
    {
        var log = LogManager.GetLogger(&quot;Test&quot;);
        log.Info(&quot;CheckFooAndBar&quot;);
        try
        {
            await Foo();
        }
        catch (Exception ex)
        {
            log.Info(&quot;StackTrace of last exception: &quot; + ex.StackTrace);
        }
        Console.ReadKey();
    }
    private async Task Foo()
    {
        await Task.Factory.StartNew(() =&gt; Thread.Sleep(1000));
        await Bar();
        await Task.Factory.StartNew(() =&gt; Thread.Sleep(1000));
    }
    private async Task Bar()
    {
        await Task.Factory.StartNew(() =&gt; Thread.Sleep(1000));
        throw new Exception();
        await Task.Factory.StartNew(() =&gt; Thread.Sleep(1000));
    }

This gives:

    StackTrace of last exception:    at NLogAsyncExceptionTestCase.Program.&lt;Bar&gt;d__d.MoveNext() in c:\Users\Jens\Documents\Visual Studio 2012\Projects\NLogAsyncExceptionTestCase\NLogAsyncExceptionTestCase.Console\Program.cs:line 53
    --- End of stack trace from previous location where exception was thrown ---
       at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
       at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
       at System.Runtime.CompilerServices.TaskAwaiter.GetResult()
       at NLogAsyncExceptionTestCase.Program.&lt;Foo&gt;d__8.MoveNext() in c:\Users\Jens\Documents\Visual Studio 2012\Projects\NLogAsyncExceptionTestCase\NLogAsyncExceptionTestCase.Console\Program.cs:line 44
    --- End of stack trace from previous location where exception was thrown ---
       at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
       at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
       at System.Runtime.CompilerServices.TaskAwaiter.GetResult()
       at NLogAsyncExceptionTestCase.Program.&lt;CheckFooAndBar&gt;d__0.MoveNext() in c:\Users\Jens\Documents\Visual Studio 2012\Projects\NLogAsyncExceptionTestCase\NLogAsyncExceptionTestCase.Console\Program.cs:line 30 

My question is: Is there a (convenient, standard) way to convert this to a proper backtrace in the semantic sense, such as:

    CheckFooAndBar
    Foo
    Bar

Of course there could be a mixture of awaits and inline path fragments in the stack.

I tried looking at the stack as it is with .NET 4.5 and SL5 with the async targetting pack, but not yet with WinRT. The output is from .NET 4.5.

In SL5, which is what I mainly do, the situation is more problematic: You don&#39;t get line numbers in stack traces in Silverlight (even with elevated privileges), which makes the need for context more important.

Stack traces with async/await

I&#39;ve got this code:

    private async void ContextMenuForGroupRightTapped(object sender, RightTappedRoutedEventArgs args)
    {
        CheckBox ckbx = null;
        if (sender is CheckBox)
        {
            ckbx = sender as CheckBox;
        }
        if (null == ckbx)
        {
            return;
        }
        string groupName = ckbx.Content.ToString();

        var contextMenu = new PopupMenu();

        // Add a command to edit the current Group
        contextMenu.Commands.Add(new UICommand(&quot;Edit this Group&quot;, (contextMenuCmd) =&gt;
        {
            Frame.Navigate(typeof(LocationGroupCreator), groupName);
        }));

        // Add a command to delete the current Group
        contextMenu.Commands.Add(new UICommand(&quot;Delete this Group&quot;, (contextMenuCmd) =&gt;
        {
            SQLiteUtils slu = new SQLiteUtils();
            slu.DeleteGroupAsync(groupName); // this line raises Resharper&#39;s hackles, but appending await raises err msg. Where should the &quot;async&quot; be?
        }));

        // Show the context menu at the position the image was right-clicked
        await contextMenu.ShowAsync(args.GetPosition(this));
    }

...that Resharper&#39;s inspection complained about with, &quot;*Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the &#39;await&#39; operator to the result of the call*&quot; (on the line with the comment).

And so, I prepended an &quot;await&quot; to it but, of course, I then need to add an &quot;async&quot; somewhere, too - but where?

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

How to get awaitable Thread.Sleep?

C# Problem Overview

C# Solutions

Solution 1 - C#

Rearranging Tab Bar Controller Order in StoryBoard

From ND to 1D arrays

Attributions