C# IMemberDefinition类代码示例

		public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
		{
			TypeDefinition type = Utilities.GetDeclaringTypeOrSelf(member);

            Dictionary<FieldDefinition, PropertyDefinition> fieldToPropertyMap = type.GetFieldToPropertyMap(language);
            IEnumerable<FieldDefinition> propertyFields = fieldToPropertyMap.Keys;
            HashSet<PropertyDefinition> autoImplementedProperties = new HashSet<PropertyDefinition>(fieldToPropertyMap.Values);
			HashSet<EventDefinition> autoImplementedEvents = GetAutoImplementedEvents(type);

			TypeSpecificContext typeContext = new TypeSpecificContext(type) { AutoImplementedProperties = autoImplementedProperties, AutoImplementedEvents = autoImplementedEvents };

			TypeDefinition declaringType = Utilities.GetDeclaringTypeOrSelf(member);

			Dictionary<string, string> renamedNamespacesMap = new Dictionary<string, string>();
			MemberRenamingData memberReanmingData = GetMemberRenamingData(declaringType.Module, language);

			ModuleSpecificContext moduleContext =
				new ModuleSpecificContext(declaringType.Module, new List<string>(), new Dictionary<string, List<string>>(), new Dictionary<string, HashSet<string>>(), 
					renamedNamespacesMap, memberReanmingData.RenamedMembers, memberReanmingData.RenamedMembersMap);			

			return new WriterContext(
				new AssemblySpecificContext(),
				moduleContext,
				typeContext,
				new Dictionary<string, MethodSpecificContext>(), 
				GetDecompiledStatements(member, language, propertyFields));
		}

		/// <summary>
		/// Rename a member definition
		/// </summary>
		/// <param name="imdef">Member definition</param>
		/// <param name="name">new name</param>
		public static void RenameMemberDefinition(IMemberDefinition imdef, string name)
		{
			if (imdef is TypeDefinition)
				RenameTypeDefinition(imdef as TypeDefinition, name);
			else
				imdef.Name = name;
		}

		/// <summary>
		/// Creates the part of the member's ID string representation, following the prefix showing the kind of the member, according to ECMA-334 standart. 
		/// See chapter E: Documentation Comments.
		/// </summary>
		/// <param name="member"></param>
		/// <returns></returns>
		private string GetMemberFullName(IMemberDefinition member)
		{
			StringBuilder result = new StringBuilder();
			if (member is TypeDefinition)
			{
				return GetTypeFullName(member as TypeDefinition);
			}
			else
			{
				// Every member, that is not a type, is supposed to have declaring type.
				// As the specification is for the C# language, which does not allow methods to be declared outside of classes,
				// global methods can't be documented using this format.
				result.Append(GetTypeFullName(member.DeclaringType));
				result.Append('.');
			}
			string memberName = member.Name.Replace('.', '#'); // according to the standart, '.' should be replaced with '#'
			result.Append(memberName);

			// Methods are the only members that can be generic (types are already handled).
			if (member is MethodDefinition)
			{
				string genericMarker = GetMethodGenericParametersMarker(member as MethodDefinition);
				result.Append(genericMarker);
			}

			if (member is MethodDefinition || member is PropertyDefinition)
			{
				string arguments = GetArgumentsString(member);
				result.Append(arguments);
			}
			return result.ToString();
		}

 /// <summary>
 /// Creates a new instance of this class.
 /// </summary>
 /// <param name="class">The member type.</param>
 /// <param name="definition">The member definition.</param>
 public TypeMember(TypeReference type, IMemberDefinition definition)
 {
     if (type == null) throw new ArgumentNullException("type");
       if (definition == null) throw new ArgumentNullException("definition");
       Type = type;
       Definition = definition;
 }

        public IEnumerable<KeyValuePair<IMemberDefinition, string>> GetObjectsToRename(IMemberDefinition member)
        {
            //Returns ths given intem
            yield return new KeyValuePair<IMemberDefinition, string>(member, "{0}");

            //Checks if the member is a property or an event
            if (member is PropertyDefinition)
            {
                var prop = (PropertyDefinition)member;
                if (prop.GetMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(prop.GetMethod, "get_{0}");
                if (prop.SetMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(prop.SetMethod, "set_{0}");
                if (prop.HasOtherMethods)
                    foreach (var m in prop.OtherMethods)
                        yield return new KeyValuePair<IMemberDefinition, string>(m, "{0}");
            }
            else if (member is EventDefinition)
            {
                var evt = (EventDefinition)member;
                if (evt.AddMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(evt.AddMethod, "add_{0}");
                if (evt.RemoveMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(evt.RemoveMethod, "remove_{0}");
                if (evt.InvokeMethod != null)
                    yield return new KeyValuePair<IMemberDefinition, string>(evt.InvokeMethod, "raise_{0}");
                if (evt.HasOtherMethods)
                    foreach (var m in evt.OtherMethods)
                        yield return new KeyValuePair<IMemberDefinition, string>(m, "{0}");
            }
            yield break;
        }

        private static bool IsVisibleInSubclass(IMemberDefinition member)
        {
            //TODO! internal and in another assembly are also not visible!
              //  also take into account the InternalsVisibleTo attribute!
              //  and ProtectedANDInternal

              if (member == null) return false;

              var method = member as MethodDefinition;
              if (method != null) {
            return !method.IsPrivate;
              }

              var property = member as PropertyDefinition;
              if (property != null) {
            var getterIsVisible = IsVisibleInSubclass(property.GetMethod);
            var setterIsVisible = IsVisibleInSubclass(property.SetMethod);
            return getterIsVisible || setterIsVisible;
              }

              var @event = member as EventDefinition;
              if (@event != null) {
            var adderIsVisible = IsVisibleInSubclass(@event.AddMethod);
            var removerIsVisible = IsVisibleInSubclass(@event.RemoveMethod);
            var invokerIsVisible = IsVisibleInSubclass(@event.InvokeMethod);
            return adderIsVisible || removerIsVisible || invokerIsVisible;
              }

              var field = member as FieldDefinition;
              if (field != null) {
            return !field.IsPrivate;
              }

              throw new InvalidOperationException();
        }

        // LOOKUP Path.GetRandomFileName BaseBMethod
        public string GetMemberName(IMemberDefinition member)
        {
            if (member.DeclaringType == null)
                return GetTypeName((TypeDefinition)member);

            var scopeId = GetMemberScope(member);
            return GetNextName(scopeId);
        }

		/// <summary>
		/// Gets the documentation related to <paramref name="member"/>. If no documentation is found for this particular member,
		/// an empty string is returned.
		/// </summary>
		/// <param name="member"></param>
		/// <returns>String containing the XML-formated documentation for <paramref name="member">.</returns>
		public string GetDocumentationForMember(IMemberDefinition member)
		{
			string memberName = GetDocumentationMemberName(member);
			if (documentationMap.ContainsKey(memberName))
			{
				return documentationMap[memberName];
			}
			return string.Empty;
		}

        public static string FormatMemberName(IMemberDefinition member)
        {
            var typePrefix = member.DeclaringType.Name + "_";

            if (member.Name.Contains(typePrefix))
                return EscapeIdentifier(member.Name);
            else
                return EscapeIdentifier(typePrefix + member.Name);
        }

        protected CachedDecompiledMember AddDecompiledMemberToCache(IMemberDefinition member, DecompiledMember decompiledMember, TypeSpecificContext typeContext, ILanguage language)
        {
            CachedDecompiledMember cachedMember = new CachedDecompiledMember(decompiledMember, typeContext);
            if (!this.cacheService.IsDecompiledMemberInCache(member, language, this.renameInvalidMembers))
            {
                this.cacheService.AddDecompiledMemberToCache(member, language, this.renameInvalidMembers, cachedMember);
            }

            return cachedMember;
        }

 public override void WriteBody(IMemberDefinition member, IWriterContextService writerContextService)
 {
     this.writerContextService = writerContextService;
     this.writerContext = writerContextService.GetWriterContext(member, Language);
     this.currentWritingInfo = new WritingInfo(member);
     UpdateWritingInfo(this.writerContext, this.currentWritingInfo);
     this.writingInfos = new List<WritingInfo>();
     this.writingInfos.Add(this.currentWritingInfo);
     WriteBodyInternal(member);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="StateInterceptor" /> class.
        /// </summary>
        /// <param name="memberDefinition">The method signature.</param>
        /// <param name="callbacks">The callbacks.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="memberDefinition" /> is <c>null</c>.</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="callbacks" /> is <c>null</c>.</exception>
        public StateInterceptor(IMemberDefinition memberDefinition, CallbackCollection callbacks)
        {
            Argument.IsNotNull("methodDefinition", memberDefinition);
            Argument.IsNotNull("callbacks", callbacks);

            MemberDefinition = memberDefinition;
            CallbackCollection = callbacks;

            _visitor = new SelectCallbackVisitor();
        }

		/// <summary>
		/// Generates the name, used to specify <paramref name="member"/> according to ECMA-334 standart.
		/// </summary>
		/// <param name="member">The member who's name is about to be generated.</param>
		/// <returns>Returns the string used as ID in the documentation to refer to <paramref name="member">.</returns>
		private string GetDocumentationMemberName(IMemberDefinition member)
		{
			StringBuilder sb = new StringBuilder();

			string prefix = GetMemberPrefix(member);
			sb.Append(prefix);

			string memberFullname = GetMemberFullName(member);
			sb.Append(memberFullname);
			return sb.ToString();
		}

 static void ProcessField(IMemberDefinition m)
 {
     foreach (CustomAttribute att in m.CustomAttributes)
         if (att.Constructor.DeclaringType.Name == "ProcessingStandardFieldAttribute") {
             var f = m as FieldDefinition;
             if (f != null && f.IsLiteral)
                 Console.WriteLine ("Const " + m.Name);
             else
                 Console.WriteLine ("Field " + m.Name);
         }
 }

 //TODO Same fully-qualified type names in two assemblies http://msdn.microsoft.com/en-us/library/ms173212.aspx
 private string MapMemberDefinition(IMemberDefinition member)
 {
     string newName = _codeProvider.CreateValidIdentifier(_nameGenerator.GetMemberName(member));
     #if APPEND
     DefinitionsMap[member] = member.Name + newName;
     return member.Name + newName;
     #else
     DefinitionsMap[member] = newName;
     return newName;
     #endif
 }