本文整理汇总了C#中System.Reflection.Module.ResolveField方法的典型用法代码示例。如果您正苦于以下问题：C# Module.ResolveField方法的具体用法？C# Module.ResolveField怎么用？C# Module.ResolveField使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类System.Reflection.Module的用法示例。
在下文中一共展示了Module.ResolveField方法的8个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: OpToken
public OpToken(Code aOpCode, int aPos, int aNextPos, Int32 aValue, Module aModule, Type[] aTypeGenericArgs, Type[] aMethodGenericArgs, ExceptionHandlingClause aCurrentExceptionHandler)
: base(aOpCode, aPos, aNextPos, aCurrentExceptionHandler) {
Value = aValue;
if (ValueIsField)
{
ValueField = aModule.ResolveField(Value, aTypeGenericArgs, aMethodGenericArgs);
}
if (ValueIsType)
{
ValueType = aModule.ResolveType(Value, aTypeGenericArgs, aMethodGenericArgs);
}
}示例2: ConstructInstructions
/// <summary>
/// Constructs the array of ILInstructions according to the IL byte code.
/// </summary>
/// <param name="module"></param>
private void ConstructInstructions(Module module)
{
byte[] il = this.il;
int position = 0;
instructions = new List<ILInstruction>();
while (position < il.Length)
{
ILInstruction instruction = new ILInstruction();
// get the operation code of the current instruction
OpCode code = OpCodes.Nop;
ushort value = il[position++];
if (value != 0xfe)
{
code = Globals.singleByteOpCodes[(int)value];
}
else
{
value = il[position++];
code = Globals.multiByteOpCodes[(int)value];
value = (ushort)(value | 0xfe00);
}
instruction.Code = code;
instruction.Offset = position - 1;
int metadataToken = 0;
// get the operand of the current operation
switch (code.OperandType)
{
case OperandType.InlineBrTarget:
metadataToken = ReadInt32(il, ref position);
metadataToken += position;
instruction.Operand = metadataToken;
break;
// patched from comments on CP -hwd
case OperandType.InlineField:
metadataToken = ReadInt32(il, ref position);
if (mi is ConstructorInfo)
{
instruction.Operand = module.ResolveField(metadataToken,
mi.DeclaringType.GetGenericArguments(), null);
}
else
{
instruction.Operand = module.ResolveField(metadataToken,
mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
break;
// patched from comments on CP -hwd
case OperandType.InlineMethod:
metadataToken = ReadInt32(il, ref position);
try
{
if (mi is ConstructorInfo)
{
instruction.Operand = module.ResolveMethod(metadataToken,
mi.DeclaringType.GetGenericArguments(), null);
}
else
{
instruction.Operand = module.ResolveMethod(metadataToken,
mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
}
catch
{
if (mi is ConstructorInfo)
{
instruction.Operand = module.ResolveMember(metadataToken,
mi.DeclaringType.GetGenericArguments(), null);
}
else
{
instruction.Operand = module.ResolveMember(metadataToken,
mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
}
break;
case OperandType.InlineSig:
metadataToken = ReadInt32(il, ref position);
instruction.Operand = module.ResolveSignature(metadataToken);
break;
// patched from comments on CP -hwd
case OperandType.InlineTok:
metadataToken = ReadInt32(il, ref position);
//try
//{
if (mi is ConstructorInfo)
{
instruction.Operand = module.ResolveType(metadataToken,
mi.DeclaringType.GetGenericArguments(), null);
}
else
//.........这里部分代码省略.........
示例3: ConstructInstructions
/// <summary>
/// Constructs the array of ILInstructions according to the IL byte code.
/// </summary>
/// <param name="module"></param>
private void ConstructInstructions(Module module)
{
byte[] il = this.il;
int position = 0;
instructions = new List<ILInstruction>();
while (position < il.Length)
{
ILInstruction instruction = new ILInstruction();
// get the operation code of the current instruction
OpCode code = OpCodes.Nop;
ushort value = il[position++];
if (value != 0xfe)
{
code = Globals.singleByteOpCodes[(int)value];
}
else
{
value = il[position++];
code = Globals.multiByteOpCodes[(int)value];
value = (ushort)(value | 0xfe00);
}
instruction.Code = code;
instruction.Offset = position - 1;
int metadataToken = 0;
// get the operand of the current operation
switch (code.OperandType)
{
case OperandType.InlineBrTarget:
metadataToken = ReadInt32(il, ref position);
metadataToken += position;
instruction.Operand = metadataToken;
break;
case OperandType.InlineField:
metadataToken = ReadInt32(il, ref position);
instruction.Operand = module.ResolveField(metadataToken);
break;
case OperandType.InlineMethod:
metadataToken = ReadInt32(il, ref position);
try
{
instruction.Operand = module.ResolveMethod(metadataToken);
}
catch
{
try
{
instruction.Operand = module.ResolveMember(metadataToken);
}
catch (Exception)
{
//Try generic method
try
{
instruction.Operand = module.ResolveMethod(metadataToken, mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
catch (Exception)
{
//Try generic member
try
{
instruction.Operand = module.ResolveMember(metadataToken, mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
catch (Exception)
{
throw;
}
}
}
}
break;
case OperandType.InlineSig:
metadataToken = ReadInt32(il, ref position);
instruction.Operand = module.ResolveSignature(metadataToken);
break;
case OperandType.InlineTok:
metadataToken = ReadInt32(il, ref position);
try
{
instruction.Operand = module.ResolveType(metadataToken);
}
catch
{
}
// SSS : see what to do here
break;
case OperandType.InlineType:
metadataToken = ReadInt32(il, ref position);
// now we call the ResolveType always using the generic attributes type in order
// to support decompilation of generic methods and classes
// thanks to the guys from code project who commented on this missing feature
try
//.........这里部分代码省略.........
示例4: CopyOpcode
void CopyOpcode(byte[] Bytes, ref int i, ILGenerator Gen, Module Origin, List<int> ExceptionTrinkets, Dictionary<int, Label[]> LabelOrigins)
{
OpCode Code = GetOpcode(Bytes, ref i);
// These are emitted by exception handling copier if an exception
// block is imminent. If not, copy them as usual.
if(Code == OpCodes.Leave && ExceptionTrinkets.Contains(i + 5))
{
i += 4;
return;
}
else if(Code == OpCodes.Leave_S && ExceptionTrinkets.Contains(i + 2))
{
// This is a rather tricky one. See the comment preceding the call to MineLabels above.
i++;
return;
}
else if(Code == OpCodes.Endfinally && ExceptionTrinkets.Contains(i+1)) return;
switch(Code.OperandType)
{
// If no argument, then re-emit the opcode
case OperandType.InlineNone:
{
Gen.Emit(Code);
break;
}
// If argument is a method, re-emit the method reference
case OperandType.InlineMethod:
{
int Token = BitHelper.ReadInteger(Bytes, ref i);
MethodBase Base = Origin.ResolveMethod(Token);
if(Base is MethodInfo)
Gen.Emit(Code, GrabMethod(Base as MethodInfo));
else if(Base is ConstructorInfo)
Gen.Emit(Code, GrabConstructor(Base as ConstructorInfo));
else throw new InvalidOperationException("Inline method is neither method nor constructor.");
break;
}
// Argument is a field reference
case OperandType.InlineField:
{
int Token = BitHelper.ReadInteger(Bytes, ref i);
FieldInfo Field = Origin.ResolveField(Token);
Gen.Emit(Code, GrabField(Field));
break;
}
// Argument is a type reference
case OperandType.InlineType:
{
int Token = BitHelper.ReadInteger(Bytes, ref i);
Type Ref = Origin.ResolveType(Token);
Gen.Emit(Code, GrabType(Ref));
break;
}
// Argument is an inline string
case OperandType.InlineString:
{
int Token = BitHelper.ReadInteger(Bytes, ref i);
string Copy = Origin.ResolveString(Token);
Gen.Emit(Code, Copy);
break;
}
// Argument is a metadata token
case OperandType.InlineTok:
{
int Token = BitHelper.ReadInteger(Bytes, ref i);
MemberInfo Info = Origin.ResolveMember(Token);
if(Info.MemberType == MemberTypes.Field)
{
if(Code != OpCodes.Ldtoken || !TryReplaceBackingField(Bytes, i, Gen, Origin))
Gen.Emit(Code, GrabField(Info as FieldInfo));
}
else if(Info.MemberType == MemberTypes.Method)
Gen.Emit(Code, GrabMethod(Info as MethodInfo));
else if(Info.MemberType == MemberTypes.TypeInfo || Info.MemberType == MemberTypes.NestedType)
Gen.Emit(Code, GrabType(Info as Type));
else throw new InvalidOperationException("Inline token is neither field, nor method, nor type");
break;
}
// Argument is a switch map
case OperandType.InlineSwitch:
{
if(!LabelOrigins.ContainsKey(i))
throw new Exception("No switchmap found for RVA "+i.ToString("X"));
Label[] Labels = LabelOrigins[i];
i += 4 + Labels.Length*4;
Gen.Emit(Code, Labels);
//.........这里部分代码省略.........
示例5: TryReplaceBackingField
bool TryReplaceBackingField(byte[] Bytes, int i, ILGenerator Gen, Module Origin)
{
// With a bit of clairvoyance we try to determine if we're dealing with
// a specific type of array initializer that the C#-compiler uses.
if(Bytes[i+1] != (byte) OpCodes.Call.Value)
return false;
if(Bytes[i+6] != (byte) OpCodes.Stsfld.Value)
return false;
i += 6;
int Token = BitHelper.ReadInteger(Bytes, ref i);
FieldInfo Info = Origin.ResolveField(Token);
FieldInfo Ours = GrabField(Info);
Gen.Emit(OpCodes.Ldtoken, BackingFields[Ours]);
return true;
}示例6: Write
private void Write(BinaryWriter bw, Module module, MethodBody mb)
{
var locals = mb.LocalVariables;
bw.Write(locals.Count);
for (int i=0;i< locals.Count;i++)
{
bw.Write(locals[i].LocalType.FullName);
bw.Write(locals[i].IsPinned);
}
var il = mb.GetILAsByteArray();
for(int i = 0; i < il.Length;)
{
EArgumentType argType = EArgumentType.None;
var opcode = (EOpCode)il[i];
bw.Write(il[i]);
i++;
if(opcode == EOpCode.Extended)
{
bw.Write(il[i]);
argType = ((EExtendedOpCode)il[i]).ArgFor();
i++;
}
else
argType = opcode.ArgFor();
switch (argType)
{
case EArgumentType.Field:
var fi = module.ResolveField(BitConverter.ToInt32(il, i));
i += 4;
bw.Write(Names.Field(fi));
break;
case EArgumentType.Float32:
bw.Write(BitConverter.ToSingle(il, i));
i += 4;
break;
case EArgumentType.Float64:
bw.Write(BitConverter.ToDouble(il, i));
i += 8;
break;
case EArgumentType.Token:
case EArgumentType.Int32:
bw.Write(BitConverter.ToInt32(il, i));
i += 4;
break;
case EArgumentType.Int64:
bw.Write(BitConverter.ToInt64(il, i));
i += 8;
break;
case EArgumentType.Int8:
bw.Write((sbyte)il[i]);
i++;
break;
case EArgumentType.ListOfInt:
uint count = BitConverter.ToUInt32(il, i);
bw.Write(count);
i += 4;
while(count > 0)
{
bw.Write(BitConverter.ToInt32(il, i));
i += 4;
}
break;
case EArgumentType.Method:
var mi = module.ResolveMethod(BitConverter.ToInt32(il, i));
i += 4;
bw.Write(Names.Method(mi));
break;
case EArgumentType.String:
var str = module.ResolveString(BitConverter.ToInt32(il, i));
i += 4;
bw.Write(str);
break;
case EArgumentType.Type:
var t = module.ResolveType(BitConverter.ToInt32(il, i));
i += 4;
bw.Write(t.FullName);
break;
case EArgumentType.Uint16:
bw.Write(BitConverter.ToUInt16(il, i));
i += 2;
break;
case EArgumentType.Uint32:
bw.Write(BitConverter.ToUInt32(il, i));
i += 4;
break;
case EArgumentType.Uint8:
bw.Write(il[i]);
i++;
break;
}
}
bw.Write((byte)EOpCode.Terminator);
/*
var handlers = mb.ExceptionHandlingClauses;
m_bw.Write(handlers.Count);
//.........这里部分代码省略.........
示例7: ConstructInstructions
private void ConstructInstructions(Module module)
{
byte[] localIlbytes = this.il;
int position = 0;
while (position < localIlbytes.Length)
{
var instruction = new ILInstruction();
// get the operation code of the current instruction
OpCode code;
ushort value = localIlbytes[position++];
if (GlobalIntermediateLanguageConstants.SingleByteOpCodes.Count == 0)
{
throw new InvalidOperationException(
"Attempt to use Method Body Reader before Global Intermediate Language Constants has been initialised. Global Intermediate Language Constants. Load Op Codes must be called once.");
}
if (value != 0xfe)
{
code = GlobalIntermediateLanguageConstants.SingleByteOpCodes[value];
}
else
{
value = localIlbytes[position++];
code = GlobalIntermediateLanguageConstants.MultiByteOpCodes[value];
}
instruction.Code = code;
instruction.Offset = position - 1;
int metadataToken;
// get the operand of the current operation
switch (code.OperandType)
{
case OperandType.InlineBrTarget:
metadataToken = ReadInt32(ref position);
metadataToken += position;
instruction.Operand = metadataToken;
break;
case OperandType.InlineField:
// TODO All these try catch blocks need to go
try
{
metadataToken = ReadInt32(ref position);
instruction.Operand = module.ResolveField(metadataToken);
}
catch
{
instruction.Operand = new object();
}
break;
case OperandType.InlineMethod:
metadataToken = ReadInt32(ref position);
try
{
instruction.Operand = module.ResolveMethod(metadataToken);
}
catch
{
instruction.Operand = new object();
}
break;
case OperandType.InlineSig:
metadataToken = ReadInt32(ref position);
instruction.Operand = module.ResolveSignature(metadataToken);
break;
case OperandType.InlineTok:
metadataToken = ReadInt32(ref position);
try
{
instruction.Operand = module.ResolveType(metadataToken);
}
catch
{
}
// TODO : see what to do here
break;
case OperandType.InlineType:
metadataToken = ReadInt32(ref position);
// now we call the ResolveType always using the generic attributes type in order
// to support decompilation of generic methods and classes
// thanks to the guys from code project who commented on this missing feature
Type[] declaringTypeGenericArgs = this.mi.DeclaringType.GetGenericArguments();
Type[] genericArgs = null;
if (this.mi.IsGenericMethod)
{
genericArgs = this.mi.GetGenericArguments();
}
instruction.Operand = module.ResolveType(metadataToken, declaringTypeGenericArgs, genericArgs);
break;
case OperandType.InlineI:
{
instruction.Operand = ReadInt32(ref position);
break;
//.........这里部分代码省略.........
示例8: ToString
public string ToString( Module module )
{
OpCode opCode = OpCode;
string operandStr = "";
int operandStart = _startIndex + opCode.Size;
switch (opCode.OperandType)
{
case OperandType.InlineBrTarget:
break;
case OperandType.InlineField:
operandStr = module.ResolveField(_il.GetInt32(operandStart)).Name;
break;
case OperandType.InlineI:
operandStr = _il.GetInt32(operandStart).ToString();
break;
case OperandType.InlineI8:
operandStr = _il.GetInt64(operandStart).ToString();
break;
case OperandType.InlineMethod:
operandStr = module.ResolveMethod(_il.GetInt32(operandStart)).Name;
break;
case OperandType.InlineNone:
break;
case OperandType.InlineR:
operandStr = _il.GetDouble(operandStart).ToString();
break;
case OperandType.InlineSig:
operandStr = string.Join("",
module.ResolveSignature(_il.GetInt32(operandStart))
.Select(b => b.ToString("X2")));
break;
case OperandType.InlineString:
operandStr = "\"" + module.ResolveString(_il.GetInt32(operandStart)) + "\"";
break;
case OperandType.InlineSwitch:
break;
case OperandType.InlineTok:
operandStr = module.ResolveType(_il.GetInt32(operandStart)).Name;
break;
case OperandType.InlineType:
operandStr = module.ResolveType(_il.GetInt32(operandStart)).Name;
break;
case OperandType.InlineVar:
operandStr = _il.GetInt16(operandStart).ToString();
break;
case OperandType.ShortInlineBrTarget:
break;
case OperandType.ShortInlineI:
operandStr = ((int) _il[operandStart]).ToString();
break;
case OperandType.ShortInlineR:
operandStr = _il.GetSingle(operandStart).ToString();
break;
case OperandType.ShortInlineVar:
operandStr = ((int) _il[operandStart]).ToString();
break;
}
return opCode.Name + " " + operandStr;
}