Wenn meine Schnittstelle Task zurückgeben muss, was ist der beste Weg, um eine No-Operation-Implementierung zu haben?

Question

Im folgenden Code wird aufgrund der Schnittstelle die Klasse LazyBar muss eine Aufgabe aus seiner Methode zurückgeben (und kann aus Gründen der Argumentation nicht geändert werden). Wenn LazyBar Die Implementierung der Methode ist insofern ungewöhnlich, als sie schnell und synchron abläuft - wie kann man am besten eine No-Operation-Aufgabe aus der Methode zurückgeben?

Ich bin gegangen mit Task.Delay(0) unten, aber ich würde gerne wissen, ob dies irgendwelche Leistungsnebeneffekte hat, wenn die Funktion eine Los (sagen wir mal hundertmal pro Sekunde):

• Führt dieser syntaktische Zucker zu etwas Großem?
• Wird dadurch der Thread-Pool meiner Anwendung verstopft?
• Ist der Compiler klug genug, um mit Delay(0) anders?
• Würde return Task.Run(() => { }); anders sein?

Gibt es einen besseren Weg?

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