CS1674 'IEnumerator': In einer using-Anweisung verwendeter Typ muss implizit in 'System.IDisposable' konvertiert werden

Question

Ich muss ein altes Projekt in meiner Firma verwalten, das mit C# und altem .NET Framework (vielleicht 2.0?) Codiert ist Jahre zuvor. Ich habe alte Quelldateien in Visual Studio geladen und es gibt mir einen Fehler: "CS1674 'IEnumerator': Typ in einer Verwendung Anweisung verwendet werden muss implizit in 'System.IDisposable'" Convertible wenn ich versuche, es zu bauen.

ist die komplette Funktion, die diesen Fehler verursacht, was am wichtigsten ist dieser Teil: „mit (IEnumerator enumerator = dataTable.Rows.GetEnumerator())“, ein Rat, wie man es loswerden?

Ich habe versucht, andere ähnliche Fragen zu lesen, aber ich konnte das nicht mit ihnen lösen. Gibt es vielleicht eine andere Möglichkeit, dies zu programmieren, oder könnte meine Programmierumgebung dafür verantwortlich sein?

public void CompileDynamicCode() 
    { 
     base.Session.trace_enter(); 
     try 
     { 
      try 
      { 
       DataTable dataTable = this.ChimneyTable; 
       if (dataTable.Rows.Count > 0) 
       { 
        this.oChimneys = new Chimney[dataTable.Rows.Count]; 
        int num = 0; 

        using (IEnumerator enumerator = dataTable.Rows.GetEnumerator()) 
        { 
         while (enumerator.MoveNext()) 
         { 
          DataRow dataRow = (DataRow)enumerator.Current; 
          bool entryXRight = false; 
          bool posXRight = false; 
          bool calcSteps = true; 
          bool calcCatwalk = true; 
          bool calcPlatform = true; 
          bool calcFlashing = true; 
          int connectCatwalkTo = -1; 
          if ((int)dataRow["entryXFromRight"] == 1) 
          { 
           entryXRight = true; 
          } 
          if ((int)dataRow["posXFromRight"] == 1) 
          { 
           posXRight = true; 
          } 
          if (dataTable.Columns.Contains("calcSteps") && (int)dataRow["calcSteps"] == 0) 
          { 
           calcSteps = false; 
          } 
          if (dataTable.Columns.Contains("calcCatwalk") && (int)dataRow["calcCatwalk"] == 0) 
          { 
           calcCatwalk = false; 
          } 
          if (dataTable.Columns.Contains("calcPlatform") && (int)dataRow["calcPlatform"] == 0) 
          { 
           calcPlatform = false; 
          } 
          if (dataTable.Columns.Contains("calcFlashing") && (int)dataRow["calcFlashing"] == 0) 
          { 
           calcFlashing = false; 
          } 
          if (dataTable.Columns.Contains("catwalkConnection")) 
          { 
           connectCatwalkTo = (int)dataRow["catwalkConnection"]; 
          } 
          this.oChimneys[num] = new Chimney((int)dataRow["index"], (int)dataRow["shape_index"], (int)dataRow["entry_shape_index"], (int)dataRow["entryX"], entryXRight, (int)dataRow["posX"], posXRight, (int)dataRow["posY"], (int)dataRow["sizeX"], (int)dataRow["sizeY"], (int)dataRow["sizeZ"], (ChimneyAccessTypeEnum)dataRow["access_type"], calcSteps, calcCatwalk, calcPlatform, calcFlashing, connectCatwalkTo, this); 
          num++; 
         } 
         goto IL_247; 
        } 
       } 
       this.oChimneys = new Chimney[0]; 
       IL_247: 
       dataTable = this.ShapeTable; 
       if (dataTable.Rows.Count > 0) 
       { 
        this.oShapes = new BasicShape[dataTable.Rows.Count]; 
        int num2 = 0; 
        foreach (DataRow dataRow2 in dataTable.Rows) 
        { 
         this.oShapes[num2] = new BasicShape((TopRowModeEnum)dataRow2["TopRowMode"], (EaveRowModeEnum)dataRow2["EaveRowMode"], (ShapeBehaviorEnum)dataRow2["Behavior"], num2, this); 
         num2++; 
        } 
       } 
       dataTable = this.ConnectorTable; 
       if (dataTable.Rows.Count > 0) 
       { 
        this.oConnectors = new Connector[dataTable.Rows.Count]; 
        int num3 = 0; 
        foreach (DataRow dataRow3 in dataTable.Rows) 
        { 
         BasicShape selectShape = null; 
         BasicShape selectShape2 = null; 
         try 
         { 
          selectShape = this.oShapes[(int)dataRow3["Shape1Index"]]; 
         } 
         catch 
         { 
         } 
         try 
         { 
          selectShape2 = this.oShapes[(int)dataRow3["Shape2Index"]]; 
         } 
         catch 
         { 
         } 
         this.oConnectors[num3] = new Connector((ConnectorBehaviorEnum)dataRow3["ConnectorBehavior"], selectShape, selectShape2, (ShapeConnectingLineEnum)dataRow3["Shape1Line"], (ShapeConnectingLineEnum)dataRow3["Shape2Line"], this, num3, (ConnectorStartEndMode)dataRow3["StartMode"], (ConnectorStartEndMode)dataRow3["StopMode"]); 
         num3++; 
        } 
       } 
      } 
      catch (Exception ex) 
      { 
       base.Session.HandleException(ex); 
       throw ex; 
      } 
      this.DynamicObject = this.CreateFromScript(); 
     } 
     catch (Exception ex2) 
     { 
      base.Session.HandleException(ex2); 
      throw ex2; 
     } 
     finally 
     { 
      base.Session.trace_exit(); 
     } 
    } 

Answer 1

IEnumerator nicht implementiert IDisposable. IEnumerator<T> tut aber das ist ein anderer Typ.

Entfernen Sie den using Teil dieser Zeile und den zugehörigen Block.

Answer 2

den Anruf zu GetEnumerator() ersetzen:

foreach (DataRow dataRow in dataTable.Rows) 
{ 
    bool entryXRight = false; 
    // ... 
} 

---

Als Randbemerkung, dass Code viel Liebe braucht, wie die throw ex;-throw; verändert und der goto loszuwerden.

Answer 3

Die Fehlermeldung wird ausgelöst, weil IEnumerator selbst IDisposable nicht implementiert. Letzteres ist notwendig, wenn Sie das Objekt in einer using Anweisung verwenden möchten, da using in einen try/finally Block übersetzt wird und in diesem finally Block die IDisposable.Dispose Methode des Objekts aufgerufen werden soll.

Der Code sieht komisch aus, es gibt sogar eine goto! Aber was ist eigentlich dieser Code tut, ist

• ein leeres Chimney Array erstellen, wenn es keine Zeilen
• sonst eine foreach tun über die Zeilen (Ausführung, was in der while (enumerator.MoveNext){} Schleife ist)

So kann es Umgerechnet werden:

DataTable dataTable = this.ChimneyTable; 
// changes start here 
this.oChimneys = new Chimney[dataTable.Rows.Count]; 
int num = 0; 

foreach(DataRow dataRow in dataTable.Rows) 
{ 
    // the part in the loop while (enumerator.MoveNext()) 
    num++; // was the last line... for orientation 
} 
// end of changes 
IL_247: // superflous, just for your orientation