CALCUL DU CRC32 A TRAVERS UN SYSTEM.IO.STREAM

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

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

        #region Calcul du CRC32

        /**
         * Calcul du CRC32 basé sur le code :
         * http://www.csharpfr.com/codes/CRC32-COMPATIBLE-WINRAR-WINZIP-BASE-SUR-CODE-CPLUSPLUS_29137.aspx
         * 
         * Pour un CRC32 exact du fichier, utilisez votre stream soit en Lecture, soit en Ecriture, mais pas les deux.
         * Le CRC32 sera incorrect si vous utilisez votre Stream en Lecture/Ecriture.
         **/ 

        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();
        }

    }
}