Calcul du crc32 a travers un system.io.stream

Commenter

Contenu du snippet

Le calcul du CRC32 est basé sur la source :
http://www.csharpfr.com/codes/CRC32-COMPATIBLE-WINRAR-WINZIP-BASE-SUR-CODE-CPLUSPLUS_29137.aspx

La seul différence est que dans cette class, j'implémente System.IO.Stream de sorte a connaitre soit
en fin de lecture ou écriture le CRC32 du stream de manière 'transparente'.

Exemple de fonctionnement :

// Lecture
CrcStream csRead = new CrcStream(new FileStream("C:\mon_fichier.xml", FileMode.Open, FileAccess.Read));
byte[] buf = new byte[cs.Length];
cs.Read(buf, 0, buf.Length);
csRead.Close();

// Ecriture
CrcStream csWrite = new CrcStream(new FileStream("C:\mon_fichier_backup.xml", FileMode.OpenOrCreate, FileAccess.Write));
csWrite.Write(buf, 0, buf.Length);
csWrite.Close();

// Vérif du crc
if (csRead.GetCRC32 == csWrite.GetCRC32)
// la copie s'est bien déroullé ^^
else
// Change ton disque dure ^^'

Dite moi ce que vous en pensez, pour la note, c'est inutile j'ai juste adapté, remerciez plutôt li9.

Voilà, voilà en espérant que ça vous plaise ^^

Source / Exemple : 


using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace CRC32
{
    class CrcStream : Stream
    {
        private Stream stream;

        #region Calcul du CRC32

        /**



        uint[] LookUpTable = new uint[ 256 ];
        uint poly = 0xEDB88320;
        uint crc32 = 0xFFFFFFFF;

        /*


             
  •  Génération de la table

    •          
  • /

        private void Init()
        {
            uint val;
            for (uint i = 0; i <= 0xFF; ++i)
            {
                val = i;
                for (int j = 8; j > 0; --j)
                {
                    //Capa6T , dans sa source faisait une comparaison booleene
                    // en calculant val & 1 qui donne 1 ou 0 donc true ou false en C++
                    //or en C# on ne peut plus utiliser 1 et 0 (ni -1 d ailleurs) pour faire une comparaison booleene
                    // ** c etait juste une petite note ^^ ** 
                    if ((val & 1) == 1)
                    {
                        val = (val >> 1) ^ poly; // <-- la j'ai un peu compresse l equation, mais ca passe hehe : )
                    }
                    else
                        val >>= 1;
                }
                LookUpTable[i] = val; // on stock le resultat dans notre table. 
            }
        }

        /*


             
  •  Génère le crc32 d'un tableau de byte utilisé avec la méthode Read et Write.

    •          
  • /

        private uint GetCRC32(byte[] b, int offset, int count)
        {
            for (int y = 0; y < count; y++)
            {
                crc32 = (crc32 >> 8) ^ LookUpTable[(crc32 & 0xFF) ^ b[offset + y]];
            }
            return crc32 ^ 0xFFFFFFFF;
        }

        /*


             
  •  Génère le crc32 d'un byte obtenue avec la méthode ReadByte et WriteByte.

    •          
  • /

        private uint GetCRC32(byte b)
        {
            crc32 = (crc32 >> 8) ^ LookUpTable[(crc32 & 0xFF) ^ b];
            return crc32 ^ 0xFFFFFFFF;
        }

        #endregion

        /// <summary>
        /// Retourne le CRC32 courant du stream.
        /// Pour une représentation textuelle, utilisé <c>ToString("X")</c>
        /// </summary>
        public UInt32 CRC32
        {
            get { return crc32; }
        }

        public CrcStream(Stream stream)
        {
            Init();
            this.stream = stream;
        }

        public override bool CanRead { get { return stream.CanRead; } }
        public override bool CanTimeout { get { return stream.CanTimeout; } }
        public override bool CanSeek { get { return stream.CanSeek; } }
        public override bool CanWrite { get { return stream.CanWrite; } }
        public override long Length { get { return stream.Length; } }

        public override long Position
        {
            get { return stream.Position; }
            set { stream.Position = value; }
        }

        public override void Flush()
        {
            stream.Flush();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            return stream.Seek(offset, origin);
        }

        public override void SetLength(long value)
        {
            stream.SetLength(value);
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            // On lit d'abord le buffer,
            // v correspond au nombre de byte lue.
            int v = stream.Read(buffer, offset, count);
            // notre buffer est remplis, on a le nombre de byte lue ( v ), on peut généré notre CRC32.
            GetCRC32(buffer, offset, v);
            return v;
        }

        public override int ReadByte()
        {
            int b = stream.ReadByte();
            GetCRC32((byte)b);
            return b;
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            stream.Write(buffer, offset, count);
            GetCRC32(buffer, offset, count);
        }

        public override void WriteByte(byte value)
        {
            stream.WriteByte(value);
            GetCRC32(value);
        }

        public override void Close()
        {
            stream.Close();
            base.Close();
        }

    }
}

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Vince_02)