Lớp ẩn danh có thể thực hiện giao diện?

Có thể có một loại ẩn danh thực hiện một giao diện?

Tôi đã có một đoạn mã mà tôi muốn làm việc, nhưng không biết làm thế nào để làm điều này.

Tôi đã có một vài câu trả lời là không hoặc tạo một lớp thực hiện giao diện xây dựng các thể hiện mới của điều đó. Điều này không thực sự lý tưởng, nhưng tôi tự hỏi liệu có một cơ chế để tạo ra một lớp động mỏng trên đầu một giao diện sẽ làm cho điều này trở nên đơn giản.

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

Tôi đã tìm thấy một bài viết Gói giao diện động mô tả một cách tiếp cận. Đây có phải là cách tốt nhất để làm điều này?

Không, các loại ẩn danh không thể thực hiện một giao diện. Từ hướng dẫn lập trình C # :

Các loại ẩn danh là các loại lớp bao gồm một hoặc nhiều thuộc tính chỉ đọc công khai. Không có loại thành viên khác như phương thức hoặc sự kiện được cho phép. Một loại ẩn danh không thể được truyền tới bất kỳ giao diện hoặc loại nào ngoại trừ đối tượng.

Mặc dù đây có thể là một câu hỏi hai năm tuổi và trong khi các câu trả lời trong luồng hoàn toàn đúng, tôi không thể cưỡng lại sự thôi thúc nói với bạn rằng trên thực tế có thể có một lớp ẩn danh thực hiện một giao diện, mặc dù phải mất một một chút gian lận sáng tạo để đạt được điều đó.

Quay trở lại năm 2008, tôi đã viết một nhà cung cấp LINQ tùy chỉnh cho chủ lao động lúc đó của mình và đến một lúc tôi cần có thể nói "các" lớp ẩn danh của mình từ các lớp ẩn danh khác, có nghĩa là họ thực hiện giao diện mà tôi có thể sử dụng để gõ kiểm tra họ Cách chúng tôi giải quyết là bằng cách sử dụng các khía cạnh (chúng tôi đã sử dụng PostSharp ), để thêm việc triển khai giao diện trực tiếp trong IL. Vì vậy, trên thực tế, để các lớp ẩn danh thực hiện các giao diện là có thể thực hiện được , bạn chỉ cần uốn cong các quy tắc một chút để đạt được điều đó.

Truyền các loại ẩn danh cho các giao diện là điều tôi muốn trong một thời gian nhưng thật không may, việc triển khai hiện tại buộc bạn phải thực hiện giao diện đó.

Giải pháp tốt nhất xung quanh nó là có một số loại proxy động tạo ra việc triển khai cho bạn. Sử dụng dự án LinFu tuyệt vời, bạn có thể thay thế

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

với

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

Các loại ẩn danh có thể thực hiện các giao diện thông qua một proxy động.

Tôi đã viết một phương thức mở rộng trên GitHub và một bài đăng trên blog http://wblo.gs/feE để hỗ trợ cho kịch bản này.

Phương pháp có thể được sử dụng như thế này:

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

Không; một loại ẩn danh không thể được thực hiện để làm bất cứ điều gì ngoại trừ có một vài thuộc tính. Bạn sẽ cần phải tạo loại của riêng bạn. Tôi đã không đọc bài viết được liên kết sâu, nhưng có vẻ như nó sử dụng Reflection.Emit để tạo các loại mới một cách nhanh chóng; nhưng nếu bạn giới hạn thảo luận về những điều trong chính C #, bạn không thể làm những gì bạn muốn.

Giải pháp tốt nhất là không sử dụng các lớp ẩn danh.

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

Lưu ý rằng bạn cần chuyển kết quả của truy vấn sang loại giao diện. Có thể có một cách tốt hơn để làm điều đó, nhưng tôi không thể tìm thấy nó.

Câu trả lời cho câu hỏi cụ thể là không. Nhưng bạn đã nhìn vào khuôn khổ chế giễu? Tôi sử dụng Moq nhưng có hàng triệu người trong số họ ở ngoài đó và họ cho phép bạn triển khai / sơ khai (một phần hoặc toàn bộ) giao diện trực tuyến. Ví dụ.

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

Một tùy chọn khác là tạo một lớp triển khai cụ thể, duy nhất có lambdas trong hàm tạo.

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

Nếu tất cả những gì bạn sẽ làm là chuyển đổi DummySourcethành DummyInterface, thì sẽ đơn giản hơn khi chỉ có một lớp lấy một DummySourcehàm tạo và thực hiện giao diện.

Nhưng, nếu bạn cần chuyển đổi nhiều loại sang DummyInterface, đây là tấm nồi hơi ít hơn nhiều.