public override int GetHashCode() {
HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
hashCodeCombiner.AddObject(_varyByAllParams);
// Cast _varyByCustom to an object, since the HashCodeCombiner.AddObject(string)
// overload uses StringUtil.GetStringHashCode(). We want to use String.GetHashCode()
// in this method, since we do not require a stable hash code across architectures.
hashCodeCombiner.AddObject((object)_varyByCustom);
hashCodeCombiner.AddArray(_contentEncodings);
hashCodeCombiner.AddArray(_headers);
hashCodeCombiner.AddArray(_params);
return hashCodeCombiner.CombinedHash32;
}
internal static string GetDirectoryHash(VirtualPath virtualDir) {
HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
hashCodeCombiner.AddDirectory(virtualDir.MapPathInternal());
return hashCodeCombiner.CombinedHashString;
}
public override int GetHashCode() {
// This implementation of GetHashCode uses mutable properties but matches the V1 implementation
// of Equals.
HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
foreach (DictionaryEntry attr in _bag) {
hashCodeCombiner.AddObject(attr.Key);
hashCodeCombiner.AddObject(attr.Value);
}
return hashCodeCombiner.CombinedHash32;
}
private static IWebPropertyAccessor GetPropertyAccessor(Type type, string propertyName)
{
if (s_accessorGenerator == null || s_accessorCache == null)
{
lock (s_lockObject) {
if (s_accessorGenerator == null || s_accessorCache == null)
{
s_accessorGenerator = new FastPropertyAccessor();
s_accessorCache = new Hashtable();
}
}
}
// First, check if we have it cached
// Get a hash key based on the Type and the property name
int cacheKey = HashCodeCombiner.CombineHashCodes(
type.GetHashCode(), propertyName.GetHashCode());
IWebPropertyAccessor accessor = (IWebPropertyAccessor)s_accessorCache[cacheKey];
// It was cached, so just return it
if (accessor != null)
{
return(accessor);
}
FieldInfo fieldInfo = null;
PropertyInfo propInfo = null;
Type declaringType;
GetPropertyInfo(type, propertyName, out propInfo, out fieldInfo, out declaringType);
// If the Type where the property/field is declared is not the same as the current
// Type, check if the declaring Type already has a cached accessor. This limits
// the number of different accessors we need to create. e.g. Every control has
// an ID property, but we'll end up only create one accessor for all of them.
int declaringTypeCacheKey = 0;
if (declaringType != type)
{
// Get a hash key based on the declaring Type and the property name
declaringTypeCacheKey = HashCodeCombiner.CombineHashCodes(
declaringType.GetHashCode(), propertyName.GetHashCode());
accessor = (IWebPropertyAccessor)s_accessorCache[declaringTypeCacheKey];
// We have a cached accessor for the declaring type, so use it
if (accessor != null)
{
// Cache the declaring type's accessor as ourselves
lock (s_accessorCache.SyncRoot) {
s_accessorCache[cacheKey] = accessor;
}
return(accessor);
}
}
if (accessor == null)
{
Type propertyAccessorType;
lock (s_accessorGenerator) {
propertyAccessorType = s_accessorGenerator.GetPropertyAccessorTypeWithAssert(
declaringType, propertyName, propInfo, fieldInfo);
}
// Create the type. This is the only place where Activator.CreateInstance is used,
// reducing the calls to it from 1 per instance to 1 per type.
accessor = (IWebPropertyAccessor)HttpRuntime.CreateNonPublicInstance(propertyAccessorType);
}
// Cache the accessor
lock (s_accessorCache.SyncRoot) {
s_accessorCache[cacheKey] = accessor;
if (declaringTypeCacheKey != 0)
{
s_accessorCache[declaringTypeCacheKey] = accessor;
}
}
return(accessor);
}
public override int GetHashCode()
{
return(HashCodeCombiner.CombineHashCodes(LastWriteTime.GetHashCode(), Size.GetHashCode()));
}
internal static string GetDirectoryHash(VirtualPath virtualDir)
{
HashCodeCombiner combiner = new HashCodeCombiner();
combiner.AddDirectory(virtualDir.MapPathInternal());
return combiner.CombinedHashString;
}