1. C# / Говнокод #7722

    +122

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    public class ASyncFileHashAlgorithm
	{
		protected HashAlgorithm hashAlgorithm;
		protected byte[] hash;
		protected bool cancel = false;
		protected int bufferSize = 4096;
		public delegate void FileHashingProgressHandler (object sender, FileHashingProgressArgs e);
		public event FileHashingProgressHandler FileHashingProgress;

		public ASyncFileHashAlgorithm(HashAlgorithm hashAlgorithm)
		{
			this.hashAlgorithm = hashAlgorithm;
		}

		public byte[] ComputeHash(Stream stream)
		{
			cancel = false;
			hash = null;
			int _bufferSize = bufferSize; // this makes it impossible to change the buffer size while computing

			byte[] readAheadBuffer, buffer;
			int readAheadBytesRead, bytesRead;
			long size, totalBytesRead = 0;

			size = stream.Length;
         	readAheadBuffer = new byte[_bufferSize];
            readAheadBytesRead = stream.Read(readAheadBuffer, 0, readAheadBuffer.Length);

            totalBytesRead += readAheadBytesRead;    

            do
            {
                bytesRead = readAheadBytesRead;
                buffer = readAheadBuffer;    

                readAheadBuffer = new byte[_bufferSize];
                readAheadBytesRead = stream.Read(readAheadBuffer, 0, readAheadBuffer.Length);

                totalBytesRead += readAheadBytesRead;    

                if (readAheadBytesRead == 0)
                    hashAlgorithm.TransformFinalBlock(buffer, 0, bytesRead);
                else
                    hashAlgorithm.TransformBlock(buffer, 0, bytesRead, buffer, 0);

				FileHashingProgress(this, new FileHashingProgressArgs(totalBytesRead, size));
            } while (readAheadBytesRead != 0 && !cancel);

			if(cancel)
				return hash = null;

    		return hash = hashAlgorithm.Hash;
		}

		public int BufferSize
		{
			get
			{ return bufferSize; }
			set
			{ bufferSize = value; }
		}

		public byte[] Hash
		{
			get
			{ return hash; }
		}

		public void Cancel()
		{
			cancel = true;
		}

		public override string ToString ()
		{
			string hex = "";
			foreach(byte b in Hash)
				hex += b.ToString("x2");

			return hex;
		}
	}

    Очень интересная реализация "асинхронного" хэширования.

    Запостил: martin, 31 Августа 2011

    Комментарии (7) RSS

    Добавить комментарий