Task and Task of T types in C Sharp (C#) - Mini Project: Build & Apply

Working with Task and Task<T> Types in C#

📖 Scenario: You are building a simple program that simulates asynchronous work using Task and Task&lt;T&gt; in C#. This is common when you want to run operations without blocking the main program, like loading data or performing calculations in the background.

🎯 Goal: Learn how to create and use Task for running code asynchronously without a return value, and Task&lt;T&gt; for running code that returns a result asynchronously.

📋 What You'll Learn

Create a Task that runs a simple action asynchronously.

Create a Task<int> that returns a number asynchronously.

Use await to get the result from Task<int>.

Print the results to the console.

💡 Why This Matters

🌍 Real World

Asynchronous programming is used in apps to keep the interface responsive while doing work like loading files, fetching data from the internet, or processing large calculations.

💼 Career

Understanding <code>Task</code> and <code>Task&lt;T&gt;</code> is essential for C# developers working on modern applications, especially those involving UI, web services, or any background processing.

1

Create a simple Task

Write a line of code to create a Task called simpleTask that runs a lambda expression printing "Task is running" to the console.

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // Create a Task called simpleTask that prints "Task is running"
        
    }
}

Hint

Use new Task(() => ...) to create a Task that runs the code inside the lambda.

2

Create a Task<int> that returns a value

Add a line of code to create a Task<int> called numberTask that returns the number 42 asynchronously using a lambda expression.

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task simpleTask = new Task(() => Console.WriteLine("Task is running"));
        // Create a Task called numberTask that returns 42
        
    }
}

Hint

Use new Task(() => 42) to create a Task that returns 42.

3

Start the tasks and await the result

Write code to start both simpleTask and numberTask using Start(). Then use await to get the integer result from numberTask into a variable called result.

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task simpleTask = new Task(() => Console.WriteLine("Task is running"));
        Task numberTask = new Task(() => 42);
        // Start both tasks
        // Await numberTask and store the result in variable 'result'
        
    }
}

Hint

Call Start() on each task to run them. Use await to get the result from numberTask.

4

Print the results

Write two Console.WriteLine statements: one to print "Simple task completed" after simpleTask finishes, and another to print "Number from task: {result}" using the result variable.

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task simpleTask = new Task(() => Console.WriteLine("Task is running"));
        Task numberTask = new Task(() => 42);
        simpleTask.Start();
        numberTask.Start();
        int result = await numberTask;
        // Wait for simpleTask to finish
        // Print "Simple task completed"
        // Print "Number from task: {result}"
        
    }
}

Hint

Use await simpleTask to wait for it to finish before printing. Use Console.WriteLine with an interpolated string for the number.

Practice

1. What is the main difference between Task and Task<T> in C#?

easy

A. Task does not return a value, Task<T> returns a value of type T.

B. Task runs synchronously, Task<T> runs asynchronously.

C. Task is used only for UI threads, Task<T> for background threads.

D. Task can return multiple values, Task<T> returns only one.

Solution

1. Step 1: Understand Task behavior

   Task represents an asynchronous operation that does not return a result.

2. Step 2: Understand Task<T> behavior

   Task<T> represents an asynchronous operation that returns a value of type T when it completes.

3. Final Answer:

   Task does not return a value, Task<T> returns a value of type T. -> Option A

4. Quick Check:

   Return value presence = Task does not return a value, Task<T> returns a value of type T. [OK]

Hint: Remember: Task = no result, Task<T> = returns result [OK]

Common Mistakes:

• Thinking Task runs synchronously
• Confusing Task<T> with multiple return values
• Assuming Task is only for UI threads

2. Which of the following is the correct way to declare a Task<int> that returns the number 5 asynchronously?

easy

A. Task<int> t = Task.Run(() => 5);

B. Task<int> t = new Task<int>(5);

C. Task<int> t = Task<int>.Run(5);

D. Task<int> t = Task.Run<int>(5);

Solution

1. Step 1: Check correct Task<T> creation syntax

   Use Task.Run(() => value) to create and start a task returning a value.

2. Step 2: Validate each option

   Task<int> t = Task.Run(() => 5); uses Task.Run(() => 5), which is correct. Options A, B, and C use invalid constructors or methods.

3. Final Answer:

   Task<int> t = Task.Run(() => 5); -> Option A

4. Quick Check:

   Correct Task creation syntax = Task<int> t = Task.Run(() => 5); [OK]

Hint: Use Task.Run with lambda to return values asynchronously [OK]

Common Mistakes:

• Trying to pass value directly to Task constructor
• Using non-existent Task.Run overloads
• Confusing Task and Task<T> creation

3. What will be the output of this C# code?

async Task<int> GetNumberAsync() { return 10; }

var task = GetNumberAsync();
Console.WriteLine(task.Result);

medium

A. Task<int>

B. 10

C. Compilation error

D. Deadlock or runtime error

Solution

1. Step 1: Understand async method returning Task<int>

   The method returns a Task that completes with value 10.

2. Step 2: Accessing task.Result

   Accessing Result blocks until the task finishes and returns 10.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Task.Result blocks and returns value = 10 [OK]

Hint: Task.Result blocks and returns the result value [OK]

Common Mistakes:

• Expecting Task<int> printed instead of value
• Thinking async method returns int directly
• Assuming runtime error without synchronization context

4. Identify the error in this code snippet:

Task<int> task = Task.Run(() => 42);
int result = await task;

medium

A. Task<int> must be declared as void

B. Task.Run cannot return int

C. Cannot use await outside an async method

D. Missing parentheses in Task.Run

Solution

1. Step 1: Check usage of await keyword

   await can only be used inside methods marked with async.

2. Step 2: Analyze code context

   The snippet does not show an async method, so using await here causes a compile error.

3. Final Answer:

   Cannot use await outside an async method -> Option C

4. Quick Check:

   Await requires async method = Cannot use await outside an async method [OK]

Hint: Always mark method async to use await inside it [OK]

Common Mistakes:

• Assuming Task.Run cannot return int
• Thinking Task<int> can be void
• Ignoring async keyword requirement for await

5. You want to run two tasks in parallel: one returns an int, the other returns a string. How do you wait for both and get their results efficiently?

hard

A. Use Task.WaitAll(task1, task2) and cast results to correct types.

B. Call task1.Wait() and task2.Wait() sequentially, then get results.

C. Use await task1 then await task2 one after another.

D. Use await Task.WhenAll(task1, task2) then access task1.Result and task2.Result.

Solution

1. Step 1: Understand parallel task waiting

   Task.WhenAll waits for all tasks to complete concurrently.

2. Step 2: Access results after waiting

   After await Task.WhenAll(...), you can safely access each task's Result without blocking.

3. Final Answer:

   Use await Task.WhenAll(task1, task2) then access task1.Result and task2.Result. -> Option D

4. Quick Check:

   Parallel wait with Task.WhenAll = Use await Task.WhenAll(task1, task2) then access task1.Result and task2.Result. [OK]

Hint: Use Task.WhenAll to await multiple tasks efficiently [OK]

Common Mistakes:

• Waiting tasks sequentially losing parallelism
• Using blocking Wait() causing deadlocks
• Casting results instead of accessing Task<T>.Result