Czy anonimowa klasa może zaimplementować interfejs?

Czy możliwe jest, aby anonimowy typ zaimplementował interfejs?

Mam kawałek kodu, który chciałbym pracować, ale nie wiem, jak to zrobić.

Mam kilka odpowiedzi, które albo mówią „nie”, albo tworzę klasę, która implementuje interfejs, konstruuje nowe instancje tego. To nie jest naprawdę idealne, ale zastanawiam się, czy istnieje mechanizm do tworzenia cienkiej dynamicznej klasy na interfejsie, który by tak uprościł.

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

Znalazłem artykuł Zawijanie interfejsu dynamicznego, który opisuje jedno podejście. Czy to najlepszy sposób na zrobienie tego?

Nie, typy anonimowe nie mogą implementować interfejsu. Z przewodnika po programowaniu w C # :

Anonimowe typy to typy klas, które składają się z jednej lub więcej publicznych właściwości tylko do odczytu. Żadne inne rodzaje członków klasy, takie jak metody lub zdarzenia, są niedozwolone. Anonimowego typu nie można rzutować na żaden interfejs lub typ z wyjątkiem obiektu.

Chociaż może to być pytanie dwuletnie i chociaż wszystkie odpowiedzi w wątku są wystarczająco prawdziwe, nie mogę się oprzeć pokusie, aby powiedzieć, że w rzeczywistości możliwe jest, aby anonimowa klasa zaimplementowała interfejs, nawet jeśli wymaga to trochę kreatywnego oszukiwania, aby się tam dostać.

W 2008 roku pisałem niestandardowego dostawcę LINQ dla mojego ówczesnego pracodawcy, i w pewnym momencie musiałem móc odróżnić „moje” anonimowe klasy od innych anonimowych, co oznaczało, że musieliby oni zaimplementować interfejs, którego mógłbym użyć do sprawdzania typu im. Sposób, w jaki to rozwiązaliśmy, polegał na użyciu aspektów (użyliśmy PostSharp ), aby dodać implementację interfejsu bezpośrednio w IL. W rzeczywistości pozwolenie anonimowym klasom na implementację interfejsów jest wykonalne , wystarczy lekko zgiąć reguły, aby się tam dostać.

Rzucanie anonimowych typów na interfejsy było czymś, czego chciałem od dłuższego czasu, ale niestety obecna implementacja zmusza cię do implementacji tego interfejsu.

Najlepszym rozwiązaniem jest posiadanie pewnego rodzaju dynamicznego serwera proxy, który tworzy dla Ciebie implementację. Korzystając z doskonałego projektu LinFu, możesz go wymienić

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

z

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

Anonimowe typy mogą implementować interfejsy za pośrednictwem dynamicznego serwera proxy.

Napisałem metodę rozszerzenia na GitHub i post na blogu http://wblo.gs/feE, aby wesprzeć ten scenariusz.

Metodę można zastosować w następujący sposób:

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

Nie; typu anonimowego nie można zmusić do robienia czegokolwiek poza kilkoma właściwościami. Musisz stworzyć własny typ. Nie przeczytałem dogłębnie tego artykułu, ale wygląda na to, że używa Reflection.Emit do tworzenia nowych typów w locie; ale jeśli ograniczysz dyskusję do rzeczy w samym C #, nie możesz robić tego, co chcesz.

Najlepszym rozwiązaniem jest po prostu nie używanie anonimowych klas.

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

Pamiętaj, że musisz rzutować wynik zapytania na typ interfejsu. Może być lepszy sposób, aby to zrobić, ale nie mogłem go znaleźć.

Odpowiedź na zadane pytanie brzmi „nie”. Ale czy patrzyłeś na szydzące frameworki? Używam MOQ, ale są tam miliony i pozwalają one na implementację / stub (częściowo lub całkowicie) interfejsów w linii. Na przykład.

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

Inną opcją jest utworzenie pojedynczej, konkretnej klasy implementacyjnej, która przyjmuje lambdas w konstruktorze.

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

Jeśli wszystko, co kiedykolwiek zamiar zrobić, to konwersja DummySourcedo DummyInterface, wtedy byłoby prościej po prostu jedną klasę, która trwa DummySourcew konstruktorze i implementuje interfejs.

Ale jeśli musisz przekonwertować wiele typów DummyInterface, jest to znacznie mniej płyty kotła.