Kann eine anonyme Klasse eine Schnittstelle implementieren?

Ist es möglich, dass ein anonymer Typ eine Schnittstelle implementiert?

Ich habe einen Code, mit dem ich gerne arbeiten würde, weiß aber nicht, wie ich das machen soll.

Ich habe einige Antworten erhalten, die entweder Nein sagen oder eine Klasse erstellen, die die Schnittstelle implementiert, um neue Instanzen davon zu erstellen. Das ist nicht wirklich ideal, aber ich frage mich, ob es einen Mechanismus gibt, um eine dünne dynamische Klasse über einer Schnittstelle zu erstellen, der dies einfach machen würde.

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

Ich habe einen Artikel Dynamic Interface Wrapping gefunden , der einen Ansatz beschreibt. Ist das der beste Weg, dies zu tun?

Nein, anonyme Typen können keine Schnittstelle implementieren. Aus der C # -Programmieranleitung :

Anonyme Typen sind Klassentypen, die aus einer oder mehreren öffentlichen schreibgeschützten Eigenschaften bestehen. Andere Arten von Klassenmitgliedern wie Methoden oder Ereignisse sind nicht zulässig. Ein anonymer Typ kann nur für Objekte in eine Schnittstelle oder einen Typ umgewandelt werden.

Obwohl dies eine zwei Jahre alte Frage sein könnte und die Antworten im Thread alle wahr genug sind, kann ich dem Drang nicht widerstehen, Ihnen zu sagen, dass es tatsächlich möglich ist , dass eine anonyme Klasse eine Schnittstelle implementiert, obwohl es eine benötigt ein bisschen kreatives Betrügen, um dorthin zu gelangen.

Im Jahr 2008 schrieb ich einen benutzerdefinierten LINQ-Anbieter für meinen damaligen Arbeitgeber, und irgendwann musste ich in der Lage sein, "meine" anonymen Klassen von anderen anonymen zu unterscheiden, was bedeutete, dass sie eine Schnittstelle implementierten, über die ich die Prüfung überprüfen konnte Sie. Wir haben es gelöst, indem wir Aspekte verwendet haben (wir haben PostSharp verwendet ), um die Schnittstellenimplementierung direkt in der IL hinzuzufügen. In der Tat ist es machbar , anonyme Klassen Schnittstellen implementieren zu lassen . Sie müssen nur die Regeln leicht biegen, um dorthin zu gelangen.

Ich wollte schon seit einiger Zeit anonyme Typen in Schnittstellen umwandeln, aber leider zwingt Sie die aktuelle Implementierung dazu, diese Schnittstelle zu implementieren.

Die beste Lösung besteht darin, einen dynamischen Proxy zu haben, der die Implementierung für Sie erstellt. Mit dem hervorragenden LinFu-Projekt können Sie ersetzen

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

mit

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

Anonyme Typen können Schnittstellen über einen dynamischen Proxy implementieren.

Ich habe eine Erweiterungsmethode auf GitHub und einen Blog-Beitrag http://wblo.gs/feE geschrieben , um dieses Szenario zu unterstützen.

Die Methode kann folgendermaßen verwendet werden:

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

Nein; Ein anonymer Typ kann nur dazu gebracht werden, einige Eigenschaften zu haben. Sie müssen Ihren eigenen Typ erstellen. Ich habe den verlinkten Artikel nicht ausführlich gelesen, aber es sieht so aus, als würde er Reflection.Emit verwenden, um neue Typen im laufenden Betrieb zu erstellen. Wenn Sie die Diskussion jedoch auf Dinge in C # selbst beschränken , können Sie nicht tun, was Sie wollen.

Die beste Lösung ist einfach, keine anonymen Klassen zu verwenden.

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

Beachten Sie, dass Sie das Ergebnis der Abfrage in den Typ der Schnittstelle umwandeln müssen. Es könnte einen besseren Weg geben, aber ich konnte ihn nicht finden.

Die Antwort auf die speziell gestellte Frage lautet nein. Aber haben Sie sich über spöttische Frameworks Gedanken gemacht? Ich verwende MOQ, aber es gibt Millionen von ihnen, mit denen Sie Schnittstellen (teilweise oder vollständig) inline implementieren / stubben können. Z.B.

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

Eine andere Möglichkeit besteht darin, eine einzelne konkrete Implementierungsklasse zu erstellen, die Lambdas im Konstruktor akzeptiert.

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

Wenn alles , was Sie jemals tun werden convert ist DummySourcezu DummyInterface, dann wäre es einfacher sein, nur eine Klasse, die eine nimmt DummySourceim Konstruktor und implementiert die Schnittstelle.

Wenn Sie jedoch viele Typen umrüsten müssen DummyInterface, ist dies viel weniger Kesselplatte.