Anonim sınıf arayüz uygulayabilir mi?

Anonim tipte bir arabirim uygulamak mümkün müdür?

Çalışmak istediğim bir kod parçam var, ama bunu nasıl yapacağımı bilmiyorum.

Hayır diyen ya da arayüzün yeni örneklerini inşa eden bir sınıf yaratan birkaç cevap aldım. Bu gerçekten ideal değil, ama bunu basitleştirecek bir arayüzün üstünde ince bir dinamik sınıf oluşturmak için bir mekanizma olup olmadığını merak ediyorum.

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

Bir yaklaşım açıklayan bir dinamik arayüz kaydırma makalesi buldum . Bunu yapmanın en iyi yolu bu mu?

Hayır, anonim türler bir arabirim uygulayamaz. Gönderen C # programlama rehberi :

Anonim türler, bir veya daha fazla genel salt okunur özellikten oluşan sınıf türleridir. Yöntemler veya olaylar gibi başka sınıf üyelerine izin verilmez. Anonim bir tür, nesne dışındaki herhangi bir arabirime veya türe kullanılamaz.

Bu iki yıllık bir soru olabilir ve iş parçacığındaki cevapların hepsi yeterince doğru olsa da, anonim bir sınıfın bir arabirim uygulamasının aslında bir arabirim uygulamasının mümkün olduğunu söyleme isteğine karşı koyamam biraz yaratıcı hile oraya.

2008'de o zamanlar işverenim için özel bir LINQ sağlayıcısı yazıyordum ve bir noktada anonim sınıflarıma diğer anonim sınıflardan anlatabiliyordum, bu da çek yazmak için kullanabileceğim bir arabirim kullanmaları anlamına geliyordu onlar. Çözdüğümüz yol , arayüz uygulamasını doğrudan IL'ye eklemek için yönleri ( PostSharp kullandık ) kullanmaktı . Aslında, anonim sınıfların arayüzleri uygulamasına izin vermek yapılabilir , sadece oraya ulaşmak için kuralları hafifçe bükmeniz gerekir.

Arayüzlere anonim türler dökmek bir süredir istediğim bir şeydi, ancak maalesef mevcut uygulama sizi bu arayüzün bir uygulamasını yapmaya zorluyor.

Etrafındaki en iyi çözüm, sizin için uygulamayı oluşturan bir tür dinamik proxy'ye sahip olmaktır. Mükemmel kullanma Linfu projesini sen yerini alabilir

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

ile

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

Anonim türler arabirimleri dinamik bir proxy üzerinden uygulayabilir.

Bu senaryoyu desteklemek için GitHub'da bir uzantı yöntemi ve http://wblo.gs/feE bir blog yazısı yazdım .

Yöntem şu şekilde kullanılabilir:

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

Hayır; anonim tip, birkaç özelliğe sahip olmak dışında hiçbir şey yapılamaz. Kendi türünüzü oluşturmanız gerekir. Bağlantılı makaleyi derinlemesine okumadım, ancak Reflection kullanıyor gibi görünüyor. Anında yeni türler oluşturmak için kaydolun; ancak tartışmayı C # içindeki şeylerle sınırlarsanız, istediğinizi yapamazsınız.

En iyi çözüm, anonim sınıflar kullanmak değildir.

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

Sorgunun sonucunu arabirimin türüne yayınlamanız gerektiğini unutmayın. Bunu yapmanın daha iyi bir yolu olabilir, ama bulamadım.

Özellikle sorulan sorunun cevabı hayırdır. Ama alaycı çerçevelere mi bakıyorsunuz? Ben ADEDI kullanın ama milyonlarca orada var ve onlar / satır (kısmen veya tamamen) in-line uygulamak için izin verir. Örneğin.

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

Başka bir seçenek, kurucuya lambdas alan tek, somut bir uygulama sınıfı oluşturmaktır.

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

Hiç yapacağız tüm convert ise DummySourcehiç DummyInterface, o zaman sadece alır bir sınıf var etmek kolay olurdu DummySourceyapıcı ve uygular arayüz içinde.

Ancak, birçok türü dönüştürmeniz gerekiyorsa DummyInterface, bu çok daha az kazan plakasıdır.