Я работаю над проектом. Мне нужно сравнить содержимое двух файлов и посмотреть, точно ли они соответствуют друг другу.
Перед большой проверкой ошибок и проверкой мой первый проект:
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);
}
}
Это кажется немного странным, вложенные с using заявления.
Есть лучший способ сделать это?
Предпочтительный способ сделать это - поместить только открытую скобку { после последнего оператора using, например:
using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
using (StreamReader expFile = new StreamReader(expectedFile.OpenRead()))
{
///...
}
Если объекты одного типа, вы можете сделать следующее
using (StreamReader outFile = new StreamReader(outputFile.OpenRead()),
expFile = new StreamReader(expectedFile.OpenRead()))
{
// ...
}
Когда IDisposable имеют один и тот же тип, вы можете сделать следующее:
using (StreamReader outFile = new StreamReader(outputFile.OpenRead()),
expFile = new StreamReader(expectedFile.OpenRead()) {
// ...
}
На странице MSDN на using есть документация по этой языковой функции.
Вы можете сделать следующее: есть ли IDisposable одного типа:
using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
using (StreamWriter anotherFile = new StreamReader(anotherFile.OpenRead()))
{
// ...
}
если вы не возражаете против объявления переменных для вашего блока использования перед блоком использования, вы можете объявить их все в одном и том же заявлении.
Test t;
Blah u;
using (IDisposable x = (t = new Test()), y = (u = new Blah())) {
// whatever...
}
Таким образом, x и y являются только переменными-заполнителями типа IDisposable для используемого блока, и вы используете t и u внутри своего кода. Просто подумал, что я бы сказал.
Если вы хотите эффективно сравнивать файлы, вообще не используйте StreamReaders, а затем нет необходимости в использовании - вы можете использовать чтение низкого уровня, чтобы вытащить буферы данных для сравнения.
Вы также можете сначала сравнить вещи, такие как размер файла, с тем, чтобы быстро обнаружить разные файлы, чтобы вы сами могли прочитать все данные.
Оператор using работает с интерфейсом IDisposable, поэтому другим вариантом может быть создание некоторого типа составного класса, который реализует IDisposable и имеет ссылки на все объекты IDisposable, которые вы обычно помещаете в свой оператор using. Нижняя сторона этого заключается в том, что вы должны объявить свои переменные сначала и вне области действия, чтобы они были полезны в блоке использования, требующем больше строк кода, чем потребуются некоторые другие предложения.
Connection c = new ...;
Transaction t = new ...;
using (new DisposableCollection(c, t))
{
...
}
Конструктор для DisposableCollection является массивом параметров в этом случае, поэтому вы можете загружать столько, сколько хотите.
Вы также можете сказать:
using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
using (StreamReader expFile = new StreamReader(expectedFile.OpenRead()))
{
...
}
Но некоторым людям может показаться, что их трудно читать. BTW, как оптимизация вашей проблемы, почему вы не проверяете, что размеры файлов имеют одинаковый размер, прежде чем идти по строкам?
Вы можете группировать несколько одноразовых объектов в один оператор с запятой:
using (StreamReader outFile = new StreamReader(outputFile.OpenRead()),
expFile = new StreamReader(expectedFile.OpenRead()))
{
}
В этом нет ничего странного. using - сокращенный способ обеспечения удаления объекта после завершения кода. Если в вашем внешнем блоке есть одноразовый объект, который должен использовать внутренний блок, это вполне приемлемо.
Изменить: слишком медленно набирать текст, чтобы отобразить пример сводного кода. +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;
}
}
}
Я думаю, что это чище, чем ставить несколько одинаковых типов в одно и то же использование, как и другие, но я уверен, что многие люди подумают, что это запутывает
И чтобы просто добавить к ясности, в этом случае, поскольку каждый следующий оператор представляет собой единый оператор (а не блок), вы можете опустить все скобки:
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;
Это время от времени, когда я кодирую. Вы могли бы подумать переместить второй оператор using в другую функцию?
Кроме того, если вы уже знаете пути, нет места для сканирования каталога.
Вместо этого я бы рекомендовал что-то вроде этого:
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 добавит папку или имя файла в путь и убедитесь, что между контуром и именем есть только одна обратная косая черта.
File.OpenText откроет файл и создаст StreamReader за один раз.
С помощью префикса строки с @вы можете избежать всякой обратной косой черты (например, @"a\b\c")
Вы также спрашиваете, есть ли лучший способ сравнить с файлами? Я предпочитаю вычислять CRC или MD5 для обоих файлов и сравнивать их.
Например, вы можете использовать следующий метод расширения:
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;
}
Как только вы сделали это, довольно легко сравнить файлы:
public bool filesAreEqual(string outFile, string expFile)
{
var outFileBytes = File.ReadAllBytes(outFile);
var expFileBytes = File.ReadAllBytes(expFile);
return (outFileBytes.CalculateCRC16() == expFileBytes.CalculateCRC16());
}
Вы можете использовать встроенный класс System.Security.Cryptography.MD5, но вычисленный хэш является байтом [], поэтому вам все равно придется сравнивать эти два массива.
Я думаю, что я нашел синтаксически более чистый способ объявить эту инструкцию using, и, похоже, она работает для меня? использование var в качестве вашего типа в операторе using вместо IDisposable, как представляется, динамически выводит тип для обоих объектов и позволяет мне создавать экземпляры обоих моих объектов и вызывать их свойства и методы класса, которому они распределены, как в
< br/" > using(var uow = new UnitOfWorkType1(), uow2 = new UnitOfWorkType2()){}.
Если кто-нибудь знает, почему это неправильно, сообщите мне
Если вы можете подождать С# 8.0, вы можете использовать объявление об использовании.
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);
Это нормальный способ использования и работает идеально. Хотя есть и другие способы реализации этого. Почти каждый ответ уже присутствует в ответе на этот вопрос. Но здесь я перечисляю их все вместе.
Уже используется
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;
}
}
}
Вариант 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;
}
}
}
Вариант 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;
}
}