Comment écrire des super-rapide de fichiers de streaming de code en C#?

Je ne crois pas qu'il y ait quelque chose à l'intérieur .NET pour permettre la copie d'une section d'un fichier sans mise en mémoire tampon en mémoire. Cependant, il me semble que c'est inefficace de toute façon, comme il a besoin pour ouvrir le fichier d'entrée et de chercher de nombreuses fois. Si vous êtes juste de scinder le fichier, pourquoi ne pas ouvrir le fichier d'entrée une fois, et puis il suffit d'écrire quelque chose comme:

public static void CopySection(Stream input, string targetFile, int length)
{
    byte[] buffer = new byte[8192];

    using (Stream output = File.OpenWrite(targetFile))
    {
        int bytesRead = 1;
        //This will finish silently if we couldn't read "length" bytes.
        //An alternative would be to throw an exception
        while (length > 0 && bytesRead > 0)
        {
            bytesRead = input.Read(buffer, 0, Math.Min(length, buffer.Length));
            output.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
    }
}

Cela a un mineur de l'inefficacité dans la création d'un tampon à chaque invocation - vous pouvez créer le tampon une fois et le passer dans la méthode ainsi:

public static void CopySection(Stream input, string targetFile,
                               int length, byte[] buffer)
{
    using (Stream output = File.OpenWrite(targetFile))
    {
        int bytesRead = 1;
        //This will finish silently if we couldn't read "length" bytes.
        //An alternative would be to throw an exception
        while (length > 0 && bytesRead > 0)
        {
            bytesRead = input.Read(buffer, 0, Math.Min(length, buffer.Length));
            output.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
    }
}

Noter que cette ferme également le flux de sortie (en raison de l'utilisation de déclaration) que votre code d'origine n'a pas.

Le point important est que cela permettra d'utiliser le système d'exploitation du fichier de mise en mémoire tampon de manière plus efficace, parce que vous réutilisez le même flux d'entrée, au lieu de rouvrir le fichier au début et puis en cherchant.

Je pense il va être beaucoup plus rapide, mais évidemment, vous aurez besoin de l'essayer pour voir...

Cela suppose contiguë morceaux, bien sûr. Si vous avez besoin d'ignorer les bits du fichier, vous pouvez le faire à partir de l'extérieur de la méthode. Aussi, si vous écrivez des fichiers de très petite taille, vous pouvez optimiser pour que la situation de trop - la meilleure façon de le faire serait probablement à introduire un BufferedStream enveloppant le flux d'entrée.

Quelle est la taille de length? Vous pouvez faire mieux ré-utiliser un fixe de taille moyenne (d'assez grande taille, mais pas obscène) de la mémoire tampon, et d'oublier BinaryReader... il suffit d'utiliser Stream.Read et Stream.Write.

(edit) quelque chose comme:

private static void copy(string srcFile, string dstFile, int offset,
     int length, byte[] buffer)
{
    using(Stream inStream = File.OpenRead(srcFile))
    using (Stream outStream = File.OpenWrite(dstFile))
    {
        inStream.Seek(offset, SeekOrigin.Begin);
        int bufferLength = buffer.Length, bytesRead;
        while (length > bufferLength &&
            (bytesRead = inStream.Read(buffer, 0, bufferLength)) > 0)
        {
            outStream.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
        while (length > 0 &&
            (bytesRead = inStream.Read(buffer, 0, length)) > 0)
        {
            outStream.Write(buffer, 0, bytesRead);
            length -= bytesRead;
        }
    }        
}

Avez-vous considéré l'utilisation de la CCR depuis que vous êtes à l'écriture dans des fichiers séparés, vous pouvez tout faire en parallèle (lecture et écriture) et la CCR, il est très facile à faire.

static void Main(string[] args)
    {
        Dispatcher dp = new Dispatcher();
        DispatcherQueue dq = new DispatcherQueue("DQ", dp);

        Port<long> offsetPort = new Port<long>();

        Arbiter.Activate(dq, Arbiter.Receive<long>(true, offsetPort,
            new Handler<long>(Split)));

        FileStream fs = File.Open(file_path, FileMode.Open);
        long size = fs.Length;
        fs.Dispose();

        for (long i = 0; i < size; i += split_size)
        {
            offsetPort.Post(i);
        }
    }

    private static void Split(long offset)
    {
        FileStream reader = new FileStream(file_path, FileMode.Open, 
            FileAccess.Read);
        reader.Seek(offset, SeekOrigin.Begin);
        long toRead = 0;
        if (offset + split_size <= reader.Length)
            toRead = split_size;
        else
            toRead = reader.Length - offset;

        byte[] buff = new byte[toRead];
        reader.Read(buff, 0, (int)toRead);
        reader.Dispose();
        File.WriteAllBytes("c:\\out" + offset + ".txt", buff);
    }

Ce code des postes de compensations pour un port CCR qui provoque un Thread à être créé pour exécuter le code dans la méthode de Fractionnement. Ce qui vous fait ouvrir le fichier plusieurs fois, mais se débarrasser de la nécessité pour la synchronisation. Vous pouvez la rendre plus efficace en terme de mémoire, mais vous aurez à sacrifier la vitesse.

À l'aide de FileStream + StreamWriter je sais que c'est possible de créer des fichiers en peu de temps (moins de 1 min 30 secondes). J'ai créer trois fichiers totalisant plus de 700 méga-octets d'un fichier à l'aide de cette technique.

Votre principal problème avec le code que vous utilisez est que vous ouvrez un fichier à chaque fois. C'est la création d'un fichier I/O frais généraux.

Si vous connaissait les noms des fichiers que vous serait de générer à l'avance, vous pouvez extraire le Fichier.OpenWrite dans une méthode distincte; il va augmenter la vitesse. Sans voir le code qui détermine la façon dont vous êtes fractionner les fichiers, je ne pense pas que vous pouvez obtenir beaucoup plus rapide.

(Pour référence future.)

Peut-être la façon la plus rapide de le faire serait d'utiliser les fichiers mappés en mémoire (principalement de la copie de la mémoire et de l'OS de la manipulation du fichier de lit/écrit par l'intermédiaire de sa pagination/gestion de la mémoire).

Les fichiers Mappés en mémoire sont pris en charge dans du code managé dans .NET 4.0.

Mais comme indiqué, vous avez besoin de profil et attendre pour passer en code natif pour des performances maximales.