public override void Emit(OpCode opcode, FieldInfo field)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
RuntimeFieldInfo runtimeField = field as RuntimeFieldInfo;
if (runtimeField == null)
{
throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, nameof(field));
}
int token;
if (field.DeclaringType == null)
{
token = GetTokenFor(runtimeField);
}
else
{
token = GetTokenFor(runtimeField, runtimeField.GetRuntimeType());
}
EnsureCapacity(7);
InternalEmit(opcode);
PutInteger4(token);
}
/// <include file='doc\Attribute.uex' path='docs/doc[@for="Attribute.GetHashCode"]/*' />
public override int GetHashCode()
{
BCLDebug.Assert((this.GetType() as RuntimeType) != null, "Only RuntimeType's are supported");
RuntimeType runtimeType = (RuntimeType)this.GetType();
FieldInfo[] fields = runtimeType.InternalGetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, false);
Object vThis = null;
for (int i = 0; i < fields.Length; i++)
{
RuntimeFieldInfo runtimeField = fields[i] as RuntimeFieldInfo;
vThis = runtimeField.InternalGetValue(this, false);
if (vThis != null)
{
break;
}
}
if (vThis != null)
{
return(vThis.GetHashCode());
}
return(runtimeType.GetHashCode());
}
public override void Emit(OpCode opcode, FieldInfo field)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
Contract.EndContractBlock();
RuntimeFieldInfo runtimeField = field as RuntimeFieldInfo;
if (runtimeField == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"), nameof(field));
}
int token;
if (field.DeclaringType == null)
{
token = GetTokenFor(runtimeField);
}
else
{
token = GetTokenFor(runtimeField, runtimeField.GetRuntimeType());
}
EnsureCapacity(7);
InternalEmit(opcode);
PutInteger4(token);
}
public override void Emit(OpCode opcode, FieldInfo field)
{
if (field == (FieldInfo)null)
{
throw new ArgumentNullException("field");
}
RuntimeFieldInfo runtimeField1 = field as RuntimeFieldInfo;
if ((FieldInfo)runtimeField1 == (FieldInfo)null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"), "field");
}
int tokenFor;
if (field.DeclaringType == (Type)null)
{
tokenFor = this.GetTokenFor(runtimeField1);
}
else
{
RuntimeFieldInfo runtimeField2 = runtimeField1;
RuntimeType runtimeType = runtimeField2.GetRuntimeType();
tokenFor = this.GetTokenFor(runtimeField2, runtimeType);
}
this.EnsureCapacity(7);
this.InternalEmit(opcode);
this.PutInteger4(tokenFor);
}
// Token: 0x060048BE RID: 18622 RVA: 0x001068BC File Offset: 0x00104ABC
public override void Emit(OpCode opcode, FieldInfo field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
RuntimeFieldInfo runtimeFieldInfo = field as RuntimeFieldInfo;
if (runtimeFieldInfo == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"), "field");
}
int tokenFor;
if (field.DeclaringType == null)
{
tokenFor = this.GetTokenFor(runtimeFieldInfo);
}
else
{
tokenFor = this.GetTokenFor(runtimeFieldInfo, runtimeFieldInfo.GetRuntimeType());
}
base.EnsureCapacity(7);
base.InternalEmit(opcode);
base.PutInteger4(tokenFor);
}
private FieldInfo GetFieldInfo(RuntimeTypeHandle declaringTypeHandle, FieldHandle fieldHandle)
{
RuntimeTypeInfo contextTypeInfo = declaringTypeHandle.GetTypeForRuntimeTypeHandle();
RuntimeNamedTypeInfo definingTypeInfo = contextTypeInfo.AnchoringTypeDefinitionForDeclaredMembers;
MetadataReader reader = definingTypeInfo.Reader;
return(RuntimeFieldInfo.GetRuntimeFieldInfo(fieldHandle, definingTypeInfo, contextTypeInfo));
}
internal SerializationFieldInfo(RuntimeFieldInfo field, String namePrefix)
{
Contract.Assert(field != null, "[SerializationFieldInfo.ctor]field!=null");
Contract.Assert(namePrefix != null, "[SerializationFieldInfo.ctor]namePrefix!=null");
m_field = field;
m_serializationName = String.Concat(namePrefix, FakeNameSeparatorString, m_field.Name);
}
// Token: 0x06001072 RID: 4210 RVA: 0x00031470 File Offset: 0x0002F670
internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
{
if ((field.Attributes & FieldAttributes.NotSerialized) == FieldAttributes.PrivateScope)
{
return(null);
}
return(new NonSerializedAttribute());
}
internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
{
int num;
if ((field.DeclaringType != null) && field.GetRuntimeModule().MetadataImport.GetFieldOffset(field.DeclaringType.MetadataToken, field.MetadataToken, out num))
{
return(new FieldOffsetAttribute(num));
}
return(null);
}
internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
{
int offset;
if (field.DeclaringType != (Type)null && field.GetRuntimeModule().MetadataImport.GetFieldOffset(field.DeclaringType.MetadataToken, field.MetadataToken, out offset))
{
return((Attribute) new FieldOffsetAttribute(offset));
}
return((Attribute)null);
}
private FieldInfo GetFieldInfo(RuntimeTypeHandle declaringTypeHandle, FieldHandle fieldHandle)
{
RuntimeTypeInfo contextTypeInfo = declaringTypeHandle.GetTypeForRuntimeTypeHandle();
RuntimeNamedTypeInfo definingTypeInfo = contextTypeInfo.AnchoringTypeDefinitionForDeclaredMembers;
MetadataReader reader = definingTypeInfo.Reader;
// RuntimeFieldHandles always yield FieldInfo's whose ReflectedType equals the DeclaringType.
RuntimeTypeInfo reflectedType = contextTypeInfo;
return(RuntimeFieldInfo.GetRuntimeFieldInfo(fieldHandle, definingTypeInfo, contextTypeInfo, reflectedType));
}
private int GetTokenFor(RuntimeFieldInfo runtimeField)
{
if (this.ProfileAPICheck)
{
RtFieldInfo rtFieldInfo = runtimeField as RtFieldInfo;
if ((FieldInfo)rtFieldInfo != (FieldInfo)null && (rtFieldInfo.InvocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NON_W8P_FX_API) != INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_APIInvalidForCurrentContext", (object)rtFieldInfo.FullName));
}
}
return(this.m_scope.GetTokenFor(runtimeField.FieldHandle));
}
public sealed override void MakeTypedReference(object target, FieldInfo[] flds, out Type type, out int offset)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (flds == null)
{
throw new ArgumentNullException(nameof(flds));
}
if (flds.Length == 0)
{
throw new ArgumentException(SR.Arg_ArrayZeroError);
}
offset = RuntimeAugments.ObjectHeaderSize;
Type targetType = target.GetType();
for (int i = 0; i < flds.Length; i++)
{
RuntimeFieldInfo field = flds[i] as RuntimeFieldInfo;
if (field == null)
{
throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo);
}
if (field.IsInitOnly || field.IsStatic)
{
throw new ArgumentException(SR.Argument_TypedReferenceInvalidField);
}
// For proper handling of Nullable<T> don't change to something like 'IsAssignableFrom'
// Currently we can't make a TypedReference to fields of Nullable<T>, which is fine.
Type declaringType = field.DeclaringType;
if (targetType != declaringType && !targetType.IsSubclassOf(declaringType))
{
throw new MissingMemberException(SR.MissingMemberTypeRef); // MissingMemberException is a strange exception to throw, but it is the compatible exception.
}
Type fieldType = field.FieldType;
if (fieldType.IsPrimitive)
{
throw new ArgumentException(SR.Arg_TypeRefPrimitve); // This check exists for compatibility (why such an ad-hoc restriction?)
}
if (i < (flds.Length - 1) && !fieldType.IsValueType)
{
throw new MissingMemberException(SR.MissingMemberNestErr); // MissingMemberException is a strange exception to throw, but it is the compatible exception.
}
targetType = fieldType;
offset = checked (offset + field.Offset);
}
type = targetType;
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
if (this.m_ptr == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState"));
}
RuntimeFieldInfo value = (RuntimeFieldInfo)RuntimeType.GetFieldInfo(this.GetRuntimeFieldInfo());
info.AddValue("FieldObj", value, typeof(RuntimeFieldInfo));
}
[System.Security.SecurityCritical] // auto-generated
internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
{
int fieldOffset;
if (field.DeclaringType != null &&
#if MONO
(fieldOffset = field.GetFieldOffset()) >= 0)
#else
field.GetRuntimeModule().MetadataImport.GetFieldOffset(field.DeclaringType.MetadataToken, field.MetadataToken, out fieldOffset))
#endif
{ return(new FieldOffsetAttribute(fieldOffset)); }
return(null);
}
public unsafe 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"));
}
IntPtr[] array = new IntPtr[flds.Length];
RuntimeType runtimeType = (RuntimeType)target.GetType();
for (int i = 0; i < flds.Length; i++)
{
RuntimeFieldInfo runtimeFieldInfo = flds[i] as RuntimeFieldInfo;
if (runtimeFieldInfo == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"));
}
if (runtimeFieldInfo.IsInitOnly || runtimeFieldInfo.IsStatic)
{
throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField"));
}
if (runtimeType != runtimeFieldInfo.GetDeclaringTypeInternal() && !runtimeType.IsSubclassOf(runtimeFieldInfo.GetDeclaringTypeInternal()))
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef"));
}
RuntimeType runtimeType2 = (RuntimeType)runtimeFieldInfo.FieldType;
if (runtimeType2.IsPrimitive)
{
throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve"));
}
if (i < flds.Length - 1 && !runtimeType2.IsValueType)
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr"));
}
array[i] = runtimeFieldInfo.FieldHandle.Value;
runtimeType = runtimeType2;
}
TypedReference result = default(TypedReference);
TypedReference.InternalMakeTypedReference((void *)(&result), target, array, runtimeType);
return(result);
}
public static Object[] GetObjectData(Object obj, MemberInfo[] members)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (members == null)
{
throw new ArgumentNullException("members");
}
int numberOfMembers = members.Length;
Object[] data = new Object[numberOfMembers];
MemberInfo mi;
for (int i = 0; i < numberOfMembers; i++)
{
mi = members[i];
if (mi == null)
{
throw new ArgumentNullException("members", String.Format(Environment.GetResourceString("ArgumentNull_NullMember"), i));
}
if (mi.MemberType == MemberTypes.Field)
{
BCLDebug.Assert(mi is RuntimeFieldInfo || mi is SerializationFieldInfo,
"[FormatterServices.GetObjectData]mi is RuntimeFieldInfo || mi is SerializationFieldInfo.");
RuntimeFieldInfo rfi = mi as RuntimeFieldInfo;
if (rfi != null)
{
data[i] = rfi.InternalGetValue(obj, false);
}
else
{
data[i] = ((SerializationFieldInfo)mi).InternalGetValue(obj, false);
}
}
else
{
throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMemberInfo"));
}
}
return(data);
}
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"));
}
IntPtr[] flds1 = new IntPtr[flds.Length];
RuntimeType lastFieldType = (RuntimeType)target.GetType();
for (int index = 0; index < flds.Length; ++index)
{
RuntimeFieldInfo runtimeFieldInfo = flds[index] as RuntimeFieldInfo;
if ((FieldInfo)runtimeFieldInfo == (FieldInfo)null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo"));
}
if (runtimeFieldInfo.IsInitOnly || runtimeFieldInfo.IsStatic)
{
throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField"));
}
if (lastFieldType != runtimeFieldInfo.GetDeclaringTypeInternal() && !lastFieldType.IsSubclassOf((System.Type)runtimeFieldInfo.GetDeclaringTypeInternal()))
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef"));
}
RuntimeType runtimeType = (RuntimeType)runtimeFieldInfo.FieldType;
if (runtimeType.IsPrimitive)
{
throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve"));
}
if (index < flds.Length - 1 && !runtimeType.IsValueType)
{
throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr"));
}
flds1[index] = runtimeFieldInfo.FieldHandle.Value;
lastFieldType = runtimeType;
}
TypedReference typedReference = new TypedReference();
TypedReference.InternalMakeTypedReference((void *)&typedReference, target, flds1, lastFieldType);
return(typedReference);
}
internal static void SerializationSetValue(MemberInfo fi, Object target, Object value)
{
BCLDebug.Assert(fi is RuntimeFieldInfo || fi is SerializationFieldInfo,
"[SerializationSetValue]fi is RuntimeFieldInfo || fi is SerializationFieldInfo. Contact JRoxe if you see this assert.");
RuntimeFieldInfo rfi = fi as RuntimeFieldInfo;
if (rfi != null)
{
rfi.InternalSetValue(target, value, (BindingFlags)0, Type.DefaultBinder, null, false, true);
}
else
{
((SerializationFieldInfo)fi).InternalSetValue(target, value, (BindingFlags)0, Type.DefaultBinder, null, false, true);
}
}
private int GetTokenFor(RuntimeFieldInfo runtimeField)
{
#if FEATURE_APPX
if (ProfileAPICheck)
{
RtFieldInfo rtField = runtimeField as RtFieldInfo;
if (rtField != null && (rtField.InvocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NON_W8P_FX_API) != 0)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_APIInvalidForCurrentContext", rtField.FullName));
}
}
#endif
return(m_scope.GetTokenFor(runtimeField.FieldHandle));
}
/// <include file='doc\RuntimeFieldHandle.uex' path='docs/doc[@for="RuntimeFieldHandle.GetObjectData"]/*' />
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
if (m_ptr == (IntPtr)0)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState"));
}
RuntimeFieldInfo fldInfo = (RuntimeFieldInfo)RuntimeFieldInfo.GetFieldFromHandle(this);
BCLDebug.Assert(fldInfo != null, "[RuntimeFieldHandle.GetObjectData]fldInfo!=null");
info.AddValue("FieldObj", fldInfo, typeof(RuntimeFieldInfo));
}
RuntimeFieldHandle(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
RuntimeFieldInfo mf = ((RuntimeFieldInfo)info.GetValue("FieldObj", typeof(RuntimeFieldInfo)));
value = mf.FieldHandle.Value;
if (value == IntPtr.Zero)
{
throw new SerializationException("Insufficient state.");
}
}
RuntimeFieldInfo[] GetFields_internal(string name, BindingFlags bindingAttr, MemberListType listType, RuntimeType reflectedType)
{
var refh = new RuntimeTypeHandle(reflectedType);
using (var namePtr = new Mono.SafeStringMarshal(name))
using (var h = new Mono.SafeGPtrArrayHandle(GetFields_native(namePtr.Value, bindingAttr, listType))) {
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);
}
}
internal IEnumerable <FieldInfo> CoreGetDeclaredFields(NameFilter optionalNameFilter, RuntimeTypeInfo reflectedType)
{
RuntimeNamedTypeInfo definingType = AnchoringTypeDefinitionForDeclaredMembers;
if (definingType != null)
{
MetadataReader reader = definingType.Reader;
foreach (FieldHandle fieldHandle in definingType.DeclaredFieldHandles)
{
if (optionalNameFilter == null || optionalNameFilter.Matches(fieldHandle.GetField(reader).Name, reader))
{
yield return(RuntimeFieldInfo.GetRuntimeFieldInfo(fieldHandle, definingType, this, reflectedType));
}
}
}
}
private RuntimeFieldInfo LookupDeclaredFieldByName(String name)
{
RuntimeNamedTypeInfo definingType = _runtimeTypeInfo.AnchoringTypeDefinitionForDeclaredMembers;
IEnumerator <RuntimeFieldInfo> matches = _runtimeTypeInfo.GetDeclaredFieldsInternal(definingType, name).GetEnumerator();
if (!matches.MoveNext())
{
return(null);
}
RuntimeFieldInfo result = matches.Current;
if (matches.MoveNext())
{
throw new AmbiguousMatchException();
}
return(result);
}
//
// Return all declared fields whose name matches "optionalNameFilter". If optionalNameFilter is null, return them all.
//
internal IEnumerable <RuntimeFieldInfo> GetDeclaredFieldsInternal(RuntimeNamedTypeInfo definingType, String optionalNameFilter)
{
if (definingType != null)
{
// We require the caller to pass a value that we could calculate ourselves because we're an iterator and we
// don't want any MissingMetadataException that AnchoringType throws to be deferred.
Debug.Assert(definingType.Equals(this.AnchoringTypeDefinitionForDeclaredMembers));
MetadataReader reader = definingType.Reader;
foreach (FieldHandle fieldHandle in definingType.DeclaredFieldHandles)
{
if (optionalNameFilter == null || fieldHandle.GetField(reader).Name.StringEquals(optionalNameFilter, reader))
{
yield return(RuntimeFieldInfo.GetRuntimeFieldInfo(fieldHandle, definingType, this));
}
}
}
}
internal static bool IsDefined(RuntimeFieldInfo field)
{
return(MarshalAsAttribute.GetCustomAttribute(field) != null);
}
internal static Attribute GetCustomAttribute(RuntimeFieldInfo field)
{
return(MarshalAsAttribute.GetCustomAttribute(field.MetadataToken, field.GetRuntimeModule()));
}
private int GetTokenFor(RuntimeFieldInfo runtimeField, RuntimeType rtType)
{
return(m_scope.GetTokenFor(runtimeField.FieldHandle, rtType.TypeHandle));
}
private int GetTokenFor(RuntimeFieldInfo runtimeField)
{
return(m_scope.GetTokenFor(runtimeField.FieldHandle));
}
