Meilleures pratiques pour améliorer les performances en C #

Attente synchrone de code asynchrone

ConfigureAwait

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

async void

interface IInterface
{
    void DoSomething();
}

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

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

Évitez l'async autant que possible

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();
    }
}

Comparaisons régionales

ConcurrentBag <T>

ReaderWriterLock / ReaderWriterLockSlim <T >
Ne jamais utiliser sans analyse comparative. ReaderWriterLock<T>/ReaderWriterLockSlim<T>Bien que l'utilisation de ce type de primitive de synchronisation spécialisée lorsque vous travaillez avec des lecteurs et des écrivains puisse être tentante, son coût est beaucoup plus élevé que le simple Monitor(utilisé avec le mot-clé lock). Si le nombre de lecteurs exécutant la section critique en même temps n'est pas très élevé, la simultanéité ne sera pas suffisante pour absorber la surcharge accrue et le code fonctionnera moins bien.

Préférez les fonctions lambda au lieu des groupes de méthodes

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;
}

Convertir les énumérations en chaînes

//       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";
}

Comparaison d'énumération

Remarque: cela n'est plus pertinent dans le noyau .net, depuis la version 2.1, l'optimisation est effectuée automatiquement par JIT.

[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;
}

Mise en place de méthodes de comparaison des structures

Évitez les emballages inappropriés lorsque vous utilisez des structures avec des 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
{
    // ...
}

Abonnements CancellationToken toujours en ligne

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

Les continuations de TaskCompletionSource sont souvent en ligne

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();
    }
}

• Exécution d'une tâche dans un autre planificateur.
• Exécution d'une tâche dans un thread dédié (à l'aide de TaskCreationOptions.LongRunning).
• ( TaskCreationOptions.PreferFairness).