0

我想知道如何将文件读入 4 个字节长的 ByteArrays。这些数组将被操作，然后必须转换回准备写入文件的单个数组。

编辑： 代码片段。

    var arrays = new List<byte[]>();
    using (var f = new FileStream("file.cfg.dec", FileMode.Open))
    {
        for (int i = 0; i < f.Length; i += 4)
        {
            var b = new byte[4];
            var bytesRead = f.Read(b, i, 4);
            if (bytesRead < 4)
            {
                var b2 = new byte[bytesRead];
                Array.Copy(b, b2, bytesRead);
                arrays.Add(b2);
            }
            else if (bytesRead > 0)
                arrays.Add(b);
        }
    }

    foreach (var b in arrays)
    {
        BitArray source = new BitArray(b);
        BitArray target = new BitArray(source.Length);

        target[26] = source[0];
        target[31] = source[1];
        target[17] = source[2];
        target[10] = source[3];
        target[30] = source[4];
        target[16] = source[5];
        target[24] = source[6];
        target[2] = source[7];
        target[29] = source[8];
        target[8] = source[9];
        target[20] = source[10];
        target[15] = source[11];
        target[28] = source[12];
        target[11] = source[13];
        target[13] = source[14];
        target[4] = source[15];
        target[19] = source[16];
        target[23] = source[17];
        target[0] = source[18];
        target[12] = source[19];
        target[14] = source[20];
        target[27] = source[21];
        target[6] = source[22];
        target[18] = source[23];
        target[21] = source[24];
        target[3] = source[25];
        target[9] = source[26];
        target[7] = source[27];
        target[22] = source[28];
        target[1] = source[29];
        target[25] = source[30];
        target[5] = source[31];

        var back2byte = BitArrayToByteArray(target);

        arrays.Clear();
        arrays.Add(back2byte);
    }

    using (var f = new FileStream("file.cfg.enc", FileMode.Open))
    {
        foreach (var b in arrays)
            f.Write(b, 0, b.Length);
    }

编辑 2： 这是完成我想要的丑陋贝蒂的代码。现在我必须改进它的性能......

var arrays_ = new List<byte[]>();
var arrays_save = new List<byte[]>();
var arrays = new List<byte[]>();
using (var f = new FileStream("file.cfg.dec", FileMode.Open))
{
    for (int i = 0; i < f.Length; i += 4)
    {
        var b = new byte[4];
        var bytesRead = f.Read(b, 0, b.Length);
        if (bytesRead < 4)
        {
            var b2 = new byte[bytesRead];
            Array.Copy(b, b2, bytesRead);
            arrays.Add(b2);
        }
        else if (bytesRead > 0)
            arrays.Add(b);
    }
}

foreach (var b in arrays)
{
    arrays_.Add(b);
}
foreach (var b in arrays_)
{
    BitArray source = new BitArray(b);
    BitArray target = new BitArray(source.Length);

    target[26] = source[0];
    target[31] = source[1];
    target[17] = source[2];
    target[10] = source[3];
    target[30] = source[4];
    target[16] = source[5];
    target[24] = source[6];
    target[2] = source[7];
    target[29] = source[8];
    target[8] = source[9];
    target[20] = source[10];
    target[15] = source[11];
    target[28] = source[12];
    target[11] = source[13];
    target[13] = source[14];
    target[4] = source[15];
    target[19] = source[16];
    target[23] = source[17];
    target[0] = source[18];
    target[12] = source[19];
    target[14] = source[20];
    target[27] = source[21];
    target[6] = source[22];
    target[18] = source[23];
    target[21] = source[24];
    target[3] = source[25];
    target[9] = source[26];
    target[7] = source[27];
    target[22] = source[28];
    target[1] = source[29];
    target[25] = source[30];
    target[5] = source[31];

    var back2byte = BitArrayToByteArray(target);

    arrays_save.Add(back2byte);
}

using (var f = new FileStream("file.cfg.enc", FileMode.Open))
{
    foreach (var b in arrays_save)
        f.Write(b, 0, b.Length);
}

编辑 3： 将一个大文件加载到 4 个字节的字节数组中并不是最聪明的主意……我有超过 6800 万个数组正在处理和操作。我真的想知道是否可以将它加载到单个数组中并且仍然可以进行位操作。：/

4

4 回答 4

3

这是另一种方式，类似于@igofed 的解决方案：

var arrays = new List<byte[]>();
using (var f = new FileStream("test.txt", FileMode.Open))
{
    for (int i = 0; i < f.Length; i += 4)
    {
        var b = new byte[4];
        var bytesRead = f.Read(b, i, 4);
        if (bytesRead < 4)
        {
            var b2 = new byte[bytesRead];
            Array.Copy(b, b2, bytesRead);
            arrays.Add(b2);
        }
        else if (bytesRead > 0)
            arrays.Add(b);
    }
}
//make changes to arrays
using (var f = new FileStream("test-out.txt", FileMode.Create))
{
    foreach (var b in arrays)
        f.Write(b, 0, b.Length);
}
于 2012-05-04T16:55:48.377 回答
2

这是你想要的： 

using (var reader = new StreamReader("inputFileName"))
{
    using (var writer = new StreamWriter("outputFileName"))
    {
        char[] buff = new char[4];
        int readCount = 0;
        while((readCount = reader.Read(buff, 0, 4)) > 0)
        {
            //manipulations with buff

            writer.Write(buff);
        }
    }
}
于 2012-05-04T16:29:35.447 回答
2

关于您的“编辑 3”……我会咬一口，尽管这确实是对原始问题的转移。

没有理由需要数组列表，因为您只是将文件分解为 4 字节序列的连续列表，循环并处理每个序列，然后循环并写入每个序列。你可以做得更好。 注意：下面的实现不会检查或处理长度不完全是 4 的倍数的输入文件。如果它很重要，我把它留给你作为练习。

为了直接解决您的评论，这里是一个单阵列解决方案。我们将丢弃 List 对象，将整个文件读入一个 byte[] 数组，然后复制该数组的 4 字节部分来进行位转换，然后将结果放回去。最后，我们将把整个内容放入输出文件中。

byte[] data;
using (Stream fs = File.OpenRead("E:\\temp\\test.bmp")) {
    data = new byte[fs.Length];
    fs.Read(data, 0, data.Length);
}

byte[] element = new byte[4];
for (int i = 0; i < data.Length; i += 4) {
    Array.Copy(data, i, element, 0, element.Length);

    BitArray source = new BitArray(element);
    BitArray target = new BitArray(source.Length);

    target[26] = source[0];
    target[31] = source[1];
    // ...
    target[5] = source[31];

    target.CopyTo(data, i);
}

using (Stream fs = File.OpenWrite("E:\\temp\\test_out.bmp")) {
    fs.Write(data, 0, data.Length);
}

所有丑陋的初始读取代码都消失了，因为我们只使用了一个单字节数组。请注意，我在处理循环之前保留了一个 4 字节数组以供重复使用，因此我们可以为垃圾收集器节省一些工作。然后我们一次遍历 4 个字节的巨型数据数组并将它们复制到我们的工作数组中，使用它来初始化 BitArrays 以进行转换，然后块中的最后一条语句将 BitArray 转换回字节数组，并复制它直接回到了它在巨大数据阵列中的原始位置。这将替换BitArrayToByteArray方法，因为您没有提供它。最后，写入也很容易，因为它只是猛击现在转换的巨型数据阵列。

当我运行您的原始解决方案时，我的 100MB 原始测试文件出现 OutOfMemory 异常，因此我使用了 44MB 文件。它消耗了 650MB 的内存并在 30 秒内运行。单阵列解决方案使用 54MB 内存，运行时间为 10 秒。不错的改进，它展示了持有数百万个小数组对象是多么糟糕。

于 2012-05-06T03:08:51.930 回答
2 
IEnumerable<byte[]> arraysOf4Bytes = File
    .ReadAllBytes(path)
    .Select((b,i) => new{b, i})
    .GroupBy(x => x.i / 4)
    .Select(g => g.Select(x => x.b).ToArray())
于 2012-05-04T16:31:28.513 回答