C# ITypeDefinition.GetNonInterfaceBaseTypes方法代码示例

		public static bool BaseClassIsFormOrControl(ITypeDefinition c)
		{
			if (c == null)
				return false;
			// Simple test for fully qualified name
			foreach (var baseType in c.GetNonInterfaceBaseTypes()) {
				var baseTypeName = baseType.FullName;
				if (baseTypeName == "System.Windows.Forms.Form"
				    || baseTypeName == "System.Windows.Forms.UserControl")
				{
					return true;
				}
			}
			return false;
		}

		public void UpdateTestClass(ITypeDefinition typeDefinition)
		{
			fullTypeName = typeDefinition.FullTypeName;
			if (this.NestedTestsInitialized) {
				int baseClassIndex = 0;
				foreach (IType baseType in typeDefinition.GetNonInterfaceBaseTypes()) {
					ITypeDefinition baseTypeDef = baseType.GetDefinition();
					// Check that the base type isn't equal to System.Object or the current class itself
					if (baseTypeDef == null || baseTypeDef == typeDefinition || baseTypeDef.KnownTypeCode == KnownTypeCode.Object)
						continue;
					if (baseTypeDef.DeclaringTypeDefinition != null)
						continue; // we only support inheriting from top-level classes
					var baseClassName = baseTypeDef.FullTypeName;
					if (baseClassIndex < baseClassNames.Count && baseClassName == baseClassNames[baseClassIndex]) {
						// base class is already in the list, just keep it
						baseClassIndex++;
					} else {
						// base class is not in the list, or the remaining portion of the list differs
						// remove remaining portion of the list:
						RemoveBaseClasses(baseClassIndex);
						// Add new base class:
						parentProject.RegisterInheritedClass(baseClassName, this);
						baseClassNames.Add(baseClassName);
						baseClassIndex++;
					}
				}
				
				HashSet<ITest> newOrUpdatedNestedTests = new HashSet<ITest>();
				// Update nested test classes:
				foreach (ITypeDefinition nestedClass in typeDefinition.NestedTypes) {
					if (!NUnitTestFramework.IsTestClass(nestedClass))
						continue;
					
					NUnitTestClass nestedTestClass = FindNestedTestClass(nestedClass.Name, nestedClass.TypeParameterCount);
					if (nestedTestClass != null) {
						nestedTestClass.UpdateTestClass(nestedClass);
					} else {
						nestedTestClass = new NUnitTestClass(parentProject, nestedClass.FullTypeName);
						this.NestedTestCollection.Add(nestedTestClass);
					}
					newOrUpdatedNestedTests.Add(nestedTestClass);
				}
				// Get methods (not operators etc.)
				foreach (IMethod method in typeDefinition.GetMethods(m => m.SymbolKind == SymbolKind.Method)) {
					if (!NUnitTestFramework.IsTestMethod(method))
						continue;
					
					IUnresolvedMethod unresolvedMethod = (IUnresolvedMethod)method.UnresolvedMember;
					string methodNameWithDeclaringType;
					FullTypeName derivedFixture;
					if (method.DeclaringTypeDefinition == typeDefinition) {
						derivedFixture = default(FullTypeName); // method is not inherited
						methodNameWithDeclaringType = method.Name;
					} else {
						if (method.DeclaringTypeDefinition == null)
							continue;
						derivedFixture = fullTypeName; // method is inherited
						methodNameWithDeclaringType = method.DeclaringTypeDefinition.Name + "." + method.Name;
					}
					
					NUnitTestMethod testMethod;
					if (method.IsOverride) {
						testMethod = FindTestMethodWithShortName(method.Name);
					} else {
						testMethod = FindTestMethod(methodNameWithDeclaringType);
					}
					if (testMethod != null) {
						testMethod.UpdateTestMethod(unresolvedMethod, derivedFixture);
					} else {
						testMethod = new NUnitTestMethod(parentProject, unresolvedMethod, derivedFixture);
						this.NestedTestCollection.Add(testMethod);
					}
					newOrUpdatedNestedTests.Add(testMethod);
				}
				// Remove all tests that weren't contained in the new type definition anymore:
				this.NestedTestCollection.RemoveAll(t => !newOrUpdatedNestedTests.Contains(t));
			}
		}