Verschachtelt mit Anweisungen in C #

Ich bin an einem Projekt arbeiten. Ich habe so vergleichen Sie den Inhalt von zwei Dateien, und sehen, ob Sie zueinander passen genau.

Bevor eine Menge von Fehler-überprüfung und-Validierung, mein Erster Entwurf ist:

  DirectoryInfo di = new DirectoryInfo(Environment.CurrentDirectory + "\\TestArea\\");
  FileInfo[] files = di.GetFiles(filename + ".*");

  FileInfo outputFile = files.Where(f => f.Extension == ".out").Single<FileInfo>();
  FileInfo expectedFile = files.Where(f => f.Extension == ".exp").Single <FileInfo>();

  using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
  {
    using (StreamReader expFile = new StreamReader(expectedFile.OpenRead()))
    {
      while (!(outFile.EndOfStream || expFile.EndOfStream))
      {
        if (outFile.ReadLine() != expFile.ReadLine())
        {
          return false;
        }
      }
      return (outFile.EndOfStream && expFile.EndOfStream);
    }
  }

Es scheint ein wenig seltsam für geschachtelte using Aussagen.

Gibt es einen besseren Weg, dies zu tun?

InformationsquelleAutor der Frage SBurris | 2009-08-25

.net c#file using

444

Der bevorzugte Weg, dies zu tun ist, nur eine öffnende Klammer { nach der letzten using - Anweisung wie folgt:

using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
using (StreamReader expFile = new StreamReader(expectedFile.OpenRead())) 
{
    ///...
}

InformationsquelleAutor der Antwort SLaks

112

Wenn die Objekte der gleichen Typ können Sie die folgenden

using (StreamReader outFile = new StreamReader(outputFile.OpenRead()), 
                    expFile = new StreamReader(expectedFile.OpenRead()))
{
    //...
}

InformationsquelleAutor der Antwort Gavin H

Wenn die IDisposables vom gleichen Typ sind, können Sie Folgendes tun:

 using (StreamReader outFile = new StreamReader(outputFile.OpenRead()), 
     expFile = new StreamReader(expectedFile.OpenRead()) {
     //...
 }

Auf der MSDN-Seite auf hat die Dokumentation in dieser Sprache verfügen.

Können Sie Folgendes tun, ob oder nicht die IDisposables sind vom gleichen Typ:

using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
using (StreamWriter anotherFile = new StreamReader(anotherFile.OpenRead()))
{ 
     //...
}

InformationsquelleAutor der Antwort jason

15

wenn Sie nichts dagegen haben, deklarieren Sie die Variablen für Ihre Verwendung zu blockieren, bevor Sie den using-block, konnte Sie erklären Sie alle in der gleichen Anweisung verwenden.
```
    Test t; 
    Blah u;
    using (IDisposable x = (t = new Test()), y = (u = new Blah())) {
        //whatever...
    }
```
So, x und y sind nur Platzhalter-Variablen vom Typ IDisposable für die using-block verwenden, und verwenden Sie t und u im Quellcode. Ich dachte, ich würde erwähnen.

InformationsquelleAutor der Antwort Botz3000
8

Wenn Sie wollen, vergleichen Sie die Dateien effizient, nicht verwenden StreamReaders, und dann die aufzuhalten der Benutzung nicht nötig - Sie können low-level-stream liest, um zu ziehen in Puffern von Daten zu vergleichen.

Können Sie auch Dinge vergleichen, wie die Größe der Datei zunächst schnell zu erkennen, verschiedene Dateien zu speichern, Sie müssen, um alle Daten Lesen zu können.

InformationsquelleAutor der Antwort Jason Williams
7

Die using-Anweisung funktioniert aus der IDisposable-Schnittstelle, so dass eine weitere option könnte sein, die irgendeine Art von composite-Klasse, die IDisposable implementiert und hat Referenzen zu allen von der IDisposable-Objekten, die Sie normalerweise in Ihrem using-Anweisung. Die Kehrseite davon ist, dass müssen Sie deklarieren Sie Ihre Variablen erste und außerhalb der Reichweite für Sie nützlich zu sein innerhalb des using-Blocks, die mehr Zeilen code als einige der anderen Vorschläge erfordern würde.
```
Connection c = new ...; 
Transaction t = new ...;

using (new DisposableCollection(c, t))
{
   ...
}
```
Konstruktor für DisposableCollection ist ein params-array in diesem Fall, damit können Sie Futter in so viele wie Sie möchten.

InformationsquelleAutor der Antwort jpierson
6

Können Sie auch sagen:
```
using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
using (StreamReader expFile = new StreamReader(expectedFile.OpenRead()))
{
   ...
}
```
Aber einige Leute finden, dass schwer zu Lesen. BTW, wie eine Optimierung zu deinem problem, warum nicht Sie überprüfen, dass die Datei-Größen sind die gleiche Größe ersten, bevor Sie gehen Zeile für Zeile?

InformationsquelleAutor der Antwort aquinas

Könnte man weglassen der Klammern auf alle, aber die inner-die meisten mit:

using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
using (StreamReader expFile = new StreamReader(expectedFile.OpenRead()))
{
  while (!(outFile.EndOfStream || expFile.EndOfStream))
  {
    if (outFile.ReadLine() != expFile.ReadLine())
    {
      return false;
    }
  }
}

Ich denke, das ist übersichtlicher, als mehrere der gleichen Art in der gleichen Verwendung, wie andere vorgeschlagen haben, aber ich bin sicher, viele Leute denken, dass dies verwirrend

InformationsquelleAutor der Antwort yoyoyoyosef

4

Es ist nichts sonderbares daran. using ist ein Kürzel Art und Weise der Sicherstellung der Entsorgung des Objekts sobald der code-block beendet ist. Wenn Sie eine Wegwerf-Objekt im äußeren block, dass der innere block verwenden muss, ist dies durchaus akzeptabel.

Edit: Zu langsam auf die Eingabe, um zu zeigen, konsolidierte code-Beispiel. +1 zu allen anderen.

InformationsquelleAutor der Antwort womp

Und einfach auf die Klarheit, in diesem Fall, da jede nachfolgende Anweisung ist eine einzelne Anweisung, (und nicht blockieren), kann man auch weglassen aller Klammern :

using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
  using (StreamReader expFile = new StreamReader(expectedFile.OpenRead()))
    while (!(outFile.EndOfStream || expFile.EndOfStream))  
       if (outFile.ReadLine() != expFile.ReadLine())    
          return false;

InformationsquelleAutor der Antwort Charles Bretana

Können Sie mehrere Einweg-Objekte in einer using-Anweisung durch Kommata getrennt werden:

using (StreamReader outFile = new StreamReader(outputFile.OpenRead()), 
       expFile = new StreamReader(expectedFile.OpenRead()))
{

}

InformationsquelleAutor der Antwort codymanix

2

Diese kommen Zeit zu Zeit, wenn ich den code als gut. Sie könnte in Erwägung ziehen, verschieben Sie den zweiten using-Anweisung in einer anderen Funktion?

InformationsquelleAutor der Antwort obelix

Sind Sie auch gefragt, ob es einen besseren Weg gibt, um zu vergleichen, um Dateien?
Ich bevorzuge die Berechnung einer CRC oder MD5 für die Dateien und vergleichen diese.

Beispielsweise können Sie mit der folgenden extension Methode:

public static class ByteArrayExtender
    {
        static ushort[] CRC16_TABLE =  { 
                      0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241, 
                      0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440, 
                      0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40, 
                      0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841, 
                      0XD801, 0X18C0, 0X1980, 0XD941, 0X1B00, 0XDBC1, 0XDA81, 0X1A40, 
                      0X1E00, 0XDEC1, 0XDF81, 0X1F40, 0XDD01, 0X1DC0, 0X1C80, 0XDC41, 
                      0X1400, 0XD4C1, 0XD581, 0X1540, 0XD701, 0X17C0, 0X1680, 0XD641, 
                      0XD201, 0X12C0, 0X1380, 0XD341, 0X1100, 0XD1C1, 0XD081, 0X1040, 
                      0XF001, 0X30C0, 0X3180, 0XF141, 0X3300, 0XF3C1, 0XF281, 0X3240, 
                      0X3600, 0XF6C1, 0XF781, 0X3740, 0XF501, 0X35C0, 0X3480, 0XF441, 
                      0X3C00, 0XFCC1, 0XFD81, 0X3D40, 0XFF01, 0X3FC0, 0X3E80, 0XFE41, 
                      0XFA01, 0X3AC0, 0X3B80, 0XFB41, 0X3900, 0XF9C1, 0XF881, 0X3840, 
                      0X2800, 0XE8C1, 0XE981, 0X2940, 0XEB01, 0X2BC0, 0X2A80, 0XEA41, 
                      0XEE01, 0X2EC0, 0X2F80, 0XEF41, 0X2D00, 0XEDC1, 0XEC81, 0X2C40, 
                      0XE401, 0X24C0, 0X2580, 0XE541, 0X2700, 0XE7C1, 0XE681, 0X2640, 
                      0X2200, 0XE2C1, 0XE381, 0X2340, 0XE101, 0X21C0, 0X2080, 0XE041, 
                      0XA001, 0X60C0, 0X6180, 0XA141, 0X6300, 0XA3C1, 0XA281, 0X6240, 
                      0X6600, 0XA6C1, 0XA781, 0X6740, 0XA501, 0X65C0, 0X6480, 0XA441, 
                      0X6C00, 0XACC1, 0XAD81, 0X6D40, 0XAF01, 0X6FC0, 0X6E80, 0XAE41, 
                      0XAA01, 0X6AC0, 0X6B80, 0XAB41, 0X6900, 0XA9C1, 0XA881, 0X6840, 
                      0X7800, 0XB8C1, 0XB981, 0X7940, 0XBB01, 0X7BC0, 0X7A80, 0XBA41, 
                      0XBE01, 0X7EC0, 0X7F80, 0XBF41, 0X7D00, 0XBDC1, 0XBC81, 0X7C40, 
                      0XB401, 0X74C0, 0X7580, 0XB541, 0X7700, 0XB7C1, 0XB681, 0X7640, 
                      0X7200, 0XB2C1, 0XB381, 0X7340, 0XB101, 0X71C0, 0X7080, 0XB041, 
                      0X5000, 0X90C1, 0X9181, 0X5140, 0X9301, 0X53C0, 0X5280, 0X9241, 
                      0X9601, 0X56C0, 0X5780, 0X9741, 0X5500, 0X95C1, 0X9481, 0X5440, 
                      0X9C01, 0X5CC0, 0X5D80, 0X9D41, 0X5F00, 0X9FC1, 0X9E81, 0X5E40, 
                      0X5A00, 0X9AC1, 0X9B81, 0X5B40, 0X9901, 0X59C0, 0X5880, 0X9841, 
                      0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40, 
                      0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41, 
                      0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641, 
                      0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040 };


        public static ushort CalculateCRC16(this byte[] source)
        {
            ushort crc = 0;

            for (int i = 0; i < source.Length; i++)
            {
                crc = (ushort)((crc >> 8) ^ CRC16_TABLE[(crc ^ (ushort)source[i]) & 0xFF]);
            }

            return crc;
        }

Sobald Sie dies getan haben, ist es ziemlich einfach, um Dateien zu vergleichen:

public bool filesAreEqual(string outFile, string expFile)
{
    var outFileBytes = File.ReadAllBytes(outFile);
    var expFileBytes = File.ReadAllBytes(expFile);

    return (outFileBytes.CalculateCRC16() == expFileBytes.CalculateCRC16());
}

Konnte man mit dem eingebauten System.Sicherheit.Die Kryptographie.MD5 Klasse,
aber der berechnete hash wird ein byte[] so würden Sie immer noch haben, vergleichen Sie diese beiden arrays.

InformationsquelleAutor der Antwort TimothyP

2

Auch, wenn Sie bereits wissen, die Wege, es gibt keinen Punkt, ist die scan-Verzeichnis.

Stattdessen würde ich empfehlen, so etwas wie dieses:
```
string directory = Path.Combine(Environment.CurrentDirectory, @"TestArea\");

using (StreamReader outFile = File.OpenText(directory + filename + ".out"))
using (StreamReader expFile = File.OpenText(directory + filename + ".exp"))) 
{
    //...
```
Weg.Kombinieren wird fügen Sie einen Ordner-oder Dateinamen, einen Pfad und stellen Sie sicher, dass es genau einen backslash zwischen Pfad und den Namen.

- Datei.OpenText wird, öffnen Sie eine Datei, und erstellen Sie eine StreamReader.

Durch ein Präfix eines Strings mit @, können Sie vermeiden, zu entkommen jeden backslash (zB @"a\b\c")

InformationsquelleAutor der Antwort SLaks
2

Kann ich denke ich gefunden haben, die syntaktisch sauberer Weg, deklarieren Sie diese using-Anweisung, und es scheint für mich arbeiten? mit var als Ihre Art in der using-Anweisung anstelle von IDisposable scheint dynamisch infer type auf beide Objekte und es mir erlaubt zu instanziieren meine beiden Objekte und rufen deren Eigenschaften und Methoden der Klasse Sie zugeordnet sind, wie in

using(var uow = new UnitOfWorkType1(), uow2 = new UnitOfWorkType2()){}.

Wenn jemand weiß, warum dies nicht richtig ist, bitte lassen Sie mich wissen,

InformationsquelleAutor der Antwort Caleb

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.