คุณจะป้องกัน IDisposable จากการแพร่กระจายไปยังชั้นเรียนทั้งหมดของคุณได้อย่างไร

เริ่มด้วยคลาสที่เรียบง่ายเหล่านี้ ...

สมมติว่าฉันมีชุดเรียนที่เรียบง่ายเช่นนี้:

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

BusมีDriverที่DriverมีสองShoes แต่ละมีShoe Shoelaceทั้งหมดโง่มาก

เพิ่มวัตถุ IDisposable ใน Shoelace

ต่อมาฉันตัดสินใจว่าการดำเนินการบางอย่างเกี่ยวกับShoelaceอาจเป็นหลายเธรดดังนั้นฉันจึงเพิ่มEventWaitHandleสำหรับเธรดที่จะสื่อสารด้วย ดังนั้นShoelaceตอนนี้ดูเหมือนว่านี้:

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

ติดตั้ง IDisposable บนเชือกผูกรองเท้า

แต่ตอนนี้FxCop ของ Microsoftจะบ่นว่า: "Implement IDisposable ใน 'Shoelace' เพราะมันจะสร้างสมาชิกประเภท IDisposable ต่อไปนี้: 'EventWaitHandle'

โอเคฉันใช้IDisposableต่อไปShoelaceและชั้นเรียนเล็ก ๆ ที่เรียบร้อยของฉันจะกลายเป็นความยุ่งเหยิงที่น่ากลัว:

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

หรือ (ตามที่ผู้วิจารณ์ให้ความเห็น) เนื่องจากShoelaceตัวมันเองไม่มีทรัพยากรที่ไม่มีการจัดการฉันอาจใช้การจัดการที่ง่ายกว่าโดยไม่จำเป็นต้องใช้Dispose(bool)และ 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);
    }
}

ดูในหนังสยองขวัญในขณะที่ IDisposablek แพร่กระจาย

ใช่แล้วนั่นคือการแก้ไข แต่ตอนนี้ FxCop จะบ่นว่าShoeสร้าง a Shoelaceดังนั้นShoeต้องเป็นIDisposableเช่นกัน

และDriverสร้างShoeจึงต้องDriver IDisposableและBusสร้างDriverดังนั้นBusจะต้องเป็นIDisposableและอื่น ๆ

ทันใดนั้นการเปลี่ยนแปลงขนาดเล็กของฉันที่จะShoelaceเป็นสาเหตุของผมมากในการทำงานและเจ้านายของฉันจะสงสัยว่าทำไมฉันต้องเช็คเอาท์เพื่อให้การเปลี่ยนแปลงไปBusShoelace

คำถาม

คุณจะป้องกันการแพร่กระจายนี้ได้IDisposableอย่างไร แต่ยังมั่นใจได้ว่าวัตถุที่ไม่มีการจัดการของคุณถูกกำจัดอย่างเหมาะสม

คุณไม่สามารถ "ป้องกัน" IDisposable จากการแพร่กระจาย บางคลาสจำเป็นต้องกำจัดเช่นAutoResetEventและวิธีที่มีประสิทธิภาพมากที่สุดคือการทำในDispose()วิธีการเพื่อหลีกเลี่ยงค่าใช้จ่ายของ finalizers แต่วิธีการนี้จะต้องเรียกว่าอย่างใดดังนั้นในตัวอย่างของคุณคลาสที่แค็ปซูลหรือมี IDisposable ต้องกำจัดสิ่งเหล่านี้ดังนั้นพวกเขาจะต้องถูกทิ้งเช่นกัน ฯลฯ วิธีเดียวที่จะหลีกเลี่ยงคือ:

• หลีกเลี่ยงการใช้คลาส IDisposable หากเป็นไปได้ล็อคหรือรอเหตุการณ์ในที่เดียวเก็บทรัพยากรราคาแพงไว้ในที่เดียว ฯลฯ
• สร้างพวกเขาเฉพาะเมื่อคุณต้องการพวกเขาและทิ้งพวกเขาในภายหลัง ( usingรูปแบบ)

ในบางกรณี IDisposable สามารถละเว้นได้เพราะรองรับกรณีที่ไม่จำเป็น ตัวอย่างเช่น WaitHandle ใช้ IDisposable เพื่อสนับสนุน Mutex ที่มีชื่อ หากไม่ได้ใช้ชื่อวิธีการกำจัดจะไม่ทำอะไรเลย MemoryStream เป็นอีกตัวอย่างหนึ่งที่ไม่ใช้ทรัพยากรระบบและการใช้งานการกำจัดก็ไม่ทำอะไรเลย พิจารณาอย่างรอบคอบว่ามีการใช้ทรัพยากรที่ไม่มีการจัดการหรือไม่และสามารถให้คำแนะนำได้ ดังนั้นสามารถตรวจสอบแหล่งข้อมูลที่มีอยู่สำหรับไลบรารี. net หรือใช้ตัวถอดรหัส

ในแง่ของความถูกต้องคุณไม่สามารถป้องกันการแพร่กระจายของ IDisposable ผ่านความสัมพันธ์ของวัตถุถ้าวัตถุหลักสร้างและเป็นเจ้าของวัตถุลูกซึ่งจะต้องถูกทิ้ง FxCop ถูกต้องในสถานการณ์นี้และพาเรนต์ต้องเป็น IDisposable

สิ่งที่คุณสามารถทำได้คือหลีกเลี่ยงการเพิ่ม IDisposable ในคลาสใบไม้ในลำดับชั้นวัตถุของคุณ นี่ไม่ใช่เรื่องง่ายเสมอไป แต่เป็นการออกกำลังกายที่น่าสนใจ จากมุมมองเชิงตรรกะไม่มีเหตุผลที่ ShoeLace ต้องถูกทิ้ง แทนที่จะเพิ่ม WaitHandle ที่นี่เป็นไปได้หรือไม่ที่จะเพิ่มการเชื่อมโยงระหว่าง ShoeLace และ WaitHandle ณ จุดที่ใช้ วิธีที่ง่ายที่สุดคือผ่านอินสแตนซ์พจนานุกรม

หากคุณสามารถย้าย WaitHandle ไปสู่การเชื่อมโยงที่หลวมผ่านแผนที่ ณ จุดที่ WaitHandle ใช้งานจริงคุณสามารถแบ่งสายโซ่นี้ได้

เพื่อป้องกันIDisposableการแพร่กระจายคุณควรพยายามห่อหุ้มการใช้วัตถุที่ใช้แล้วทิ้งภายในวิธีการเดียว ลองออกแบบให้Shoelaceแตกต่างกัน:

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

    } 

  }
} 

ขอบเขตของการจัดการการรอคอย จำกัด อยู่ที่Tieวิธีการและคลาสไม่จำเป็นต้องมีฟิลด์แบบใช้ครั้งเดียวและดังนั้นจึงไม่จำเป็นต้องถูกทิ้ง

เนื่องจากหมายเลขอ้างอิงการรอคอยเป็นรายละเอียดการนำไปปฏิบัติด้านในShoelaceจึงไม่ควรเปลี่ยนแปลงอินเทอร์เฟซสาธารณะใด ๆ เช่นเพิ่มอินเทอร์เฟซใหม่ในการประกาศ จะเกิดอะไรขึ้นเมื่อคุณไม่ต้องการฟิลด์ที่ใช้แล้วทิ้งอีกต่อไปคุณจะลบการIDisposableประกาศหรือไม่ หากคุณคิดเกี่ยวกับShoelace สิ่งที่เป็นนามธรรม , IDisposableคุณรู้อย่างรวดเร็วว่ามันไม่ควรจะถูกปนเปื้อนด้วยการพึ่งพาโครงสร้างพื้นฐานเช่น IDisposableควรสงวนไว้สำหรับคลาสที่ abstraction encapsulate ทรัพยากรที่เรียกใช้เพื่อล้างค่าที่กำหนดขึ้น กล่าวคือสำหรับการเรียนที่ใช้ได้ตามความเป็นส่วนหนึ่งของสิ่งที่เป็นนามธรรม

นี่เป็นสิ่งที่เกิดขึ้นเมื่อคุณผสมการผสมผสานหรือการรวมกับคลาสที่ใช้แล้วทิ้ง ดังที่กล่าวไว้วิธีแรกที่จะทำคือรอคอยการเกาะมือจากเชือกผูกรองเท้า

ต้องบอกว่าคุณสามารถตัดรูปแบบทิ้งได้อย่างมากเมื่อคุณไม่มีทรัพยากรที่ไม่มีการจัดการ (ฉันยังคงมองหาข้อมูลอ้างอิงอย่างเป็นทางการสำหรับเรื่องนี้)

แต่คุณสามารถละเว้น destructor และ GC.SuppressFinalize (นี่); และอาจจะล้างข้อมูล void Dispose (bool disposing) เล็กน้อย

ที่น่าสนใจหากDriverมีการกำหนดไว้ข้างต้น:

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

จากนั้นเมื่อShoeสร้างเสร็จIDisposableแล้ว FxCop (v1.36) ก็ไม่Driverควรบ่นเช่นIDisposableกัน

อย่างไรก็ตามถ้ามันถูกกำหนดเช่นนี้:

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

แล้วมันจะบ่น

ฉันสงสัยว่านี่เป็นเพียงข้อ จำกัด ของ FxCop แทนที่จะเป็นวิธีแก้ปัญหาเพราะในรุ่นแรกShoeอินสแตนซ์ยังคงถูกสร้างโดยDriverและยังคงต้องถูกกำจัดอย่างใด

ฉันไม่คิดว่าจะมีวิธีการทางเทคนิคในการป้องกัน IDisposable จากการแพร่กระจายถ้าคุณทำให้การออกแบบของคุณควบคู่กันอย่างแน่นหนา จากนั้นควรสงสัยว่าการออกแบบนั้นถูกต้องหรือไม่

ในตัวอย่างของคุณฉันคิดว่ามันสมเหตุสมผลที่จะมีรองเท้าเป็นเชือกผูกรองเท้าและบางทีผู้ขับขี่ควรเป็นเจ้าของรองเท้าของเขา / เธอ อย่างไรก็ตามรถบัสไม่ควรเป็นเจ้าของคนขับ โดยทั่วไปแล้วคนขับรถโดยสารจะไม่เดินตามรถเมล์ไปที่โรงเก็บขยะ :) ในกรณีของคนขับและรองเท้าคนขับมักไม่ค่อยทำรองเท้าของตัวเองซึ่งหมายความว่าพวกเขาไม่ได้เป็นเจ้าของ

การออกแบบทางเลือกอาจเป็น:

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
{
   ...
}

การออกแบบใหม่นั้นน่าเสียดายที่มีความซับซ้อนมากขึ้นเนื่องจากต้องใช้คลาสเพิ่มเติมเพื่อยกตัวอย่างและกำจัดรองเท้าและไดรเวอร์ที่เป็นรูปธรรม แต่ภาวะแทรกซ้อนนี้เป็นปัญหาของการแก้ไข สิ่งที่ดีคือรถเมล์ไม่จำเป็นต้องทิ้งเพียงเพื่อจุดประสงค์ในการทิ้งเชือกผูกรองเท้า

วิธีการเกี่ยวกับการใช้ 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))}));
        }
    }
}