หากอินเทอร์เฟซของฉันต้องส่งคืนงานเป็นวิธีที่ดีที่สุดในการปรับใช้งานที่ไม่ดำเนินการอย่างไร

ในโค้ดด้านล่างเนื่องจากอินเทอร์เฟซคลาสLazyBarจะต้องส่งคืนภารกิจจากเมธอดของมัน (และสำหรับเหตุผลที่ไม่สามารถเปลี่ยนแปลงได้) หากLazyBarการติดตั้งใช้งานผิดปกติเกิดขึ้นกับการทำงานที่รวดเร็วและพร้อมกัน - วิธีใดที่ดีที่สุดในการส่งคืนภารกิจที่ไม่มีการดำเนินการจากเมธอด?

ฉันได้ไปTask.Delay(0)ข้างล่างนี้ แต่ฉันอยากจะรู้ว่าสิ่งนี้มีผลข้างเคียงของการทำงานหรือไม่ถ้าฟังก์ชั่นนี้มีการเรียกใช้มาก (เพื่อประโยชน์ในการโต้แย้งพูดหลายร้อยครั้งต่อวินาที):

• น้ำตาลซินแทติกติกนี้ไม่ทำให้ลมออกมาเป็นเรื่องใหญ่หรือไม่?
• มันเริ่มอุดตันกลุ่มแอปพลิเคชันของฉันหรือไม่
• คอมไพเลอร์มีดเพียงพอที่จะจัดการกับDelay(0)แตกต่างกันหรือไม่?
• จะreturn Task.Run(() => { });แตกต่างกันอย่างไร

มีวิธีที่ดีกว่า?

using System.Threading.Tasks;

namespace MyAsyncTest
{
    internal interface IFooFace
    {
        Task WillBeLongRunningAsyncInTheMajorityOfImplementations();
    }

    /// <summary>
    /// An implementation, that unlike most cases, will not have a long-running
    /// operation in 'WillBeLongRunningAsyncInTheMajorityOfImplementations'
    /// </summary>
    internal class LazyBar : IFooFace
    {
        #region IFooFace Members

        public Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
        {
            // First, do something really quick
            var x = 1;

            // Can't return 'null' here! Does 'Task.Delay(0)' have any performance considerations?
            // Is it a real no-op, or if I call this a lot, will it adversely affect the
            // underlying thread-pool? Better way?
            return Task.Delay(0);

            // Any different?
            // return Task.Run(() => { });

            // If my task returned something, I would do:
            // return Task.FromResult<int>(12345);
        }

        #endregion
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            Test();
        }

        private static async void Test()
        {
            IFooFace foo = FactoryCreate();
            await foo.WillBeLongRunningAsyncInTheMajorityOfImplementations();
            return;
        }

        private static IFooFace FactoryCreate()
        {
            return new LazyBar();
        }
    }
}

การใช้Task.FromResult(0)หรือTask.FromResult<object>(null)สร้างค่าโสหุ้ยน้อยกว่าการสร้างTaskด้วยนิพจน์แบบไม่ใช้ เมื่อสร้าง a ที่Taskมีการกำหนดผลลัพธ์ล่วงหน้าจะไม่มีค่าใช้จ่ายในการกำหนดตารางเวลาที่เกี่ยวข้อง

วันนี้ฉันอยากจะแนะนำให้ใช้Task.CompletedTaskเพื่อทำสิ่งนี้ให้สำเร็จ

หากต้องการเพิ่มคำตอบของ Reed Copseyเกี่ยวกับการใช้Task.FromResultงานคุณสามารถปรับปรุงประสิทธิภาพได้มากขึ้นหากคุณแคชงานที่เสร็จสิ้นแล้วเนื่องจากอินสแตนซ์ทั้งหมดของงานที่เสร็จสมบูรณ์เหมือนกัน:

public static class TaskExtensions
{
    public static readonly Task CompletedTask = Task.FromResult(false);
}

ด้วยTaskExtensions.CompletedTaskคุณสามารถใช้อินสแตนซ์เดียวกันได้ตลอดทั้งโดเมนแอพ

รุ่นล่าสุดของกรอบ NET (v4.6)เพิ่มเพียงว่ามีTask.CompletedTaskคุณสมบัติคงที่

Task completedTask = Task.CompletedTask;

Task.Delay(0) ในคำตอบที่ได้รับการยอมรับเป็นวิธีการที่ดีเพราะเป็นสำเนาของแคชที่เสร็จสมบูรณ์ Taskเช่นเดียวกับในคำตอบที่ได้รับการยอมรับเป็นวิธีการที่ดีในขณะที่มันเป็นสำเนาที่เก็บไว้ของเสร็จ

จาก 4.6 มีตอนนี้Task.CompletedTaskที่ชัดเจนยิ่งขึ้นในวัตถุประสงค์ของมัน แต่ไม่เพียง แต่Task.Delay(0)ยังคงส่งคืนอินสแตนซ์แคชเดียวมันกลับมาเหมือนกันTask.CompletedTaskเช่นแคชเดียวไม่

ลักษณะแคชไม่รับประกันว่าจะคงที่ แต่เป็น optimisations การดำเนินการขึ้นอยู่กับว่าเป็นเพียงการดำเนินการขึ้นอยู่กับว่าเป็น optimisations (นั่นคือพวกเขายังคงทำงานอย่างถูกต้องถ้าการดำเนินการเปลี่ยนแปลงเพื่อสิ่งที่ยังคงถูกต้อง) ใช้Task.Delay(0)เป็น ดีกว่าคำตอบที่ยอมรับ

พบปัญหานี้เมื่อไม่นานมานี้และยังคงได้รับคำเตือน / ข้อผิดพลาดเกี่ยวกับวิธีการที่เป็นโมฆะ

เราอยู่ในธุรกิจการปิดตัวคอมไพเลอร์และสิ่งนี้ล้างมัน:

    public async Task MyVoidAsyncMethod()
    {
        await Task.CompletedTask;
    }

นี่เป็นการรวมคำแนะนำที่ดีที่สุดของทั้งหมดไว้ที่นี่ ไม่จำเป็นต้องมีคำสั่ง return ใด ๆ เว้นแต่ว่าคุณกำลังทำอะไรบางอย่างในวิธีการนั้น

return Task.CompletedTask; // this will make the compiler happy

เมื่อคุณต้องส่งคืนชนิดที่ระบุ:

Task.FromResult<MyClass>(null);

ฉันชอบTask completedTask = Task.CompletedTask;วิธีการแก้ปัญหาของ. Net 4.6 แต่อีกวิธีหนึ่งคือการทำเครื่องหมายวิธีการ async และส่งคืนโมฆะ:

    public async Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
    {
    }

คุณจะได้รับคำเตือน (CS1998 - ฟังก์ชัน Async โดยไม่ต้องรอนิพจน์) แต่การเพิกเฉยในบริบทนี้จะปลอดภัย

หากคุณกำลังใช้ข้อมูลทั่วไปคำตอบทั้งหมดจะทำให้เรารวบรวมข้อผิดพลาด return default(T);คุณสามารถใช้ ตัวอย่างด้านล่างเพื่ออธิบายเพิ่มเติม

public async Task<T> GetItemAsync<T>(string id)
            {
                try
                {
                    var response = await this._container.ReadItemAsync<T>(id, new PartitionKey(id));
                    return response.Resource;
                }
                catch (CosmosException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
                {

                    return default(T);
                }

            }

return await Task.FromResult(new MyClass());