.NET

Design patterns are reusable solutions to common problems in software design and factory design pattern is one of the common design patterns.

The Factory method is a creational design pattern that provides an interface for creating objects without specifying their concrete classes. It defines a method that we can use to create an object instead of using its constructor. The important thing is that the subclasses can override this method and create objects of different types.

Resources

• C# Design Patterns - Factory Method - Code Maze (code-maze.com)
• C# Factory Design Pattern - Dot Net Perls
• C# Factory Method Design Pattern - Dofactory
• Factory Method Design Pattern In C# (c-sharpcorner.com)
• Abstract Factories are a Code Smell · .NET Junkie - Weblog of a workaholic (cuttingedge.it)

The Task asynchronous programming model (TAP) provides an abstraction over asynchronous code. You write code as a sequence of statements, just like always. You can read that code as though each statement completes before the next begins. The compiler performs many transformations because some of those statements may start work and return a Task representing the ongoing work.

In .NET, when you assign one list (list2) to another list (list1) directly, both lists will reference the same memory location. As a result, any modifications made to list2 will also affect list1. To create a separate copy of the list, you should use the List<T> constructor to initialize a new list based on the elements of the original list (list1).

To illustrate the issue the following code assigns list1 directly to list2.

List<string> list1 = new List<string>();
List<string> list2 = list1;

list2.Add("Item A");

Console.WriteLine("List1 elements:");
list1.ForEach(item => Console.WriteLine(item));

This will output the list1 elements and show 'Item A'.

List1 elements:
Item A

As you can see, modifying list2 also modified list1.

Explanation of direct assignment issue

When you assign one list to another using list2 = list1, you're not creating a new list. Instead, both list1 and list2 will point to the same list in memory. Any changes made to one list will be reflected in the other because they are essentially the same list.

The following code shows modifying of list2 does not affect list1 because list2 is a separate copy of list1.

List<string> list1 = new List<string>();
List<string> list2 = new List<string>(list1);

list2.Add("Item A");

Console.WriteLine("List1 elements:");
list1.ForEach(item => Console.WriteLine(item));

This will output list1 without any item.

List1 elements:

Explanation of copying the List

You can use the List<T> constructor with the original list as an argument to create a new list that is a separate copy of the original list. This constructor creates a new list with the same elements as the original list.

.NET APIs include classes, interfaces, delegates, and value types that expedite and optimize the development process and provide access to system functionality.

.NET types use a dot syntax naming scheme that connotes a hierarchy. This technique groups related types into namespaces, which can be searched and referenced more easily. The first part of the full name—up to the rightmost dot—is the namespace name.

The System namespace is the root namespace for fundamental types in .NET. This namespace includes classes representing the base data types used by all applications.

.NET includes a set of data structures that are the workhorses of many .NET apps. These are mostly collections, but also include other types.

.NET includes a set of utility APIs that provide functionality for many important tasks.

There are many app models that can be used with .NET.

Further reading at .NET class library overview - .NET | Microsoft Learn.

URI stands for Uniform Resource Identifier. A URI is a string of characters that identifies a particular resource. Resources can be anything with an identity, such as a document, image, service, or concept. URIs are used to uniquely identify and locate resources on the internet or within a network.

URIs are categorized into two main types: URLs (Uniform Resource Locators) and URNs (Uniform Resource Names).

URL (Uniform Resource Locator)

• A URL is a type of URI that specifies the location of a resource on the internet or a network.
• It typically consists of several components, including the scheme (e.g., "http" or "https"), the host (domain name or IP address), and the path to the resource.
• Example: https://www.example.com/path/to/resource

URN (Uniform Resource Name)

• A URN is a type of URI used to identify a resource by name in a particular namespace uniquely.
• Unlike URLs, URNs are meant to identify resources even if their location changes persistently.
• Example: urn:isbn:0451450523

In .NET, the System.Uri class is used to represent URIs. You can create a Uri object by passing a URI string to its constructor. The Uri class provides various properties and methods for working with different components of the URI, such as the scheme, host, path, query, and fragment.

Here's a simple example in C#:

// Creating a Uri object
Uri uri = new Uri("https://www.example.com/path/to/resource");

// Accessing components of the URI
Console.WriteLine($"Scheme: {uri.Scheme}");
Console.WriteLine($"Host: {uri.Host}");
Console.WriteLine($"Path: {uri.AbsolutePath}");
Console.WriteLine($"Query: {uri.Query}");

This example demonstrates creating a Uri object from a URL string and accessing different components of the URI using properties like Scheme, Host, AbsolutePath, and Query.

OriginalString and AbsoluteUri have different behaviors.

AbsoluteUri does escaping

Uri uri = new Uri("http://www.example.com/test.aspx?v=hello world");

Console.WriteLine(uri.OriginalString);
// http://www.example.com/test.aspx?v=hello world

Console.WriteLine(uri.AbsoluteUri);
// http://www.example.com/test.aspx?v=hello%20world  <--  different

AbsoluteUri doesn't support relative URIs

var uri = new Uri("/test.aspx?v=hello world", UriKind.Relative);

Console.WriteLine(uri.OriginalString);
// /test.aspx?v=hello world

Console.WriteLine(uri.AbsoluteUri);
// InvalidOperationException: This operation is not supported for a relative URI.

In C#, you can replace multiple white spaces with a single white space using regular expressions. You can use the Regex class from the System.Text.RegularExpressions namespace to achieve this. Here's an example:

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string inputString = "This   is   a    sample    string   with   multiple   spaces.";

        // Use regular expression to replace multiple white spaces with a single white space
        string result = Regex.Replace(inputString, @"\s+", " ");

        Console.WriteLine("Original string: " + inputString);
        Console.WriteLine("Modified string: " + result);
    }
}

In this example, the \s+ regular expression pattern matches one or more white spaces, and the Regex.Replace method replaces these occurrences with a single white space.

Additional Resources

• string - c# Fastest way to remove extra white spaces - Stack Overflow
• c# - How to replace multiple white spaces with one white space - Stack Overflow

The C# Retry Pattern is a coding strategy that enhances fault tolerance by automatically reattempting failed operations. Employing this pattern involves defining retry logic, such as delays between attempts, to improve the robustness and reliability of code handling transient errors.

Further Resources

• Retry pattern - Azure Architecture Center | Microsoft Learn
• Build resilient HTTP apps: Key development patterns - .NET | Microsoft Learn
• How to Implement Retry Logic in C# - Code Maze (code-maze.com)
• How to Implement Effective Retry Logic in C# | by Dev·edium | Medium
• Retry Pattern — a Not so Naive Approach | by Yini Yin | Medium

This example in C# illustrates an implementation of the Retry pattern. The purpose of this method is to repeatedly attempt to execute a piece of code (referred to as the "main logic") until either the operation is successful or a specified number of retries has been reached.

public async Task RetryAsync()
{
  int retryCount = 3;
  int currentRetry = 0;

  for (;;)
  {
    try
    {
      // main logic here

      break; // Return or break.
    }
    catch (Exception ex)
    {
      currentRetry++;

      if (currentRetry > this.retryCount) throw;
    }

    await Task.Delay(TimeSpan.FromSeconds(5));
  }
}

Breakdown of the code:

1. Initialization
2. Infinite Loop (for (;;))
   • The method enters an infinite loop using a for loop without a condition, meaning it will continue indefinitely until explicitly broken out of.
   • Inside the loop:
     • If the main logic succeeds, the break statement is encountered, and the loop is exited.
     • If an exception occurs during the main logic execution (catch (Exception ex)), the catch block is executed.
3. Handling Exceptions
   • currentRetry++;: Increments the currentRetry counter each time an exception is caught.
   • Checks whether the number of retries (currentRetry) has exceeded the maximum allowed retries (retryCount).
     • If the maximum retries have been reached, the exception is rethrown using throw;, propagating it further.
     • If the maximum retries have not been reached, the method proceeds to the next iteration after a delay.
4. Delay Between Retries

The Task class is a key component of the Task Parallel Library, providing a framework for asynchronous programming. It represents a unit of work that can run concurrently with other tasks, offering efficient and scalable execution. Programmers use it to create, manage, and coordinate asynchronous operations, enhancing application responsiveness.

Namespace: System.Threading.Tasks

The Task.Delay Method creates a task that will complete after a time delay.

• Task.Delay is generally preferred when working with asynchronous programming using async and await.
• It returns a Task that represents a time delay.
• It doesn't block the calling thread. Instead, it allows the thread to be released and continue with other work while waiting for the specified time to elapse.
• It's more suitable for scenarios where you want to introduce a delay without blocking the execution of the current method or freezing the user interface in GUI applications.

Example:

async Task MyMethod()
{
    // Do something before the delay
    await Task.Delay(1000); // Delay for 1000 milliseconds (1 second)
    // Do something after the delay
}

The Thread class allows programmers to create and manage multithreaded applications. It enables concurrent code execution, allowing tasks to run independently for improved performance. Developers can utilize methods like Start, Join, and Sleep to control thread execution, facilitating efficient parallel processing in .NET applications.

Namespace: System.Threading

The Thread.Sleep Method Suspends the current thread for the specified amount of time.

• Thread.Sleep is a synchronous method that blocks the current thread for the specified amount of time.
• It's generally used in non-async scenarios or when dealing with multi-threading where you explicitly want to pause the execution of the current thread.
• It can introduce responsiveness issues, especially in GUI applications, as it will freeze the UI during the sleep period.

Example:

void MyMethod()
{
    // Do something before the delay
    Thread.Sleep(1000); // Sleep for 1000 milliseconds (1 second)
    // Do something after the delay
}