Práticas recomendadas para melhorar o desempenho em C #

Esperando de forma síncrona por código assíncrono

ConfigureAwait

//  ConfigureAwait        
var result = ProcessAsync().ConfigureAwait(false).GetAwaiter().GetResult();

vazio assíncrono

interface IInterface
{
    void DoSomething();
}

class Implementation : IInterface
{
    public void DoSomething()
    {
        //      ,
        //      
        _ = DoSomethingAsync();
    }

    private async Task DoSomethingAsync()
    {
        await Task.Delay(100);
    }
}

Evite async sempre que possível

public async Task CallAsync()
{
    var client = new Client();
    return await client.GetAsync();
}

public Task CallAsync()
{
    var client = new Client();
    return _client.GetAsync();
}

public async Task Correct()
{
    using (var client = new Client())
    {
        return await client.GetAsync();
    }
}

public Task Incorrect()
{
    using (var client = new Client())
    {
        return client.GetAsync();
    }
}

Comparações regionais

ConcurrentBag <T>

ReaderWriterLock / ReaderWriterLockSlim <T >
Nunca use sem benchmarking. ReaderWriterLock<T>/ReaderWriterLockSlim<T>Embora o uso desse tipo de primitiva de sincronização especializada ao trabalhar com leitores e gravadores possa ser tentador, seu custo é muito maior que o simples Monitor(usado com uma palavra-chave lock). Se o número de leitores que executam a seção crítica ao mesmo tempo não for muito grande, a simultaneidade não será suficiente para absorver o aumento da sobrecarga e o código funcionará pior.

Preferir funções lambda em vez de grupos de métodos

public IEnumerable<int> GetItems()
{
    return _list.Where(i => Filter(i));
}
private static bool Filter(int element)
{
    return i % 2 == 0;
}

public IEnumerable<int> GetItems()
{
    return _list.Where(Filter);
}
private static bool Filter(int element)
{
    return i % 2 == 0;
}

public IEnumerable<int> GetItems()
{
    return _list.Where(new Predicate<int>(Filter));
}
private static bool Filter(int element)
{
    return i % 2 == 0;
}

private Predicate<int> _filter;

public Constructor()
{
    _filter = new Predicate<int>(Filter);
}

public IEnumerable<int> GetItems()
{
    return _list.Where(_filter);
}

private bool Filter(int element)
{
    return i % 2 == 0;
}

Converter enumerações em seqüências de caracteres

//       Numbers.One, Numbers.Two, ...
public enum Numbers
{
    One,
    Two,
    Three
}

public static class Numbers
{
    public const string One = "One";
    public const string Two = "Two";
    public const string Three = "Three";
}

Comparação de enumeração

Nota: isso não é mais relevante no núcleo .net, desde a versão 2.1, a otimização é executada pelo JIT automaticamente.

[Flags]
public enum Options
{
    Option1 = 1,
    Option2 = 2,
    Option3 = 4
}

private Options _option;

public bool IsOption2Enabled()
{
    return _option.HasFlag(Options.Option2);
}

public bool IsOption2Enabled()
{
    return (_option & Options.Option2) == Options.Option2;
}

Implementação de métodos de comparação para estruturas

Evite embalagens inadequadas ao usar estruturas com interfaces

public class IntValue : IValue
{
}

public void DoStuff()
{
    var value = new IntValue();

    LogValue(value);
    SendValue(value);
}

public void SendValue(IValue value)
{
    // ...
}

public void LogValue(IValue value)
{
    // ...
}

public struct IntValue : IValue
{
}

public void DoStuff()
{
    var value = new IntValue();

    LogValue(value);
    SendValue(value);
}

public void SendValue<T>(T value) where T : IValue
{
    // ...
}

public void LogValue<T>(T value) where T : IValue
{
    // ...
}

CancellationToken Subscriptions Always Inline

var cts = new CancellationTokenSource();
cts.Token.Register(() => Thread.Sleep(5000));
cts.Cancel(); //     5 

Continuações de origem frequentemente alinhadas

class Program
{
    private static ManualResetEventSlim _mutex = new ManualResetEventSlim();
    
    public static async Task Deadlock()
    {
        await ProcessAsync();
        _mutex.Wait();
    }
    
    private static Task ProcessAsync()
    {
        var tcs = new TaskCompletionSource<bool>();
        
        Task.Run(() =>
        {
            Thread.Sleep(2000); //  - 
            tcs.SetResult(true);
            _mutex.Set();
        });
        
        return tcs.Task;
    }
    
    static void Main(string[] args)
    {
        Deadlock().Wait();
        Console.WriteLine("Will never get there");
    }
}

Task.Run / Task.Factory.StartNew

class Program
{
    public static async Task ProcessAsync()
    {
        await Task.Delay(2000);
        Console.WriteLine("Processing done");
    }
    
    static async Task Main(string[] args)
    {
        await Task.Factory.StartNew(ProcessAsync);
        Console.WriteLine("End of program");
        Console.ReadLine();
    }
}

• Executando uma tarefa em outro planejador.
• Executando uma tarefa em um encadeamento dedicado (usando TaskCreationOptions.LongRunning).
• ( TaskCreationOptions.PreferFairness).