C# AssemblyHashAlgorithm类代码示例

		/// <summary>
		/// Constructor
		/// </summary>
		/// <remarks>If <paramref name="hashAlgo"/> is an unsupported hash algorithm, then
		/// <see cref="AssemblyHashAlgorithm.SHA1"/> will be used as the hash algorithm.</remarks>
		/// <param name="hashAlgo">The algorithm to use</param>
		public AssemblyHash(AssemblyHashAlgorithm hashAlgo) {
			switch (hashAlgo) {
			case AssemblyHashAlgorithm.MD5:
				hasher = MD5.Create();
				break;

			case AssemblyHashAlgorithm.None:
			case AssemblyHashAlgorithm.MD2:
			case AssemblyHashAlgorithm.MD4:
			case AssemblyHashAlgorithm.SHA1:
			case AssemblyHashAlgorithm.MAC:
			case AssemblyHashAlgorithm.SSL3_SHAMD5:
			case AssemblyHashAlgorithm.HMAC:
			case AssemblyHashAlgorithm.TLS1PRF:
			case AssemblyHashAlgorithm.HASH_REPLACE_OWF:
			default:
				hasher = SHA1.Create();
				break;

			case AssemblyHashAlgorithm.SHA_256:
				hasher = SHA256.Create();
				break;

			case AssemblyHashAlgorithm.SHA_384:
				hasher = SHA384.Create();
				break;

			case AssemblyHashAlgorithm.SHA_512:
				hasher = SHA512.Create();
				break;
			}
		}

        internal ImmutableArray<byte> GetHash(AssemblyHashAlgorithm algorithmId)
        {
            using (HashAlgorithm algorithm = TryGetAlgorithm(algorithmId))
            {
                // ERR_CryptoHashFailed has already been reported:
                if (algorithm == null)
                {
                    return ImmutableArray.Create<byte>();
                }

                switch (algorithmId)
                {
                    case AssemblyHashAlgorithm.None:
                    case AssemblyHashAlgorithm.Sha1:
                        return GetHash(ref _lazySHA1Hash, algorithm);

                    case AssemblyHashAlgorithm.Sha256:
                        return GetHash(ref _lazySHA256Hash, algorithm);

                    case AssemblyHashAlgorithm.Sha384:
                        return GetHash(ref _lazySHA384Hash, algorithm);

                    case AssemblyHashAlgorithm.Sha512:
                        return GetHash(ref _lazySHA512Hash, algorithm);

                    case AssemblyHashAlgorithm.MD5:
                        return GetHash(ref _lazyMD5Hash, algorithm);

                    default:
                        throw ExceptionUtilities.UnexpectedValue(algorithmId);
                }
            }
        }

		public AssemblyHash (AssemblyHashAlgorithm algorithm, byte[] value)
		{
			_algorithm = algorithm;
			if (value != null)
				_value = (byte[]) value.Clone ();
			else
				_value = null;
		}

		/// <summary>
		/// Hash data
		/// </summary>
		/// <remarks>If <paramref name="hashAlgo"/> is an unsupported hash algorithm, then
		/// <see cref="AssemblyHashAlgorithm.SHA1"/> will be used as the hash algorithm.</remarks>
		/// <param name="data">The data</param>
		/// <param name="hashAlgo">The algorithm to use</param>
		/// <returns>Hashed data or null if <paramref name="data"/> was <c>null</c></returns>
		public static byte[] Hash(byte[] data, AssemblyHashAlgorithm hashAlgo) {
			if (data == null)
				return null;

			using (var asmHash = new AssemblyHash(hashAlgo)) {
				asmHash.Hash(data);
				return asmHash.ComputeHash();
			}
		}

 public void Read(ClrModuleReader reader)
 {
     this.HashAlgId = (AssemblyHashAlgorithm)reader.Binary.ReadUInt32();
     this.Version = reader.ReadVersion();
     this.Flags = (AssemblyFlags)reader.Binary.ReadUInt32();
     this.PublicKey = reader.ReadBlob();
     this.Name = reader.ReadString();
     this.Culture = reader.ReadString();
 }

     public AssemblyHash(AssemblyHashAlgorithm algorithm, byte[] value) {
         _Algorithm = algorithm;
         _Value = null;
 
         if (value != null) {
             int length = value.Length;
             _Value = new byte[length];
             Array.Copy(value, _Value, length);
         }
     }

        public AssemblyNameReference(string name, Version version)
        {
            if (name == null)
                throw new ArgumentNullException("name");

            this.name = name;
            this.version = version;
            this.hash_algorithm = AssemblyHashAlgorithm.None;
            this.token = new MetadataToken(TokenType.AssemblyRef);
        }

 public static IncrementalHash Create(AssemblyHashAlgorithm hashAlgorithm)
 {
     if (PortableShim.IncrementalHash.TypeOpt != null)
     {
         return new Core(hashAlgorithm);
     }
     else
     {
         return new Desktop(hashAlgorithm);
     }
 }

 public AssemblyNameReference(string name, string culture, Version version)
 {
     if (name == null)
         throw new ArgumentNullException ("name");
     if (culture == null)
         throw new ArgumentNullException ("culture");
     m_name = name;
     m_culture = culture;
     m_version = version;
     m_hashAlgo = AssemblyHashAlgorithm.None;
 }

 public AssemblyHash(byte[] value)
 {
     this._Algorithm = AssemblyHashAlgorithm.SHA1;
     this._Value = null;
     if (value != null)
     {
         int length = value.Length;
         this._Value = new byte[length];
         Array.Copy(value, this._Value, length);
     }
 }

 public AssemblyReference(string name, AssemblyAttributes attributes, Version version, AssemblyHashAlgorithm hashAlgorithm, uint publicKey, string culture)
     : base(new MetaDataRow(
         (byte)version.Major, (byte)version.Minor, (byte)version.Build, (byte)version.Revision,
         (uint)attributes,
         publicKey,
         0U,
         0U,
         (uint)hashAlgorithm))
 {
     this._name = name;
     this._culture = culture;
 }

            /// <summary>
            /// Returns the actual FX implementation of HashAlgorithmName for given hash algorithm id.
            /// </summary>
            private static object GetHashAlgorithmNameObj(AssemblyHashAlgorithm algorithmId)
            {
                switch (algorithmId)
                {
                    case AssemblyHashAlgorithm.Sha1:
                        return PortableShim.HashAlgorithmName.SHA1;

                    default:
                        // More algorithms can be added as needed.
                        throw ExceptionUtilities.UnexpectedValue(algorithmId);
                }
            }

		private void LoadData(CLIFile pFile)
		{
			HashAlgId = (AssemblyHashAlgorithm)pFile.ReadUInt32();
			MajorVersion = pFile.ReadUInt16();
			MinorVersion = pFile.ReadUInt16();
			BuildNumber = pFile.ReadUInt16();
			RevisionNumber = pFile.ReadUInt16();
			Flags = (AssemblyFlags)pFile.ReadUInt32();
			PublicKey = pFile.ReadBlobHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Blob32Bit));
			Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
			Culture = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
		}

	public AssemblyHash(AssemblyHashAlgorithm algorithmId, byte[] value)
			{
				hashAlg = algorithmId;
				if(value != null)
				{
					hash = new byte [value.Length];
					Array.Copy(value, hash, value.Length);
				}
				else
				{
					hash = null;
				}
			}

        /// <summary>
        /// Initializes a new instance of the <see cref="AssemblyRow"/> struct.
        /// </summary>
        /// <param name="hashAlgId">The hash alg id.</param>
        /// <param name="majorVersion">The major version.</param>
        /// <param name="minorVersion">The minor version.</param>
        /// <param name="buildNumber">The build number.</param>
        /// <param name="revision">The revision.</param>
        /// <param name="flags">The flags.</param>
        /// <param name="publicKey">The public key.</param>
        /// <param name="name">The name.</param>
        /// <param name="culture">The culture.</param>
        public AssemblyRow(AssemblyHashAlgorithm hashAlgId,
							ushort majorVersion, ushort minorVersion, ushort buildNumber, ushort revision,
							AssemblyAttributes flags, HeapIndexToken publicKey, HeapIndexToken name, HeapIndexToken culture)
        {
            this.hashAlgId = hashAlgId;
            this.majorVersion = majorVersion;
            this.minorVersion = minorVersion;
            this.buildNumber = buildNumber;
            this.revisionNumber = revision;
            this.flags = flags;
            this.publicKey = publicKey;
            this.name = name;
            this.culture = culture;
        }