Подтвердить что ты не робот

Как я могу написать общий класс контейнера, который реализует данный интерфейс в С#?

Контекст:.NET 3.5, VS2008. Я не уверен в названии этого вопроса, поэтому не стесняйтесь прокомментировать название:-)

Здесь сценарий: у меня есть несколько классов, например Foo и Bar, все они реализуют следующий интерфейс:

public interface IStartable
{
    void Start();
    void Stop();
}

И теперь я хотел бы иметь контейнерный класс, который получает IEnumerable <IStartable> как аргумент в его конструкторе. Этот класс, в свою очередь, должен также реализовать интерфейс IStartable:

public class StartableGroup : IStartable // this is the container class
{
    private readonly IEnumerable<IStartable> startables;

    public StartableGroup(IEnumerable<IStartable> startables)
    {
        this.startables = startables;
    }

    public void Start()
    {
        foreach (var startable in startables)
        {
            startable.Start();
        }
    }

    public void Stop()
    {
        foreach (var startable in startables)
        {
            startable.Stop();
        }
    }
}

Итак, мой вопрос: как я могу это сделать без ручной записи кода и без генерации кода? Другими словами, я хотел бы иметь что-то вроде следующего.

var arr = new IStartable[] { new Foo(), new Bar("wow") };
var mygroup = GroupGenerator<IStartable>.Create(arr);
mygroup.Start(); // --> calls Foo Start and Bar Start

Ограничения:

  • Нет генерации кода (то есть реального текстового кода во время компиляции)
  • Интерфейс имеет только void методы, с аргументами или без них

Мотивация:

  • У меня есть довольно большое приложение, с большим количеством плагинов различных интерфейсов. Вручную писать класс "group container" для каждого интерфейса "перегружает" проект классами
  • Вручную писать код подвержен ошибкам
  • Любые дополнения или обновления сигнатур для интерфейса IStartable приведут к (ручным) изменениям в классе "group container"
  • Обучение

Я понимаю, что здесь я должен использовать отражение, но я бы предпочел использовать надежную структуру (например, Castle DynamicProxy или RunSharp), чтобы сделать проводку для меня.

Любые мысли?

4b9b3361

ОТВЕТЫ

Ответ 1

Это не очень, но, похоже, это работает:

public static class GroupGenerator
{
    public static T Create<T>(IEnumerable<T> items) where T : class
    {
        return (T)Activator.CreateInstance(Cache<T>.Type, items);
    }
    private static class Cache<T> where T : class
    {
        internal static readonly Type Type;
        static Cache()
        {
            if (!typeof(T).IsInterface)
            {
                throw new InvalidOperationException(typeof(T).Name
                    + " is not an interface");
            }
            AssemblyName an = new AssemblyName("tmp_" + typeof(T).Name);
            var asm = AppDomain.CurrentDomain.DefineDynamicAssembly(
                an, AssemblyBuilderAccess.RunAndSave);
            string moduleName = Path.ChangeExtension(an.Name,"dll");
            var module = asm.DefineDynamicModule(moduleName, false);
            string ns = typeof(T).Namespace;
            if (!string.IsNullOrEmpty(ns)) ns += ".";
            var type = module.DefineType(ns + "grp_" + typeof(T).Name,
                TypeAttributes.Class | TypeAttributes.AnsiClass |
                TypeAttributes.Sealed | TypeAttributes.NotPublic);
            type.AddInterfaceImplementation(typeof(T));

            var fld = type.DefineField("items", typeof(IEnumerable<T>),
                FieldAttributes.Private);
            var ctor = type.DefineConstructor(MethodAttributes.Public,
                CallingConventions.HasThis, new Type[] { fld.FieldType });
            var il = ctor.GetILGenerator();
            // store the items
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Stfld, fld);
            il.Emit(OpCodes.Ret);

            foreach (var method in typeof(T).GetMethods())
            {
                var args = method.GetParameters();
                var methodImpl = type.DefineMethod(method.Name,
                    MethodAttributes.Private | MethodAttributes.Virtual,
                    method.ReturnType,
                    Array.ConvertAll(args, arg => arg.ParameterType));
                type.DefineMethodOverride(methodImpl, method);
                il = methodImpl.GetILGenerator();
                if (method.ReturnType != typeof(void))
                {
                    il.Emit(OpCodes.Ldstr,
                        "Methods with return values are not supported");
                    il.Emit(OpCodes.Newobj, typeof(NotSupportedException)
                        .GetConstructor(new Type[] {typeof(string)}));
                    il.Emit(OpCodes.Throw);
                    continue;
                }

                // get the iterator
                var iter = il.DeclareLocal(typeof(IEnumerator<T>));
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldfld, fld);
                il.EmitCall(OpCodes.Callvirt, typeof(IEnumerable<T>)
                    .GetMethod("GetEnumerator"), null);
                il.Emit(OpCodes.Stloc, iter);
                Label tryFinally = il.BeginExceptionBlock();

                // jump to "progress the iterator"
                Label loop = il.DefineLabel();
                il.Emit(OpCodes.Br_S, loop);

                // process each item (invoke the paired method)
                Label doItem = il.DefineLabel();
                il.MarkLabel(doItem);
                il.Emit(OpCodes.Ldloc, iter);
                il.EmitCall(OpCodes.Callvirt, typeof(IEnumerator<T>)
                    .GetProperty("Current").GetGetMethod(), null);
                for (int i = 0; i < args.Length; i++)
                { // load the arguments
                    switch (i)
                    {
                        case 0: il.Emit(OpCodes.Ldarg_1); break;
                        case 1: il.Emit(OpCodes.Ldarg_2); break;
                        case 2: il.Emit(OpCodes.Ldarg_3); break;
                        default:
                            il.Emit(i < 255 ? OpCodes.Ldarg_S
                                : OpCodes.Ldarg, i + 1);
                            break;
                    }
                }
                il.EmitCall(OpCodes.Callvirt, method, null);

                // progress the iterator
                il.MarkLabel(loop);
                il.Emit(OpCodes.Ldloc, iter);
                il.EmitCall(OpCodes.Callvirt, typeof(IEnumerator)
                    .GetMethod("MoveNext"), null);
                il.Emit(OpCodes.Brtrue_S, doItem);
                il.Emit(OpCodes.Leave_S, tryFinally);

                // dispose iterator
                il.BeginFinallyBlock();
                Label endFinally = il.DefineLabel();
                il.Emit(OpCodes.Ldloc, iter);
                il.Emit(OpCodes.Brfalse_S, endFinally);
                il.Emit(OpCodes.Ldloc, iter);
                il.EmitCall(OpCodes.Callvirt, typeof(IDisposable)
                    .GetMethod("Dispose"), null);
                il.MarkLabel(endFinally);
                il.EndExceptionBlock();
                il.Emit(OpCodes.Ret);
            }
            Cache<T>.Type = type.CreateType();
#if DEBUG       // for inspection purposes...
            asm.Save(moduleName);
#endif
        }
    }
}

Ответ 2

Это не такой чистый интерфейс, как решение на основе отражения, но очень простым и гибким решением является создание метода ForAll, например:

static void ForAll<T>(this IEnumerable<T> items, Action<T> action)
{
    foreach (T item in items)
    {
        action(item);
    }
}

И можно вызвать так:

arr.ForAll(x => x.Start());

Ответ 3

Вы можете подклассифицировать List<T> или какой-либо другой класс коллекции и использовать ограничение типа where общего типа, чтобы ограничить тип T только классом IStartable.

class StartableList<T> : List<T>, IStartable where T : IStartable
{
    public StartableList(IEnumerable<T> arr)
        : base(arr)
    {
    }

    public void Start()
    {
        foreach (IStartable s in this)
        {
            s.Start();
        }
    }

    public void Stop()
    {
        foreach (IStartable s in this)
        {
            s.Stop();
        }
    }
}

Вы также можете объявить класс следующим образом, если вы не хотите, чтобы он был универсальным классом, требующим параметр типа.

public class StartableList : List<IStartable>, IStartable
{ ... }

Ваш пример кода использования будет выглядеть примерно так:

var arr = new IStartable[] { new Foo(), new Bar("wow") };
var mygroup = new StartableList<IStartable>(arr);
mygroup.Start(); // --> calls Foo Start and Bar Start

Ответ 4

Automapper является хорошим решением. Он полагается на LinFu ниже, чтобы создать экземпляр, который реализует интерфейс, но он заботится о некоторых гидратациях и миксинах под несколько беглый api. Автор LinFu утверждает, что он на самом деле намного более легкий и быстрый, чем Castle Proxy.

Ответ 5

Вы можете подождать С# 4.0 и использовать динамическое связывание.

Это отличная идея - мне пришлось несколько раз реализовать это для IDisposable; когда я хочу, чтобы многие вещи были удалены. Одна вещь, о которой нужно помнить, - это то, как будут обрабатываться ошибки. Если он регистрируется и продолжает запускать другие и т.д., Вам нужны некоторые параметры, чтобы дать класс.

Я не знаком с DynamicProxy и как его можно использовать здесь.

Ответ 6

Вы можете использовать класс "Список" и их метод "ForEach".

var startables = new List<IStartable>( array_of_startables );
startables.ForEach( t => t.Start(); }

Ответ 7

Если я правильно понимаю, вы просите о реализации "GroupGenerator".

Без реального опыта с CastleProxy моей рекомендацией было бы использовать GetMethods(), чтобы получить начальные методы, перечисленные в интерфейсе, а затем создать новый тип "на лету" с помощью Reflection.Emit с новыми методами, которые перечисляют объекты и вызовите каждый соответствующий метод. Производительность не должна быть слишком плохой.