Чи може анонімний клас реалізувати інтерфейс?

Чи можливо мати анонімний тип реалізації інтерфейсу?

У мене є фрагмент коду, над яким я хотів би працювати, але не знаю, як це зробити.

У мене було кілька відповідей, які або кажуть «ні», або створюють клас, який реалізує інтерфейсну конструкцію нових примірників цього. Це насправді не ідеально, але мені цікаво, чи існує механізм створення тонкого динамічного класу поверх інтерфейсу, який би спростив це.

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);
        }
    }
}

Я знайшов статтю Динамічне обгортання інтерфейсу, яка описує один підхід. Це найкращий спосіб зробити це?

Ні, анонімні типи не можуть реалізувати інтерфейс. З посібника з програмування C # :

Анонімні типи - це типи класів, які складаються з одного або кількох загальнодоступних властивостей лише для читання Не допускаються інші види членів класу, такі як методи або події. Анонімний тип не може бути переданий до будь-якого інтерфейсу чи типу, крім об'єкта.

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

Ще в 2008 році я писав спеціальний постачальник LINQ для свого тодішнього роботодавця, і в один момент мені потрібно було вміти розповідати про "мої" анонімні класи від інших анонімних, що означало, щоб вони реалізували інтерфейс, який я міг би використовувати для перевірки їх. Ми вирішили це шляхом використання аспектів (ми використовували PostSharp ), щоб додати реалізацію інтерфейсу безпосередньо в ІЛ. Тож насправді дозволяти анонімним класам реалізовувати інтерфейси доцільно , вам просто потрібно трохи зігнути правила, щоб потрапити туди.

Віддавання анонімних типів до інтерфейсів - це те, що я хотів на деякий час, але, на жаль, поточна реалізація змушує вас реалізувати цей інтерфейс.

Найкраще рішення навколо нього - мати якийсь тип динамічного проксі, який створює реалізацію для вас. Використовуючи відмінний проект 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>();

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

Я написав метод розширення на 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; }
}

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

Найкраще рішення - просто не використовувати анонімні класи.

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);
        }
    }
}

Зауважте, що результат запиту потрібно привести до типу інтерфейсу. Можливо, є кращий спосіб зробити це, але я не зміг його знайти.

Відповідь на спеціально задане питання - ні. Але ви дивилися на глузуючі рамки? Я використовую 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);
}

Інший варіант - створити єдиний, конкретний клас реалізації, який займає лямбда в конструкторі.

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, це набагато менше плит котла.