Wenn meine Schnittstelle Task zurückgeben muss, was ist der beste Weg für eine Implementierung ohne Operation?

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

Ich bin mit Task.Delay(0) weiter unten gegangen, möchte jedoch wissen, ob dies irgendwelche Leistungsnebenwirkungen hat, wenn die Funktion lot (aus Gründen, die Hunderte von Malen bedeuten) genannt wird eine Sekunde):

• Entspannt sich dieser syntaktische Zucker zu etwas Großem?
• Verstopft es den Thread-Pool meiner Anwendung?
• Reicht der Compiler-Cleaver aus, um mit Delay(0) anders umzugehen?
• Wäre return Task.Run(() => { }); anders?

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