Best Practices zur Verbesserung der Leistung in C #

Synchrones Warten auf asynchronen Code

ConfigureAwait

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

asynchrone Leere

interface IInterface
{
    void DoSomething();
}

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

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

Vermeiden Sie nach Möglichkeit Asynchronität

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

Regionale Vergleiche

ConcurrentBag <T.>

ReaderWriterLock / ReaderWriterLockSlim <T >
Niemals ohne Benchmarking verwenden. ReaderWriterLock<T>/ReaderWriterLockSlim<T>Obwohl die Verwendung dieser Art von spezialisiertem Synchronisationsprimitiv bei der Arbeit mit Lesern und Schreibern verlockend sein kann, sind die Kosten viel höher als bei einfachen Monitor(mit einem Schlüsselwort verwendeten lock). Wenn die Anzahl der Leser, die gleichzeitig den kritischen Abschnitt ausführen, nicht sehr groß ist, reicht die Parallelität nicht aus, um den erhöhten Overhead zu absorbieren, und der Code funktioniert schlechter.

Bevorzugen Sie Lambda-Funktionen anstelle von Methodengruppen

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

Aufzählungen in Zeichenfolgen konvertieren

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

Listenvergleich

Hinweis: Dies ist in .net Core nicht mehr relevant, da die Optimierung ab Version 2.1 automatisch von JIT durchgeführt wird.

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

Implementierung von Vergleichsmethoden für Strukturen

Vermeiden Sie ungeeignete Verpackungen, wenn Sie Strukturen mit Schnittstellen verwenden

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-Abonnements immer inline

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

TaskCompletionSource-Fortsetzungen werden häufig inline ausgeführt

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

• Ausführen einer Aufgabe in einem anderen Scheduler.
• Ausführen einer Aufgabe in einem dedizierten Thread (mit TaskCreationOptions.LongRunning).
• ( TaskCreationOptions.PreferFairness).