Annidato usando le istruzioni in C #

Sto lavorando a un progetto. Devo confrontare il contenuto di due file e vedere se corrispondono esattamente tra loro.

Prima di molti controlli e convalide degli errori, la mia prima bozza è:

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

Sembra un po 'strano avere usingdichiarazioni annidate .

C'è un modo migliore per farlo?

Il modo preferito per farlo è mettere una parentesi graffa aperta solo {dopo l'ultima usingaffermazione, in questo modo:

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

Se gli oggetti sono dello stesso tipo puoi fare quanto segue

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

Quando le IDisposables sono dello stesso tipo, puoi fare quanto segue:

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

La pagina MSDN su usingcontiene documentazione su questa funzione di lingua.

È possibile effettuare le seguenti operazioni indipendentemente dal fatto che le IDisposables siano dello stesso tipo:

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

se non ti dispiace dichiarare le variabili per il blocco using prima del blocco using, puoi dichiararle tutte nella stessa istruzione using.

    Test t; 
    Blah u;
    using (IDisposable x = (t = new Test()), y = (u = new Blah())) {
        // whatever...
    }

In questo modo, x e y sono solo variabili segnaposto di tipo ID che possono essere utilizzate dal blocco using e si usa te all'interno del codice. Ho pensato di menzionare.

Se si desidera confrontare i file in modo efficiente, non utilizzare affatto StreamReader e quindi gli usi non sono necessari: è possibile utilizzare letture di flusso di basso livello per estrarre buffer di dati da confrontare.

Puoi anche confrontare prima cose come la dimensione del file per rilevare rapidamente diversi file per evitare di dover leggere anche tutti i dati.

L'istruzione using funziona al di fuori dell'interfaccia IDisposable, quindi un'altra opzione potrebbe essere quella di creare un tipo di classe composita che implementa IDisposable e abbia riferimenti a tutti gli oggetti IDisposable che normalmente inseriresti nell'istruzione using. Il lato negativo di questo è che devi dichiarare le tue variabili al di fuori e al di fuori dell'ambito affinché siano utili all'interno del blocco using che richiede più righe di codice di quanto richiederebbero alcuni degli altri suggerimenti.

Connection c = new ...; 
Transaction t = new ...;

using (new DisposableCollection(c, t))
{
   ...
}

La funzione di costruzione per DisposableCollection è un array di parametri in questo caso, quindi è possibile inserire tutti gli elementi desiderati.

Puoi anche dire:

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

Ma alcune persone potrebbero trovarlo difficile da leggere. A proposito, come ottimizzazione del tuo problema, perché non controlli che le dimensioni del file abbiano le stesse dimensioni prima di procedere riga per riga?

Puoi omettere le parentesi su tutti tranne quelli più interni usando:

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

Penso che questo sia più pulito rispetto al mettere molti dello stesso tipo nello stesso uso, come altri hanno suggerito, ma sono sicuro che molte persone penseranno che questo sia confuso

Puoi raggruppare più oggetti usa e getta in una dichiarazione using con virgole:

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

}

Non c'è niente di strano. usingè un modo abbreviato di garantire lo smaltimento dell'oggetto al termine del blocco di codice. Se hai un oggetto usa e getta nel tuo blocco esterno che il blocco interno deve usare, questo è perfettamente accettabile.

Modifica: troppo lento nella digitazione per mostrare un esempio di codice consolidato. +1 a tutti gli altri.

E per aggiungere alla chiarezza, in questo caso, poiché ogni istruzione successiva è una singola istruzione (e non un blocco), puoi omettere tutte le parentesi:

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;  

Da C # 8.0 è possibile utilizzare una dichiarazione using .

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

Questo eliminerà le variabili utilizzanti alla fine dell'ambito delle variabili, cioè alla fine del metodo.

Questi vengono di volta in volta anche quando scrivo codice. Potresti considerare di spostare la seconda istruzione using in un'altra funzione?

Stai anche chiedendo se esiste un modo migliore per confrontare i file? Preferisco calcolare un CRC o MD5 per entrambi i file e confrontarli.

Ad esempio, è possibile utilizzare il seguente metodo di estensione:

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

Una volta fatto, è abbastanza facile confrontare i file:

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

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

È possibile utilizzare la classe System.Security.Cryptography.MD5 integrata, ma l'hash calcolato è un byte [], quindi è comunque necessario confrontare questi due array.

Inoltre, se conosci già i percorsi, non ha senso scansionare la directory.

Invece, consiglierei qualcosa del genere:

string directory = Path.Combine(Environment.CurrentDirectory, @"TestArea\");

using (StreamReader outFile = File.OpenText(directory + filename + ".out"))
using (StreamReader expFile = File.OpenText(directory + filename + ".exp"))) 
{
    //...

Path.Combine aggiungerà una cartella o un nome file a un percorso e si assicurerà che ci sia esattamente una barra rovesciata tra il percorso e il nome.

File.OpenTextaprirà un file e creerà uno StreamReaderin una volta sola.

Con il prefisso di una stringa con @, puoi evitare di dover sfuggire a tutte le barre rovesciate (ad es. @"a\b\c")

Penso di aver trovato un modo sintatticamente più pulito di dichiarare questa affermazione usando, e sembra funzionare per me? usare var come tipo nell'istruzione using anziché IDisposable sembra inferire dinamicamente il tipo su entrambi gli oggetti e mi permette di creare un'istanza di entrambi i miei oggetti e di chiamarne le proprietà e i metodi della classe con cui sono allocati, come in

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

Se qualcuno sa perché questo non è giusto, per favore fatemi sapere

È il normale modo di utilizzo e funziona perfettamente. Sebbene ci siano altri modi per implementarlo. Quasi ogni risposta è già presente nella risposta a questa domanda. Ma qui li sto elencando tutti insieme.

Già usato

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

opzione 1

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

opzione 2

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