public void LoadOverride(MethodInfo method)
{
OverrideAttribute attribute = (OverrideAttribute)Attribute.GetCustomAttribute(method, typeof(OverrideAttribute));
bool flag = Overrides.Count((KeyValuePair <OverrideAttribute, OverrideWrapper> a) => a.Key.Method == attribute.Method) > 0;
if (!flag)
{
OverrideWrapper overrideWrapper = new OverrideWrapper(attribute.Method, method, attribute, null);
overrideWrapper.Override();
Overrides.Add(attribute, overrideWrapper);
}
}
public OverrideWrapper(MethodInfo original, MethodInfo modified, OverrideAttribute attribute, object instance = null)
{
Original = original;
Modified = modified;
Instance = instance;
Attribute = attribute;
Local = (Modified.DeclaringType.Assembly == Assembly.GetExecutingAssembly());
RuntimeHelpers.PrepareMethod(original.MethodHandle);
RuntimeHelpers.PrepareMethod(modified.MethodHandle);
PtrOriginal = Original.MethodHandle.GetFunctionPointer();
PtrModified = Modified.MethodHandle.GetFunctionPointer();
OffsetBackup = new OverrideUtilities.OffsetBackup(PtrOriginal);
Detoured = false;
}
// Token: 0x06000083 RID: 131 RVA: 0x000064B0 File Offset: 0x000046B0
public static object CallOriginal(object instance = null, params object[] args)
{
StackTrace stackTrace = new StackTrace(false);
bool flag = stackTrace.FrameCount < 1;
bool flag2 = flag;
if (flag2)
{
throw new Exception("Invalid trace back to the original method! Please provide the methodinfo instead!");
}
MethodBase method = stackTrace.GetFrame(1).GetMethod();
MethodInfo original = null;
bool flag3 = !Attribute.IsDefined(method, typeof(OverrideAttribute));
bool flag4 = flag3;
if (flag4)
{
method = stackTrace.GetFrame(2).GetMethod();
}
OverrideAttribute overrideAttribute = (OverrideAttribute)Attribute.GetCustomAttribute(method, typeof(OverrideAttribute));
bool flag5 = overrideAttribute == null;
bool flag6 = flag5;
if (flag6)
{
throw new Exception("This method can only be called from an overwritten method!");
}
bool flag7 = !overrideAttribute.MethodFound;
bool flag8 = flag7;
if (flag8)
{
throw new Exception("The original method was never found!");
}
original = overrideAttribute.Method;
bool flag9 = OverrideManager.Overrides.All((KeyValuePair <OverrideAttribute, OverrideWrapper> o) => o.Value.Original != original);
bool flag10 = flag9;
if (flag10)
{
throw new Exception("The Override specified was not found!");
}
OverrideWrapper value = OverrideManager.Overrides.First((KeyValuePair <OverrideAttribute, OverrideWrapper> a) => a.Value.Original == original).Value;
return(value.CallOriginal(args, instance));
}
/// <summary>
/// Loads override information for method
/// </summary>
/// <param name="method">Method to override another</param>
public static void LoadOverride(MethodInfo method)
{
// Get attribute related variables
OverrideAttribute attribute =
(OverrideAttribute)Attribute.GetCustomAttribute(method, typeof(OverrideAttribute));
// Check if method has been overrided before
if (Overrides.Count(a => a.Key.Method == attribute.Method) > 0)
{
return;
}
// Create wrapper for override
OverrideWrapper wrapper = new OverrideWrapper(attribute.Method, method, attribute);
// Override
wrapper.Override();
// Add override to the list
Overrides.Add(attribute, wrapper);
}
/// <summary>
/// Calls the original method that was Overrideed
/// </summary>
/// <param name="instance">The instance for the method(null if static)</param>
/// <param name="args">The arguments for the method</param>
/// <returns>The value tahat the original function returns</returns>
public static object CallOriginal(object instance = null, params object[] args)
{
StackTrace trace = new StackTrace(false);
if (trace.FrameCount < 1)
{
throw new Exception("Invalid trace back to the original method! Please provide the methodinfo instead!");
}
MethodBase modded = trace.GetFrame(1).GetMethod();
MethodInfo original = null;
if (!Attribute.IsDefined(modded, typeof(OverrideAttribute)))
{
modded = trace.GetFrame(2).GetMethod();
}
OverrideAttribute att = (OverrideAttribute)Attribute.GetCustomAttribute(modded, typeof(OverrideAttribute));
if (att == null)
{
throw new Exception("This method can only be called from an overwritten method!");
}
if (!att.MethodFound)
{
throw new Exception("The original method was never found!");
}
original = att.Method;
if (OverrideManager.Overrides.All(o => o.Value.Original != original))
{
throw new Exception("The Override specified was not found!");
}
OverrideWrapper wrapper = OverrideManager.Overrides.First(a => a.Value.Original == original).Value;
return(wrapper.CallOriginal(args, instance));
}
/// <summary>
/// Read a list of attributes
/// </summary>
private void ReadAttributes(ConstantPool cp, IModifiableAttributeProvider provider)
{
var count = stream.ReadU2();
for (var i = 0; i < count; i++)
{
var nameIndex = stream.ReadU2();
var name = cp.GetEntry <ConstantPoolUtf8>(nameIndex).Value;
var length = stream.ReadU4();
Attribute attr;
int tmp;
switch (name)
{
case CodeAttribute.AttributeName:
attr = ReadCodeAttribute((MethodDefinition)provider, cp);
break;
case ConstantValueAttribute.AttributeName:
tmp = stream.ReadU2();
attr = new ConstantValueAttribute(((IConstantPoolValue)cp[tmp]).Value);
break;
case ExceptionsAttribute.AttributeName:
attr = ReadExceptionsAttribute(cp);
break;
case InnerClassesAttribute.AttributeName:
attr = ReadInnerClassesAttribute(cp);
break;
case SyntheticAttribute.AttributeName:
attr = new SyntheticAttribute();
break;
case SourceFileAttribute.AttributeName:
tmp = stream.ReadU2();
attr = new SourceFileAttribute(cp.GetEntry <ConstantPoolUtf8>(tmp).Value);
break;
case LineNumberTableAttribute.AttributeName:
attr = ReadLineNumberTableAttribute();
break;
case LocalVariableTableAttribute.AttributeName:
attr = ReadLocalVariableTableAttribute(cp);
break;
case DeprecatedAttribute.AttributeName:
attr = new DeprecatedAttribute();
break;
case OverrideAttribute.AttributeName:
attr = new OverrideAttribute();
break;
case SignatureAttribute.AttributeName:
tmp = stream.ReadU2();
attr = new SignatureAttribute(cp.GetEntry <ConstantPoolUtf8>(tmp).Value);
break;
case RuntimeVisibleAnnotationsAttribute.AttributeName:
attr = new RuntimeVisibleAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case RuntimeInvisibleAnnotationsAttribute.AttributeName:
attr = new RuntimeInvisibleAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case RuntimeVisibleParameterAnnotationsAttribute.AttributeName:
attr = new RuntimeVisibleParameterAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case RuntimeInvisibleParameterAnnotationsAttribute.AttributeName:
attr = new RuntimeInvisibleParameterAnnotationsAttribute(ReadAnnotationsAttribute(cp));
break;
case AnnotationDefaultAttribute.AttributeName:
attr = new AnnotationDefaultAttribute(ReadElementValue(cp));
break;
default:
stream.Skip(length);
attr = new UnknownAttribute(name);
break;
}
provider.Add(attr);
}
provider.AttributesLoaded();
}
public OverrideDetails(OverrideAttribute attribute, Type containingType, PropertyInfo property)
{
Attribute = attribute;
ContainingType = containingType;
Property = property;
}
