hiển thị loại tham chiếu (lớp) mà không cần tham chiếu bổ sung

Question

Tôi có hệ thống lớp .dll giữa ứng dụng của tôi, nơi cấp thấp nhất có một lớp cung cấp chức năng nhất định - một thể hiện của lớp này có thể nhận được thông qua GetClass() chức năng và sau đó tôi có thể truy cập các thuộc tính của nó (về cơ bản, một tập hợp các thông tin của các đối tượng thay đổi).

Bây giờ tôi nhận thấy rằng khi tôi muốn truy cập thông tin đó từ cấp cao hơn tiếp theo .dll, trình biên dịch phàn nàn rằng tôi không có trình độ thấp hơn .dll được tham chiếu (lớp xác định lớp) - mà thực sự tôi muốn để tránh, để có một cấu trúc lớp đẹp trong kiến ​​trúc của tôi.

Làm cách nào để giải quyết vấn đề này? Tôi có thể hiển thị lại loại được tham chiếu không? Tôi có thực sự phải viết một wrapper của riêng tôi, nếu tôi muốn chính xác cùng một chức năng? Hoặc tôi thậm chí cần phải tham khảo các cấp độ thấp .dll một lần nữa?

(Nếu giúp:

dll1: class myClass, myClass GetMyClass() 
dll2: myClass GetMyClass() 
exe: how to access result from calling GetMyClass (dll2) without referencing dll1? 

)

Answer 1

Dường như không có cách nào để đạt được điều này, nếu myClass được xác định trong dll1, vì các đối tượng thuộc loại myClass có thể được khởi tạo khi chạy. Để tránh điều này, bạn cần phải thay đổi loại trả lại là GetMyClass() trong dll2 để trả về một số thứ được xác định trong dll2. Nó có thể là một lớp khá giống với myClass và có các thuộc tính giống nhau (thậm chí bạn có thể sử dụng các công cụ như AutoMapper để dễ dàng chuyển đổi giữa các đối tượng), nhưng nó chắc chắn phải ở trong dll2. Một cái gì đó như:

// dll1 
class myClass 
{ 
    ... 
} 

myClass GetMyClass() 
{ 
    ... 
} 

// dll2 
class myClass2 
{ 
    public myClass2(myClass c) 
    { 
     // instantiate myClass2 with values from myClass 
    } 
} 

myClass2 GetMyClass() 
{ 
    // somehow get myClass and convert it to myClass2 here 
} 

Answer 2

Người gọi phải có một tham chiếu đến lớp trong DLL1 biết những gì loại nó được truy cập. Vì vậy, có bạn cần phải tham khảo dll đầu tiên trong exe. Kể từ khi GetMyClass() trả về một loại trong DLL1 loại cần phải được tiếp xúc trong exe, do đó dll1 phải được tham chiếu.

Answer 3

Một giải pháp ở đây là cung cấp DLL thứ 4 chứa giao diện cho lớp học của bạn. Bạn sẽ tham chiếu điều này trong tất cả 3 lớp của bạn và trả về các giao diện này thay vì các lớp của bạn.

này sẽ cung cấp cho bạn một ý tưởng tốt về những gì tôi muốn nói:

// DLL1 
class ClassInDLL1 : IClassInDLL1 
{ 
} 

// DLL2 
class ClassInDLL2 
{ 
    public IClassInDLL1 GetClassInDLL1() 
    { 
     return new ClassInDLL1(); 
    } 
} 

// DLL3 
class ClassInDLL3 
{ 
    public void DoSomething() 
    { 
     var dll2 = new ClassInDLL2(); 
     var dll1 = dll2.GetClassInDLL1(); // dll1 variable is of type IClassInDLL1 

     // do stuff with dll1 
    } 
} 

// interface DLL 
interface IClassInDLL1 
{ 
} 

Sẽ trung thực dù, layering kiến ​​trúc của bạn như thế này thường không phải là một ý tưởng tuyệt vời nếu dự án của bạn là thực sự lớn. Tôi thấy rằng việc lắp ráp nhân tạo tách ra như thế này trước thời hạn có thể khiến bạn đau đớn không cần thiết, chưa kể đến thực tế là bạn kết thúc với 3-4 hội đồng cho một dự án vừa hoặc nhỏ chỉ có thể cần 1.

Answer 4

Bạn cần để tách tất cả các lớp phổ biến mà bạn sử dụng trên tất cả các lớp của bạn thành một dll mới, sau đó tham khảo dll này trên mọi dự án.

Hãy thử sử dụng interfaces để bạn có thể làm việc trên hợp đồng (chức năng) thay vì triển khai cụ thể. Nó sẽ giúp bạn tránh các tham chiếu không cần thiết.

// common dll 
public interface IMyClass 
{ 
    string MyData { get; set; } 
    IMyClass GetMyClass(); 
} 

// dll1 
public class myClass : IMyClass 
{ 
    public string MyData { get; set; } 
    public IMyClass GetMyClass() { return new myClass() { MyData = "abc" }; } 
} 

// dll2 
public class myClass2 
{ 
    public IMyClass GetMyClass() 
    { 
     var c1 = new myClass(); 
     var c2 = c1.GetMyClass(); 
     return c2; 
    } 
} 

// exe (references common and dll2) 
public class Program 
{ 
    public static void Main(string[] args) 
    { 
     var c1 = new myClass2(); 
     IMyClass c2 = c1.GetMyClass(); 
     Console.Writeline(c2.MyData); 
    } 
} 

Answer 5

Tôi đi với Nick sử dụng bất kỳ khuôn khổ Ioc nào như spring.net hoặc microsoft unity. để có ý tưởng chính xác, hãy xem qua http://martinfowler.com/articles/injection.html

Answer 6

Chúng tôi làm điều tương tự như vậy trong mã cục bộ của chúng tôi.Bạn có thể nạp assembly vào thời gian chạy, quét các kiểu nó chứa sử dụng sự phản chiếu, và một lần nữa sử dụng các chức năng gọi phản chiếu và các kiểu khởi tạo từ dll đó, mà không bao giờ tham chiếu nó trực tiếp trong dự án.

một số chức năng quan trọng, bạn sẽ cần là:

Assembly.LoadFrom(path); //get the assembly as a local object 
Activator.CreateInstance(type); //create an instance of a type 
Assembly.GetType(string);//fetch a type by name from the assembly 

Khi bạn có các loại, phản ánh cơ bản sẽ cung cấp cho bạn khá nhiều mỗi mảnh khác mà bạn cần.

Dưới đây là đoạn mã từ mã địa phương của tôi:

asm = Assembly.LoadFrom(Path.Combine(Environment.CurrentDirectory, filePath)); 

Type[] types = asm.GetTypes(); 
for (var x = 0; x < types.Length; x++) 
{ 
    var interfaces = types[x].GetInterfaces(); 
    for (var y = 0; y < interfaces.Length; y++) 
    { 
     if (interfaces[y].Name.Equals("MyTypeName")) 
     { 
      isValidmod = true; 
      var p = (IMyType)Activator.CreateInstance(types[x]); 
          //Other stuff 
      } 
    } 

Cũng lưu ý: đây là mã khá cũ bây giờ. Nó đã không được xem xét và cũng không được tái cấu trúc trong nhiều năm, do đó, nó cơ bản hiện đại như của .NET 1.1, NHƯNG: Nó minh họa quan điểm. Cách tải loại từ một cụm từ xa không được tham chiếu cục bộ.

Ngoài ra, đây là một phần của động cơ tải 50 trong số này, được cung cấp cấu trúc thư mục cứng nhắc, đó là lý do tại sao nó trông rất chung chung. Lấy những gì bạn cần từ nó.