Advanced C# Techniques for Better Code Performance

public struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

var p = new Point(10, 20);

[Flags]
public enum Colors
{
    None = 0,
    Red = 1,
    Green = 2,
    Blue = 4
}

var colors = Colors.Red | Colors.Green;

var sb = new StringBuilder();
sb.Append("Hello ");
sb.Append("World");
var result = sb.ToString();

public IEnumerable<int> GetNumbers()
{
    for (int i = 0; i < 1000000; i++)
    {
        yield return i;
    }
}

foreach (var number in GetNumbers())
{
    Console.WriteLine(number);
}

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var result = numbers.Where(n => n % 2 == 0).OrderByDescending(n => n);

async Task<string> ReadFileAsync(string filePath)
{
    using (var reader = new StreamReader(filePath))
    {
        return await reader.ReadToEndAsync();
    }
}

In this example, the ReadFileAsync method uses the StreamReader class to read the contents of a file. The await keyword indicates that the method should wait for the ReadToEndAsync method to complete before continuing execution.

7. Parallel Processing

Another technique for improving the performance of your C# code is parallel processing. Parallel processing allows you to execute multiple tasks simultaneously, using multi-core processors to achieve faster results.

In C#, parallel processing is implemented using the Parallel class. Here's an example of parallel processing:

Parallel.For(0, 1000000, i =>
{
    // Perform some calculation here
});

In this example, the Parallel.For the method is used to perform a calculation in parallel. The method takes three parameters: the starting value, the ending value, and a delegate that calculates each value in the range.

8. Use Generics

Generics are a powerful feature in C# that allows you to create reusable code. By defining a class or method with a generic type parameter, you can create a type-safe, reusable component that can work with various data types. This can help improve performance by reducing the duplicated code you need to write.

Here's an example of using generics to create a reusable sorting method:

public static void Sort<T>(T[] array) where T : IComparable<T>
{
    for (int i = 0; i < array.Length; i++)
    {
        for (int j = i + 1; j < array.Length; j++)
        {
            if (array[j].CompareTo(array[i]) < 0)
            {
                T temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
}

In this example, the Sort method takes an array of type T, where T is constrained to be a type that implements the IComparable<T> interface. This allows the method to compare the elements in the array and sort them accordingly. Using generics, we can write a single sorting method that can work with any type that implements IComparable<T>.

9. Use LINQ

LINQ is a powerful feature in C# that allows you to write expressive, concise code for querying data. By using LINQ, you can write code that is easy to read and understand while still being performant.

Here's an example of using LINQ to filter and sort a collection of objects.

public static IEnumerable<Customer> GetCustomers(IEnumerable<Customer> customers, string filter, string orderBy)
{
    var filteredCustomers = customers.Where(c => c.Name.Contains(filter));
    var sortedCustomers = filteredCustomers.OrderBy(c => c.LastName);

    switch (orderBy)
    {
        case "FirstName":
            sortedCustomers = filteredCustomers.OrderBy(c => c.FirstName);
            break;
        case "LastName":
            sortedCustomers = filteredCustomers.OrderBy(c => c.LastName);
            break;
    }

    return sortedCustomers;
}

In this example, the GetCustomers method takes a collection of Customers.

10. Use Interfaces for Loose Coupling

In C#, interfaces provide a powerful mechanism for loose coupling between components. By defining interfaces for services or functionality, you can ensure that components can be easily swapped out or replaced without affecting the rest of the system. This approach can lead to better code performance by minimizing the impact of changes on the system as a whole. For example, consider the following interface that defines a generic repository for accessing data:

interface IRepository<T> {
    void Save(T entity);
    T Get(int id);
}

This interface can define a generic data access layer that can be easily replaced or updated without affecting the rest of the system.

Conclusion

I hope these above 10 points are helpful to each developer to improve the quality of code; by utilizing features such as parallel processing, asynchronous programming, memory management, etc., developers can create applications that perform faster and consume fewer system resources.