C # में प्रदर्शन में सुधार के लिए सर्वोत्तम अभ्यास

अतुल्यकालिक कोड के लिए तुल्यकालिक प्रतीक्षा कर रहा है

ConfigureAwait

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

async शून्य

interface IInterface
{
    void DoSomething();
}

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

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

जब भी संभव हो async से बचें

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

क्षेत्रीय तुलना

समवर्तीबाग <टी>

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 कोर में प्रासंगिक नहीं है, संस्करण 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).