private static void Append(this HashAlgorithm algorithm, Attribute value, bool isFinalAppend = false) { algorithm.Append(AttributePrefix); Type attributeType = value.GetType(); algorithm.Append(attributeType, AttributeBehavior.Exclude, isFinalAppend); }
public static void Append(this HashAlgorithm algorithm, AssemblyName value, bool isFinalAppend = false) { algorithm.Append(AssemblyNamePrefix); algorithm.Append(value.Name); algorithm.Append(value.FullName); algorithm.Append(value.Version.ToString(), isFinalAppend); }
private void Hash(HashAlgorithm algorithm, bool isFinalAppend) { algorithm.Append(Name); algorithm.AppendType(Type); // TODO Find a way to include the serializer and deserializer in the identity hash //algorithm.Append(Serializer); //algorithm.Append(Deserializer); algorithm.Append(Id.Id, isFinalAppend); }
private void HashInternal(byte[] value) { if (digest != null) { // we started to hash some data. If this instance was previously // used, let's wipe the cached digest value digest = null; #if !NETFX_CORE if (!hash.CanReuseTransform) { throw new InvalidOperationException("This hash algorithm cannot be reused."); } hash.Initialize(); #endif // NETFX_CORE } #if NETFX_CORE hash.Append(CryptographicBuffer.CreateFromByteArray(value)); #else // DEBUG -- useful for seeing all bytes that get hashed, when debugging two implementations that don't interop //System.Diagnostics.Debug.Write("Hashing: "); //for (int i = 0; i < value.Length; i++) // System.Diagnostics.Debug.Write(value[i] + ","); //System.Diagnostics.Debug.WriteLine(""); // END DEBUG hash.TransformBlock(value, 0, value.Length, value, 0); #endif // NETFX_CORE }
private static void Append(this HashAlgorithm algorithm, PropertyInfo value, bool isFinalAppend = false) { algorithm.Append(PropertyPrefix); algorithm.AppendMemberInfo(value, AttributeBehavior.Include); var indexParameters = value.GetIndexParameters(); foreach (var i in indexParameters) { algorithm.Append(i); } algorithm.Append(indexParameters.Length); if (value.GetMethod == null) { algorithm.Append(ExplicitNull); } else { algorithm.Append(value.GetMethod); } if (value.SetMethod == null) { algorithm.Append(ExplicitNull); } else { algorithm.Append(value.SetMethod); } algorithm.AppendType(value.PropertyType, isFinalAppend); }
private static void AppendMemberInfo(this HashAlgorithm algorithm, MemberInfo value, AttributeBehavior attributeBehavior, bool isFinalAppend = false) { algorithm.Append((int)value.MemberType); int attributeCount = 0; if (attributeBehavior == AttributeBehavior.Include) { foreach (var a in value.GetCustomAttributes <Attribute>()) { algorithm.Append(a); ++attributeCount; } } // Always add the attribute count. This way a type without any attributes hashes the same no matter what the parameter says algorithm.Append(attributeCount); algorithm.Append(value.Name, isFinalAppend); }
/// <summary> /// Calculates a hash of a Delegate object. The resulting hash can be used to validate that two different Delegate instanses /// are setup in the same way (meaning they have the same type of targets and in the same order). /// The hash value is also stable outside of the current process lifetime, so it can be used to validate saved data. /// </summary> /// <param name="algorithm"></param> /// <param name="value"></param> /// <param name="isFinalAppend"></param> public static void Append(this HashAlgorithm algorithm, Delegate value, bool isFinalAppend = false) { algorithm.Append(DelegatePrefix); var invocationList = value.GetInvocationList(); foreach (var d in invocationList) { if (d.Target == null) { algorithm.Append(ExplicitNull); } else { algorithm.AppendType(d.Target.GetType()); } algorithm.Append(d.Method); } algorithm.Append(invocationList.Length, isFinalAppend); }
public IContext EndSetup() { // Finish the hashing if it's enabled if (payloadHashAlgorithm != null) { payloadHashAlgorithm.Append(payloads.Count, true); } return(new DefaultContext(contextName, payloads)); }
private static void Append(this HashAlgorithm algorithm, MethodInfo value, bool isFinalAppend = false) { algorithm.Append(MethodPrefix); algorithm.AppendMemberInfo(value, AttributeBehavior.Include); algorithm.Append((int)value.Attributes); if (value.IsGenericMethod) { algorithm.Append(ExplicitTrue); if (value.IsGenericMethodDefinition) { algorithm.Append(ExplicitTrue); } else { algorithm.Append(ExplicitFalse); } var genericArguments = value.GetGenericArguments(); foreach (var arg in genericArguments) { algorithm.AppendType(arg); } algorithm.Append(genericArguments.Length); } else { algorithm.Append(ExplicitFalse); } var parameters = value.GetParameters(); foreach (var p in parameters) { algorithm.Append(p); } algorithm.Append(parameters.Length); algorithm.AppendType(value.ReturnType, isFinalAppend); }
private static void Append(this HashAlgorithm algorithm, ParameterInfo value, bool isFinalAppend = false) { algorithm.Append(ParameterPrefix); algorithm.Append((int)value.Attributes); algorithm.Append(value.Name); algorithm.Append(value.Position); int attributeCount = 0; foreach (var a in value.GetCustomAttributes <Attribute>()) { algorithm.Append(a); ++attributeCount; } algorithm.Append(attributeCount); algorithm.AppendType(value.ParameterType, isFinalAppend); }
/// <summary> /// If two class types have the same name, interface, and attributes (not including the values in the attribute), they generate the same hash. /// This does *NOT* mean that they are implemented the same, just that they look the same on the surface. /// </summary> /// <param name="algorithm"></param> /// <param name="value"></param> /// <param name="isFinalAppend"></param> public static void AppendClass(this HashAlgorithm algorithm, Type value, bool isFinalAppend = false) { algorithm.Append(ClassPrefix); var methods = value.GetMethods(); foreach (var m in methods) { algorithm.Append(m); } algorithm.Append(methods.Length); var properties = value.GetProperties(); foreach (var p in properties) { algorithm.Append(p); } algorithm.Append(properties.Length); algorithm.Append(value, AttributeBehavior.Include, isFinalAppend); }
public static void Append(this HashAlgorithm algorithm, long value, bool isFinalAppend = false) { var bytes = BitConverter.GetBytes(value); algorithm.Append(bytes, isFinalAppend); }
public static void Append(this HashAlgorithm algorithm, string value, bool isFinalAppend = false) { var bytes = Encoding.UTF8.GetBytes(value); algorithm.Append(bytes, isFinalAppend); }
public static byte[] CalculateHash(this HashAlgorithm algorithm, long value) { algorithm.Initialize(); algorithm.Append(value, true); return(algorithm.Hash); }
private static void Append(this HashAlgorithm algorithm, Type value, AttributeBehavior attributeBehavior, bool isFinalAppend = false) { algorithm.Append(TypePrefix); if (value.IsGenericType) { algorithm.Append(ExplicitTrue); } else { algorithm.Append(ExplicitFalse); } if (value.IsGenericTypeDefinition) { algorithm.Append(ExplicitTrue); } else { algorithm.Append(ExplicitFalse); } // TODO Add more explicit type info for generic versions if (value.IsGenericParameter) { algorithm.Append(ExplicitTrue); } else { algorithm.Append(ExplicitFalse); } if (value.ContainsGenericParameters) { algorithm.Append(ExplicitTrue); } else { algorithm.Append(ExplicitFalse); } if (value.IsArray) { algorithm.Append(ExplicitTrue); algorithm.AppendType(value.GetElementType()); } else { algorithm.Append(ExplicitFalse); } algorithm.AppendMemberInfo(value, attributeBehavior, isFinalAppend); }
/// <summary> /// Calculates a hash of the specified type. /// </summary> /// <param name="algorithm"></param> /// <param name="value"></param> /// <param name="isFinalAppend"></param> public static void AppendType(this HashAlgorithm algorithm, Type value, bool isFinalAppend = false) { algorithm.Append(value, AttributeBehavior.Include, isFinalAppend); }