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 IDataService _service;

        public Client(IDataService service)

        {

            _service = service;

        }

​

        public void ClientMethod()

        {

            Console.WriteLine(_service.Foo());

            Console.WriteLine(_service.Bar("Hello"));

        }

    }

​

    public class DataServiceAdapter<TService> : IDataService

        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 bool Foo()

        {

            return _run(x => x.Foo());

        }

        public int Bar(string arg)

        {

            return _run(x => x.Bar(arg));

        }

    }

​

    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 IDataService

    {

        bool Foo();

        int Bar(string arg);

    }