أفضل الممارسات لتحسين الأداء في C #

انتظار رمز غير متزامن بشكل متزامن

ConfigureAwait

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

فراغ غير متزامن

interface IInterface
{
    void DoSomething();
}

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

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

تجنب التزامن كلما أمكن ذلك

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

المقارنات الإقليمية

ConcurrentBag <T>

ReaderWriterLock / ReaderWriterLockSlim <T >
لا تستخدم أبدًا بدون قياس الأداء. ReaderWriterLock<T>/ReaderWriterLockSlim<T>على الرغم من أن استخدام هذا النوع من المزامنة المتخصصة البدائية عند العمل مع القراء والكتاب يمكن أن يكون مغريًا ، إلا أن تكلفته أعلى بكثير من التكلفة البسيطة Monitor(المستخدمة مع الكلمة الرئيسية lock). إذا لم يكن عدد القراء الذين يؤدون القسم الحاسم في نفس الوقت كبيرًا جدًا ، فلن يكون التزامن كافيًا لامتصاص زيادة الحمل ، وسيعمل الرمز بشكل أسوأ.

تفضل وظائف لامدا بدلا من مجموعات الطريقة

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

تحويل التعدادات إلى سلاسل

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

مقارنة التعداد

ملاحظة: هذا لم يعد مناسبًا في .net core ، نظرًا لأن الإصدار 2.1 ، يتم تنفيذ التحسين بواسطة 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;
}

تنفيذ طرق المقارنة للهياكل

تجنب التغليف غير المناسب عند استخدام الهياكل ذات الواجهات

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

إلغاء الاشتراكات المنطوقة مضمنة دائمًا

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

غالبًا ما تكون عمليات متابعة TaskCompletionSource مضمنة

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

• تشغيل مهمة في برنامج جدولة آخر.
• تنفيذ مهمة في خيط مخصص (باستخدام TaskCreationOptions.LongRunning).
• ( TaskCreationOptions.PreferFairness).