เกิดการรั่วไหลของหน่วยความจำหาก MemoryStream ใน. NET ไม่ได้ปิด?

ฉันมีรหัสต่อไปนี้:

MemoryStream foo(){
    MemoryStream ms = new MemoryStream();
    // write stuff to ms
    return ms;
}

void bar(){
    MemoryStream ms2 = foo();
    // do stuff with ms2
    return;
}

มีโอกาสไหมที่ MemoryStream ที่ฉันจัดสรรไว้จะล้มเหลวในการกำจัดทิ้งในภายหลัง?

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

หากสิ่งที่ใช้แล้วทิ้งคุณควรกำจัดทิ้งเสมอ คุณควรใช้usingคำสั่งในbar()วิธีการของคุณเพื่อให้แน่ใจว่าms2ได้รับการกำจัด

ในที่สุดเครื่องเก็บขยะก็จะถูกเก็บกวาดไป แต่ทางปฏิบัติที่ดีที่จะเรียก Dispose หากคุณเรียกใช้ FxCop กับโค้ดของคุณระบบจะตั้งค่าสถานะเป็นคำเตือน

คุณจะไม่รั่วไหลอะไรเลย - อย่างน้อยก็ในการใช้งานปัจจุบัน

การเรียก Dispose จะไม่ล้างหน่วยความจำที่ใช้โดย MemoryStream ให้เร็วขึ้น มันจะหยุดกระแสของคุณจากการทำงานได้สำหรับการอ่าน / เขียนเรียกหลังจากที่โทรซึ่งอาจหรือไม่อาจจะเป็นประโยชน์กับคุณ

หากคุณแน่ใจจริงๆว่าคุณไม่ต้องการย้ายจาก MemoryStream ไปยังสตรีมประเภทอื่นการไม่เรียก Dispose จะไม่ทำอันตรายใด ๆ แต่ก็ปฏิบัติที่ดีโดยทั่วไปส่วนหนึ่งเป็นเพราะถ้าคุณเคยทำการเปลี่ยนแปลงการใช้สตรีมที่แตกต่างกันที่คุณไม่ต้องการที่จะได้รับกัดโดยข้อผิดพลาดที่ยากต่อการค้นหาเนื่องจากคุณเลือกวิธีที่ง่ายออกในช่วงต้น (ในทางกลับกันมีอาร์กิวเมนต์ YAGNI ... )

อีกเหตุผลหนึ่งที่ต้องทำก็คือการใช้งานใหม่อาจแนะนำทรัพยากรที่จะปล่อยให้ทิ้ง

ใช่มีการรั่วไหลขึ้นอยู่กับว่าคุณกำหนด LEAK ไว้อย่างไรและคุณหมายถึง LATER เท่าไร ...

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

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

ประโยชน์ของคำสั่งการใช้ (เรียกง่ายๆว่า dispose) คือคุณสามารถประกาศการอ้างอิงของคุณในคำสั่งใช้ เมื่อคำสั่งการใช้งานเสร็จสิ้นไม่เพียง แต่ถูกเรียกว่าทิ้งเท่านั้น แต่การอ้างอิงของคุณยังอยู่นอกขอบเขตทำให้การอ้างอิงเป็นโมฆะอย่างมีประสิทธิภาพและทำให้วัตถุของคุณมีสิทธิ์ได้รับการรวบรวมขยะทันทีโดยไม่ต้องจำไว้ว่าต้องเขียนโค้ด "reference = null"

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

ไม่จำเป็นต้องโทร.Dispose()(หรือห่อด้วยUsing)

เหตุผลที่คุณโทรหา.Dispose()คือการปล่อยทรัพยากรโดยเร็วที่สุดเท่าที่เป็นไปได้

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

นี่เป็นคำตอบแล้ว แต่ฉันจะเพิ่มว่าหลักการซ่อนข้อมูลแบบเก่าที่ดีหมายความว่าในอนาคตคุณอาจต้องการ refactor:

MemoryStream foo()
{    
    MemoryStream ms = new MemoryStream();    
    // write stuff to ms    
    return ms;
}

ถึง:

Stream foo()
{    
   ...
}

สิ่งนี้เน้นว่าผู้โทรไม่ควรสนใจว่าสตรีมจะถูกส่งกลับประเภทใดและทำให้สามารถเปลี่ยนการใช้งานภายในได้ (เช่นเมื่อจำลองการทดสอบหน่วย)

จากนั้นคุณจะต้องประสบปัญหาหากคุณไม่ได้ใช้ Dispose ในการใช้งานบาร์ของคุณ:

void bar()
{    
    using (Stream s = foo())
    {
        // do stuff with s
        return;
    }
}

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

ทุกที่ที่คุณโทรหา Foo คุณสามารถทำได้โดยใช้ (MemoryStream ms = foo ()) และฉันคิดว่าคุณน่าจะยังโอเค

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

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

ฉันอยากจะแนะนำให้รวม MemoryStream ไว้bar()ในusingคำสั่งเพื่อความสอดคล้องเป็นหลัก:

• ตอนนี้ MemoryStream ไม่ได้เปิดหน่วยความจำ.Dispose()ให้ว่าง แต่เป็นไปได้ว่าในอนาคตอาจมีหรือคุณ (หรือคนอื่นใน บริษัท ของคุณ) อาจแทนที่ด้วย MemoryStream ที่คุณกำหนดเองซึ่งทำเป็นต้น
• ช่วยสร้างรูปแบบในโปรเจ็กต์ของคุณเพื่อให้แน่ใจว่าสตรีมทั้งหมดจะได้รับการกำจัด - เส้นจะถูกวาดอย่างแน่นหนามากขึ้นโดยการพูดว่า "ต้องกำจัดสตรีมทั้งหมด" แทนที่จะเป็น "สตรีมบางรายการต้องถูกกำจัด แต่บางสตรีมไม่จำเป็นต้อง" ...
• หากคุณเคยเปลี่ยนรหัสเพื่ออนุญาตให้ส่งคืนสตรีมประเภทอื่นคุณจะต้องเปลี่ยนรหัสเพื่อกำจัดต่อไป

อีกสิ่งหนึ่งที่ฉันมักจะทำในกรณีเช่นfoo()เมื่อสร้างและส่งคืน IDisposable คือเพื่อให้แน่ใจว่าความล้มเหลวระหว่างการสร้างวัตถุและreturnข้อยกเว้นถูกจับโดยข้อยกเว้นทิ้งวัตถุและเรียกคืนข้อยกเว้นใหม่:

MemoryStream x = new MemoryStream();
try
{
    // ... other code goes here ...
    return x;
}
catch
{
    // "other code" failed, dispose the stream before throwing out the Exception
    x.Dispose();
    throw;
}

หากวัตถุใช้ IDisposable คุณต้องเรียกใช้เมธอด. Dispose เมื่อคุณทำเสร็จแล้ว

ในบางออบเจ็กต์ Dispose มีความหมายเหมือนกับปิดและในทางกลับกันในกรณีนั้นก็ดีเช่นกัน

ตอนนี้สำหรับคำถามเฉพาะของคุณไม่คุณจะไม่ทำให้หน่วยความจำรั่วไหล

ฉันไม่ใช่ผู้เชี่ยวชาญ. net แต่ปัญหาที่นี่อาจเป็นทรัพยากรคือที่จับไฟล์ไม่ใช่หน่วยความจำ ฉันเดาว่าในที่สุดคนเก็บขยะจะปล่อยสตรีมและปิดที่จับ แต่ฉันคิดว่าการปิดอย่างชัดเจนจะเป็นแนวทางปฏิบัติที่ดีที่สุดเสมอเพื่อให้แน่ใจว่าคุณล้างเนื้อหาลงในดิสก์

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

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