Запрос функции С#: реализовать интерфейсы на анонимных типах

Мне интересно, что нужно сделать, чтобы сделать что-то вроде этой работы:

using System;

class Program
{
    static void Main()
    {
        var f = new IFoo { 
                    Foo = "foo",
                    Print = () => Console.WriteLine(Foo)
            };
    }
}

interface IFoo
{
    String Foo { get; set; }
    void Print();
}

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

internal sealed class <>f__AnonymousType0<<Foo>j__TPar> : IFoo
{
    readonly <Foo>j__TPar <Foo>i__Field;

    public <>f__AnonymousType0(<Foo>j__TPar Foo)
    {
        this.<Foo>i__Field = Foo;
    }

    public <Foo>j__TPar Foo
    {
        get { return this.<Foo>i__Field; }
    }

    public void Print()
    {
        Console.WriteLine(this.Foo);
    }
}

Есть ли причина, по которой компилятор не сможет сделать что-то подобное? Даже для непустых методов или методов, которые принимают параметры, компилятор должен иметь возможность выводить типы из декларации интерфейса.

Отказ от ответственности: Пока я понимаю, что в настоящее время это невозможно, и было бы разумнее просто создать конкретный класс в этом случае. Меня больше интересуют теоретические аспекты этого.

ОТВЕТЫ

Ответ 1

Было бы несколько проблем с перегруженными членами, индексаторами и явными реализациями интерфейса.

Однако вы могли бы определить синтаксис таким образом, чтобы разрешить эти проблемы.

Интересно, что вы можете приблизиться к тому, что хотите с С# 3.0, написав библиотеку. В принципе, вы можете сделать это:

Create<IFoo>
(
    new
    {
        Foo = "foo",
        Print = (Action)(() => Console.WriteLine(Foo))
    }
);

Это довольно близко к тому, что вы хотите. Основными отличиями являются призыв "Создать" вместо "нового" ключевого слова и тот факт, что вам нужно указать тип делегата.

Объявление "Создать" будет выглядеть так:

T Create<T> (object o)
{
//...
}

Затем он будет использовать Reflection.Emit для динамического создания реализации интерфейса во время выполнения.

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

Альтернативой может быть использование инициализатора коллекции, а не анонимного типа. Это будет выглядеть так:

Create
{
    new Members<IFoo>
    {
        {"Print", ((IFoo @this)=>Console.WriteLine(Foo))},
        {"Foo", "foo"}
    }
}

Это позволит вам:

  • Обработать явную реализацию интерфейса, указав что-то вроде "IEnumerable.Current" для строкового параметра.
  • Определить Members.Add, чтобы вам не нужно указывать тип делегата в инициализаторе.

Вам нужно сделать несколько вещей, чтобы реализовать это:

  • Writer - небольшой парсер для имен типов С#. Для этого требуется только ".", "[]", "< > ", ID и имена примитивных типов, поэтому вы могли бы сделать это через несколько часов.
  • Реализовать кеш, чтобы вы генерировали только один класс для каждого уникального интерфейса
  • Внедрить код Reflection.Emit. Это, вероятно, займет не более 2 дней.

Ответ 2

Для этого требуется С# 4, но интерфейс импровизированного интерфейса может подделать его из коробки, используя внутренние прокси DLR. Производительность хороша, хотя и не так хороша, как если бы предложенное вами изменение существовало.

using ImpromptuInterface.Dynamic;

...

var f = ImpromptuGet.Create<IFoo>(new{ 
                Foo = "foo",
                Print = ReturnVoid.Arguments(() => Console.WriteLine(Foo))
            });

Ответ 3

Анонимный тип не может быть сделан, чтобы делать что-либо, кроме как иметь свойства только для чтения.

Цитирование Руководство по программированию на С# (анонимные типы):

"Анонимные типы - это типы классов, которые состоят из одного или нескольких публичных только для чтения. Никаких других видов членов класса, таких как методы или события разрешены. Анонимный тип не могут быть добавлены к любому интерфейсу или тип, за исключением объекта."

Ответ 4

Пока мы собираем список желаний интерфейса, мне бы очень хотелось сообщить компилятору, что класс реализует интерфейс вне определения класса - даже в отдельной сборке.

Например, скажем, я работаю над программой для извлечения файлов из разных архивных форматов. Я хочу, чтобы иметь возможность использовать существующие реализации из разных библиотек — скажем, SharpZipLib и коммерческая реализация PGP — и потребляют обе библиотеки, используя один и тот же код, без создания новых классов. Тогда я мог бы использовать типы из любого источника в общих ограничениях, например.

Другим использованием было бы сказать компилятору, что System.Xml.Serialization.XmlSerializer реализует интерфейс System.Runtime.Serialization.IFormatter (он уже делает, но компилятор этого не знает).

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

Ответ 5

У вас может быть что-то вроде анонимных классов в Java:

using System; 

class Program { 
  static void Main() { 
    var f = new IFoo() {  
      public String Foo { get { return "foo"; } } 
      public void Print() { Console.WriteLine(Foo); }
    }; 
  } 
} 

interface IFoo { 
  String Foo { get; set; } 
  void Print(); 
}

Ответ 6

Разве это не было бы круто. Inline анонимный класс:

List<Student>.Distinct(new IEqualityComparer<Student>() 
{ 
    public override bool Equals(Student x, Student y)
    {
        return x.Id == y.Id;
    }

    public override int GetHashCode(Student obj)
    {
        return obj.Id.GetHashCode();
    }
})

Ответ 7

Я собираюсь свалить это здесь. Я написал это некоторое время назад, но IIRC работает нормально.

Сначала вспомогательная функция принимает MethodInfo и возвращает Type для сопоставления Func или Action. К сожалению, вам нужна ветка для каждого количества параметров, и я, по-видимому, остановился в три раза.

static Type GenerateFuncOrAction(MethodInfo method)
{
    var typeParams = method.GetParameters().Select(p => p.ParameterType).ToArray();
    if (method.ReturnType == typeof(void))
    {
        if (typeParams.Length == 0)
        {
            return typeof(Action);
        }
        else if (typeParams.Length == 1)
        {
            return typeof(Action<>).MakeGenericType(typeParams);
        }
        else if (typeParams.Length == 2)
        {
            return typeof(Action<,>).MakeGenericType(typeParams);
        }
        else if (typeParams.Length == 3)
        {
            return typeof(Action<,,>).MakeGenericType(typeParams);
        }
        throw new ArgumentException("Only written up to 3 type parameters");
    }
    else
    {
        if (typeParams.Length == 0)
        {
            return typeof(Func<>).MakeGenericType(typeParams.Concat(new[] { method.ReturnType }).ToArray());
        }
        else if (typeParams.Length == 1)
        {
            return typeof(Func<,>).MakeGenericType(typeParams.Concat(new[] { method.ReturnType }).ToArray());
        }
        else if (typeParams.Length == 2)
        {
            return typeof(Func<,,>).MakeGenericType(typeParams.Concat(new[] { method.ReturnType }).ToArray());
        }
        else if (typeParams.Length == 3)
        {
            return typeof(Func<,,,>).MakeGenericType(typeParams.Concat(new[] { method.ReturnType }).ToArray());
        }
        throw new ArgumentException("Only written up to 3 type parameters");
    }
}

И теперь метод, который принимает интерфейс как общий параметр и возвращает Type, который реализует интерфейс, и имеет конструктор (должен быть вызван через Activator.CreateInstance), беря Func или Action для каждого метод/геттер/сеттер. Однако вам нужно знать правильный порядок, чтобы поместить их в конструктор. Альтернативно (код с комментариями) он может генерировать DLL, которую вы можете ссылаться и использовать тип напрямую.

static Type GenerateInterfaceImplementation<TInterface>()
{
    var interfaceType = typeof(TInterface);
    var funcTypes = interfaceType.GetMethods().Select(GenerateFuncOrAction).ToArray();

    AssemblyName aName =
        new AssemblyName("Dynamic" + interfaceType.Name + "WrapperAssembly");
    var assBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
            aName,
            AssemblyBuilderAccess.Run/*AndSave*/); // to get a DLL

    var modBuilder = assBuilder.DefineDynamicModule(aName.Name/*, aName.Name + ".dll"*/); // to get a DLL

    TypeBuilder typeBuilder = modBuilder.DefineType(
        "Dynamic" + interfaceType.Name + "Wrapper",
            TypeAttributes.Public);

    // Define a constructor taking the same parameters as this method.
    var ctrBuilder = typeBuilder.DefineConstructor(
        MethodAttributes.Public | MethodAttributes.HideBySig |
            MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
        CallingConventions.Standard,
        funcTypes);


    // Start building the constructor.
    var ctrGenerator = ctrBuilder.GetILGenerator();
    ctrGenerator.Emit(OpCodes.Ldarg_0);
    ctrGenerator.Emit(
        OpCodes.Call,
        typeof(object).GetConstructor(Type.EmptyTypes));

    // For each interface method, we add a field to hold the supplied
    // delegate, code to store it in the constructor, and an
    // implementation that calls the delegate.
    byte methodIndex = 0;
    foreach (var interfaceMethod in interfaceType.GetMethods())
    {
        ctrBuilder.DefineParameter(
            methodIndex + 1,
            ParameterAttributes.None,
            "del_" + interfaceMethod.Name);

        var delegateField = typeBuilder.DefineField(
            "del_" + interfaceMethod.Name,
            funcTypes[methodIndex],
            FieldAttributes.Private);

        ctrGenerator.Emit(OpCodes.Ldarg_0);
        ctrGenerator.Emit(OpCodes.Ldarg_S, methodIndex + 1);
        ctrGenerator.Emit(OpCodes.Stfld, delegateField);

        var metBuilder = typeBuilder.DefineMethod(
            interfaceMethod.Name,
            MethodAttributes.Public | MethodAttributes.Virtual |
                MethodAttributes.Final | MethodAttributes.HideBySig |
                MethodAttributes.NewSlot,
            interfaceMethod.ReturnType,
            interfaceMethod.GetParameters()
                .Select(p => p.ParameterType).ToArray());

        var metGenerator = metBuilder.GetILGenerator();
        metGenerator.Emit(OpCodes.Ldarg_0);
        metGenerator.Emit(OpCodes.Ldfld, delegateField);

        // Generate code to load each parameter.
        byte paramIndex = 1;
        foreach (var param in interfaceMethod.GetParameters())
        {
            metGenerator.Emit(OpCodes.Ldarg_S, paramIndex);
            paramIndex++;
        }
        metGenerator.EmitCall(
            OpCodes.Callvirt,
            funcTypes[methodIndex].GetMethod("Invoke"),
            null);

        metGenerator.Emit(OpCodes.Ret);
        methodIndex++;
    }

    ctrGenerator.Emit(OpCodes.Ret);

    // Add interface implementation and finish creating.
    typeBuilder.AddInterfaceImplementation(interfaceType);
    var wrapperType = typeBuilder.CreateType();
    //assBuilder.Save(aName.Name + ".dll"); // to get a DLL

    return wrapperType;
}

Вы можете использовать это, например,

public interface ITest
{
    void M1();
    string M2(int m2, string n2);
    string prop { get; set; }

    event test BoopBooped;
}

Type it = GenerateInterfaceImplementation<ITest>();
ITest instance = (ITest)Activator.CreateInstance(it,
    new Action(() => {Console.WriteLine("M1 called"); return;}),
    new Func<int, string, string>((i, s) => "M2 gives " + s + i.ToString()),
    new Func<String>(() => "prop value"),
    new Action<string>(s => {Console.WriteLine("prop set to " + s);}),
    new Action<test>(eh => {Console.WriteLine(eh("handler added"));}),
    new Action<test>(eh => {Console.WriteLine(eh("handler removed"));}));

// or with the generated DLL
ITest instance = new DynamicITestWrapper(
    // parameters as before but you can see the signature
    );

Ответ 8

Интересная идея, я был бы немного обеспокоен тем, что даже если это можно было бы сделать, это может запутать. Например. при определении свойства с нетривиальными сеттерами и геттерами, или как устранить ошибки Foo, если тип объявления также содержит свойство Foo.

Интересно, будет ли это проще в более динамичном языке или даже с динамическим типом и DLR в С# 4.0?

Возможно, сегодня на С# некоторые из намерений могут быть достигнуты с помощью lambdas:

void Main() {
    var foo = new Foo();
    foo.Bar = "bar";
    foo.Print = () => Console.WriteLine(foo.Bar);
    foo.Print();
}


class Foo : IFoo {
    public String Bar { get; set; }    
    public Action Print {get;set;}
}

Ответ 9

В настоящее время это невозможно.

Какая разница между этим и просто созданием IFoo конкретного класса? Похоже, это лучший вариант.

Что нужно? Новый компилятор и тонны проверок, чтобы они не нарушили другие функции. Лично я считаю, что проще просто потребовать от разработчиков просто создать конкретную версию своего класса.

Ответ 10

Я использовал в Java класс Amonimous через "новый IFoo() {...}" sintax, и это практично и легко, когда вам нужно быстро реализовать простой интерфейс.

В качестве примера было бы неплохо реализовать IDisposable таким образом на устаревшем объекте, который использовался только один раз, вместо того, чтобы выводить новый класс для его реализации.