C#で動的な１次元配列を確保する際のロジックについて

Question

C#でのメモリ管理について質問です。(もしかしたらメモリ関係ないかもしれませんが...)

今制作しているプログラムで、
while(true)のように永続的なループにおいて、各ループ毎に異なるサイズ(要素数)の１次元配列を確保(生成)する
というロジックがあります。
その際いくつかロジックとして候補がでたのですが、メモリ管理の観点からどれがいいのか悩んでいます。

具体的には以下のようなコードです。恐らくコード上ではしていることは変わらないと思います。

//パターン１
            Random random = new Random();
            byte[] byteArray = null;

            while (true)
            {
                int index = random.Next(1024);

                byteArray = new byte[index];
                for (int count = 0; count < index; count++)
                {
                    byteArray[count] = 0x01;
                }
                //byteArrayを使って関数を実行

                if (index == 0)
                {
                    break;
                }
            }

//パターン２
            Random random = new Random();
            byte[] byteArray2 = new byte[1024];

            while (true)
            {
                int index = random.Next(1024);

                Array.Resize(ref byteArray2, index);
                for (int count = 0; count < index; count++)
                {
                    byteArray2[count] = 0x01;
                }

                //byteArray2を使って関数を実行

                Array.Clear(byteArray2, 0, byteArray2.Length);

                if (index == 0)
                {
                    break;
                }
            }

//パターン３
            Random random = new Random();
            List<byte> list = new List<byte>();

            while (true)
            {
                int index = random.Next(1024);

                for (int count = 0; count < index; count++)
                {
                    list.Add(0x01);
                }

                //list.ToArray()として関数を実行

                list.Clear();

                if (index == 0)
                {
                    break;
                }
            }

上記の３パターンはこの質問用に組んだコードですが、実際のロジックと変わらない点としては

・配列は1024サイズより上回ることはないが、各ループでサイズは異なる
・コメントアウトで実行する関数に引数として配列が渡されるが、その際初期値の0x00は除かなければならない(※)
・配列はbyteの１次元配列に限定する(※)
・ループを何回繰り返すかわからない上、上記１・２点の理由から、while(true)前に予め配列を確保することはできない

上記の４点です。

このような場合、パターン１～３の中ではメモリ管理の観点としてどれが優れているのでしょうか？

実行速度などもできれば伺いたいのですがまだ自分で試しておらず、自分で確認すべきだと思っていますので、
他の方法も含めてもしご助言いただけますと幸いです。
(C#およびプログラミングを始めて半年と少ししか経っていない初学者ですので、至らぬ点がありましたら申し訳ありません。)

追記(実際にやりたいこと)

実際に制作しているプログラムのロジック(ほぼそのまま)を掲載します。
要件としては

・1024バイト毎にファイルの中身を読みとる
・改行コードが見つかったら、もしくはファイルの最後まで読んだら外部関数を実行
・改行コードがあるまでは外部関数は実行しないが、改行コードまでが1MB以上だった場合はエラーとする(未記載)

以上になります。
上記３点および前述の(※)については要件として変えられないので、「1024バイトごとではなく一気にファイルを読めばいい」「ReadLineを使って」等は実装として不可能です。

            string filePath = "任意のテキストファイルのフルパス";
            byte[] readdata = new byte[1024];
            byte[] buffer = new byte[1048576];  //1MB
            int index = 0;

            FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);

            while (true)
            {
                int readByte = fileStream.Read(readdata, 0, 1024);

                if (readByte == 0)
                {
                    Array.Resize(ref buffer, index + 1);
                    //外部関数 0x00を除いたbyte配列を引数に指定しなければならない
                    break;   //ファイルを全て読んだことになるのでwhile(true)から抜ける
                }

                foreach (byte byte1 in readdata)
                {
                    if (byte1 == 0x00)
                    {
                        break;
                    }

                    if (byte1 == 0x0a)
                    {
                        buffer[index] = byte1;

                        if (buffer[index - 1] == 0x0d)
                        {
                            Array.Resize(ref buffer, index + 1);
                            //外部関数 0x00を除いたbyte配列を引数に指定しなければならない
                            index = 0;
                            Array.Clear(buffer, 0, buffer.Length);
                            Array.Resize(ref buffer, 1048576);
                            continue;
                        }

                        index++;
                    }

                    buffer[index++] = byte1;
                }
            }

「Array関数を多用している箇所はインスタンス生成やListでどうにかならないかな？その場合どちらを使う方がいいんだろう？」と思い質問させていただいた次第であります。
ご助言いただけますと幸いです...！

Comments

[papinianus]

どれも気にするほどかわらないと思うのですが、本当は配列に入れるデータは固定ではないのですよね？それってどういう型のデータでどういうところから取得できるのですか？

[siksmtt]

papinianus 様　閲覧いただきありがとうございます。本来は固定ではなく、バイト型のデータを通信パケット等から取得するプログラムになります。

[Zuishin]

そもそも新しい配列を確保しなくてはなりませんか？ 配列を初期化するのに使っているデータをどうやって取得しているかによって、もしかしたらもっと効率のいいやり方があるかもしれません。

[siksmtt]

Zuishin 様　閲覧いただきありがとうございます。配列は確保しないとどうにもなりません。というのも任意のファイルの中身を1024バイト毎に読み、改行コードがある度に文字列検索を行うプログラムを作っております。要件や仕様などを言葉で説明すると長くなるのでお昼頃までにロジックを質問文の方に載せたいと思います。

[Zuishin]

1024 と １MB は hihijiji さんの仰る通り固定でいいと思います。呼び出し用の引数はその都度確保しなくてはならないかもしれませんが、もし呼び出されるメソッドを書き換えていいのであれば、これもサイズを引数として加えればバッファを使いまわせると思います。非同期でないので。

[siksmtt]

ZUishin 様　ご助言いただきありがとうございます。やはり引数に指定できることが最善になりますよね。その点についても検討しようと思います...。

Answer 1

問題なのは最大1MBになる「外部関数」とやらに食わせる配列の側，ということでしょうか．

外部関数の側の引数が
ExternalFunc( byte[] Data )
みたいな形になっていて，Data内の有効な区間を指定する引数のようなものが存在せず，そのことは変えられない，と．
であれば，外部関数を呼び出す毎にその引数に渡すための配列を新たに生成することは避けられないように思われます．

ファイルから１度に何byte読もうが，そんなこととは無関係に結局最大1MBになるかもしれないのですから，

1. 1MBサイズのバッファAを用意してファイルから1024byte読み出した内容を追加していく(FileStream.Readには格納箇所を指定するoffset引数があるからそれを使えばよいかと)
2. 条件を満たした時点で，外部関数に渡すための配列Bを必要サイズで新規に生成し，Aから必要なサイズ分のデータをコピーして，外部関数に渡す

という形でしょうか．

Comments

[siksmtt]

実際のロジックでは外部関数に食わせる配列の方の問題になります。

やはりそのようになってしまいますよね。
「新規に生成し、Aから必要なサイズ文のデータをコピーして」というコメントについてですが、new byte[] で適したサイズの配列を生成してArray.Copyを使う、という認識で合っていますでしょうか？

[fana]

そういうことになると思います．

Listを使ったところで，「配列」を要求する外部関数の仕様がある以上，最後はToArray()で配列メモリ確保と内容コピーをすることは変わらないでしょうから，特別利点があるとは思えませんし．

[siksmtt]

やはりToArrayは内容をコピーするような動きになるのですね...。
非常に参考になりました、ありがとうございます！

Answer 2

パターン２のArray.Resizeメソッドは新たにヒープ領域を確保したうえで、元の配列から要素がコピーされますから問題外です。
ワークエリアとして使う場合は、領域確保は1回だけにするのが最も効率がいいです。

            //パターン4
            Random random = new Random();
            byte[] byteArray = new byte[1024];

            while (true)
            {
                int index = random.Next(1024);

                for (int count = 0; count < index; count++)
                {
                    byteArray[count] = 0x01;
                }
                //byteArrayを使って関数を実行

                if (index == 0)
                {
                    break;
                }
            }

Comments

[siksmtt]

hihijiji 様
ご回答ありがとうございます。
なるほど、Resizeに関してはコピーなどを使うのかなと薄々考えていたのですが、ヒープ領域を確保するのですね。

hihijiji様にご提示いただいた案ですが、もし仮にindexが1024以下だった場合、初期値の0x00が1024-index分残っていると思います。
コメントアウト時の関数で0x00は除いた形にしたいのですが、そうなると領域確保の回数を考慮してListにしたほうがいいのでしょうか？

[hihijiji]

List<T>も中身は配列と同じでシーケンシャルなヒープ領域が必要なのです。
ですからAddメソッドの中では領域確保に勤しんでいると予想されます。
外部関数の引数で位置指定が出来ないなら、パターン1ですね。
PS.縮めるだけならResizeでもうまい事してくれるかもしれません。

[hihijiji]

パターン1の場合、byteArrayはループの中で宣言と同時に初期化してください。

[siksmtt]

hihijiji 様
ご回答、ご助言ありがとうございます。
残念ながら外部関数の仕様(引数の型や引数の数など)がすでにほぼ決まっており、それに沿う必要がありますので、パターン１で組んでみたいと思います。(不思議な組み方と思われるのは承知しておりますが...泣)

参考になりました、先日に引き続きありがとうございます！
ベストアンサーについてはまだ他の方の回答を待ちたいと思います。

Answer 3

hihijijiさんとのやりとりをみていると、
ListのCapacityを指定すればいいんじゃない？とか思った。

https://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,aa9d469618cd43b0,references

List<T>のソース読むと、初期値は４で、倍々＋１で増えていく。
１０２４までには、領域確保は数回発生する。

予め、量がわかっているなら、もうちょっと大きい数でいいはず。

Comments

[siksmtt]

kiichi54321 様
ご回答ありがとうございます。
Listのcapacityは初めて目にしたので調べてのですが、
つまり最初に1024を指定したあと、外部関数の前でTrimExcessを使えばいい、ということでよろしいでしょうか？

そういうことでしたら使えるかもしれないです、後で試してみようと思います！

[kiichi54321]

1024じゃなくても、５１２、２５６あたりで指定しておけば、領域拡張の回数が抑制される。ということです。
そうすれば、過剰に確保するという問題は解決される。

[siksmtt]

なるほど、ご指摘ありがとうございます。
検討してみようと思います！

Answer 4

ご回答、ご助言いただいた皆様ありがとうございました。
どのお方のコメントも知らないことばかりで非常に参考になりました！

ベストアンサーについてはとても悩みましたが１番始めにご回答いただいたhihijiji様にさせていただきました。ありがとうございました。