การเชื่อมต่อฐานข้อมูลจะถูกปิดหรือไม่ถ้าเราให้ผลแถวของ data datader และไม่อ่านบันทึกทั้งหมด?

ในขณะที่ทำความเข้าใจวิธีการyieldทำงานของคำหลักฉันเจอlink1และlink2บน StackOverflow ซึ่งสนับสนุนการใช้งานyield returnในขณะวนซ้ำ DataReader และเหมาะสมกับความต้องการของฉันเช่นกัน แต่มันทำให้ฉันสงสัยว่าเกิดอะไรขึ้นถ้าฉันใช้yield returnดังที่แสดงด้านล่างและถ้าฉันไม่ทำซ้ำใน DataReader ทั้งหมดการเชื่อมต่อฐานข้อมูลจะเปิดตลอดไปหรือไม่

IEnumerable<IDataRecord> GetRecords()
{
    SqlConnection myConnection = new SqlConnection(@"...");
    SqlCommand myCommand = new SqlCommand(@"...", myConnection);
    myCommand.CommandType = System.Data.CommandType.Text;
    myConnection.Open();
    myReader = myCommand.ExecuteReader(CommandBehavior.CloseConnection);
    try
       {               
          while (myReader.Read())
          {
            yield return myReader;          
          }
        }
    finally
        {
            myReader.Close();
        }
}


void AnotherMethod()
{
    foreach(var rec in GetRecords())
    {
       i++;
       System.Console.WriteLine(rec.GetString(1));
       if (i == 5)
         break;
  }
}

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

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

ขอบคุณ Jakob และ Ben สำหรับคำอธิบายโดยละเอียด

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

ผลักอย่าดึง

ขณะนี้คุณกำลังส่งคืนIEnumerable<IDataRecord>โครงสร้างข้อมูลที่คุณสามารถดึงได้ แต่คุณสามารถเปลี่ยนวิธีการของคุณเพื่อผลักดันผลลัพธ์ของมัน วิธีที่ง่ายที่สุดคือการส่งผ่านการAction<IDataRecord>เรียกซ้ำแต่ละครั้ง:

void GetRecords(Action<IDataRecord> callback)
{
    // ...
      while (myReader.Read())
      {
        callback(myReader);
      }
}

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

ประเมินความกระตือรือร้น

อีกทางเลือกหนึ่งคือตรวจสอบให้แน่ใจว่าการทำซ้ำเสร็จสิ้นก่อนที่จะกลับมาทั้งหมด

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

IEnumerable<T> GetRecords<T>(Func<IDataRecord,T> extractor)
{
    // ...
     var result = new List<T>();
     try
     {
       while (myReader.Read())
       {
         result.Add(extractor(myReader));         
       }
     }
     finally
     {
         myReader.Close();
     }
     return result;
}

finallyบล็อกของคุณจะทำงานเสมอ

เมื่อคุณใช้yield returnคอมไพเลอร์จะสร้างคลาสที่ซ้อนกันใหม่เพื่อใช้งานเครื่องสถานะ

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

ตามข้อกำหนดภาษา C # foreach (V v in x) embedded-statementถูกขยายเป็น

{
    E e = ((C)(x)).GetEnumerator();
    try
    {
        while (e.MoveNext())
        {
            V v = (V)(T)e.Current;
            embedded - statement
        }
    }
    finally {
        … // Dispose e
    }
}

เพื่อให้การแจงนับจะถูกกำจัดแม้ว่าคุณจะออกจากวงด้วยหรือbreakreturn

เพื่อรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้ตัววนซ้ำคุณสามารถอ่านบทความนี้โดย Jon Skeet

แก้ไข

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

คุณควรพิจารณาหนึ่งในโซลูชันที่แนะนำโดย @BenAaronson

ไม่ว่าyieldพฤติกรรมของคุณจะเป็นอย่างไรรหัสของคุณจะมีเส้นทางการปฏิบัติงานที่จะไม่จัดการทรัพยากรของคุณอย่างถูกต้อง เกิดอะไรขึ้นถ้าบรรทัดที่สองของคุณส่งข้อยกเว้นหรือข้อที่สามของคุณ หรือแม้แต่สี่ของคุณ? คุณจะต้องลอง / ต่อท้ายที่ซับซ้อนมากหรือใช้usingบล็อก

IEnumerable<IDataRecord> GetRecords()
{
    using(var connection = new SqlConnection(@"..."))
    {
        connection.Open();

        using(var command = new SqlCommand(@"...", connection);
        {
            using(var reader = command.ExecuteReader())
            {
               while(reader.Read())
               {
                   // your code here.
                   yield return reader;
               }
            }
        }
    }
}

ผู้คนตั้งข้อสังเกตว่าวิธีนี้ไม่ง่ายนักที่คนที่เรียกวิธีการของคุณอาจไม่รู้ว่าการแจกแจงผลลัพธ์สองครั้งจะเรียกวิธีนี้สองครั้ง โชคดีนะ นั่นคือวิธีการทำงานของภาษา นั่นคือสัญญาณที่IEnumerable<T>ส่ง มีเหตุผลนี้ไม่ได้กลับมาเป็นหรือList<T> T[]คนที่ไม่ทราบว่าจำเป็นต้องได้รับการศึกษาไม่ใช่ทำงานได้

Visual Studio มีคุณสมบัติที่เรียกว่าการวิเคราะห์รหัสแบบคงที่ คุณสามารถใช้มันเพื่อตรวจสอบว่าคุณได้จัดสรรทรัพยากรอย่างเหมาะสมหรือไม่

สิ่งที่คุณทำผิดไป แต่จะทำงานได้ดี

คุณควรใช้IEnumerator <>เนื่องจากยังสืบทอดIDisposable IDisposable

แต่เนื่องจากคุณใช้ foreach คอมไพเลอร์ยังคงใช้IDisposableในการสร้างIEnumerator <>สำหรับ foreach

โดยข้อเท็จจริงแล้ว foreach เกี่ยวข้องกับสิ่งต่าง ๆ มากมาย

ตรวจสอบ/programming/13459447/do-i-need-to-consider-disposing-of-any-ienumerablet-i-use