C# TypeDefinition.ExternallyVisible方法代码示例

		private bool DoIsVisible(TypeDefinition type)
		{
			bool visible = type.ExternallyVisible(Cache);
			Log.DebugLine(this, "{0}.visible = {1}", type.Name, visible);
			
			return visible;
		}

		public void VisitType(TypeDefinition type)
		{				
			if (type.ExternallyVisible(Cache))
			{
				Log.DebugLine(this, "-----------------------------------"); 
				Log.DebugLine(this, "checking {0}", type.Name);				

				if (DoObsoleteTerm(type.Name))
				{
					Reporter.TypeFailed(type, CheckID, string.Empty);
				}
			}
		}

		public void VisitType(TypeDefinition type)
		{						
			DBC.Assert(m_state == State.Types, "state is {0}", m_state);
			Log.DebugLine(this, "{0}", type.FullName);

			if (!type.ExternallyVisible(Cache) && DoInstantiable(type) && DoValidType(type))
			{	
				if (!type.IsCompilerGenerated())
				{
					var key = new AssemblyCache.TypeKey(type);
					DBC.Assert(m_keys.IndexOf(key) < 0, "{0} is already in types", type.FullName);
					Log.DebugLine(this, "adding {0}", type.FullName);
					
					m_keys.Add(key);
				}
			}
		}

		public void VisitType(TypeDefinition type)
		{
			if (type.BaseType != null && type.IsSubclassOf("System.Attribute", Cache))
			{			
				Log.DebugLine(this, "-----------------------------------"); 
				Log.DebugLine(this, "checking {0}", type);		
				
				if (!type.IsSealed && !type.IsAbstract)
				{
					if (type.ExternallyVisible(Cache))
					{
						Log.DebugLine(this, "{0} has no usage attribute", type.Name); 
						Reporter.TypeFailed(type, CheckID, string.Empty);
					}
				}
			}
		}

		public void VisitType(TypeDefinition type)
		{		
			if (!type.IsSealed && type.ExternallyVisible(Cache))
			{
				Log.DebugLine(this, "-----------------------------------"); 
				Log.DebugLine(this, "{0}", type);
				
				foreach (MethodDefinition method in type.Methods)
				{
					if (method.IsPrivate && !method.IsReuseSlot)
					{
						Log.DebugLine(this, "{0} is an explicit implementation", method);
						
						string name = method.Name.Substring(method.Name.LastIndexOf('.') + 1);
						
						bool found = false;
						MethodDefinition[] methods = type.Methods.GetMethod(name);
						foreach (MethodDefinition candidate in methods)
						{
							Log.DebugLine(this, "   checking {0}", candidate);
							
							if (!candidate.IsPrivate)
							{
								Log.DebugLine(this, "   it's an alternative");
								found = true;
								break;
							}
						}
						
						if (!found)
						{
							string details = "Method: " + name;
							Reporter.TypeFailed(type, CheckID, details);
							break;
						}
					}
				}
			}
		}

		public void VisitType(TypeDefinition candidate)
		{
			if (!candidate.IsAbstract && !candidate.ExternallyVisible(Cache) && candidate.IsClass && !candidate.IsSealed)
			{
				if (candidate.FullName != "<Module>" && !candidate.IsCompilerGenerated())
				{
					Log.DebugLine(this, "checking {0}", candidate);	
					
					foreach (TypeDefinition type in Cache.Types)
					{	
						if (type.IsSubclassOf(candidate, Cache))
						{
//							Log.DebugLine(this, "   is base class for {0} [{1}]", type, type.BaseType);	
							return;
						}
//						else
//							Log.DebugLine(this, "   not a base class for {0} [{1}]", type, type.BaseType);	
					}
	
//					Log.DebugLine(this, "   failed");	
					Reporter.TypeFailed(candidate, CheckID, string.Empty);
				}
			}
		}

		protected override bool OnNeedsCheck(TypeDefinition type, MethodDefinition method) 
		{
			if (type.ExternallyVisible(Cache))
				return method.IsAssembly;
			else
				return method.IsPublic || method.IsAssembly;
		}

		public void VisitType(TypeDefinition type)
		{						
			if (type.ExternallyVisible(Cache))
			{
				m_types.Add(type.FullName);
			
				if (m_namespaces.IndexOf(type.Namespace) < 0)	// namespaces only matter if they have a public type
					m_namespaces.Add(type.Namespace);
			}
		}