C# FieldReference.Resolve方法代码示例

 public WeakEventWeaver(FieldReference eventDelegate, ModuleImporter moduleimporter)
 {
     _eventDelegate = eventDelegate.Resolve();
     _moduleimporter = moduleimporter;
     _closedGenericEventHandler = moduleimporter.GetClosedEventHandlerT(eventDelegate.FieldType.GetEventArgsType());
     _isGenericHandler = _closedGenericEventHandler.FullName.Equals(eventDelegate.FieldType.FullName);
 }

        private FieldReference FixFieldReference(FieldReference yourFieldRef)
        {
            if (yourFieldRef == null) {
                Log_called_to_fix_null("field");
                return null;
            }
            Log_fixing_reference("field", yourFieldRef);
            Asserts.AssertTrue(yourFieldRef.DeclaringType != null);

            var yourFieldDef = yourFieldRef.Resolve();
            if (yourFieldDef.IsDisablePatching()) {
                Log_trying_to_fix_disabled_reference("field", yourFieldRef);
            }
            var targetType = FixTypeReference(yourFieldRef.DeclaringType);
            var targetBaseFieldDef = yourFieldRef;
            if (yourFieldDef.Module.Assembly.IsPatchingAssembly()) {
                //additional checking
                var targetFieldDef = CurrentMemberCache.Fields.TryGet(yourFieldDef)?.TargetMember;
                if (targetFieldDef == null) {
                    throw Errors.Could_not_resolve_reference("field", yourFieldRef);
                }
                targetBaseFieldDef = targetFieldDef;
            } else {
                //we assume that types that aren't in a patching assembly will never reference types in a patching assembly
                targetBaseFieldDef = yourFieldRef;
            }
            var newFieldRef = targetBaseFieldDef.CloneReference();
            newFieldRef.DeclaringType = targetType;
            newFieldRef.FieldType = FixTypeReference(newFieldRef.FieldType);
            var targetFieldRef = TargetAssembly.MainModule.Import(newFieldRef);

            Log_fixed_reference("field", yourFieldRef, targetFieldRef);
            targetFieldRef.Module.Assembly.AssertEqual(TargetAssembly);

            return targetFieldRef;
        }

 private bool CheckAndSaveStateField(FieldReference foundStateField)
 {
     FieldDefinition foundFieldDef = foundStateField.Resolve();
     if (stateField == null)
     {
         stateField = foundFieldDef;
     }
     else if(stateField != foundFieldDef)
     {
         return false;
     }
     return true;
 }

 private static void CreateWellName(FieldReference fr)
 {
     var name = CleanName(fr.Name);
     var start = name.IndexOf(NONWELLFLAG);
     if (start == -1)
     {
         if (IsNameRepeated(fr.DeclaringType, name)) name = "f_" + name + "_" + GetShortName(fr.FieldType);
     }
     else
     {
         var fd = fr.Resolve();
         if (fd.DeclaringType.IsEnum)
         {
             var value = fd.Constant.ToString().Replace('-', 'n');
             var suffix = "_" + value;
             name = Replace(name, start, 1, "V") + suffix;
         }
         else
         {
             var suffix = "_" + GetShortName(fd.FieldType);
             name = fd.IsLiteral
                 ? Replace(name, start, 1, "CONST").ToUpper() + suffix.ToUpper() + "_" + Regex.Replace(fd.Constant.ToString(), @"\W", "_")
                 : Replace(name, start, 1, "f") + suffix;
         }
     }
     fr.mWellName = Regex.Replace(name, @"\W", "_");
 }

        private bool IsBlacklisted(FieldReference field)
        {
            var fieldDef = field.Resolve();
            if (fieldDef == null)
                return true; // TODO: log

            if (ReferenceEquals(Module, fieldDef.Module))
                return false;

            return _accessLists.IsBlacklisted(fieldDef);
        }

        protected virtual string GetFieldName(FieldReference field)
        {
            FieldDefinition fieldDefinition = field.Resolve();

            if (fieldDefinition != null && fieldDefinition.Module.FilePath == this.ModuleContext.Module.FilePath)
            {

                if (this.TypeContext != null && this.TypeContext.BackingFieldToNameMap.ContainsKey(fieldDefinition))
                {
                    return this.TypeContext.BackingFieldToNameMap[fieldDefinition];
                }

                return this.ModuleContext.RenamedMembersMap[fieldDefinition.MetadataToken.ToUInt32()];
            }

            return Utilities.EscapeName(GenericHelper.GetNonGenericName(field.Name), this.Language);
        }

 private UInt16 GetFieldReferenceId(
     FieldReference fieldReference)
 {
     UInt16 referenceId;
     if (_context.FieldReferencesTable.TryGetFieldReferenceId(fieldReference, out referenceId))
     {
         referenceId |= 0x8000; // External field reference
     }
     else
     {
         _context.FieldsTable.TryGetFieldReferenceId(fieldReference.Resolve(), false, out referenceId);
     }
     return referenceId;
 }

		static FieldDefinition GetFieldDefinition(FieldReference field)
		{
			if (field != null && field.DeclaringType.IsGenericInstance)
				return field.Resolve();
			else
				return field as FieldDefinition;
		}

        private void AddField(FieldReference field) {
            if (field == null || IsIgnored(field)) {
                return;
            }

            AddType(field.FieldType);
            AddType(field.DeclaringType);
            FieldDefinition resolvedField = field.Resolve();

            fields.Add(resolvedField);
        }

        private bool CheckAndSaveCurrentItemField(FieldReference foundCurrentItemFieldRef)
        {
            FieldDefinition fieldDef = foundCurrentItemFieldRef.Resolve();
            if(currentItemField == null)
            {
                currentItemField = fieldDef;
            }
            else if(currentItemField != fieldDef)
            {
                return false;
            }

            return true;
        }

        static bool IsObsolete(FieldReference field)
        {
            if (field == null)
                return false;

            bool obsolete = false;
            if (!fields.TryGetValue (field, out obsolete)) {
                FieldDefinition fd = field.Resolve ();
                obsolete = fd.HasAttribute ("System", "ObsoleteAttribute");
                fields.Add (field, obsolete);
            }
            return obsolete;
        }

 static bool GenericFieldComparer(FieldReference fieldReference, FieldDefinition fieldDefinition)
 {
     return fieldDefinition == fieldReference.Resolve();
 }

        public virtual FieldReference FindLinked(FieldReference field)
        {
            FieldDefinition def = field.Resolve();
            if (def == null || !def.HasCustomAttributes) {
                return field;
            }
            CustomAttribute attrib = null;
            foreach (CustomAttribute attrib_ in def.CustomAttributes) {
                if (attrib_.AttributeType.FullName == "MonoMod.MonoModLinkTo") {
                    attrib = attrib_;
                    break;
                }
            }
            if (attrib == null) {
                return field;
            }

            TypeDefinition type = null;

            if (attrib.ConstructorArguments[0].Type.FullName == "System.String") {
                //TODO get type from name
            } else {
                type = FindType((TypeReference) attrib.ConstructorArguments[0].Value).Resolve();
            }

            //TODO get method from name
            for (int i = 0; i < type.Fields.Count; i++) {
                if (type.Methods[i].Name == ((string) attrib.ConstructorArguments[1].Value)) {
                    //Probably check for more than that
                    field = type.Fields[i];
                    break;
                }
            }

            //TODO cache somewhere

            return field;
        }

        private bool IsAutoPropertyConstructorInitializerExpression(FieldReference fieldReference, out PropertyDefinition property)
        {
            FieldDefinition fieldDefinition = fieldReference.Resolve();
            if (fieldDefinition != null)
            {
                Dictionary<FieldDefinition, PropertyDefinition> map = this.typeContext.FieldToPropertyMap;
                if (map.ContainsKey(fieldDefinition) &&
                    map[fieldDefinition] != null &&
                    !map[fieldDefinition].ShouldStaySplit())
                {
                    property = map[fieldDefinition];
                    return true;
                }
            }

            property = null;
            return false;
        }

		bool IsVisibleFrom (TypeDefinition type, FieldReference reference)
		{
			if (reference == null)
				return true;

			FieldDefinition field = reference.Resolve ();
			if (field == null)
				return true;

			TypeDefinition dec = (TypeDefinition) field.DeclaringType;
			if (!IsVisibleFrom (type, dec))
				return false;

			if (field.IsPublic)
				return true;

			if (type == dec || IsNestedIn (type, dec))
				return true;

			if (field.IsFamily && InHierarchy (type, dec))
				return true;

			if (field.IsFamilyOrAssembly && (!AreInDifferentAssemblies (type, dec) || InHierarchy (type, dec)))
				return true;

			if (field.IsFamilyAndAssembly && (!AreInDifferentAssemblies (type, dec) && InHierarchy (type, dec)))
				return true;

			if (!AreInDifferentAssemblies (type, dec) && field.IsAssembly)
				return true;

			return false;
		}