Praktik terbaik untuk meningkatkan kinerja dalam C #

Sinkron menunggu kode asinkron

Konfigurasikan, Tunggu

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

batal async

interface IInterface
{
    void DoSomething();
}

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

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

Hindari async bila memungkinkan

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

Perbandingan regional

ConcurrentBag <T>

ReaderWriterLock / ReaderWriterLockSlim <T >
Jangan pernah gunakan tanpa pembandingan. ReaderWriterLock<T>/ReaderWriterLockSlim<T>Meskipun menggunakan jenis sinkronisasi khusus yang primitif saat bekerja dengan pembaca dan penulis bisa menggoda, biayanya jauh lebih tinggi daripada yang sederhana Monitor(digunakan dengan kata kunci lock). Jika jumlah pembaca yang melakukan bagian kritis pada saat yang sama tidak terlalu besar, konkurensi tidak akan cukup untuk menyerap peningkatan overhead, dan kode akan bekerja lebih buruk.

Lebih suka fungsi lambda daripada kelompok metode

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

Konversi Enumerasi ke Strings

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

Perbandingan Pencacahan

Catatan: ini tidak lagi relevan di .net core, sejak versi 2.1, optimasi dilakukan oleh JIT secara otomatis.

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

Implementasi metode perbandingan untuk struktur

Hindari pengemasan yang tidak tepat saat menggunakan struktur dengan antarmuka

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
{
    // ...
}

Pembatalan Langganan Berlalu Selalu Sebaris

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

Kelanjutan TaskCompletionSource sering kali sejalan

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

• Menjalankan tugas di penjadwal lain.
• Melakukan tugas dalam utas khusus (menggunakan TaskCreationOptions.LongRunning).
• ( TaskCreationOptions.PreferFairness).