Làm thế nào để bạn ngăn IDis Dùng lan rộng đến tất cả các lớp của bạn?

Bắt đầu với những lớp đơn giản này ...

Hãy nói rằng tôi có một tập hợp các lớp đơn giản như thế này:

class Bus
{
    Driver busDriver = new Driver();
}

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

class Shoe
{
    Shoelace lace = new Shoelace();
}

class Shoelace
{
    bool tied = false;
}

A Buscó a Driver, Drivercó hai Shoes, mỗi Shoecó a Shoelace. Tất cả đều rất ngớ ngẩn.

Thêm một đối tượng IDis Dùng cho Shoelace

Sau đó tôi quyết định rằng một số thao tác trên Shoelacecó thể là đa luồng, vì vậy tôi thêm một EventWaitHandlecho các luồng để giao tiếp. Vì vậy, Shoelacebây giờ trông như thế này:

class Shoelace
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    // ... other stuff ..
}

Triển khai IDis Dùng trên Dây giày

Nhưng bây giờ FxCop của Microsoft sẽ phàn nàn: "Triển khai IDis Dùng trên 'Dây giày' vì nó tạo ra các thành viên của các loại IDis Dùng sau: 'EventWaitHandle'."

Được rồi, tôi thực hiện IDisposabletrên Shoelacevà lớp nhỏ gọn của tôi trở nên lộn xộn khủng khiếp này:

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    private bool disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~Shoelace()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                if (waitHandle != null)
                {
                    waitHandle.Close();
                    waitHandle = null;
                }
            }
            // No unmanaged resources to release otherwise they'd go here.
        }
        disposed = true;
    }
}

Hoặc (như được chỉ ra bởi các nhà bình luận) vì Shoelacebản thân nó không có tài nguyên không được quản lý, tôi có thể sử dụng triển khai xử lý đơn giản hơn mà không cần Dispose(bool)và Destructor:

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;

    public void Dispose()
    {
        if (waitHandle != null)
        {
            waitHandle.Close();
            waitHandle = null;
        }
        GC.SuppressFinalize(this);
    }
}

Xem trong kinh dị khi lây lan IDis Dùng

Đúng là đã sửa. Nhưng bây giờ FxCop sẽ phàn nàn rằng Shoetạo ra một Shoelace, vì vậy Shoecũng phải như IDisposablevậy.

Và Drivertạo ra Shoenhư vậy Driverphải được IDisposable. Và Bustạo ra Drivernhư vậy Busphải được IDisposablevà như vậy.

Đột nhiên, sự thay đổi nhỏ của tôi Shoelacegây ra cho tôi rất nhiều công việc và ông chủ của tôi đang tự hỏi tại sao tôi cần phải kiểm tra Busđể thực hiện một thay đổi Shoelace.

Câu hỏi

Làm thế nào để bạn ngăn chặn sự lây lan này IDisposable, nhưng vẫn đảm bảo rằng các đối tượng không được quản lý của bạn được xử lý đúng cách?

Bạn thực sự không thể "ngăn chặn" IDis Dùng lan rộng. Một số lớp cần phải được xử lý, như AutoResetEvent, và cách hiệu quả nhất là thực hiện nó trong Dispose()phương thức để tránh chi phí chung của người hoàn thiện. Nhưng phương thức này phải được gọi bằng cách nào đó, vì vậy, chính xác như trong ví dụ của bạn, các lớp đóng gói hoặc chứa IDis Dùng phải loại bỏ chúng, vì vậy chúng cũng phải dùng một lần, v.v. Cách duy nhất để tránh nó là:

• tránh sử dụng các lớp IDis Dùng một lần nếu có thể, khóa hoặc chờ các sự kiện ở những nơi duy nhất, giữ các tài nguyên đắt tiền ở một nơi, v.v.
• chỉ tạo chúng khi bạn cần và loại bỏ chúng ngay sau đó ( usingmẫu)

Trong một số trường hợp, IDis Dùng có thể được bỏ qua vì nó hỗ trợ một trường hợp tùy chọn. Ví dụ: WaitHandle triển khai IDis Dùng để hỗ trợ Mutex có tên. Nếu tên không được sử dụng, phương thức Vứt bỏ không làm gì cả. MemoryStream là một ví dụ khác, nó không sử dụng tài nguyên hệ thống và việc triển khai Vứt bỏ của nó cũng không làm gì cả. Suy nghĩ cẩn thận về việc một tài nguyên không được quản lý đang được sử dụng hay không có thể được hướng dẫn. Vì vậy, có thể kiểm tra các nguồn có sẵn cho các thư viện .net hoặc sử dụng trình dịch ngược.

Về tính chính xác, bạn không thể ngăn chặn sự lây lan của IDis Dùng thông qua mối quan hệ đối tượng nếu một đối tượng cha mẹ tạo và về cơ bản sở hữu một đối tượng con mà bây giờ phải dùng một lần. FxCop là chính xác trong tình huống này và cha mẹ phải là IDis Dùng.

Những gì bạn có thể làm là tránh thêm IDis Dùng một lớp lá trong hệ thống phân cấp đối tượng của bạn. Đây không phải lúc nào cũng là một nhiệm vụ dễ dàng nhưng nó là một bài tập thú vị. Từ góc độ logic, không có lý do gì mà ShoeLace cần phải dùng một lần. Thay vì thêm WaitHandle ở đây, bạn cũng có thể thêm liên kết giữa ShoeLace và WaitHandle tại điểm được sử dụng. Cách đơn giản nhất là thông qua một ví dụ từ điển.

Nếu bạn có thể di chuyển WaitHandle thành một liên kết lỏng lẻo thông qua bản đồ tại điểm WaitHandle thực sự được sử dụng thì bạn có thể phá vỡ chuỗi này.

Để ngăn chặn sự IDisposablelây lan, bạn nên cố gắng gói gọn việc sử dụng một vật thể dùng một lần bên trong một phương thức duy nhất. Cố gắng thiết kế Shoelacekhác nhau:

class Shoelace { 
  bool tied = false; 

  public void Tie() {

    using (var waitHandle = new AutoResetEvent(false)) {

      // you can even pass the disposable to other methods
      OtherMethod(waitHandle);

      // or hold it in a field (but FxCop will complain that your class is not disposable),
      // as long as you take control of its lifecycle
      _waitHandle = waitHandle;
      OtherMethodThatUsesTheWaitHandleFromTheField();

    } 

  }
} 

Phạm vi của xử lý chờ được giới hạn trong Tiephương thức và lớp không cần phải có trường dùng một lần và vì vậy sẽ không cần phải dùng một lần.

Vì tay cầm chờ là một chi tiết triển khai bên trong Shoelace, nên nó không thay đổi theo bất kỳ cách nào giao diện công khai của nó, như thêm một giao diện mới trong khai báo. Điều gì sẽ xảy ra sau đó khi bạn không cần một trường dùng một lần nữa, bạn sẽ xóa phần IDisposablekhai báo chứ? Nếu bạn nghĩ về sự Shoelace trừu tượng , bạn sẽ nhanh chóng nhận ra rằng nó không nên bị ô nhiễm bởi các phụ thuộc cơ sở hạ tầng, như thế nào IDisposable. IDisposablenên được dành riêng cho các lớp có sự trừu tượng hóa đóng gói một tài nguyên yêu cầu dọn dẹp xác định; tức là, đối với các lớp trong đó tính định đoạt là một phần của sự trừu tượng hóa .

Về cơ bản, điều này xảy ra khi bạn trộn Thành phần hoặc Tập hợp với các lớp dùng một lần. Như đã đề cập, lối thoát đầu tiên sẽ là tái cấu trúc bộ phận chờ ra khỏi dây giày.

Có nói rằng, bạn có thể loại bỏ mô hình Dùng một lần đáng kể khi bạn không có tài nguyên không được quản lý. (Tôi vẫn đang tìm kiếm một tài liệu tham khảo chính thức cho việc này.)

Nhưng bạn có thể bỏ qua hàm hủy và GC.SuppressFinalize (cái này); và có thể dọn sạch khoảng trống ảo Vứt bỏ (bool dispose) một chút.

Thật thú vị nếu Driverđược định nghĩa như trên:

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

Sau đó, khi Shoeđược thực hiện IDisposable, FxCop (v1.36) không phàn nàn rằng Drivercũng nên IDisposable.

Tuy nhiên nếu nó được định nghĩa như thế này:

class Driver
{
    Shoe leftShoe = new Shoe();
    Shoe rightShoe = new Shoe();
}

sau đó nó sẽ phàn nàn.

Tôi nghi ngờ rằng đây chỉ là một hạn chế của FxCop, chứ không phải là một giải pháp, bởi vì trong phiên bản đầu tiên, các phiên bản Shoevẫn đang được tạo bởi Drivervà vẫn cần phải được xử lý bằng cách nào đó.

Tôi không nghĩ rằng có một cách kỹ thuật để ngăn chặn IDis Dùng lan rộng nếu bạn giữ thiết kế của mình thật chặt. Sau đó, người ta nên tự hỏi nếu thiết kế là đúng.

Trong ví dụ của bạn, tôi nghĩ thật hợp lý khi để giày sở hữu dây giày, và có lẽ, người lái xe nên sở hữu đôi giày của mình. Tuy nhiên, xe buýt không nên sở hữu tài xế. Thông thường, tài xế xe buýt không theo xe buýt đến bãi phế liệu :) Trong trường hợp tài xế và giày, tài xế hiếm khi tự làm giày, nghĩa là họ không thực sự "sở hữu" chúng.

Một thiết kế thay thế có thể là:

class Bus
{
   IDriver busDriver = null;
   public void SetDriver(IDriver d) { busDriver = d; }
}

class Driver : IDriver
{
   IShoePair shoes = null;
   public void PutShoesOn(IShoePair p) { shoes = p; }
}

class ShoePairWithDisposableLaces : IShoePair, IDisposable
{
   Shoelace lace = new Shoelace();
}

class Shoelace : IDisposable
{
   ...
}

Thật không may, thiết kế mới phức tạp hơn, vì nó yêu cầu các lớp học thêm để khởi tạo và xử lý các trường hợp cụ thể của giày và trình điều khiển, nhưng sự phức tạp này là cố hữu đối với vấn đề đang được giải quyết. Điều tốt là xe buýt không cần phải dùng một lần chỉ đơn giản cho mục đích xử lý dây giày.

Làm thế nào về việc sử dụng Inversion of Control?

class Bus
{
    private Driver busDriver;

    public Bus(Driver busDriver)
    {
        this.busDriver = busDriver;
    }
}

class Driver
{
    private Shoe[] shoes;

    public Driver(Shoe[] shoes)
    {
        this.shoes = shoes;
    }
}

class Shoe
{
    private Shoelace lace;

    public Shoe(Shoelace lace)
    {
        this.lace = lace;
    }
}

class Shoelace
{
    bool tied;
    private AutoResetEvent waitHandle;

    public Shoelace(bool tied, AutoResetEvent waitHandle)
    {
        this.tied = tied;
        this.waitHandle = waitHandle;
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (var leftShoeWaitHandle = new AutoResetEvent(false))
        using (var rightShoeWaitHandle = new AutoResetEvent(false))
        {
            var bus = new Bus(new Driver(new[] {new Shoe(new Shoelace(false, leftShoeWaitHandle)),new Shoe(new Shoelace(false, rightShoeWaitHandle))}));
        }
    }
}