C#でByte配列を特定のByte数ごとに切り出してBigIntegerに変換した後、Byte配列を復元したいが、なぜか最後の277Byteだけ値が変わってしまう

Question

実現したいこと

好きな長さのByte配列
↓
256byteずつ切り出してそれぞれBigIntegerに変換しBigIntegerの配列を作成
↓
BigIntegerの配列から元のByte配列を復元

発生している問題

C#のコンソールアプリケーションを作っています。
上記のことを実装中に、ほとんどはうまく変換、逆変換されもとのByte配列に戻ってくれるのですが、最後の277Byteのみなぜか全く違う値になってしまいます。
色々考えてみたのですが原因を見つけられません。
Byte配列→BigInteger配列の変換、BigInteger配列→Byte配列の変換のソースコードは以下の通りです。
（あまり質問したことがないためわかりづらい部分等あったら申し訳ありません。。。）

該当のソースコード

変数名	説明
byArray(byte配列)	与えられるByte配列
bintArray（BigInteger配列）	Byte配列から変換してできるBigInteger配列
nowbyArray（byte配列）	切り出したByte配列
C(int)	切り出す値の長さ、今回は256

//バイナリ配列→BigInteger配列変換
        public static BigInteger[] by2bint(byte[] byArray) 
        {
            int C = ２５６;

            BigInteger[] bintArray = new BigInteger[0];
            for(int i=0; i<(double)byArray.Length/C; i++) 
            {
                byte[] nowbyArray;
               //ｂｙArrayから２５６ずつ切り出していくと最後に256以下のByteが余るので、その時だけ切り出すByte数を調節しています
                if (byArray.Length < (i + 1) * C)
                {
                    nowbyArray = new byte[byArray.Length - i * C];
                    Array.Copy(byArray, i * C, nowbyArray, 0, nowbyArray.Length)
                }
                else
                {
                    nowbyArray = new byte[C];
                    Array.Copy(byArray, i * C, nowbyArray, 0, C);
                }

                Array.Resize(ref bintArray, bintArray.Length + 1);
                bintArray[i] = new BigInteger(nowbyArray, true, true);
            }


            return bintArray;
        }


        //BigInteger配列→バイナリ配列変換
        public static byte[] bint2by(BigInteger[] bintArray) 
        {
            int C = 256;

            byte[] byArray = new byte[0];
            byte[] nowbyArray;
            int x = 0;
            foreach(BigInteger bint in bintArray) 
            {
                nowbyArray = bint.ToByteArray(true, true);

                int l = byArray.Length;//この時点でのbyArrayの長さを保存して、byArrayの要素数を増やした部分に書き込めるようにしています

                Array.Resize(ref byArray, byArray.Length + nowbyArray.Length);
                Array.Copy(nowbyArray, 0, byArray, l, nowbyArray.Length);
                x++;
            }

            return byArray;
        }

補足情報（FW/ツールのバージョンなど）

.net core 3.1で、System.Numericsを使用しています。

Comments

[退会済みユーザー]

> int C = ２５６;

これは何ですか？　その先もそういう調子ではないかと思ってしまいます・・・

[poekura]

最初に今回切り出すbyte配列の要素数を指定しています（今回であれば256です）
また、変数の表に表記ミスがあったため修正しました

[ozwk]

> 最後の277Byte

277byte より少ない入力はどうなりますか？

[退会済みユーザー]

何で 256 でなくて ２５６ なのですか？

[otn]

> これは何ですか？　その先もそういう調子ではないかと思ってしまいます・・・
コメントの意味が伝わってないようなので、横から解説すると、
「半角文字と全角文字の違いに無頓着な人の書いたコードは最初から信用できない」
という意味でしょう。

質問文のコードは手入力じゃなくてコピペしましょう。

[Zuishin]

超絶テクニックが色々使われているので読むのに苦労します。
もっと普通に組めば別の結果が得られるかもしれません。
まず int を double にして int と比較しているところから脳が拒否反応を示し始めます。

[poekura]

>コメントの意味が伝わってないようなので（略）
あーすいません、その部分、実は元は違う表記だったのですがそうするより普通に書いたほうがいいということをこちらにコピペした後で気づいて書き換えたんですよね。今使っているフォントが全角数字と半角数字を全く同じように表示してしまうので気が付きませんでした。

>超絶テクニックが（略）
完全に独学なもので、なにが普通かわからないんですよね
int を doubleにして intと比較、というのもこれ以外にいい方法を思いつかなかったんです。(割り算の答えを小数にしたかっただけなのですが）

[poekura]

>277byte より少ない入力はどうなりますか？
確認したところ、全体が全く違う値になっていました

[Zuishin]

byArray.Length が 384 だった場合、384 / 256 = 1.5 です。
i < 1.5 の間ループするということは、i は 0 か 1 の二つの値を取り、二回ループします。
i が 1 の場合、byArray.Length - i * C は 384 - 256 = 128 になります。
一回目のループで 0 から 255 までのデータを使っているので、二回目のループで 128 からのデータを使うと重複します。
一方、復元の方は重複を考慮に入れていません。

[YAmaGNZ]

これ復元できるのですか？
Byte[] a ＝ {0,1}
これすら復元できないのでは？

[otn]

> こちらにコピペした後で気づいて書き換えたんですよね。
正しいやり方は、元プログラムの方を 256 に書き直した上で、再度実行して同じ結果になることを確認した上で、元プログラムを改変せずコピペです。
まあ、ちゃんとコピペしてない質問者は多数いるし、半角でキーインしていれば、誰も改変に気づかなかった所なので、別にこのままで良いですけど。

[Zuishin]

嘘を書きました。
私の書いたのは読み間違えなので無視してください。

[poekura]

>>Zuishin
byArray.Length - i * C はあくまでコピーする数を扱っています。
実際には下の行のArray.CopyでbyArrayの i * C 個目からの部分を nowbyArrayの0個目からの部分へbyArray.Length - i * C (= nowbyArray.Length)個コピーしているので重複は起こらないかと。

byArray.Length が 384 だった場合でいうと、一回目(i = 0)はbyArrayの 0 * C = 0個目から256個nowbyArrayにコピーして、二回目(i = 1)はbyArrayの 1 * C = 256個目からbyArray.Length - i * C、つまり384 - 256 = 128個nowbyArrayへコピーします。

[poekura]

>>Zuishin
ああ、ちょうどすれ違いになってしまったみたいですね。わかりました。

[Zuishin]

とにかく 256 づつに区切ることができればいいのであれば、Chunk を使い、Select で BigInteger に変換し、ToArray すると見通しよくなります。
.NET Core 3.1 だと Chunk はないので、InteractiveExtensions を導入して Buffer を使うか、自作します。
すると条件分岐も無くなり、by2bint が一行に収まります。

あるいは for を for (i = 0; i < byArray.Length; i += C) のようにし、List<BigInteger> に Add する形にすると見やすくなります。
これは Math.Min を使えば条件分岐不要です。
戻り値が配列でないといけないのであれば、最後に ToArray で配列にできます。

あるいは Span<T> を使い、256 毎に Slice すれば、ややこしい計算も条件分岐も排除できます。

Answer 1

YAmaGNZさんも指摘されていますが、頭にゼロが来ていませんか？
前後で配列サイズはあっていますか？

使用できる最も少ないバイト数を使用して、この BigInteger の値をバイト配列として返します。

BigInteger.ToByteArray メソッド (System.Numerics) | Microsoft Learn

先頭ゼロさえ来なければあってそうな気もしますが、そうでもないなら再現する（短めの）データが欲しいですね^^;

.NET Core3.1は既にサポート切れですので、.NET7を（C#8.0に落として）使用しました^^
.NET および .NET Core オフィシャル サポート ポリシー

using System;
using System.Linq;
using System.Numerics;


namespace Qrxl0vycu5kh9f9
{
    class Program
    {
        static void Main()
        {
            {
                // ゼロから始まると短くなってしまう
                var a = new byte[] { 0, 1, 2, 3 };
                var b = new BigInteger(a, true, true);
                var c = b.ToByteArray(true, true);
                Console.WriteLine(string.Join(", ", c)); // 1, 2, 3
            }


            {
                // チャンク先頭にゼロが来るので3byte減った
                var a = Enumerable.Range(0, 533).Select(i => (byte)(i % 256)).ToArray();
                var b = bint2by(by2bint(a));
                Print(a, b); // a.Length:533 b.Length:530 SequenceEqual:False
            }
            {
                // 1個目チャンクの先頭ゼロで1byte減った
                var a = Enumerable.Range(0, 533).Select(i => (byte)(i % 200)).ToArray();
                var b = bint2by(by2bint(a));
                Print(a, b); // a.Length:533 b.Length:532 SequenceEqual:False
            }
            {
                // チャンク先頭にゼロが来なければあってそう？
                var a = Enumerable.Range(1, 533).Select(i => (byte)(i % 256)).ToArray();
                var b = bint2by(by2bint(a));
                Print(a, b); // a.Length:533 b.Length:533 SequenceEqual:True
            }


            try
            {
                // 最終チャンクに先頭ゼロが来ると（トータルサイズを知らないと）戻しようがない
                var a = Enumerable.Range(0, 533).Select(i => (byte)(i % 256)).ToArray();
                var b = BigIntArray2ByteArray(ByteArray2BigIntArray(a));
                Print(a, b);
            }
            catch (Exception e)
            {
                Console.WriteLine($"{e.Message}\n"); // 復元不可能なsourceです
            }
            {
                // 最終チャンク以外の先頭ゼロは分割サイズを知っていれば戻せるが...
                var a = Enumerable.Range(0, 533).Select(i => (byte)(i % 200)).ToArray();
                var b = BigIntArray2ByteArray(ByteArray2BigIntArray(a));
                Print(a, b); // a.Length:533 b.Length:533 SequenceEqual:True
            }
            {
                var a = Enumerable.Range(1, 533).Select(i => (byte)(i % 256)).ToArray();
                var b = BigIntArray2ByteArray(ByteArray2BigIntArray(a));
                Print(a, b); // a.Length:533 b.Length:533 SequenceEqual:True
            }
        }

        static BigInteger[] by2bint(byte[] byArray)
        {
            var C = 256;
            var bintArray = new BigInteger[0];

            for (var i = 0; i < (double)byArray.Length / C; i++)
            {
                byte[] nowbyArray;
                if (byArray.Length < (i + 1) * C)
                {
                    nowbyArray = new byte[byArray.Length - i * C];
                    Array.Copy(byArray, i * C, nowbyArray, 0, nowbyArray.Length);
                }
                else
                {
                    nowbyArray = new byte[C];
                    Array.Copy(byArray, i * C, nowbyArray, 0, C);
                }

                Array.Resize(ref bintArray, bintArray.Length + 1);
                bintArray[i] = new BigInteger(nowbyArray, true, true);
            }

            return bintArray;
        }
        static byte[] bint2by(BigInteger[] bintArray)
        {
            var byArray = new byte[0];
            foreach (var bint in bintArray)
            {
                var nowbyArray = bint.ToByteArray(true, true);
                var l = byArray.Length;

                Array.Resize(ref byArray, byArray.Length + nowbyArray.Length);
                Array.Copy(nowbyArray, 0, byArray, l, nowbyArray.Length);
            }

            return byArray;
        }



        static BigInteger[] ByteArray2BigIntArray(byte[] source, int size = 256)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));
            if (size < 1) throw new ArgumentOutOfRangeException(nameof(size));

            if (source.Length == 0) return Array.Empty<BigInteger>();


            var dest = new BigInteger[(source.Length + size - 1) / size];

            var span = source.AsSpan();
            for (var i = 0; i < dest.Length - 1; i++)
            {
                dest[i] = new BigInteger(span[..size], true, true);
                span = span[size..];
            }

            if (span[0] == 0) throw new ArgumentException("復元不可能なsourceです");

            dest[^1] = new BigInteger(span, true, true);

            return dest;


            // 先頭ゼロを無条件で弾いていいなら戻すのも楽なのだが...
            //return source.Chunk(size).Select(x =>
            //{
            //    if (x[0] == 0) throw new ArgumentException("チャンク先頭がゼロです");
            //    return new BigInteger(x, true, true);
            //}).ToArray();
        }
        static byte[] BigIntArray2ByteArray(BigInteger[] source, int size = 256)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));
            if (size < 1) throw new ArgumentOutOfRangeException(nameof(size));

            if (source.Length == 0) return Array.Empty<byte>();


            var dest = new byte[source.Length * size];
            var length = 0;
            for (var i = 0; i < source.Length; i++)
            {
                var array = source[i].ToByteArray(true, true);
                if (size < array.Length) throw new ArgumentException("sourceがsizeより大きいです");

                if (i < source.Length - 1)
                {
                    Array.Copy(array, 0, dest, length + size - array.Length, array.Length);
                    length += size;
                }
                else
                {
                    Array.Copy(array, 0, dest, length, array.Length);
                    length += array.Length;
                }
            }
            Array.Resize(ref dest, length);

            return dest;


            // 先頭ゼロがないのであれば1行なのだが...
            //return source.SelectMany(x => x.ToByteArray(true, true)).ToArray();
        }


        static void Print(byte[] a, byte[] b)
           => Console.WriteLine($"a.Length:{a.Length} b.Length:{b.Length} SequenceEqual:{a.SequenceEqual(b)}\n");
    }
}