Может ли анонимный класс реализовать интерфейс?

Возможно ли, чтобы анонимный тип реализовывал интерфейс?

У меня есть фрагмент кода, над которым я хотел бы поработать, но не знаю, как это сделать.

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

public interface DummyInterface
{
    string A { get; }
    string B { get; }
}

public class DummySource
{
    public string A { get; set; }
    public string C { get; set; }
    public string D { get; set; }
}

public class Test
{
    public void WillThisWork()
    {
        var source = new DummySource[0];
        var values = from value in source
                     select new
                     {
                         A = value.A,
                         B = value.C + "_" + value.D
                     };

        DoSomethingWithDummyInterface(values);

    }

    public void DoSomethingWithDummyInterface(IEnumerable<DummyInterface> values)
    {
        foreach (var value in values)
        {
            Console.WriteLine("A = '{0}', B = '{1}'", value.A, value.B);
        }
    }
}

Я нашел статью Динамическая упаковка интерфейса, которая описывает один подход. Это лучший способ сделать это?

ОТВЕТЫ

Ответ 1

Нет, анонимные типы не могут реализовать интерфейс. Из руководства С#:

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

Ответ 2

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

Еще в 2008 году я писал пользовательского провайдера LINQ для моего работодателя, и в какой-то момент мне нужно было сказать "мои" анонимные классы из других анонимных, что означало, что они реализуют интерфейс, который я мог бы использовать чтобы напечатать их. Способ, которым мы это решали, заключался в использовании аспектов (мы использовали PostSharp), чтобы добавить реализацию интерфейса непосредственно в IL. Таким образом, на самом деле предоставление анонимным классам реализации интерфейсов выполнимо, вам просто нужно немного свернуть правила, чтобы добраться туда.

Ответ 3

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

Лучшее решение вокруг него - это некоторый тип динамического прокси, который создает реализацию для вас. Используя отличный проект LinFu, вы можете заменить

select new
{
  A = value.A,
  B = value.C + "_" + value.D
};

с

 select new DynamicObject(new
 {
   A = value.A,
   B = value.C + "_" + value.D
 }).CreateDuck<DummyInterface>();

Ответ 4

Анонимные типы могут реализовывать интерфейсы через динамический прокси.

Я написал метод расширения GitHub и сообщение в блоге http://wblo.gs/feE для поддержки этого сценарий.

Метод можно использовать следующим образом:

class Program
{
    static void Main(string[] args)
    {
        var developer = new { Name = "Jason Bowers" };

        PrintDeveloperName(developer.DuckCast<IDeveloper>());

        Console.ReadKey();
    }

    private static void PrintDeveloperName(IDeveloper developer)
    {
        Console.WriteLine(developer.Name);
    }
}

public interface IDeveloper
{
    string Name { get; }
}

Ответ 5

Нет; анонимный тип не может сделать ничего, кроме нескольких свойств. Вам нужно будет создать свой собственный тип. Я не читал связанную статью в глубину, но похоже, что она использует Reflection.Emit для создания новых типов "на лету"; но если вы ограничиваете обсуждение вещами внутри самого С#, вы не можете делать то, что хотите.

Ответ 6

Лучшее решение - это не использовать анонимные классы.

public class Test
{
    class DummyInterfaceImplementor : IDummyInterface
    {
        public string A { get; set; }
        public string B { get; set; }
    }

    public void WillThisWork()
    {
        var source = new DummySource[0];
        var values = from value in source
                     select new DummyInterfaceImplementor()
                     {
                         A = value.A,
                         B = value.C + "_" + value.D
                     };

        DoSomethingWithDummyInterface(values.Cast<IDummyInterface>());

    }

    public void DoSomethingWithDummyInterface(IEnumerable<IDummyInterface> values)
    {
        foreach (var value in values)
        {
            Console.WriteLine("A = '{0}', B = '{1}'", value.A, value.B);
        }
    }
}

Обратите внимание, что вам нужно передать результат запроса в тип интерфейса. Возможно, лучший способ это сделать, но я не смог найти его.

Ответ 7

Ответ на заданный вопрос - нет. Но вы смотрели на насмешливые рамки? Я использую MOQ, но там их миллионы, и они позволяют вам реализовать/заглушить (частично или полностью) интерфейсы в режиме онлайн. Например.

public void ThisWillWork()
{
    var source = new DummySource[0];
    var mock = new Mock<DummyInterface>();

    mock.SetupProperty(m => m.A, source.Select(s => s.A));
    mock.SetupProperty(m => m.B, source.Select(s => s.C + "_" + s.D));

    DoSomethingWithDummyInterface(mock.Object);
}

Ответ 8

Другой вариант - создать один конкретный реализующий класс, который принимает лямбда-выражения в конструкторе.

public interface DummyInterface
{
    string A { get; }
    string B { get; }
}

// "Generic" implementing class
public class Dummy : DummyInterface
{
    private readonly Func<string> _getA;
    private readonly Func<string> _getB;

    public Dummy(Func<string> getA, Func<string> getB)
    {
        _getA = getA;
        _getB = getB;
    }

    public string A => _getA();

    public string B => _getB();
}

public class DummySource
{
    public string A { get; set; }
    public string C { get; set; }
    public string D { get; set; }
}

public class Test
{
    public void WillThisWork()
    {
        var source = new DummySource[0];
        var values = from value in source
                     select new Dummy // Syntax changes slightly
                     (
                         getA: () => value.A,
                         getB: () => value.C + "_" + value.D
                     );

        DoSomethingWithDummyInterface(values);

    }

    public void DoSomethingWithDummyInterface(IEnumerable<DummyInterface> values)
    {
        foreach (var value in values)
        {
            Console.WriteLine("A = '{0}', B = '{1}'", value.A, value.B);
        }
    }
}

Если все, что вы когда-либо собираетесь сделать, это преобразовать DummySource в DummyInterface, то было бы проще иметь только один класс, который принимает DummySource в конструкторе и реализует интерфейс.

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

Ответ 9

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