System.Type.GetHashCode()

public override int GetHashCode()
            {
                return Type.GetHashCode();
            }

static int GetParameterHash(object dynamicObject)
        {
            unchecked
            {
                int hash = 31; //any prime number
                PropertyInfo[] propertyInfo = dynamicObject.GetType().GetProperties();
                for (int i = 0; i < propertyInfo.Length; i++)
                {
                    object propertyName = propertyInfo[i].Name;
                    //dynamic property will always return System.Object as property type. Get Type from the value
                    Type propertyType = GetTypeOfDynamicProperty(propertyInfo[i], dynamicObject);

                    //prime numbers to generate hash
                    hash = (-97 * ((hash * 29) + propertyName.GetHashCode())) + propertyType.GetHashCode();
                }
                return hash;
            }
        }

public override int GetHashCode()
			{
				// note: we cannot just xor both hash codes, because if left and right are the same, we will return 0
				int h = this.Left.GetHashCode();
				h = (h >> 13) | (h << 19);
				h ^= this.Right.GetHashCode();
				return h;
			}

public override int GetHashCode()
            {
                int hashCode = 7443; // "large" prime to start the seed
                
                // Bitshifting and subtracting once is an efficient way to multiply by our second "large" prime, 0x7ffff = 524287
                hashCode = (hashCode << 19) - hashCode + (RootNamespace?.GetHashCode() ?? 0);
                hashCode = (hashCode << 19) - hashCode + ElementName.GetHashCode();
                hashCode = (hashCode << 19) - hashCode + ElementType.GetHashCode();

                return hashCode;
            }

public int GetHashCode(ClientCacheKey obj)
                {
                    return obj.Type.GetHashCode() ^ obj.ServiceIdentifier.GetHashCode();
                }

protected virtual bool IsReadRequest(object request)
		{
			return request != null && Array.BinarySearch(_cachedRequestsSorted, request.GetType().GetHashCode()) >= 0;
		}

public override int GetHashCode()
        {
            //TODO: Use old hash code system?
            return A.GetHashCode() + B.GetHashCode();
        }

public override int GetHashCode()
            {
                return _initialType.GetHashCode() ^ _targetType.GetHashCode();
            }

public override int GetHashCode()
        {
            return _resolverType.GetHashCode() ^ _contractType.GetHashCode();
        }

public override int GetHashCode () => Type.GetHashCode () + 37 * base.GetHashCode ();

public override int GetHashCode () => Type.GetHashCode () + 37 * Name.GetHashCode ();

protected virtual int CompareType(Type x, Type y)
        {
            if (x == y) return 0;

            if (CompareNull(x, y, out var result)) return result;

            result = x.GetHashCode() - y.GetHashCode();
            if (result != 0) return result;

            result = String.Compare(x.Name, y.Name, StringComparison.Ordinal);
            if (result != 0) return result;

            return x.replacedemblyQualifiedName.CompareTo(y.replacedemblyQualifiedName);
        }

public override int GetHashCode()
		{
			return position.GetHashCode()
				+ type.GetHashCode()
				+ forcePositon.GetHashCode()
				+ name.GetHashCode()
				+ nodeType.GetHashCode()
				+ fromNodeName.GetHashCode()
				+ toNodeName.GetHashCode();
		}

public override int GetHashCode()
        {
            return (GetType().GetHashCode() * 451) + Id.GetHashCode();
        }

private bool AddToBuckets(Entry[] buckets, Type newKey, Entry newEntryOrNull, Func<Type, TValue> valueFactory, out TValue resultingValue)
        {
            var h = (newEntryOrNull != null) ? newEntryOrNull.Hash : newKey.GetHashCode();
            if (buckets[h & (buckets.Length - 1)] == null)
            {
                if (newEntryOrNull != null)
                {
                    resultingValue = newEntryOrNull.Value;
                    VolatileWrite(ref buckets[h & (buckets.Length - 1)], newEntryOrNull);
                }
                else
                {
                    resultingValue = valueFactory(newKey);
                    VolatileWrite(ref buckets[h & (buckets.Length - 1)], new Entry { Key = newKey, Value = resultingValue, Hash = h });
                }
            }
            else
            {
                Entry searchLastEntry = buckets[h & (buckets.Length - 1)];
                while (true)
                {
                    if (searchLastEntry.Key == newKey)
                    {
                        resultingValue = searchLastEntry.Value;
                        return false;
                    }

                    if (searchLastEntry.Next == null)
                    {
                        if (newEntryOrNull != null)
                        {
                            resultingValue = newEntryOrNull.Value;
                            VolatileWrite(ref searchLastEntry.Next, newEntryOrNull);
                        }
                        else
                        {
                            resultingValue = valueFactory(newKey);
                            VolatileWrite(ref searchLastEntry.Next, new Entry { Key = newKey, Value = resultingValue, Hash = h });
                        }

                        break;
                    }

                    searchLastEntry = searchLastEntry.Next;
                }
            }

            return true;
        }

[MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool TryGetValue(Type key, out TValue value)
        {
            Entry[] table = this.buckets;
            var hash = key.GetHashCode();
            Entry entry = table[hash & table.Length - 1];

            while (entry != null)
            {
                if (entry.Key == key)
                {
                    value = entry.Value;
                    return true;
                }

                entry = entry.Next;
            }

            value = default(TValue);
            return false;
        }

public override int GetHashCode()
      {
         return 31 * ClreplacedType.GetHashCode() + Field.GetHashCode();
      }

private static int Hash(Type type, string methodname, object[] args)
        {
            var hash = 23;
            hash = hash * 31 + type.GetHashCode();
            hash = hash * 31 + methodname.GetHashCode();
            for (var index = 0; index < args.Length; index++)
            {
                var argtype = args[index].GetType();
                hash = hash * 31 + argtype.GetHashCode();
            }
            return hash;
        }

public override int GetHashCode()
        {
            return (GetType().GetHashCode() * 907) + Id.GetHashCode();
        }

public override int GetHashCode()
        {
            int hashCode = ControllerName.ToUpperInvariant().GetHashCode() ^ ActionName.ToUpperInvariant().GetHashCode();
            if (MediaType != null)
            {
                hashCode ^= MediaType.GetHashCode();
            }
            if (SampleDirection != null)
            {
                hashCode ^= SampleDirection.GetHashCode();
            }
            if (ParameterType != null)
            {
                hashCode ^= ParameterType.GetHashCode();
            }
            foreach (string parameterName in ParameterNames)
            {
                hashCode ^= parameterName.ToUpperInvariant().GetHashCode();
            }

            return hashCode;
        }

public override int GetHashCode()
        {
            if (Id.Equals(default(TIdenreplacedy)))
            {
                return base.GetHashCode();
            }

            return GetType().GetHashCode() ^ Id.GetHashCode();
        }

protected void SetHashCode()
            {
                long th = TargetType.GetHashCode();
                long sh = SourceType.GetHashCode();
                // Cantor pairing
                hash = (int)((th + sh) * (th + sh + 1) / 2 + sh);
            }

public int hashCode() => Type.GetHashCode();

public override int GetHashCode()
        {
            unchecked
            {
                var result = 0;
                result = (result * 397) ^ replacedemblyType.GetHashCode();
                result = (result * 397) ^ AllowAbstract.GetHashCode();
                result = (result * 397) ^ AllowObsolete.GetHashCode();
                return result;
            }
        }

public override int GetHashCode() => Type.GetHashCode();

public override int GetHashCode()
      {
        return m_Contract.GetHashCode();
      }

public override int GetHashCode()
            {
                return MurmurHash.HashCode(opnds, typeof(SemanticContext.AND).GetHashCode());
            }

public override int GetHashCode()
            {
                return MurmurHash.HashCode(opnds, typeof(SemanticContext.OR).GetHashCode());
            }

public int GetHashCode(T obj)
        {
            return obj.GetType().GetHashCode();
        }

public override int GetHashCode()
        {
            return SystemType.GetHashCode();
        }

public override int GetHashCode()
         {
            return Type.GetHashCode() + MemberName.GetHashCode();
         }

public override int GetHashCode()
        {
            return this.GetType().GetHashCode() + this.Language.GetHashCode() + this.Body.GetHashCode();
        }

private static int Hash(Type type, string methodname, object[] args)
        {
            var hash = 23;
            hash = (hash * 31) + type.GetHashCode();
            hash = (hash * 31) + methodname.GetHashCode();
            for (var index = 0; index < args.Length; index++)
            {
                var argtype = args[index].GetType();
                hash = (hash * 31) + argtype.GetHashCode();
            }

            return hash;
        }

public override int GetHashCode() => _type.GetHashCode();

[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetHashCode(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			System.Type obj = ToLua.CheckMonoType(L, 1);
			int o = obj.GetHashCode();
			LuaDLL.lua_pushinteger(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

public override int GetHashCode()
        {
            return Name != null ? Type.GetHashCode() ^ Name.GetHashCode() : Type.GetHashCode();
        }

public int GetHashCode(Type obj)
        {
            if (obj != null && obj.GetType() != _runtimeType && obj.IsGenericType)
            {
                var hashcode = obj.GetGenericTypeDefinition().GetHashCode();
                if (!obj.IsGenericTypeDefinition)
                {
                    foreach (var item in obj.GetGenericArguments())
                    {
                        hashcode ^= item.GetHashCode();
                    }
                }
                return hashcode;
            }
            return obj?.GetHashCode() ?? 0;
        }

public override int GetHashCode() => GenericTypeDefinition.GetHashCode();

public override int GetHashCode()
            {
                return typeof(T).GetHashCode() ^ 8510;
            }

public override int GetHashCode()
        {
            if (this.IsEmpty)
            {
                return 0;
            }

            const int P = 16777619;

            unchecked
            {
                return (int)2166136261
                    ^ ((this.Name == null ? 12321 : this.Name.GetHashCode()) * P)
                    ^ (this.Id * P)
                    ^ ((this.Type == null ? 1423 : this.Type.GetHashCode()) * P)
                    ^ ((this.IsArray ? 124124 : 43234) * P)
                    ^ ((this.IsEmpty ? 872934 : 27323) * P);
            }
        }

public override int GetHashCode()
        {
            unchecked
            {
                return (In.GetHashCode() * 397) ^ Out.GetHashCode();
            }
        }

public override int GetHashCode()
        {
            unchecked { return name.GetHashCode() * type.GetHashCode(); }
        }

public override int GetHashCode() => From == null ? 0 : From.GetHashCode() + To.GetHashCode() + MissingMethods.GetHashCode();

public override int GetHashCode()
            {
                return MurmurHash.HashCode(opnds, typeof(SemanticContext.AND).GetHashCode());
            }

public override int GetHashCode()
            {
                return MurmurHash.HashCode(opnds, typeof(SemanticContext.OR).GetHashCode());
            }

public override int GetHashCode() => InterfaceType.GetHashCode();

public override int GetHashCode()
        {
            unchecked
            {
                var hashCode = _sid.GetHashCode();
                hashCode = (hashCode*397) ^ Type.GetHashCode();
                hashCode = (hashCode*397) ^ (int) TickType;
                hashCode = (hashCode*397) ^ (int) Resolution;
                hashCode = (hashCode*397) ^ FillDataForward.GetHashCode();
                hashCode = (hashCode*397) ^ ExtendedMarketHours.GetHashCode();
                hashCode = (hashCode*397) ^ IsInternalFeed.GetHashCode();
                hashCode = (hashCode*397) ^ IsCustomData.GetHashCode();
                hashCode = (hashCode*397) ^ DataTimeZone.Id.GetHashCode();// timezone hash is expensive, use id instead
                hashCode = (hashCode*397) ^ ExchangeTimeZone.Id.GetHashCode();// timezone hash is expensive, use id instead
                hashCode = (hashCode*397) ^ IsFilteredSubscription.GetHashCode();
                return hashCode;
            }
        }

public override int GetHashCode()
        {
            return GetType().GetHashCode();
        }

private static Type CreateProxyType()
        {
            var interfaceType = InterfaceType;
            var typeName = string.Format("{0}_{1}_Imp_{2}", typeof(EasyProxyGenerator<T>).Name, interfaceType.Name, interfaceType.GetHashCode());

            TypeBuilder typeBuilder = ModuleBuilder.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Clreplaced | TypeAttributes.Sealed, typeof(ProxyBase));
            typeBuilder.AddInterfaceImplementation(interfaceType);

            MethodInfo interceptMethodInfo = typeof(IInterceptor).GetMethod("Proceed", BindingFlags.Instance | BindingFlags.Public);
            FieldBuilder fieldBuilder = DynamicProxyHelper.DefineField(typeBuilder, "interceptor", typeof(IInterceptor), FieldAttributes.Private);

            DynamicProxyHelper.DefineConstructor(typeBuilder, fieldBuilder);
            DynamicProxyHelper.DefineMethods(typeBuilder, fieldBuilder, interfaceType, interceptMethodInfo);

            return typeBuilder.CreateTypeInfo().AsType();
        }

public override int GetHashCode()
        {
            return type.GetHashCode();
        }

See More Examples