public static void InitializeArray(Array array, RuntimeFieldHandle fldHandle)
{
// Arguments:
// Array aArray, RuntimeFieldHandle aFieldHandle
XS.Set(XSRegisters.EDI, XSRegisters.EBP, sourceDisplacement: 20); // array
XS.Set(XSRegisters.ESI, XSRegisters.EBP, sourceDisplacement: 12); // aFieldHandle
XS.Add(XSRegisters.EDI, 8);
XS.Push(EDI, isIndirect: true); // element size
XS.Add(XSRegisters.EDI, 4);
XS.Set(EAX, EDI, sourceIsIndirect: true);
XS.Multiply(ESP, isIndirect: true, size: RegisterSize.Int32);
XS.Pop(XSRegisters.ECX);
XS.Set(XSRegisters.ECX, XSRegisters.EAX);
XS.Set(XSRegisters.EAX, 0);
XS.Add(XSRegisters.EDI, 4);
XS.Label(".StartLoop");
XS.Set(DL, ESI, sourceIsIndirect: true);
XS.Set(EDI, DL, destinationIsIndirect: true);
XS.Add(XSRegisters.EAX, 1);
XS.Add(XSRegisters.ESI, 1);
XS.Add(XSRegisters.EDI, 1);
XS.Compare(XSRegisters.EAX, XSRegisters.ECX);
XS.Jump(CPUx86.ConditionalTestEnum.Equal, ".EndLoop");
XS.Jump(".StartLoop");
XS.Label(".EndLoop");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(7);
var t1 = new Type();
assert.Ok(t1 != null, "#565 t1");
var t2 = new ValueType();
assert.Ok(t2 != null, "#565 t2");
var t3 = new IntPtr();
assert.Ok(t3.GetType() == typeof(IntPtr) , "#565 t3");
var t4 = new UIntPtr();
assert.Ok(t4.GetType() == typeof(UIntPtr), "#565 t4");
var t5 = new ParamArrayAttribute();
assert.Ok(t5 != null, "#565 t5");
var t6 = new RuntimeTypeHandle();
assert.Ok(t6.GetType() == typeof(RuntimeTypeHandle), "#565 t6");
var t7 = new RuntimeFieldHandle();
assert.Ok(t7.GetType() == typeof(RuntimeFieldHandle), "#565 t7");
}
public static void InitializeArray(Array array, RuntimeFieldHandle fldHandle) {
// Arguments:
// Array aArray, RuntimeFieldHandle aFieldHandle
new CPUx86.Mov { DestinationReg = CPUx86.Registers.EDI, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0xC }; // array
new CPUx86.Mov { DestinationReg = CPUx86.Registers.ESI, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 8 };// aFieldHandle
new CPUx86.Add { DestinationReg = CPUx86.Registers.EDI, SourceValue = 8 };
new CPUx86.Push{DestinationReg=CPUx86.Registers.EDI, DestinationIsIndirect=true};
new CPUx86.Add { DestinationReg = CPUx86.Registers.EDI, SourceValue = 4 };
new CPUx86.Mov { DestinationReg = CPUx86.Registers.EAX, SourceReg = CPUx86.Registers.EDI, SourceIsIndirect = true };
new CPUx86.Multiply{DestinationReg=CPUx86.Registers.ESP, DestinationIsIndirect=true, Size=32};
new CPUx86.Pop { DestinationReg = CPUx86.Registers.ECX };
new CPUx86.Mov { DestinationReg = CPUx86.Registers.ECX, SourceReg = CPUx86.Registers.EAX };
new CPUx86.Mov { DestinationReg = CPUx86.Registers.EAX, SourceValue = 0 };
new CPUx86.Add { DestinationReg = CPUx86.Registers.EDI, SourceValue = 4 };
new Label(".StartLoop");
new CPUx86.Mov { DestinationReg = CPUx86.Registers.DL, SourceReg = CPUx86.Registers.ESI, SourceIsIndirect = true };
new CPUx86.Mov { DestinationReg = CPUx86.Registers.EDI, DestinationIsIndirect = true, SourceReg = CPUx86.Registers.DL };
new CPUx86.Add{DestinationReg = CPUx86.Registers.EAX, SourceValue=1};
new CPUx86.Add { DestinationReg = CPUx86.Registers.ESI, SourceValue = 1 };
new CPUx86.Add { DestinationReg = CPUx86.Registers.EDI, SourceValue = 1 };
new CPUx86.Compare { DestinationReg = CPUx86.Registers.EAX, SourceReg = CPUx86.Registers.ECX };
new CPUx86.ConditionalJump { Condition = CPUx86.ConditionalTestEnum.Equal, DestinationLabel = ".EndLoop" };
new CPUx86.Jump { DestinationLabel = ".StartLoop" };
new Label(".EndLoop");
}
internal object LoadRemoteFieldNew (IntPtr classPtr, IntPtr fieldPtr) {
Mono.RuntimeClassHandle classHandle = new Mono.RuntimeClassHandle (classPtr);
RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle (fieldPtr);
RuntimeTypeHandle typeHandle = classHandle.GetTypeHandle ();
FieldInfo field = FieldInfo.GetFieldFromHandle (fieldHandle);
if (InCurrentContext ()) {
object o = _rp._server;
return field.GetValue(o);
}
string typeName = Type.GetTypeFromHandle(typeHandle).FullName;
string fieldName = field.Name;
object[] inArgs = new object[] { typeName,
fieldName };
object[] outArgsMsg = new object[1];
MethodInfo minfo = typeof(object).GetMethod("FieldGetter", BindingFlags.NonPublic | BindingFlags.Instance);
if (minfo == null)
throw new MissingMethodException ("System.Object", "FieldGetter");
MonoMethodMessage msg = new MonoMethodMessage (minfo, inArgs, outArgsMsg);
object[] outArgs;
Exception exc;
RealProxy.PrivateInvoke (_rp, msg, out exc, out outArgs);
if (exc != null)
throw exc;
return outArgs[0];
}
public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType)
{
if (handle.IsNullHandle())
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
return RuntimeType.GetFieldInfo(declaringType.GetRuntimeType(), handle.GetRuntimeFieldInfo());
}
public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle)
{
if (handle.IsNullHandle())
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
#if !FEATURE_CORECLR
if (FrameworkEventSource.IsInitialized && FrameworkEventSource.Log.IsEnabled(EventLevel.Informational, FrameworkEventSource.Keywords.DynamicTypeUsage))
{
FrameworkEventSource.Log.BeginGetFieldFromHandle();
}
#endif
FieldInfo f = RuntimeType.GetFieldInfo(handle.GetRuntimeFieldInfo());
Type declaringType = f.DeclaringType;
#if !FEATURE_CORECLR
if (FrameworkEventSource.IsInitialized && FrameworkEventSource.Log.IsEnabled(EventLevel.Informational, FrameworkEventSource.Keywords.DynamicTypeUsage) && declaringType != null && f != null)
{
FrameworkEventSource.Log.EndGetFieldFromHandle(declaringType.GetFullNameForEtw(), f.GetFullNameForEtw());
}
#endif
if (declaringType != null && declaringType.IsGenericType)
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_FieldDeclaringTypeGeneric"),
f.Name, declaringType.GetGenericTypeDefinition()));
return f;
}
static StackObject *GetFieldFromHandle_20(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.RuntimeTypeHandle @declaringType = (System.RuntimeTypeHandle) typeof(System.RuntimeTypeHandle).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
System.RuntimeFieldHandle @handle = (System.RuntimeFieldHandle) typeof(System.RuntimeFieldHandle).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = System.Reflection.FieldInfo.GetFieldFromHandle(@handle, @declaringType);
object obj_result_of_this_method = result_of_this_method;
if (obj_result_of_this_method is CrossBindingAdaptorType)
{
return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
internal static void Initialize(RuntimeFieldHandle field, byte opKey)
{
FieldInfo fieldInfo = FieldInfo.GetFieldFromHandle(field);
byte[] sig = fieldInfo.Module.ResolveSignature(fieldInfo.MetadataToken);
int len = sig.Length;
int key = fieldInfo.GetOptionalCustomModifiers()[0].MetadataToken;
key += (fieldInfo.Name[Mutation.KeyI0] ^ sig[--len]) << Mutation.KeyI4;
key += (fieldInfo.Name[Mutation.KeyI1] ^ sig[--len]) << Mutation.KeyI5;
key += (fieldInfo.Name[Mutation.KeyI2] ^ sig[--len]) << Mutation.KeyI6;
len--;
key += (fieldInfo.Name[Mutation.KeyI3] ^ sig[--len]) << Mutation.KeyI7;
int token = Mutation.Placeholder(key);
token *= fieldInfo.GetCustomAttributes(false)[0].GetHashCode();
MethodBase method = fieldInfo.Module.ResolveMethod(token);
Type delegateType = fieldInfo.FieldType;
if (method.IsStatic)
fieldInfo.SetValue(null, Delegate.CreateDelegate(delegateType, (MethodInfo)method));
else {
DynamicMethod dm = null;
Type[] argTypes = null;
foreach (MethodInfo invoke in fieldInfo.FieldType.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance))
if (invoke.DeclaringType == delegateType) {
ParameterInfo[] paramTypes = invoke.GetParameters();
argTypes = new Type[paramTypes.Length];
for (int i = 0; i < argTypes.Length; i++)
argTypes[i] = paramTypes[i].ParameterType;
Type declType = method.DeclaringType;
dm = new DynamicMethod("", invoke.ReturnType, argTypes, (declType.IsInterface || declType.IsArray) ? delegateType : declType, true);
break;
}
DynamicILInfo info = dm.GetDynamicILInfo();
info.SetLocalSignature(new byte[] { 0x7, 0x0 });
var code = new byte[2 * argTypes.Length + 6];
int index = 0;
for (int i = 0; i < argTypes.Length; i++) {
code[index++] = 0x0e;
code[index++] = (byte)i;
}
code[index++] = (byte)((byte)fieldInfo.Name[Mutation.KeyI8] ^ opKey);
int dmToken = info.GetTokenFor(method.MethodHandle);
code[index++] = (byte)dmToken;
code[index++] = (byte)(dmToken >> 8);
code[index++] = (byte)(dmToken >> 16);
code[index++] = (byte)(dmToken >> 24);
code[index] = 0x2a;
info.SetCode(code, argTypes.Length + 1);
fieldInfo.SetValue(null, dm.CreateDelegate(delegateType));
}
}
//
// This overload of GetFieldForHandle only accepts handles for fields declared on non-generic types. To resolve handles for fields
// declared on generic types, you must pass the declaring type explicitly using the two-argument overload of GetFieldFromHandle.
//
// This is a vestige from desktop generic sharing that got itself enshrined in the code generated by the C# compiler for Linq Expressions.
//
public override sealed FieldInfo GetFieldFromHandle(RuntimeFieldHandle runtimeFieldHandle)
{
ExecutionEnvironment executionEnvironment = ReflectionCoreExecution.ExecutionEnvironment;
FieldHandle fieldHandle;
RuntimeTypeHandle declaringTypeHandle;
if (!executionEnvironment.TryGetFieldFromHandle(runtimeFieldHandle, out declaringTypeHandle, out fieldHandle))
throw new ArgumentException(SR.Argument_InvalidHandle);
FieldInfo fieldInfo = GetFieldInfo(declaringTypeHandle, fieldHandle);
if (fieldInfo.DeclaringType.IsConstructedGenericType) // For compat with desktop, insist that the caller pass us the declaring type to resolve members of generic types.
throw new ArgumentException(SR.Format(SR.Argument_FieldDeclaringTypeGeneric, fieldInfo));
return fieldInfo;
}
public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle)
{
if (handle.IsNullHandle())
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
}
FieldInfo fieldInfo = RuntimeType.GetFieldInfo(handle);
if ((fieldInfo.DeclaringType != null) && fieldInfo.DeclaringType.IsGenericType)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_FieldDeclaringTypeGeneric"), new object[] { fieldInfo.Name, fieldInfo.DeclaringType.GetGenericTypeDefinition() }));
}
return fieldInfo;
}
public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle)
{
if (handle.IsNullHandle())
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"), "handle");
FieldInfo f = RuntimeType.GetFieldInfo(handle.GetRuntimeFieldInfo());
Type declaringType = f.DeclaringType;
if (declaringType != null && declaringType.IsGenericType)
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_FieldDeclaringTypeGeneric"),
f.Name, declaringType.GetGenericTypeDefinition()));
return f;
}
public static void InitializeArray(uint* array, RuntimeFieldHandle handle)
{
MetadataFieldDefinitionStruct* fieldDefinition = (MetadataFieldDefinitionStruct*)((uint**)&handle)[0];
byte* arrayElements = (byte*)(array + 3);
// See FieldDefinition for format of field handle
byte* fieldData = fieldDefinition->FieldData;
uint dataLength = fieldDefinition->OffsetOrSize;
while (dataLength > 0)
{
*arrayElements = *fieldData;
arrayElements++;
fieldData++;
dataLength--;
}
}
public static void InitializeArray(uint* array, RuntimeFieldHandle handle)
{
uint* fieldDefinition = ((uint**)&handle)[0];
byte* arrayElements = (byte*)(array + 3);
// See FieldDefinition for format of field handle
byte* fieldData = (byte*)*(fieldDefinition + 4);
uint dataLength = *(fieldDefinition + 5);
while (dataLength > 0)
{
*arrayElements = *fieldData;
arrayElements++;
fieldData++;
dataLength--;
}
}
public static unsafe TypedReference MakeTypedReference(object target, FieldInfo[] flds)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (flds == null)
{
throw new ArgumentNullException("flds");
}
if (flds.Length == 0)
{
throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError"));
}
RuntimeFieldHandle[] handleArray = new RuntimeFieldHandle[flds.Length];
System.Type type = target.GetType();
for (int i = 0; i < flds.Length; i++)
{
FieldInfo info = flds[i];
if (!(info is RuntimeFieldInfo))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"));
}
if (info.IsInitOnly || info.IsStatic)
{
throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField"));
}
if ((type != info.DeclaringType) && !type.IsSubclassOf(info.DeclaringType))
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef"));
}
System.Type fieldType = info.FieldType;
if (fieldType.IsPrimitive)
{
throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve"));
}
if ((i < (flds.Length - 1)) && !fieldType.IsValueType)
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr"));
}
handleArray[i] = info.FieldHandle;
type = fieldType;
}
TypedReference reference = new TypedReference();
InternalMakeTypedReference((void*) &reference, target, handleArray, type.TypeHandle);
return reference;
}
private unsafe bool TryGetDynamicRuntimeFieldHandleComponents(RuntimeFieldHandle runtimeFieldHandle, out RuntimeTypeHandle declaringTypeHandle, out string fieldName)
{
IntPtr runtimeFieldHandleValue = *(IntPtr*)&runtimeFieldHandle;
// Special flag in the handle value to indicate it was dynamically allocated
Debug.Assert((runtimeFieldHandleValue.ToInt64() & 0x1) == 0x1);
runtimeFieldHandleValue = runtimeFieldHandleValue - 1;
DynamicFieldHandleInfo* fieldData = (DynamicFieldHandleInfo*)runtimeFieldHandleValue.ToPointer();
declaringTypeHandle = *(RuntimeTypeHandle*)&(fieldData->DeclaringType);
// FieldName points to the field name in NativeLayout format, so we parse it using a NativeParser
IntPtr fieldNamePtr = fieldData->FieldName;
fieldName = GetStringFromMemoryInNativeFormat(fieldNamePtr);
return true;
}
//
// This overload of GetFieldHandle can handle all field handles.
//
public override sealed FieldInfo GetFieldFromHandle(RuntimeFieldHandle runtimeFieldHandle, RuntimeTypeHandle declaringTypeHandle)
{
ExecutionEnvironment executionEnvironment = ReflectionCoreExecution.ExecutionEnvironment;
FieldHandle fieldHandle;
if (!executionEnvironment.TryGetFieldFromHandleAndType(runtimeFieldHandle, declaringTypeHandle, out fieldHandle))
{
// This may be a field declared on a non-generic type: this api accepts that too so try the other table.
RuntimeTypeHandle actualDeclaringTypeHandle;
if (!executionEnvironment.TryGetFieldFromHandle(runtimeFieldHandle, out actualDeclaringTypeHandle, out fieldHandle))
throw new ArgumentException(SR.Argument_InvalidHandle);
if (!actualDeclaringTypeHandle.Equals(declaringTypeHandle))
throw new ArgumentException(SR.Format(SR.Argument_ResolveFieldHandle,
declaringTypeHandle.GetTypeForRuntimeTypeHandle(),
actualDeclaringTypeHandle.GetTypeForRuntimeTypeHandle()));
}
FieldInfo fieldInfo = GetFieldInfo(declaringTypeHandle, fieldHandle);
return fieldInfo;
}
public static TypedReference MakeTypedReference(Object target, FieldInfo[] flds) {
if (target == null)
throw new ArgumentNullException("target");
if (flds == null)
throw new ArgumentNullException("flds");
if (flds.Length == 0)
throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError"));
else {
RuntimeFieldHandle[] fields = new RuntimeFieldHandle[flds.Length];
// For proper handling of Nullable<T> don't change GetType() to something like 'IsAssignableFrom'
// Currently we can't make a TypedReference to fields of Nullable<T>, which is fine.
Type targetType = target.GetType();
for (int i = 0; i < flds.Length; i++) {
FieldInfo field = flds[i];
if (!(field is RuntimeFieldInfo))
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"));
else if (field.IsInitOnly || field.IsStatic)
throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField"));
if (targetType != field.DeclaringType && !targetType.IsSubclassOf(field.DeclaringType))
throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef"));
Type fieldType = field.FieldType;
if (fieldType.IsPrimitive)
throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve"));
if (i < flds.Length - 1)
if (!fieldType.IsValueType)
throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr"));
fields[i] = field.FieldHandle;
targetType = fieldType;
}
TypedReference result = new TypedReference ();
// reference to TypedReference is banned, so have to pass result as pointer
unsafe
{
InternalMakeTypedReference(&result, target, fields, targetType.TypeHandle);
}
return result;
}
}
public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType)
{
if (handle.IsNullHandle())
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
#if !FEATURE_CORECLR
if (FrameworkEventSource.IsInitialized && FrameworkEventSource.Log.IsEnabled(EventLevel.Informational, FrameworkEventSource.Keywords.DynamicTypeUsage))
{
FrameworkEventSource.Log.BeginGetFieldFromHandle();
}
#endif
FieldInfo f = RuntimeType.GetFieldInfo(declaringType.GetRuntimeType(), handle.GetRuntimeFieldInfo());
#if !FEATURE_CORECLR
if (FrameworkEventSource.IsInitialized && FrameworkEventSource.Log.IsEnabled(EventLevel.Informational, FrameworkEventSource.Keywords.DynamicTypeUsage) && declaringType != null && f != null)
{
FrameworkEventSource.Log.EndGetFieldFromHandle(declaringType.GetRuntimeType().GetFullNameForEtw(), f.GetFullNameForEtw());
}
#endif
return f;
}
private static unsafe void GetSignature(ref SignatureStruct signature, void* pCorSig, int cCorSig, RuntimeFieldHandle fieldHandle, RuntimeMethodHandle methodHandle, RuntimeTypeHandle declaringTypeHandle)
{
_GetSignature(ref signature, pCorSig, cCorSig, fieldHandle.Value, methodHandle.Value, declaringTypeHandle.Value);
}
public Signature(RuntimeFieldHandle fieldHandle, RuntimeTypeHandle declaringTypeHandle)
{
SignatureStruct signature = new SignatureStruct();
GetSignature(ref signature, null, 0, fieldHandle, new RuntimeMethodHandle(null), declaringTypeHandle);
this.m_signature = signature;
}
public void InitializeArray_Default ()
{
RuntimeFieldHandle h = new RuntimeFieldHandle ();
RuntimeHelpers.InitializeArray (new Fielder ().array, h);
}
internal GenericFieldInfo(RuntimeFieldHandle fieldHandle, RuntimeTypeHandle context)
{
m_fieldHandle = fieldHandle;
m_context = context;
}
public void System_RuntimeFieldHandle_Value ()
{
RuntimeFieldHandle handle = new RuntimeFieldHandle ();
Assert.IsNotNull (handle, ".ctor");
Assert.Throws<MethodAccessException> (delegate {
Assert.IsNotNull (handle.Value);
}, "RuntimeFieldHandle.Value"); // new SC in SL4
}
private static extern bool IsSecurityTransparent(RuntimeFieldHandle fieldHandle);
public static void _register_field(Symbol globname, System.RuntimeFieldHandle hndl, Object value)
{
comp_hash_f[globname.v] = System.Reflection.FieldInfo.GetFieldFromHandle(hndl);
comp_hash[globname.v] = null;
Precompiler.symbols[globname] = value;
}
public unsafe bool Equals(RuntimeFieldHandle handle)
{
return handle.Value == Value;
}
private static extern bool IsSecurityTransparent(RuntimeFieldHandle fieldHandle);
public int GetTokenFor (RuntimeFieldHandle field) {
return this.method.GetILGenerator ().TokenGenerator.GetToken (FieldInfo.GetFieldFromHandle (field), false);
}
public bool Equals(RuntimeFieldHandle handle)
{
return(value == handle.Value);
}
public bool Equals(RuntimeFieldHandle handle)
{
return(handle.m_ptr == this.m_ptr);
}
[Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
public void GetFieldFromHandle2_Handle_Zero ()
{
object instance = new Class2 ();
RuntimeTypeHandle th = Type.GetTypeHandle (instance);
RuntimeFieldHandle fh = new RuntimeFieldHandle ();
try {
FieldInfo.GetFieldFromHandle (fh, th);
Assert.Fail ("#1");
} catch (ArgumentException ex) {
// Handle is not initialized
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsNull (ex.ParamName, "#5");
}
}
public bool Equals(RuntimeFieldHandle handle)
{
throw new NotImplementedException();
}
RuntimeFieldInfo[] GetFields_internal (string name, BindingFlags bindingAttr, RuntimeType reflectedType)
{
var refh = new RuntimeTypeHandle (reflectedType);
using (var h = new Mono.SafeGPtrArrayHandle (GetFields_native (name, bindingAttr))) {
int n = h.Length;
var a = new RuntimeFieldInfo[n];
for (int i = 0; i < n; i++) {
var fh = new RuntimeFieldHandle (h[i]);
a[i] = (RuntimeFieldInfo) FieldInfo.GetFieldFromHandle (fh, refh);
}
return a;
}
}
private static extern bool IsSecuritySafeCritical(RuntimeFieldHandle fieldHandle);
public int GetTokenFor (RuntimeFieldHandle field, RuntimeTypeHandle contextType) {
throw new NotImplementedException ();
}
public static System.Reflection.FieldInfo GetFieldFromHandle(System.RuntimeFieldHandle handle)
{
throw null;
}
private static extern bool IsSecuritySafeCritical(RuntimeFieldHandle fieldHandle);
public static System.Reflection.FieldInfo GetFieldFromHandle(System.RuntimeFieldHandle handle, System.RuntimeTypeHandle declaringType)
{
throw null;
}
internal static extern void CheckAttributeAccess(RuntimeFieldHandle fieldHandle, RuntimeModule decoratedTarget);
internal static extern void CheckAttributeAccess(RuntimeFieldHandle fieldHandle, RuntimeModule decoratedTarget);