Async expects performance in web applications

So far, I think I figured out the concepts of how waiting async can make your application more responsive, but I hung up on two points:

Layer States Is the expectation of async expected to go from the repository level all the way down to the MVC or WCF layer in order to gain performance benefits, or can I just perform asynchronous operations on my repository methods that are taking a long time?

"waiting" for use . If I can just work at the repository level then one part I don't understand. Using this (low-level) approach, would a thread be able to service incoming client requests while waiting for the associated io code to complete?

I put together a sample console application, in my opinion, while a lengthy work is in progress, another user can make a request to my web application. Using my little library (to make it easier to integrate and handle exceptions), will their request be served by a deferred thread, or will it not voidTask.Wait();

block the thread?

public class AsyncTest
{
    public void RunTest()
    {
        try
        {
            using (var task = new RunTask(LongRunningTask))
            {
                Console.WriteLine("Echo two things:");

                for (int i = 0; i < 2; i++)
                {
                    var input = Console.ReadLine();
                    Console.WriteLine(string.Format("Echoing \"{0}\"", input));
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Error, hm, what happened??");
            Console.WriteLine();
            Console.WriteLine(e.Message);
            Console.WriteLine(e.StackTrace);
        }
    }

    public void LongRunningTask()
    {
        var totals = 0;

        for (int i = 0; i < 30; i++)
        {
            Thread.Sleep(1000);
            totals += 5;

            if (i == 25)
                throw new ArgumentException("I can't handle this! Errorr!!@!@");

            Console.WriteLine(string.Format("LongRunningTask Step {0}...", (i + 1)));
        }
    }
}

public class RunTask : IDisposable
{
    public delegate void IOBoundOperations();
    private Task voidTask;

    public RunTask(IOBoundOperations task)
    {
        voidTask = Execute(task);
    }

    async public Task Execute(IOBoundOperations task)
    {
        await Task.Run(() =>
        {
            task();
        });
    }

    public void Dispose()
    {
        try
        {
            voidTask.Wait();
        }
        catch
        {
            throw new AsyncException("Failed to run task asynchronously: " + 
                voidTask.Exception.InnerException.Message, voidTask.Exception.InnerException);
        }
    }
}

      

        
        
        
      

    

I put a wait because I will need this for tasks that will return data to the calling code that it can depend on. I also did this because I noticed that the process would not terminate until the thread finished my asynchronous stuff.

I can find a lot of information about async / await and it will be useful, just nothing in this particular aspect.