Bináris fájlkezelés

A legegyszerűbb példa a Streamek és a bináris fájlkezelés bemutatására egy másoló program.

using System;
using System.IO;

namespace PeldaBinarisFajlkezeles
{
    class Program
    {
        private static void Masol(string forras, string cel)
        {
            try
            {
                using (FileStream src = File.OpenRead(forras))
                {
                    using (FileStream target = File.Create(cel))
                    {
                        byte[] buffer = new byte[32 * 1024];
                        int beolvasott = 0;
                        long atmasolt = 0;
                        do
                        {
                            beolvasott = src.Read(buffer, 0, buffer.Length);
                            target.Write(buffer, 0, beolvasott);
                            atmasolt += beolvasott;
                            Console.WriteLine("Kész: {0:P2} \r", (double)atmasolt / src.Length);
                        }
                        while (beolvasott > 0);

                    }
                }
            }
            catch (IOException ex)
            {
                Console.WriteLine(ex);
            }
        }

        static void Main(string[] args)
        {
            Console.Write("Forrás: ");
            string forras = Console.ReadLine();
            Console.Write("Cél: ");
            string cel = Console.ReadLine();
            Masol(forras, cel);

            Console.ReadKey();
        }
    }
}

A program egy lehetséges kimenete:

Forrás: c:

A példaprogramunk erősen épít a using blokkokra, amik automatikusan meghívják az IDisposable interfész Dispose metódusát, amint a vezérlés kilép az adott using blokkból, vagy ha a blokkon belül kivétel történt. Ez a programunkban garantálja, hogy csak addig maradnak használatban a fájlok, amíg kellenek. A másolás végeztével más programok is hozzájuk férhetnek, még akkor is, ha közben kivétel keletkezett.

Kivételkezelésünk csak az IOException típust kezeli le, mert a blokkban a legnagyobb valószínűséggel ez fog előfordulni.

A másolás egy do – while ciklussal van jelen esetben megoldva. A beolvasott változó értéke a beolvasott byte-ok számát fogja tatalmazni. Erre külön azért van szükség, mert a 32 KiB méretű buffer változó nem garantált, hogy tartalmazni is fog ennyi adatot. (Pl a fájl lehet eleve kisebb, mint 32 KiB vagy nem osztható pontosan 32 KiB mérettel. Ekkor biztos, hogy az utolsó blokk ennél kisebb lesz.) Ezért a target nevű változóba csak annyi byte-ot írunk ki a bufferből, amit ténylegesen be is olvastunk.

Az átmásolás közben % arányban megjelenítjük a felhasználónak, hogy mennyi adatot másoltunk át. Itt a kiírásnál a \r karakter használatával érjük el, hogy a program ne szemetelje tele a konzolt, mindig csak egy sorba írja ki az aktuális új állapotot.

A másolási ciklusnak akkor van vége, ha menet közben IOException keletkezett vagy a fájl végére értünk, mert 0 byte-ot sikerült beolvasni.