C# IHashCodeProvider类代码示例

 private static IDiff[] makediffs (IList original, IList [] changed, IComparer comparer, IHashCodeProvider hashcoder)
 {
     IDiff[] diffs = new IDiff[changed.Length];
     for (int i = 0; i < changed.Length; i++)
         diffs [i] = new Diff (original, changed [i], comparer, hashcoder);
     return diffs;
 }

 public Diff(IList left, IList right, IComparer comparer, IHashCodeProvider hashcoder)
 {
     this.left = left;
     this.right = right;
     this.comparer = comparer;
     this.hashcoder = hashcoder;
     init();
 }

 public Diff(IList left, IList right, IComparer comparer, IHashCodeProvider hashcoder)
 {
     if (left == null) throw new ArgumentNullException("left");
     if (right == null) throw new ArgumentNullException("right");
     this.left = left;
     this.right = right;
     this.comparer = comparer;
     this.hashcoder = hashcoder;
     init();
 }

        public k_HashTable(int ai_Capacity, double ad_LoadFactor, IHashCodeProvider ak_HashProvider, IComparer ak_Comparer)
        {
            if (ad_LoadFactor <= .0 || ad_LoadFactor > 1.0)
                throw new ArgumentException("Load factor must be greater than .0 and smaller or equal to 1.0", "ad_LoadFactor");
            md_LoadFactor = ad_LoadFactor;

            double ld_Size = ai_Capacity/ad_LoadFactor;
            if (ld_Size > int.MaxValue)
                throw new ArgumentException("k_HashTable overflow");

            int li_TableSize = FindPrimeGreater((int)ld_Size);
            mk_Buckets = new r_Bucket[li_TableSize];
            mi_GrowSize = (md_LoadFactor < 1.0) ? (int)(md_LoadFactor * li_TableSize) : li_TableSize-1;

            mk_HashProvider = ak_HashProvider;
            mk_Comparer = ak_Comparer;

            mk_End = new k_PinnedBucketIterator(this, -1);
        }

	protected NameObjectCollectionBase(int capacity,
									   IHashCodeProvider hashProvider,
									   IComparer comparer)
			{
				if(capacity < 0)
				{
					throw new ArgumentOutOfRangeException
						("capacity", S._("ArgRange_NonNegative"));
				}
				if(hashProvider == null)
				{
					hashProvider = CaseInsensitiveHashCodeProvider.Default;
				}
				if(comparer == null)
				{
					comparer = CaseInsensitiveComparer.Default;
				}
				table = new Entry [HashTableSize];
				hcp = hashProvider;
				cmp = comparer;
				entries = new ArrayList(capacity);
				readOnly = false;
			}

 public Hashtable(IDictionary d, IHashCodeProvider hcp, IComparer comparer) 
     : this(d, 1.0f, hcp, comparer)  {
 }

 internal CompatibleComparer(IComparer comparer, IHashCodeProvider hashCodeProvider) {
     _comparer = comparer;
     _hcp = hashCodeProvider;
 }

 public StringIntegerHashtable(IDictionary dictionary, float loadFactor, IHashCodeProvider codeProvider, IComparer comparer)
 {
     innerHash = new Hashtable (dictionary, loadFactor, codeProvider, comparer);
 }

 public IntegerHashtable(int capacity, IHashCodeProvider codeProvider, IComparer comparer)
 {
     innerHash = new Hashtable (capacity, codeProvider, comparer);
 }

 public NameValueCollection(IHashCodeProvider hashProvider, IComparer comparer) 
     : base(hashProvider, comparer) {
 }

 public ComparableHashtable(int capacity, IHashCodeProvider hcp, IComparer comparer) : base(capacity, hcp, comparer) { }

		public UnitTestNameObjectCollectionBase (int capacity, IHashCodeProvider provider, IComparer comparer)
			: base (capacity, provider, comparer)
		{
		}

 protected NameObjectCollectionBase(IHashCodeProvider hashProvider, IComparer comparer) {
     _keyComparer = new CompatibleComparer( comparer, hashProvider); 
     Reset();
 }

		public ReadOnlyNameValueCollection(IHashCodeProvider hcp, IComparer comp) : base(hcp, comp)
		{
		}

 public FrameworkInfoDictionary(IDictionary dictionary, IHashCodeProvider codeProvider, IComparer comparer)
 {
     _innerHash = new Hashtable (dictionary, codeProvider, comparer);
 }