using System;

​

    public class Program

    {

        public static void Main()

        {

            //Dependency register logic here. Choose either

            //var service = new DataServiceAdapter<SpecificNotDisposableDataService>();

            var service = new DataServiceAdapter<SpecificDisposableDataService>();

            var client = new Client(service);

            client.ClientMethod();

            Console.ReadLine();

        }

    }

​

    public class Client

    {

        private readonly IDataServiceAdapter<IDataService> _service;

        public Client(IDataServiceAdapter<IDataService> service)

        {

            _service = service;

        }

​

        public void ClientMethod()

        {

            Console.WriteLine(_service.Run(s => s.Foo()));

            Console.WriteLine(_service.Run(s => s.Bar("Hello")));

        }

    }

​

    public class DataServiceAdapter<TService> : IDataServiceAdapter<TService>

        where TService : IDataService, new()

    {

        private readonly TService _service;

        private readonly Func<Func<TService, dynamic>, dynamic> _run;

        public DataServiceAdapter()

        {

            if (typeof(IDisposable).IsAssignableFrom(typeof(TService)))

            {

                _run = RunWithUsing;

            }

            else

            {

                _service = new TService();

                _run = RunWithoutUsing;

            }

        }

​

        private dynamic RunWithUsing(Func<TService, dynamic> func)

        {

            using (var service = (IDisposable) new TService())

            {

                return func((TService)service);

            }

        }

​

        private dynamic RunWithoutUsing(Func<TService, dynamic> func)

        {

            return func(_service);

        }

        public dynamic Run(Func<TService, dynamic> func)

        {

            return _run(func);

        }

    }

​

    public class SpecificDisposableDataService : IDataService, IDisposable

    {

        public bool Foo()

        {

            return true;

        }

​

        public int Bar(string arg)

        {

            return arg.Length;

        }

​

        public void Dispose()

        {

            //Dispose logic here

        }

    }

​

    public class SpecificNotDisposableDataService : IDataService

    {

        public bool Foo()

        {

            return false;

        }

​

        public int Bar(string arg)

        {

            return arg.Length*2;

        }

    }

​

    public interface IDataServiceAdapter<out TService>

        where TService : IDataService

    {

        dynamic Run(Func<TService, dynamic> func);

    }

​

    public interface IDataService

    {

        bool Foo();

        int Bar(string arg);

    }