private SynchronizingFileStream(ITransactionalStorage transactionalStorage, string fileName,
										StorageStreamAccess storageStreamAccess, NameValueCollection metadata,
										IndexStorage indexStorage, StorageOperationsTask operations)
			: base(transactionalStorage, fileName, storageStreamAccess, metadata, indexStorage, operations)
		{
			md5Hasher = new MD5CryptoServiceProvider();
		}

 public Program()
 {
     md5Hasher = MD5.Create();
     InitializeComponent();
     folderSelector = new FolderBrowserDialog ();
     //Could help improve time from open to use?  Nah.
     //folderSelector.RootFolder = Environment.CurrentDirectory;
 }

 public override void AppendData(byte[] data, int offset, int count)
 {
     if (_md5 == null)
     {
         _md5 = MD5.Create();
     }
     _md5.TransformBlock(data, offset, count, null, 0);
 }

		public HMACSSLv3Verify(byte[] key)
		{
			this.HashSizeValue = 288;
			this.KeyValue = (byte[]) key.Clone();
			
			_md5 = new MD5CryptoServiceProvider();
			_sha1 = new SHA1CryptoServiceProvider();
		}

 public WriterWorkItem(FileStream stream, BinaryWriter writer, MD5 md5)
 {
     Stream = stream;
     Writer = writer;
     Buffer = new MemoryStream(2048);
     BufferWriter = new BinaryWriter(Buffer);
     MD5 = md5;
 }

 public WriterWorkItem(FileStream fileStream, UnmanagedMemoryStream memStream, MD5 md5)
 {
     _fileStream = fileStream;
     _memStream = memStream;
     _workingStream = (Stream)fileStream ?? memStream;
     Buffer = new MemoryStream(8192);
     BufferWriter = new BinaryWriter(Buffer);
     MD5 = md5;
 }

		/// <summary>
		/// Rfc 2104.
		/// </summary>
		/// <param name="rgbKey"></param>
		public HMACMD5 (byte[] rgbKey) 
		{
			HashSizeValue = 128;
			// Create the hash algorithms.
			hash1 = MD5.Create();
			hash2 = MD5.Create();

			this.Key = rgbKey;
		}    

        /// <summary>
        /// Frees an object for generating the hashes that was acquired from <see cref="GetHasher"/>,
        /// adding it back to the pool for later reuse.
        /// </summary>
        /// <param name="hasher">The object to free.</param>
        static void FreeHasher(MD5 hasher)
        {
            lock (_hashersSync)
            {
                if (log.IsDebugEnabled)
                    log.DebugFormat("Freeing hasher [object hash: {0}].", hasher.GetHashCode());

                _hashers.Push(hasher);
            }
        }

        public static byte[] CreateMD5Checksum(this Stream stream, bool startAtBeginning = true, MD5 md5 = null)
        {
            if (md5 == null)
                md5 = MD5.Create();

            if (startAtBeginning)
                stream.Seek(0, SeekOrigin.Begin);

            return md5.ComputeHash(stream);
        }

		public void FixtureSetUp () 
		{
			Assembly a = Assembly.GetExecutingAssembly ();
			hashEvidence = new Hash (a);

			md5 = MD5.Create ();
			digestMd5 = hashEvidence.GenerateHash (md5);

			sha1 = SHA1.Create ();
			digestSha1 = hashEvidence.GenerateHash (sha1);
		}

 public override byte[] GetHashAndReset()
 {
     if (_md5 == null)
     {
         _md5 = MD5.Create();
     }
     _md5.TransformFinalBlock(__emptyByteArray, 0, 0);
     var hash = _md5.Hash;
     _md5.Dispose();
     _md5 = null;
     return hash;
 }

 public static string GetMD5Hash(FileInfo fileInfo)
 {
     if(MD5Crypto == null)
     {
         MD5Crypto = MD5.Create();
     }
     using (FileStream fs = fileInfo.OpenRead())
     {
         byte[] output = MD5Crypto.ComputeHash(fs);
         string hashString = Convert.ToBase64String(output);
         return hashString;
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MD5HashStream"/> class.
        /// </summary>
        /// <param name="stream">Stream object.</param>
        /// <param name="lastTransferOffset">Offset of the transferred bytes.</param>
        /// <param name="md5hashCheck">Whether need to calculate MD5Hash.</param>
        public MD5HashStream(
            Stream stream,
            long lastTransferOffset,
            bool md5hashCheck)
        {
            this.stream = stream;
            this.md5hashOffset = lastTransferOffset;

            if ((0 == this.md5hashOffset)
                || (!md5hashCheck))
            {
                this.finishedSeparateMd5Calculator = true;
                this.succeededSeparateMd5Calculator = true;
            }
            else
            {
                this.semaphore = new SemaphoreSlim(1, 1);
            }

            if (md5hashCheck)
            {
                if (CloudStorageAccount.UseV1MD5)
                {
                    this.md5hash = new MD5CryptoServiceProvider();
                }
                else
                {
                    this.md5hash = new NativeMD5();
                }
            }

            if ((!this.finishedSeparateMd5Calculator)
                && (!this.stream.CanRead))
            {
                throw new NotSupportedException(string.Format(
                    CultureInfo.CurrentCulture,
                    Resources.StreamMustSupportReadException,
                    "Stream"));
            }

            if (!this.stream.CanSeek)
            {
                throw new NotSupportedException(string.Format(
                    CultureInfo.CurrentCulture,
                    Resources.StreamMustSupportSeekException,
                    "Stream"));
            }
        }

 //clientServer: true if random bytes should be processed as first the client bytes, then the server bytes
 //              false otherwise
 public Ssl3DeriveBytes(byte[] secret, byte[] clientRandom, byte[] serverRandom, bool clientServer)
 {
     if (secret == null || clientRandom == null || serverRandom == null)
         throw new ArgumentNullException();
     if (clientRandom.Length != 32 || serverRandom.Length != 32)
         throw new ArgumentException();
     m_Disposed = false;
     m_Secret = (byte[])secret.Clone();
     m_Random = new byte[64];
     if (clientServer) {
         Array.Copy(clientRandom, 0, m_Random, 0, 32);
         Array.Copy(serverRandom, 0, m_Random, 32, 32);
     } else {
         Array.Copy(serverRandom, 0, m_Random, 0, 32);
         Array.Copy(clientRandom, 0, m_Random, 32, 32);
     }
     m_MD5 = new MD5CryptoServiceProvider();
     m_SHA1 = new SHA1CryptoServiceProvider();
     Reset();
 }

        public static void ContinuousHashFor(MD5 md5, Stream s, int startPosition, long count)
        {
            Ensure.NotNull(md5, "md5");
            Ensure.Nonnegative(count, "count");

            if (s.Position != startPosition)
                s.Position = startPosition;

            var buffer = new byte[4096];
            long toRead = count;
            while (toRead > 0)
            {
                int read = s.Read(buffer, 0, (int)Math.Min(toRead, buffer.Length));
                if (read == 0)
                    break;

                md5.TransformBlock(buffer, 0, read, null, 0);
                toRead -= read;
            }
        }

        // constructors
        public GridFSForwardOnlyDownloadStream(
            GridFSBucket bucket,
            IReadBinding binding,
            GridFSFilesCollectionDocument filesCollectionDocument,
            bool checkMD5)
            : base(bucket, binding, filesCollectionDocument)
        {
            _checkMD5 = checkMD5;
            if (_checkMD5)
            {
                _md5 = MD5.Create();
            }

            _lastChunkNumber = (int)((filesCollectionDocument.Length - 1) / filesCollectionDocument.ChunkSizeBytes);
            _lastChunkSize = (int)(filesCollectionDocument.Length % filesCollectionDocument.ChunkSizeBytes);

            if (_lastChunkSize == 0)
            {
                _lastChunkSize = filesCollectionDocument.ChunkSizeBytes;
            }
        }

        // constructors
        public GridFSForwardOnlyUploadStream(
            GridFSBucket bucket,
            IWriteBinding binding,
            ObjectId id,
            string filename,
            BsonDocument metadata,
            IEnumerable<string> aliases,
            string contentType,
            int chunkSizeBytes,
            int batchSize)
        {
            _bucket = bucket;
            _binding = binding;
            _id = id;
            _filename = filename;
            _metadata = metadata; // can be null
            _aliases = aliases == null ? null : aliases.ToList(); // can be null
            _contentType = contentType; // can be null
            _chunkSizeBytes = chunkSizeBytes;
            _batchSize = batchSize;

            _batch = new List<byte[]>();
            _md5 = MD5.Create();
        }

 internal ByteStore(PRStream str)
 {
     md5 = new MD5CryptoServiceProvider();
     ByteBuffer bb = new ByteBuffer();
     int level = 100;
     SerObject(str, level, bb);
     this.b = bb.ToByteArray();
     md5 = null;
 }

        public int ReadStreamEnd()
        {
            int exitCode = StopChildProcess();

            if (md5 != null) {
                md5.TransformFinalBlock(new byte[0], 0, 0);
                mMD5SumOfPcm = md5.Hash;
                md5.Dispose();
                md5 = null;
                mMD5TmpBuffer = null;
            }

            mBytesPerFrame = 0;

            return exitCode;
        }

        /// <summary>
        /// FLACファイルからPCMデータを取り出し開始。
        /// </summary>
        /// <param name="flacFilePath">読み込むファイルパス。</param>
        /// <param name="skipFrames">ファイルの先頭からのスキップするフレーム数。0以外の値を指定するとMD5のチェックが行われなくなる。</param>
        /// <param name="wantFrames">取得するフレーム数。</param>
        /// <param name="pcmData">出てきたデコード後のPCMデータ。</param>
        /// <returns>0: 成功。負: 失敗。</returns>
        public int ReadStreamBegin(string flacFilePath, long skipFrames, long wantFrames, int typicalReadFrames, out PcmDataLib.PcmData pcmData_return)
        {
            List<FlacCuesheetTrackInfo> cti;
            int rv = ReadStartCommon(ReadMode.HeadereAndData, flacFilePath, skipFrames, wantFrames, out pcmData_return, out cti);
            if (rv != 0) {
                StopChildProcess();
                mBytesPerFrame = 0;
                return rv;
            }

            mBytesPerFrame = pcmData_return.BitsPerFrame / 8;

            if (CalcMD5 && skipFrames == 0 && wantFrames == mNumFrames) {
                md5 = new MD5CryptoServiceProvider();
                mMD5SumOfPcm = new byte[MD5_BYTES];
                mMD5TmpBuffer = new byte[mBytesPerFrame * typicalReadFrames];
            }

            return 0;
        }