using System;

using System.Threading.Tasks;

​

namespace Question

{

    public interface IMyInterface<T>

    {

        void RegisterCallback(Action<T> callback);

        void RegisterAsyncCallback(Func<T, Task> callback);

    }

​

    public class Implementation : IMyInterface<string>

    {

        public void RegisterCallback(Action<string> callback)

        {

            //do something

            callback("hello");

        }

​

        public void RegisterAsyncCallback(Func<string, Task> callback)

        {

            //do something

            Task.Run(() => callback("hello")).Wait();

        }

    }

​

    public class MyClass

    {

        public MyClass(IMyInterface<string> instance)

        {

            instance.RegisterCallback(Callback); //method group

            instance.RegisterCallback(t => { }); //lambda

​

            instance.RegisterCallback(async t => await Task.Delay(0));

            instance.RegisterAsyncCallback(async t => await Task.Delay(0));

            instance.RegisterAsyncCallback(t => Task.Delay(0));

            instance.RegisterAsyncCallback(AsyncCallbackWithAwait); //method group with async

            instance.RegisterAsyncCallback(AsyncCallback); //method group with async

        }

​

        private void Callback(string obj)

        {

            throw new NotImplementedException();

        }

​

        private Task AsyncCallback(string s)

        {

            return Task.Delay(0);

        }

​

        public async Task AsyncCallbackWithAwait(string s)

        {

            await Task.Delay(0);

        }

    }

}