250116 ‐ Async 2 - cywongg/2025 GitHub Wiki

To efficiently retrieve all distinct values for a specific field ("field") from all rows in a DataTable, you can use LINQ (Language-Integrated Query). LINQ provides a concise and efficient way to query collections like DataTable.

Here’s how you can do it:

using System.Linq;
using System.Data;

// Assuming your DataTable is named `dataTable`
var distinctValues = dataTable.AsEnumerable()
                              .Select(row => row.Field<string>("field")) // Replace `string` with the actual type of the field
                              .Distinct()
                              .ToList();

1. dataTable.AsEnumerable():

   • Converts the DataTable into an enumerable collection of DataRow, which allows LINQ queries to be applied.

2. Select(row => row.Field<string>("field")):

   • Extracts the value of the "field" column for each row. Replace string with the actual type of your field (e.g., int, DateTime, etc.).

3. Distinct():

   • Ensures that the resulting collection contains only unique values.

4. ToList():

   • Converts the result into a List<T> for further use.

DataTable dataTable = new DataTable();
dataTable.Columns.Add("field", typeof(string));
dataTable.Rows.Add("Value1");
dataTable.Rows.Add("Value2");
dataTable.Rows.Add("Value1");

var distinctValues = dataTable.AsEnumerable()
                              .Select(row => row.Field<string>("field"))
                              .Distinct()
                              .ToList();
                              
// distinctValues will contain: ["Value1", "Value2"]

Yes, you should use await when calling an async function if you need to wait for the result or ensure the function completes before proceeding. Let’s break this down:

• The async method starts execution, and the current method pauses at the await keyword until the async function finishes.
• The paused method yields control back to the calling thread (e.g., the UI thread in a WPF application), allowing it to remain responsive if it’s on the UI thread.
• Once the async function completes, execution resumes after the await statement.

• The async function starts running, but the calling method will not wait for it to complete.
• The calling method will continue executing the next lines of code immediately, which could lead to unexpected behavior if you rely on the result of the async function.

1. Use await if you need the result of the async function:

   async Task<int> GetValueAsync() { return await Task.FromResult(42); }
   
   async Task CallAsyncFunction()
   {
       int result = await GetValueAsync();
       Console.WriteLine(result); // Output: 42
   }

2. Do NOT use await if you want the async function to run in the background:

   async Task DoSomethingAsync() { await Task.Delay(1000); }
   
   void CallAsyncFunction()
   {
       DoSomethingAsync(); // Fire-and-forget; this will run in the background.
       Console.WriteLine("This happens immediately.");
   }

Important: For fire-and-forget calls, ensure proper exception handling because unhandled exceptions in async functions can crash your application.

Task.WhenAll is used to run multiple tasks concurrently and wait for all of them to complete. When combined with await, it allows the caller to asynchronously wait for all tasks to finish.

1. Starts All Tasks Concurrently:

   • Task.WhenAll takes a collection of Task objects and starts them concurrently (not sequentially).
   • Each task runs independently on a background thread.

2. Waits for All Tasks to Complete:

   • The method pauses at the await statement until all tasks in the collection complete.

3. Returns Results (if applicable):

   • If the tasks return results, Task.WhenAll aggregates the results into an array.

async Task<int> Task1()
{
    await Task.Delay(1000);
    return 1;
}

async Task<int> Task2()
{
    await Task.Delay(2000);
    return 2;
}

async Task RunTasksConcurrently()
{
    var tasks = new[] { Task1(), Task2() };

    // Wait for all tasks to complete
    int[] results = await Task.WhenAll(tasks);

    // Results: [1, 2]
    Console.WriteLine(string.Join(", ", results));
}

1. All Tasks Start Concurrently:

   • Both Task1 and Task2 start running at the same time.

2. The Calling Method Pauses:

   • The await keyword pauses RunTasksConcurrently until both tasks are complete.

3. Results Are Aggregated:

   • The results of Task1 and Task2 are combined into an array.

4. UI Thread Is Not Blocked:

   • If RunTasksConcurrently is called from the UI thread, the UI remains responsive while the tasks are running.

• Improved Efficiency:

  • Instead of waiting for each task sequentially, all tasks run concurrently, reducing the overall wait time.

• Error Handling:

  • If any task fails, Task.WhenAll will throw an AggregateException that contains the individual exceptions from each task.

• Aggregate Results:

  • You can collect the results of all tasks into a single array.

async Task RunTasksWithErrorHandling()
{
    var tasks = new[]
    {
        Task.Run(() => { throw new Exception("Task 1 failed"); }),
        Task.Run(() => { throw new Exception("Task 2 failed"); })
    };

    try
    {
        await Task.WhenAll(tasks);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

1. To Get Distinct Values from a DataTable:

   • Use LINQ with AsEnumerable and Distinct for efficient querying.
   • Example: dataTable.AsEnumerable().Select(row => row.Field<string>("field")).Distinct().ToList();.

2. When to Use await:

   • Use await when you want to pause execution until the async function completes.
   • Do not use await if you want the async function to run in the background (fire-and-forget).

3. Task.WhenAll:

   • Runs multiple tasks concurrently and waits for all of them to complete.
   • It keeps the UI thread unblocked while waiting.
   • It aggregates results (if the tasks return values) and handles errors using AggregateException.

Let me know if you need further clarification! 😊