DeclaringType

Implemented interface member:

property

DeclaringType

System.Runtime.InteropServices._MemberInfo.DeclaringType

46 overrides of DeclaringType

mscorlib (18)

system\reflection\ConstructorInfo.cs (1)

446public override Type DeclaringType

system\reflection\emit\constructorbuilder.cs (1)

104public override Type DeclaringType

system\reflection\emit\dynamicmethod.cs (2)

606public override Type DeclaringType { get { return m_dynMethod.DeclaringType; } } 884public override Type DeclaringType {

system\reflection\emit\fieldbuilder.cs (1)

99public override Type DeclaringType

system\reflection\emit\methodbuilder.cs (1)

548public override Type DeclaringType

system\reflection\emit\methodbuilderinstantiation.cs (1)

52public override Type DeclaringType { get { return m_method.DeclaringType; } }

system\reflection\emit\propertybuilder.cs (1)

287public override Type DeclaringType {

system\reflection\emit\symbolmethod.cs (1)

95public override Type DeclaringType

system\reflection\emit\xxxontypebuilderinstantiation.cs (3)

50public override Type DeclaringType { get { return m_type; } } 147public override Type DeclaringType { get { return m_type; } } 248public override Type DeclaringType { get { return m_type; } }

system\reflection\eventinfo.cs (1)

357public override Type DeclaringType { get { return m_declaringType; } }

system\reflection\fieldinfo.cs (1)

305public override Type DeclaringType

system\reflection\methodinfo.cs (1)

531public override Type DeclaringType

system\reflection\propertyinfo.cs (1)

426public override Type DeclaringType

system\runtime\serialization\serializationfieldinfo.cs (1)

59public override Type DeclaringType {

system\type.cs (1)

72public override Type DeclaringType {

PresentationFramework (1)

src\Framework\MS\Internal\Data\IndexerPropertyInfo.cs (1)

84public override Type DeclaringType

System (1)

net\System\Net\_AutoWebProxyScriptHelper.cs (1)

143public override Type DeclaringType {

System.Activities.Presentation (3)

System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (3)

1825public override Type DeclaringType { get { return _info.DeclaringType; } } 1901public override Type DeclaringType { get { return _info.DeclaringType; } } 1956public override Type DeclaringType { get { return _info.DeclaringType; } }

System.Core (1)

System\Runtime\InteropServices\ComAwareEventInfo.cs (1)

83public override Type DeclaringType {

System.Data (3)

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (3)

System.Workflow.Activities (4)

Designers\StateDesigner.cs (1)

2441public override Type DeclaringType

Rules\RuleValidation.cs (3)

247public override Type DeclaringType 364public override Type DeclaringType 753public override Type DeclaringType

System.Workflow.ComponentModel (14)

AuthoringOM\Bind.cs (1)

1711public override Type DeclaringType

AuthoringOM\Compiler\TypeSystem\EventInfo.cs (1)

114public override Type DeclaringType

AuthoringOM\Compiler\TypeSystem\FieldInfo.cs (1)

88public override Type DeclaringType

AuthoringOM\Compiler\TypeSystem\MethodInfo.cs (2)

98public override Type DeclaringType 259public override Type DeclaringType

AuthoringOM\Compiler\TypeSystem\PropertyInfo.cs (2)

162public override Type DeclaringType 248public override Type DeclaringType

AuthoringOM\Compiler\TypeSystem\RTTypeWrapper.cs (5)

839public override Type DeclaringType 910public override Type DeclaringType 1013public override Type DeclaringType 1129public override Type DeclaringType 1203public override Type DeclaringType

AuthoringOM\Design\ComponentSerializationService.cs (1)

812public override Type DeclaringType

AuthoringOM\Serializer\ExtendedPropertyInfo.cs (1)

81public override Type DeclaringType

System.WorkflowServices (1)

System\Workflow\Activities\ContractMethodInfo.cs (1)

99public override Type DeclaringType

745 references to DeclaringType

mscorlib (137)

system\attribute.cs (2)

271if (param.Member.DeclaringType == null) // This is an interface so we are done. 341if (param.Member.DeclaringType == null || !inherit) // This is an interface so we are done.

system\defaultbinder.cs (7)

967int hierarchyDepth1 = GetHierarchyDepth(m1.DeclaringType); 968int hierarchyDepth2 = GetHierarchyDepth(m2.DeclaringType); 994int hierarchyDepth1 = GetHierarchyDepth(cur1.DeclaringType); 995int hierarchyDepth2 = GetHierarchyDepth(cur2.DeclaringType); 1016int hierarchyDepth1 = GetHierarchyDepth(cur1.DeclaringType); 1017int hierarchyDepth2 = GetHierarchyDepth(cur2.DeclaringType); 1073int currentHierarchyDepth = GetHierarchyDepth(match[i].DeclaringType);

system\delegateserializationholder.cs (5)

31if (!method.IsPublic || (method.DeclaringType != null && !method.DeclaringType.IsVisible)) 39if (method.DeclaringType == null) 247if ((d.Method != null && !d.Method.IsPublic) || (d.Method.DeclaringType != null && !d.Method.DeclaringType.IsVisible))

system\diagnostics\contracts\contractsbcl.cs (1)

71Assembly caller = stack.GetFrame(i).GetMethod().DeclaringType.Assembly;

system\diagnostics\stacktrace.cs (2)

499Type t = mb.DeclaringType; 666Type t = mb.DeclaringType;

system\io\stream.cs (1)

1216if (method.DeclaringType == typeof(Stream) &&

system\reflection\customattribute.cs (6)

344if (attrs[i].Constructor.DeclaringType == caType) 380FieldInfo[] fields = m_ctor.DeclaringType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 381PropertyInfo[] properties = m_ctor.DeclaringType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 512return String.Format(CultureInfo.CurrentCulture, "[{0}({1}{2})]", Constructor.DeclaringType.FullName, ctorArgs, namedArgs); 525public Type AttributeType { get { return Constructor.DeclaringType; } } 1417SpecialAllowCriticalAttributes((RuntimeType)method.DeclaringType);

system\reflection\emit\assemblybuilder.cs (6)

379if (attribute.m_con.DeclaringType == typeof(SecurityTransparentAttribute)) 383else if (attribute.m_con.DeclaringType == typeof(SecurityCriticalAttribute)) 402else if (attribute.m_con.DeclaringType == typeof(SecurityRulesAttribute)) 407else if (attribute.m_con.DeclaringType == typeof(SecurityTreatAsSafeAttribute)) 413else if (attribute.m_con.DeclaringType == typeof(AllowPartiallyTrustedCallersAttribute)) 1680typeof(System.Diagnostics.DebuggableAttribute) == con.DeclaringType);

system\reflection\emit\assemblybuilderdata.cs (1)

146Type conType = m_CABuilders[i].m_con.DeclaringType;

system\reflection\emit\customattributebuilder.cs (21)

198if (namedProperties[i].DeclaringType != con.DeclaringType 199&& (!(con.DeclaringType is TypeBuilderInstantiation)) 200&& !con.DeclaringType.IsSubclassOf(namedProperties[i].DeclaringType)) 205if (!TypeBuilder.IsTypeEqual(namedProperties[i].DeclaringType, con.DeclaringType)) 211if (!(namedProperties[i].DeclaringType is TypeBuilder) || 212!con.DeclaringType.IsSubclassOf(((TypeBuilder)namedProperties[i].DeclaringType).BakedRuntimeType)) 250if (namedFields[i].DeclaringType != con.DeclaringType 251&& (!(con.DeclaringType is TypeBuilderInstantiation)) 252&& !con.DeclaringType.IsSubclassOf(namedFields[i].DeclaringType)) 257if (!TypeBuilder.IsTypeEqual(namedFields[i].DeclaringType, con.DeclaringType)) 263if (!(namedFields[i].DeclaringType is TypeBuilder) || 264!con.DeclaringType.IsSubclassOf(((TypeBuilder)namedFields[i].DeclaringType).BakedRuntimeType)) 555typeof(System.Diagnostics.DebuggableAttribute) == m_con.DeclaringType);

system\reflection\emit\dynamicilgenerator.cs (4)

206if (field.DeclaringType == null) 324if (methodInfo.DeclaringType != null && methodInfo.DeclaringType.ContainsGenericParameters) 1240Type t = m.DeclaringType.GetGenericTypeDefinition();

system\reflection\emit\methodbuilder.cs (2)

1215Type caType = con.DeclaringType; 1223Type caType = con.DeclaringType;

system\reflection\emit\methodbuilderinstantiation.cs (1)

52public override Type DeclaringType { get { return m_method.DeclaringType; } }

system\reflection\emit\modulebuilder.cs (37)

542tr = GetTypeTokenInternal(con.DeclaringType).Token; 543mr = GetMemberRef(con.DeclaringType.Module, tr, conOnTypeBuilderInst.MetadataTokenInternal); 685if (method.DeclaringType.IsGenericType) 716methDef.DeclaringType != null ? methDef.DeclaringType.GetGenericArguments() : null, 723method.DeclaringType != null ? method.DeclaringType.GetGenericArguments() : null, 741if (method.DeclaringType.IsGenericType) 744byte[] sig = SignatureHelper.GetTypeSigToken(this, method.DeclaringType).InternalGetSignature(out length); 750tkParent = GetTypeToken(method.DeclaringType).Token; 1842if (method.DeclaringType == null) 1846tr = getGenericTypeDefinition ? GetTypeToken(method.DeclaringType).Token : GetTypeTokenInternal(method.DeclaringType).Token; 1847mr = GetMemberRef(method.DeclaringType.Module, tr, methodToken); 1863Type declaringType = method.DeclaringType; 1885tr = getGenericTypeDefinition ? GetTypeToken(method.DeclaringType).Token : GetTypeTokenInternal(method.DeclaringType).Token; 1905tr = getGenericTypeDefinition ? GetTypeToken(method.DeclaringType).Token : GetTypeTokenInternal(method.DeclaringType).Token; 1989|| (methodInfoUnbound.DeclaringType != null && methodInfoUnbound.DeclaringType.IsGenericType)) 2015(method.DeclaringType == null || !method.DeclaringType.IsGenericType)) 2132if (field.DeclaringType != null && field.DeclaringType.IsGenericType) 2135byte[] sig = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length); 2147if (field.DeclaringType == null) 2151tr = GetTypeTokenInternal(field.DeclaringType).Token; 2160if (field.DeclaringType == null) 2165if (field.DeclaringType != null && field.DeclaringType.IsGenericType) 2168byte[] sig = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length); 2170mr = GetMemberRefOfFieldInfo(tr, field.DeclaringType.GetTypeHandleInternal(), rtField); 2174tr = GetTypeTokenInternal(field.DeclaringType).Token; 2175mr = GetMemberRefOfFieldInfo(tr, field.DeclaringType.GetTypeHandleInternal(), rtField); 2182byte[] sig = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length); 2384if (entryPoint.DeclaringType != null)

system\reflection\emit\typebuilder.cs (8)

112if (method.DeclaringType == null || !method.DeclaringType.IsGenericTypeDefinition) 115if (type.GetGenericTypeDefinition() != method.DeclaringType) 135if (!constructor.DeclaringType.IsGenericTypeDefinition) 146if (type.GetGenericTypeDefinition() != constructor.DeclaringType) 156if (!field.DeclaringType.IsGenericTypeDefinition) 167if (type.GetGenericTypeDefinition() != field.DeclaringType) 1638if (!object.ReferenceEquals(methodInfoBody.DeclaringType, this))

system\reflection\fieldinfo.cs (1)

45Type declaringType = f.DeclaringType;

system\reflection\methodbase.cs (2)

69Type declaringType = m.DeclaringType; 306return String.Format("{0}.{1}", DeclaringType.FullName, FormatNameAndSig());

system\reflection\methodbody.cs (1)

75Type declaringType = m_methodBody.m_methodBase.DeclaringType;

system\reflection\parameterinfo.cs (1)

651Type attrType = attr.Constructor.DeclaringType;

system\resources\resourcemanager.cs (1)

880if (data.Constructor.DeclaringType == typeof(SatelliteContractVersionAttribute)) {

system\rttype.cs (8)

1792if (Object.ReferenceEquals(attrs[i].Constructor.DeclaringType, DefaultMemberAttrType)) 2418bool isInherited = !Object.ReferenceEquals(memberInfo.DeclaringType, memberInfo.ReflectedType); 3372if (Object.ReferenceEquals(fieldInfo.DeclaringType, match.DeclaringType)) 3375if ((match.DeclaringType.IsInterface == true) && (fieldInfo.DeclaringType.IsInterface == true)) 3379if (match == null || fieldInfo.DeclaringType.IsSubclassOf(match.DeclaringType) || match.DeclaringType.IsInterface) 3384if (multipleStaticFieldMatches && match.DeclaringType.IsInterface) 5287if (RuntimeType.DelegateType.IsAssignableFrom(invokeMethod.DeclaringType))

system\runtime\compilerservices\datetimeconstantattribute.cs (1)

31Contract.Requires(attr.Constructor.DeclaringType == typeof(DateTimeConstantAttribute));

system\runtime\compilerservices\decimalconstantattribute.cs (1)

54Contract.Requires(attr.Constructor.DeclaringType == typeof(DecimalConstantAttribute));

system\runtime\interopservices\marshal.cs (3)

2303if (!m.DeclaringType.IsInterface) 2305if (m.DeclaringType.IsGenericType) 2358if (cas[i].Constructor.DeclaringType == typeof(ProgIdAttribute))

system\runtime\interopservices\tceadaptergen\eventproviderwriter.cs (1)

70if ( m_SrcItfType == aMethods[cMethods].DeclaringType )

system\runtime\interopservices\tceadaptergen\eventsinkhelperwriter.cs (1)

64if ( m_InputType == aMethods[cMethods].DeclaringType )

system\runtime\interopservices\windowsruntime\custompropertyimpl.cs (1)

120accessor.DeclaringType.FullName));

system\runtime\interopservices\windowsruntime\windowsruntimemarshal.cs (1)

551return removeMethod.Method.DeclaringType;

system\runtime\remoting\message.cs (1)

524mb.DeclaringType.FullName, mb.Name,

system\runtime\remoting\remotingattributes.cs (3)

324if (mb.DeclaringType != null) { 325_typeAndAssemblyName = RemotingServices.GetDefaultQualifiedTypeName((RuntimeType)mb.DeclaringType); 801Type declaringType = ((MemberInfo)ReflectInfo).DeclaringType;

system\runtime\remoting\remotingservices.cs (1)

2086Type type = method.DeclaringType;

system\runtime\remoting\soap.cs (2)

487String actualTypeName = mb.DeclaringType.FullName; 533typeName = mb.DeclaringType.FullName + ", " + rtModule.GetRuntimeAssembly().GetSimpleName();

system\runtime\remoting\stackbuildersink.cs (2)

382RuntimeType declaringType = (RuntimeType)mb.DeclaringType; 392mb.DeclaringType.FullName, srvType.FullName));

system\security\cryptography\utils.cs (1)

1063Type declaringType = method.DeclaringType;

PresentationBuildTasks (27)

Base\System\Windows\Markup\TypeConverterHelper.cs (1)

93memberInfo = methodInfo.DeclaringType.GetMethod(

BuildTasks\Ms\Internal\MarkupCompiler\MarkupCompiler.cs (9)

1781CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name); 1800CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name); 1818CodeObjectCreateExpression coce = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName); 1860FieldInfo fiEvent = miEvent.DeclaringType.GetField(eventName + EVENT, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); 1863ThrowCompilerException(SRID.RoutedEventNotRegistered, miEvent.DeclaringType.FullName, eventName, eventHandler); 1866CodeTypeReferenceExpression ctreEvent = new CodeTypeReferenceExpression(miEvent.DeclaringType.FullName); 1874Type eventTarget = cc != null ? cc.ElementType : miEvent.DeclaringType; 1928if (mei.mi.DeclaringType.IsAssignableFrom(eventTarget)) 3059(memberInfo.DeclaringType.IsAssignableFrom(_ccRoot.ElementType) && (memberInfo is PropertyInfo)));

BuildTasks\Ms\Internal\MarkupCompiler\ParserExtension.cs (2)

171KnownTypes.Types[(int)KnownElements.Application].IsAssignableFrom(memberInfo.DeclaringType)) 578bool appEvent = KnownTypes.Types[(int)KnownElements.Application].IsAssignableFrom(xamlClrEventNode.EventMember.DeclaringType);

Framework\System\Windows\Markup\MarkupExtensionParser.cs (1)

1699declaringType = mi.DeclaringType;

Framework\System\Windows\Markup\StyleXamlParser.cs (2)

369dpInfo.DeclaringType, 562_setterOrTriggerValueNode.ValueDeclaringType = _setterOrTriggerPropertyInfo.DeclaringType;

Framework\System\Windows\Markup\TemplateXamlParser.cs (2)

417dpInfo.DeclaringType, 584_setterOrTriggerValueNode.ValueDeclaringType = _setterOrTriggerPropertyMemberInfo.DeclaringType;

Framework\System\Windows\Markup\XamlReaderHelper.cs (5)

1107XamlPropertyFullName declaringProp = new XamlPropertyFullName(mi.DeclaringType, propertyName); 1822declaringType = eventMember.DeclaringType; 1876declaringType = mi.DeclaringType; 3218methodInfo = methodInfo.DeclaringType.GetMethod( 3527null != methodInfo.DeclaringType.GetMethod("Set" + methodInfo.Name.Substring("Get".Length),

Framework\System\Windows\Markup\XamlTypeMapper.cs (5)

1110if (fi.ReflectedType.Assembly == fi.DeclaringType.Assembly) 1167if (mi.ReflectedType.Assembly == mi.DeclaringType.Assembly) 2215validType = memInfo.DeclaringType; 2410if (memberInfo.DeclaringType != targetType) 2412targetType = memberInfo.DeclaringType;

PresentationFramework (19)

src\Framework\MS\Internal\Data\PropertyPathWorker.cs (4)

706Type declaringType = (oldPI != null) ? oldPI.DeclaringType 876Type declaringType = (newPI != null) ? newPI.DeclaringType 1463Type type = pi.DeclaringType; 1717typeName = pi.DeclaringType.Name;

src\Framework\System\Windows\Markup\Baml2006\WpfKnownMemberInvoker.cs (1)

49Type declaringType = _member.UnderlyingMember.DeclaringType;

src\Framework\System\Windows\Markup\Baml2006\WpfMemberInvoker.cs (1)

69Type declaringType = _member.UnderlyingMember.DeclaringType;

src\Framework\System\Windows\Markup\Baml2006\WpfXamlType.cs (1)

105return method.DeclaringType != typeof(ResourceDictionary);

src\Framework\System\Windows\Markup\BamlRecordReader.cs (2)

1590ThrowExceptionWithLine(SR.Get(SRID.ParserFailedToCreateFromConstructor, info.DeclaringType.Name), e); 5229return pi.DeclaringType.Name + "." + pi.Name;

src\Framework\System\Windows\Markup\BamlWriter.cs (2)

1163if(mostDerived == null || mostDerived.DeclaringType.IsAssignableFrom(pi.DeclaringType))

src\Framework\System\Windows\Markup\MarkupExtensionParser.cs (1)

1699declaringType = mi.DeclaringType;

src\Framework\System\Windows\Markup\XamlTypeMapper.cs (6)

1218isPublic = mi != null && mi.IsPublic && ReflectionHelper.IsPublicType(mi.DeclaringType); 1231isPublic = mi != null && mi.IsPublic && ReflectionHelper.IsPublicType(mi.DeclaringType); 1244isPublic = mi != null && mi.IsPublic && ReflectionHelper.IsPublicType(mi.DeclaringType); 2215validType = memInfo.DeclaringType; 2410if (memberInfo.DeclaringType != targetType) 2412targetType = memberInfo.DeclaringType;

src\Framework\System\Windows\PropertyPathConverter.cs (1)

234type = pi.DeclaringType;

System (7)

compmod\system\componentmodel\ReflectTypeDescriptionProvider.cs (3)

1045if ((!(eventInfo.DeclaringType.IsPublic || eventInfo.DeclaringType.IsNestedPublic)) && (eventInfo.DeclaringType.Assembly == typeof(ReflectTypeDescriptionProvider).Assembly)) {

misc\SecurityUtils.cs (3)

200Type type = field.DeclaringType; 216Type type = method.DeclaringType; 235Type type = ctor.DeclaringType;

net\System\Net\HttpWebRequest.cs (1)

5462objectId = methodInfo.DeclaringType.FullName;

System.Activities (40)

Microsoft\VisualBasic\Activities\VisualBasicDesignerHelper.cs (3)

485EnsureTypeReferenced(memberExpression.Member.DeclaringType, true, typeReferences); 532EnsureTypeReferenced(method.DeclaringType, true, typeReferences); 585EnsureTypeReferenced(newExpression.Constructor.DeclaringType, true, typeReferences);

Microsoft\VisualBasic\Activities\VisualBasicHelper.cs (1)

891bool subTreeIsLocationExpression = isLocationExpression && memberExpression.Member.DeclaringType.IsValueType;

System\Activities\Expressions\ExpressionServices.cs (8)

76Type memberType = memberExpressionBody.Expression == null ? memberExpressionBody.Member.DeclaringType : memberExpressionBody.Expression.Type; 83Type declaringType = calledMethod.DeclaringType; 179Type memberType = memberExpressionBody.Expression == null ? memberExpressionBody.Member.DeclaringType : memberExpressionBody.Expression.Type; 195Type declaringType = methodCallExpressionBody.Method.DeclaringType; 1203TargetType = unaryExpression.Method.DeclaringType, 1227TargetType = binaryExpression.Method.DeclaringType, 1249if (string.IsNullOrEmpty(methodInfo.Name) || methodInfo.DeclaringType == null) 1301invokeMethod.TargetType = methodInfo.DeclaringType;

System\Activities\Expressions\MethodCallExpressionHelper.cs (6)

67callExpression = Expression.Call(Expression.Convert(targetInstance, methodInfo.DeclaringType), methodInfo, variables); 84if (methodInfo.DeclaringType.IsValueType) 86tempInstance = Expression.Parameter(methodInfo.DeclaringType, "tempInstance"); 87assignTempInstanceExpression = Expression.Assign(tempInstance, Expression.Convert(targetInstance, methodInfo.DeclaringType)); 93callExpression = Expression.Call(Expression.Convert(targetInstance, methodInfo.DeclaringType), methodInfo, variables); 158if (!methodInfo.IsStatic && methodInfo.DeclaringType.IsValueType && valueTypeReference)

System\Activities\Expressions\PropertyReference.cs (6)

75if (setMethod == null && TypeHelper.AreTypesCompatible(this.propertyInfo.DeclaringType, typeof(Location)) == false) 77metadata.AddValidationError(SR.ReadonlyPropertyCannotBeSet(this.propertyInfo.DeclaringType, this.propertyInfo.Name)); 137throw FxTrace.Exception.AsError(new InvalidOperationException(SR.NullReferencedMemberAccess(this.propertyInfo.DeclaringType.Name, this.propertyInfo.Name))); 142if (this.propertyInfo.GetGetMethod() == null && TypeHelper.AreTypesCompatible(this.propertyInfo.DeclaringType, typeof(Location)) == false) 144throw FxTrace.Exception.AsError(new InvalidOperationException(SR.WriteonlyPropertyCannotBeRead(this.propertyInfo.DeclaringType, this.propertyInfo.Name))); 155throw FxTrace.Exception.AsError(new InvalidOperationException(SR.NullReferencedMemberAccess(this.propertyInfo.DeclaringType.Name, this.propertyInfo.Name)));

System\Activities\Expressions\ValueTypePropertyReference.cs (2)

140if (this.propertyInfo.GetGetMethod() == null && TypeHelper.AreTypesCompatible(this.propertyInfo.DeclaringType, typeof(Location)) == false) 142throw FxTrace.Exception.AsError(new InvalidOperationException(SR.WriteonlyPropertyCannotBeRead(this.propertyInfo.DeclaringType, this.propertyInfo.Name)));

System\Activities\ExpressionUtilities.cs (11)

124Type declaringType = method.DeclaringType; 190Type declaringType = method.DeclaringType; 358if (this.fieldInfo.DeclaringType.IsValueType) 514this.setItemMethod = this.getItemMethod.DeclaringType.GetMethod( 754if (this.propertyInfo.DeclaringType.IsValueType) 805if (getMethodInfo == null && !TypeHelper.AreTypesCompatible(this.propertyInfo.DeclaringType, typeof(Location))) 807throw FxTrace.Exception.AsError(new InvalidOperationException(SR.WriteonlyPropertyCannotBeRead(this.propertyInfo.DeclaringType, this.propertyInfo.Name))); 826if (setMethodInfo == null && !TypeHelper.AreTypesCompatible(this.propertyInfo.DeclaringType, typeof(Location))) 828throw FxTrace.Exception.AsError(new InvalidOperationException(SR.ReadonlyPropertyCannotBeSet(this.propertyInfo.DeclaringType, this.propertyInfo.Name))); 1010bool subTreeIsLocationExpression = isLocationExpression && memberExpression.Member.DeclaringType.IsValueType; 1819Type targetObjectType = targetMethod.DeclaringType;

System\Activities\Runtime\CallbackWrapper.cs (2)

273if (!typeof(Activity).IsAssignableFrom(callbackMethod.DeclaringType)) 311Type declaringType = method.DeclaringType;

System\Activities\Statements\MethodResolver.cs (1)

480MethodBase[] methodsDeclaredHere = methodCandidates.Where(mb => mb.DeclaringType == declaringType).ToArray();

System.Activities.Presentation (12)

Microsoft.Tools.Common\Microsoft\Activities\Presentation\Xaml\ViewStateXamlHelper.cs (1)

839|| xamlReader.Member.UnderlyingMember.DeclaringType != typeof(XamlDebuggerXmlReader))

System.Activities.Presentation\System\Activities\Presentation\Base\Core\EditingContext.cs (2)

560callback.Method.DeclaringType.FullName, 569callback.Method.DeclaringType.FullName,

System.Activities.Presentation\System\Activities\Presentation\Base\Core\Internal\Metadata\AttributeDataCache.cs (1)

190Type targetType = member.DeclaringType.BaseType;

System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (6)

1482bool includeClrAttributes = (isType || currentMember.DeclaringType == currentType); 1532if (isType || currentMember.DeclaringType == currentType) 1539if (isType || currentMember == null || currentMember.DeclaringType == currentType) 1825public override Type DeclaringType { get { return _info.DeclaringType; } } 1901public override Type DeclaringType { get { return _info.DeclaringType; } } 1956public override Type DeclaringType { get { return _info.DeclaringType; } }

System.Activities.Presentation\System\Activities\Presentation\Base\Core\ServiceManager.cs (2)

346_genericCallback.Method.DeclaringType.FullName, 356_genericCallback.Method.DeclaringType.FullName,

System.AddIn (2)

System\Addin\Hosting\Store\PipelineComponent.cs (1)

90if (Object.ReferenceEquals(ca.Constructor.DeclaringType, s_QualificationDataAttrInReflectionLoaderContext))

System\Addin\Hosting\Utils.cs (1)

63if (Object.ReferenceEquals(ca.Constructor.DeclaringType, attributeType))

System.Configuration (2)

System\Configuration\ConfigurationProperty.cs (2)

99typeConverter = TypeUtil.CreateInstanceRestricted<TypeConverter>(info.DeclaringType, attribConverter.ConverterTypeName); 115attribValidator.SetDeclaringType(info.DeclaringType);

System.Core (44)

Microsoft\Scripting\Actions\CallSiteHelpers.cs (1)

45if (mb.DeclaringType == typeof(System.Dynamic.UpdateDelegates)) {

Microsoft\Scripting\Actions\DynamicObject.cs (2)

717if (mi.DeclaringType != typeof(DynamicObject) && mi.GetBaseDefinition().DeclaringType == typeof(DynamicObject)) {

Microsoft\Scripting\Ast\BinaryExpression.cs (3)

421MethodInfo opTrueFalse = TypeUtils.GetBooleanOperator(Method.DeclaringType, opName); 792MethodInfo opTrue = TypeUtils.GetBooleanOperator(method.DeclaringType, "op_True"); 793MethodInfo opFalse = TypeUtils.GetBooleanOperator(method.DeclaringType, "op_False");

Microsoft\Scripting\Ast\DebugViewWriter.cs (3)

553Out(member.DeclaringType.ToString() + "." + member.Name); 776} else if (node.Method.DeclaringType != null) { 777Out(node.Method.DeclaringType.ToString());

Microsoft\Scripting\Ast\ExpressionStringBuilder.cs (3)

430Out(member.DeclaringType.Name + "." + member.Name); 766Out(node.Indexer.DeclaringType.Name); 781if (toString.DeclaringType != typeof(Expression)) {

Microsoft\Scripting\Ast\MemberExpression.cs (5)

156if (!TypeUtils.AreReferenceAssignable(field.DeclaringType, expression.Type)) { 157throw Error.FieldInfoNotDefinedForType(field.DeclaringType, field.Name, expression.Type); 292Type type = mi.DeclaringType; 304throw Error.MethodNotPropertyAccessor(mi.DeclaringType, mi.Name); 314Type type = method.DeclaringType;

Microsoft\Scripting\Ast\MemberMemberBinding.cs (1)

149if (!b.Member.DeclaringType.IsAssignableFrom(type)) {

Microsoft\Scripting\Ast\MethodCallExpression.cs (1)

830throw Error.InstanceAndMethodTypeMismatch(method, method.DeclaringType, instanceType);

Microsoft\Scripting\Ast\NewExpression.cs (6)

56get { return _constructor.DeclaringType; } 167ContractUtils.RequiresNotNull(constructor.DeclaringType, "constructor.DeclaringType"); 168TypeUtils.ValidateType(constructor.DeclaringType); 244if (!TypeUtils.AreEquivalent(member.DeclaringType, constructor.DeclaringType)) { 245throw Error.ArgumentMemberNotDeclOnType(member.Name, constructor.DeclaringType.Name);

Microsoft\Scripting\Ast\TypeUtils.cs (1)

172Type targetType = member.DeclaringType;

Microsoft\Scripting\Compiler\ILGen.cs (4)

298if (ci.DeclaringType.ContainsGenericParameters) { 299throw Error.IllegalNewGenericParams(ci.DeclaringType); 512Type dt = mb.DeclaringType; 538Type dt = mb.DeclaringType;

Microsoft\Scripting\Compiler\LambdaCompiler.Expressions.cs (5)

413if (mi.DeclaringType.IsValueType) { 818EmitMemberAddress(binding.Member, binding.Member.DeclaringType); 820EmitMemberGet(binding.Member, binding.Member.DeclaringType); 831EmitMemberAddress(binding.Member, binding.Member.DeclaringType); 833EmitMemberGet(binding.Member, binding.Member.DeclaringType);

Microsoft\Scripting\Compiler\LambdaCompiler.Logical.cs (2)

283MethodInfo opFalse = TypeUtils.GetBooleanOperator(b.Method.DeclaringType, "op_False"); 410MethodInfo opTrue = TypeUtils.GetBooleanOperator(b.Method.DeclaringType, "op_True");

Microsoft\Scripting\Utils\TypeExtensions.cs (2)

41return (mi.IsConstructor) ? mi.DeclaringType : ((MethodInfo)mi).ReturnType; 52Type t = method.DeclaringType;

System\Linq\SequenceQuery.cs (3)

200if ((m.Method.IsStatic || m.Method.DeclaringType.IsAssignableFrom(obj.Type)) 205else if (m.Method.DeclaringType == typeof(Queryable)) { 214MethodInfo method = FindMethod(m.Method.DeclaringType, m.Method.Name, args, typeArgs, flags);

System\Runtime\InteropServices\ComAwareEventInfo.cs (2)

84get { return _innerEventInfo.DeclaringType; } 111object[] comEventInterfaces = eventInfo.DeclaringType.GetCustomAttributes(typeof(ComEventInterfaceAttribute), false);

System.Data (13)

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\EditingContext.cs (2)

560callback.Method.DeclaringType.FullName, 569callback.Method.DeclaringType.FullName,

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Internal\Metadata\AttributeDataCache.cs (1)

190Type targetType = member.DeclaringType.BaseType;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (6)

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\ServiceManager.cs (2)

346_genericCallback.Method.DeclaringType.FullName, 356_genericCallback.Method.DeclaringType.FullName,

fx\src\data\System\Data\Sql\sqlnorm.cs (1)

92int offset = Marshal.OffsetOf(fi.DeclaringType, fi.Name).ToInt32();

fx\src\data\System\Data\SqlClient\SqlSecurityUtility.cs (1)

116return string.Format(@"{0}.{1}", methodBase.DeclaringType.Name, methodBase.Name);

System.Data.Entity (63)

System\Data\Common\EntityUtil.cs (1)

2027t = propertyInfo.DeclaringType;

System\Data\Common\Internal\Materialization\Translator.cs (2)

1383Expression valueReaderWithErrorHandling = Emit_Shaper_GetPropertyValueWithErrorHandling(propertyType, scalarColumnMap.ColumnPos, propertyName, propertyAccessor.DeclaringType.Name, scalarColumnMap.Type); 1405declaringType = setterMethod.DeclaringType;

System\Data\Metadata\Edm\LightweightCodeGenerator.cs (8)

122if (mi.DeclaringType.IsValueType) 171DynamicMethod method = CreateDynamicMethod(ci.DeclaringType.Name, typeof(object), Type.EmptyTypes); 200if (mi.DeclaringType.IsValueType) 227gen.Emit(OpCodes.Castclass, mi.DeclaringType); 337gen.Emit(OpCodes.Castclass, mi.DeclaringType); 386gen.Emit(OpCodes.Ldstr, mi.DeclaringType.Name); 408if (setterMethodInfo.DeclaringType.IsValueType) 451return (method.IsPublic && IsPublic(method.DeclaringType));

System\Data\Metadata\ObjectLayer\ObjectItemAttributeAssemblyLoader.cs (6)

540SessionData.EdmItemErrors.Add(new EdmItemError(System.Data.Entity.Strings.Validator_OSpace_InvalidNavPropReturnType(propertyInfo.Name, propertyInfo.DeclaringType.FullName, propertyInfo.PropertyType.FullName), null)); 576propertyInfo.Name, propertyInfo.DeclaringType.FullName, attribute.TargetRoleName, attribute.RelationshipName), navigationProperty)); 596propertyInfo.Name, propertyInfo.DeclaringType.FullName, attribute.RelationshipName), declaringType)); 630SessionData.EdmItemErrors.Add(new EdmItemError(System.Data.Entity.Strings.Validator_OSpace_ScalarPropertyNotPrimitive(property.Name, property.DeclaringType.FullName, property.PropertyType.FullName), null)); 670clrProperty.DeclaringType.FullName, 703SessionData.EdmItemErrors.Add(new EdmItemError(System.Data.Entity.Strings.Validator_OSpace_ComplexPropertyNotComplex(clrProperty.Name, clrProperty.DeclaringType.FullName, clrProperty.PropertyType.FullName), null));

System\Data\Objects\ELinq\ExpressionConverter.cs (5)

1532throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_UnresolvableFunctionForMethod(methodInfo, methodInfo.DeclaringType)); 1539throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_UnresolvableFunctionForMember(memberInfo, memberInfo.DeclaringType)); 1555throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_UnresolvableFunctionForMethodAmbiguousMatch(methodInfo, methodInfo.DeclaringType)); 1559throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_UnresolvableFunctionForMethodNotFound(methodInfo, methodInfo.DeclaringType)); 1567throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_UnresolvableStoreFunctionForMember(memberInfo, memberInfo.DeclaringType));

System\Data\Objects\ELinq\InitializerFacet.cs (2)

324builder.Append("DT", member.DeclaringType); 432builder.Append(",", binding.Member.DeclaringType);

System\Data\Objects\ELinq\LinqExpressionNormalizer.cs (2)

238if (m.Method.Name == "CompareString" && m.Method.DeclaringType.FullName == "Microsoft.VisualBasic.CompilerServices.Operators") 282Type declaringType = m.Method.DeclaringType;

System\Data\Objects\ELinq\MethodCallTranslator.cs (12)

158if (s_visualBasicAssemblyFullName == methodInfo.DeclaringType.Assembly.FullName) 164InitializeVBMethods(methodInfo.DeclaringType.Assembly); 335Type declaringType = method.DeclaringType; 550if (s_visualBasicAssemblyFullName == originalMethodInfo.DeclaringType.Assembly.FullName) 556InitializeVBMethods(originalMethodInfo.DeclaringType.Assembly); 738throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionAttributedFunctionWithWrongReturnType(call.Method, call.Method.DeclaringType)); 743throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionAttributedFunctionWithWrongReturnType(call.Method, call.Method.DeclaringType)); 753throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionAttributedFunctionWithWrongReturnType(call.Method, call.Method.DeclaringType)); 761throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionAttributedFunctionWithWrongReturnType(call.Method, call.Method.DeclaringType)); 774throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionAttributedFunctionWithWrongReturnType(call.Method, call.Method.DeclaringType)); 783throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionAttributedFunctionWithWrongReturnType(call.Method, call.Method.DeclaringType)); 807throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionAttributeParameterNameNotValid(call.Method, call.Method.DeclaringType, parameterName));

System\Data\Objects\ELinq\SpatialMethodCallTranslator.cs (4)

47(method.DeclaringType == typeof(System.Data.Spatial.DbGeography) || method.DeclaringType == typeof(System.Data.Spatial.DbGeometry)), 56(method.DeclaringType == typeof(System.Data.Spatial.DbGeography) || method.DeclaringType == typeof(System.Data.Spatial.DbGeometry)),

System\Data\Objects\ELinq\SpatialPropertyTranslator.cs (2)

48(property.DeclaringType == typeof(System.Data.Spatial.DbGeography) || property.DeclaringType == typeof(System.Data.Spatial.DbGeometry)),

System\Data\Objects\ELinq\Translator.cs (6)

224if (propertyInfo.DeclaringType.IsGenericType) 228propertyInfo = propertyInfo.DeclaringType.GetGenericTypeDefinition().GetProperty(propertyInfo.Name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public); 250if (s_visualBasicAssemblyFullName == propertyInfo.DeclaringType.Assembly.FullName) 256InitializeVBProperties(propertyInfo.DeclaringType.Assembly); 464foreach (KeyValuePair<Type, Type> implementedCollectionInfo in GetImplementedICollections(propertyInfo.DeclaringType)) 648return MemberAccessTranslator.TranslateCount(parent, call.Member.DeclaringType.GetGenericArguments()[0], call.Expression);

System\Data\Objects\ELinq\TypeSystem.cs (10)

138foreach (PropertyInfo property in method.DeclaringType.GetProperties( 211if (null == test || null == match || !match.IsInterface || !match.IsGenericTypeDefinition || null == test.DeclaringType) 217if (test.DeclaringType.IsInterface && test.DeclaringType.IsGenericType && test.DeclaringType.GetGenericTypeDefinition() == match) 223foreach (Type testInterface in test.DeclaringType.GetInterfaces()) 228var map = test.DeclaringType.GetInterfaceMap(testInterface); 252if (propertyInfo.DeclaringType.IsInterface) 257Debug.Assert(Enumerable.Contains(propertyInfo.DeclaringType.GetInterfaces(), interfaceType), "Ensure propertyInfo.DeclaringType implements interfaceType before calling IsImplementationOf"); 265InterfaceMapping interfaceMap = propertyInfo.DeclaringType.GetInterfaceMap(interfaceType);

System\Data\Objects\Internal\EntityProxyTypeInfo.cs (2)

86Expression.Convert(Object_Parameter, entityWrapperField.DeclaringType), entityWrapperField), 106Expression.Convert(Object_Parameter, entityWrapperField.DeclaringType),

System\Data\Objects\ObjectContext.cs (1)

854!bodyAsMember.Member.DeclaringType.IsAssignableFrom(typeof(TEntity)) ||

System.Data.Linq (78)

DataServices.cs (1)

475if (mc.Method.DeclaringType != typeof(Queryable)) {

DataShape.cs (3)

222if (edgeTargets.Where(et=>et.IsAssignableFrom(edge.DeclaringType) || edge.DeclaringType.IsAssignableFrom(et)).Any()) { 254throw Error.SubqueryNotSupportedOnType(mi.Name, mi.DeclaringType);

Mapping\AttributedMetaModel.cs (7)

566if (mm.IsPrimaryKey && this.inheritanceRoot != this && mm.Member.DeclaringType == this.type) { 818if (mi.DeclaringType.IsInterface) { 819throw Error.MappingOfInterfacesMemberIsNotSupported(mi.DeclaringType.Name, mi.Name); 821throw Error.UnmappedClassMember(mi.DeclaringType.Name, mi.Name); 1030this.declaringType = mi.DeclaringType; 1040MemberInfo[] mis = mi.DeclaringType.GetMember(this.attr.Storage, BindingFlags.Instance | BindingFlags.NonPublic); 1042throw Error.BadStorageProperty(this.attr.Storage, mi.DeclaringType, mi.Name);

Mapping\MappedMetaModel.cs (10)

603if (mm.IsPrimaryKey && this.inheritanceRoot != this && mm.Member.DeclaringType == this.type) { 654string name = fi.Name + ":" + fi.DeclaringType.Name; 675string name = pi.Name + ":" + pi.DeclaringType.Name; 895if (mi.DeclaringType.IsInterface) { 896throw Error.MappingOfInterfacesMemberIsNotSupported(mi.DeclaringType.Name, mi.Name); 898throw Error.UnmappedClassMember(mi.DeclaringType.Name, mi.Name); 971MemberInfo[] mis = mi.DeclaringType.GetMember(this.memberMap.StorageMemberName, BindingFlags.Instance | BindingFlags.NonPublic); 973throw Error.BadStorageProperty(this.memberMap.StorageMemberName, mi.DeclaringType, mi.Name); 1039return metaType.Type == this.member.DeclaringType; 1736return metaType.Type == this.member.DeclaringType;

parent\parent\misc\SecurityUtils.cs (3)

200Type type = field.DeclaringType; 216Type type = method.DeclaringType; 235Type type = ctor.DeclaringType;

SqlClient\Common\SqlFactory.cs (1)

503MetaType metaType = this.model.GetMetaType(member.DeclaringType);

SqlClient\Common\SqlNode.cs (2)

1752if (value != null && !this.method.DeclaringType.IsAssignableFrom(value.ClrType)) 1753throw Error.ArgumentWrongType("value", this.method.DeclaringType, value.ClrType);

SqlClient\Common\TypeSystem.cs (3)

236: this(mi.DeclaringType.Assembly, mi.MetadataToken) { 296if (x.MetadataToken != y.MetadataToken || x.DeclaringType.Assembly != y.DeclaringType.Assembly) {

SqlClient\Query\Funcletizer.cs (1)

133this.isRemote |= m.Method.DeclaringType == typeof(System.Data.Linq.Provider.DataManipulation)

SqlClient\Query\MethodCallConverter.cs (4)

79call.Method.DeclaringType.FullName == "Microsoft.VisualBasic.CompilerServices.Operators" && 89mc.Method.DeclaringType.FullName == "Microsoft.VisualBasic.Interaction" && mc.Method.Name == "IIf"; 128return mc.Method.DeclaringType == typeof(string); 222else if (mc.Method.DeclaringType == typeof(string) && mc.Method.Name == "Concat") {

SqlClient\Query\QueryConverter.cs (9)

SqlClient\Query\SqlBinder.cs (4)

769if (m.Member.DeclaringType.IsAssignableFrom(sn.ClrType)) { 850throw Error.MemberNotPartOfProjection(m.Member.DeclaringType, m.Member.Name); 997MetaType root = type.GetInheritanceType(mi.DeclaringType); 999throw Error.UnmappedDataMember(mi, mi.DeclaringType, type);

SqlClient\Query\SqlFormatter.cs (1)

1385sb.Append(mc.Method.DeclaringType);

SqlClient\Query\SqlMethodCallConverter.cs (16)

SqlClient\Query\Translator.cs (3)

170Expression parameterAsDeclaring = elementType == metaMember.Member.DeclaringType ? 171(Expression)p : (Expression)Expression.Convert(p, metaMember.Member.DeclaringType); 259: (Expression)Expression.Constant(null, link.Member.Member.DeclaringType);

SqlClient\Reader\ObjectReaderCompiler.cs (1)

929return (mi.IsStatic || mi.DeclaringType.IsValueType) ? OpCodes.Call : OpCodes.Callvirt;

SqlClient\SqlProvider.cs (8)

1061mce.Method.DeclaringType == typeof(Queryable) || 1062mce.Method.DeclaringType == typeof(Enumerable)) 1146if (mc != null && typeof(DataContext).IsAssignableFrom(mc.Method.DeclaringType)) { 1348if (mce.Method.DeclaringType == typeof(Queryable) || 1349mce.Method.DeclaringType == typeof(Enumerable)) { 1360else if (mce.Method.DeclaringType == typeof(DataContext)) { 1365else if (mce.Method.DeclaringType.IsSubclassOf(typeof(DataContext))) { 1376else if (mce.Method.DeclaringType == typeof(DataManipulation) && mce.Method.ReturnType == typeof(int)) {

SubqueryRules.cs (1)

32Type declType = mi.DeclaringType;

System.Data.Services (7)

System\Data\Services\DataServiceConfiguration.cs (3)

499throw new InvalidOperationException(Strings.DataService_AuthorizationReturnedNullQuery(methods[i].Name, methods[i].DeclaringType.FullName)); 554throw new InvalidOperationException(Strings.DataService_AuthorizationReturnedNullQuery(methods[i].Name, methods[i].DeclaringType.FullName)); 934throw new InvalidOperationException(Strings.DataService_ParameterIsOut(method.DeclaringType.FullName, method.Name, parameter.Name));

System\Data\Services\Parsing\RequestQueryParser.cs (3)

1237return ((MethodCallExpression)input).Method.DeclaringType == typeof(OpenTypeMethods); 1241return ((UnaryExpression)input).Method != null && ((UnaryExpression)input).Method.DeclaringType == typeof(OpenTypeMethods); 1256return ((BinaryExpression)input).Method != null && ((BinaryExpression)input).Method.DeclaringType == typeof(OpenTypeMethods);

System\Data\Services\Providers\ReflectionServiceProvider.cs (1)

213if (property.Name == property.DeclaringType.Name + "ID")

System.Data.Services.Client (13)

System\Data\Services\Client\ALinq\ExpressionNormalizer.cs (1)

353if (visited.Method.IsStatic && visited.Method.Name == "CompareString" && visited.Method.DeclaringType.FullName == "Microsoft.VisualBasic.CompilerServices.Operators")

System\Data\Services\Client\ALinq\ExpressionWriter.cs (2)

267if (m.Member.Name == "Value" && m.Member.DeclaringType.IsGenericType 268&& m.Member.DeclaringType.GetGenericTypeDefinition() == typeof(Nullable<>))

System\Data\Services\Client\ALinq\ResourceBinder.cs (5)

1272else if (mce.Method.DeclaringType.IsGenericType && 1273mce.Method.DeclaringType.GetGenericTypeDefinition() == typeof(DataServiceQuery<>)) 1275Type t = typeof(DataServiceQuery<>).MakeGenericType(mce.Method.DeclaringType.GetGenericArguments()[0]); 2406return object.ReferenceEquals(left.DeclaringType, right.DeclaringType) && left.Name.Equals(right.Name);

System\Data\Services\Client\ALinq\TypeSystem.cs (2)

138(mi.DeclaringType.Assembly.FullName == VisualBasicAssemblyFullName && 139expressionVBMethodMap.TryGetValue(mi.DeclaringType.FullName + "." + mi.Name, out methodName)));

System\Data\Services\Client\ClientType.cs (3)

163keyPropertyDeclaredType = pinfo.DeclaringType; 165else if (keyPropertyDeclaredType != pinfo.DeclaringType) 912get { return this.propertyGetter.DeclaringType; }

System.Data.SqlXml (4)

System\Xml\Xsl\IlGen\XmlIlVisitor.cs (3)

1286Type typAgg = methAgg.DeclaringType; 3375this.helper.CallGetEarlyBoundObject(this.helper.StaticData.DeclareEarlyBound(ndName.NamespaceUri, extFunc.Method.DeclaringType), extFunc.Method.DeclaringType);

System\Xml\Xsl\Runtime\EarlyBoundInfo.cs (1)

38public Type EarlyBoundType { get { return this.constrInfo.DeclaringType; } }

System.Drawing (2)

misc\DbgUtil.cs (2)

306if( sf == null || sf.GetMethod().DeclaringType != typeof(DbgUtil) ) 357trace += String.Format(CultureInfo.CurrentCulture, "at {0} {1}.{2}({3})\r\n", fileName, mi.DeclaringType, mi.Name, args );

System.Management (1)

Instrumentation\SchemaMapping.cs (1)

464 if(field.DeclaringType != type)

System.Runtime.Remoting (1)

channels\core\corechannel.cs (1)

470Type type = methodMsg.MethodBase.DeclaringType;

System.Runtime.Serialization (43)

System\Runtime\Serialization\ClassDataContract.cs (23)

System\Runtime\Serialization\CodeGenerator.cs (14)

System\Runtime\Serialization\DataContract.cs (1)

2405if (!IsTypeVisibleInSerializationModule(member.DeclaringType))

System\Runtime\Serialization\DataContractSet.cs (1)

270DataContract.GetClrTypeFullName(dataMemberType), DataContract.GetClrTypeFullName(dataMember.MemberInfo.DeclaringType), dataMember.MemberInfo.Name)));

System\Runtime\Serialization\EnumDataContract.cs (2)

287ThrowInvalidDataContractException(SR.GetString(SR.TooManyEnumMembers, DataContract.GetClrTypeFullName(field.DeclaringType), field.Name)); 305ThrowInvalidDataContractException(SR.GetString(SR.DataMemberOnEnumField, DataContract.GetClrTypeFullName(field.DeclaringType), field.Name));

System\Runtime\Serialization\XPathQueryGenerator.cs (2)

71if (member.MemberInfo.Name == memberNode.Name && member.MemberInfo.DeclaringType.IsAssignableFrom(memberNode.DeclaringType))

System.Security (1)

system\security\cryptography\xml\SignedXmlDebugLog.cs (1)

319validationMethod.DeclaringType.FullName,

System.ServiceModel (62)

System\ServiceModel\Channels\HttpMessageHandlerFactory.cs (1)

301Type t = m.DeclaringType;

System\ServiceModel\Channels\ServiceChannelProxy.cs (2)

97Type declaringType = method.DeclaringType; 308if (methodData.MethodBase.DeclaringType == typeof(System.ServiceModel.ICommunicationObject)

System\ServiceModel\ComIntegration\TearOffProxy.cs (1)

54if (typeInfo.CanCastTo(typeMethod.DeclaringType, null))

System\ServiceModel\Description\MessageContractExporter.cs (2)

62throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CannotHaveTwoOperationsWithTheSameElement5, parentOperation.OperationMethod.DeclaringType, parentOperation.OperationMethod.Name, qname, existingElement.Operation.OperationMethod.DeclaringType, existingElement.Operation.Name)));

System\ServiceModel\Description\OperationGenerator.cs (1)

1004if (member.DeclaringType == typeof(Attribute))

System\ServiceModel\Description\ServiceReflector.cs (7)

718methodInfo.Name, methodInfo.DeclaringType.Name))); 727methodInfo.Name, methodInfo.DeclaringType.Name))); 841MemberInfo[] endMethods = beginMethod.DeclaringType.GetMember(endMethodName, ServiceModelBindingFlags); 844throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.NoEndMethodFoundForAsyncBeginMethod3, beginMethod.Name, beginMethod.DeclaringType.FullName, endMethodName))); 848throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MoreThanOneEndMethodFoundForAsyncBeginMethod3, beginMethod.Name, beginMethod.DeclaringType.FullName, endMethodName))); 859throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.InvalidAsyncEndMethodSignatureForMethod2, endMethod.Name, endMethod.DeclaringType.FullName))); 892throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.InvalidAsyncBeginMethodSignatureForMethod2, method.Name, method.DeclaringType.FullName)));

System\ServiceModel\Description\TypeLoader.cs (28)

System\ServiceModel\Description\XmlSerializerOperationBehavior.cs (1)

317keyBase = methodInfo.DeclaringType.FullName + ":" + methodInfo.ToString();

System\ServiceModel\Diagnostics\TraceUtility.cs (2)

883SR.GetString(SR.SFxUserCodeThrewException, method.DeclaringType.FullName, method.Name)); 886SR.GetString(SR.TraceCodeUnhandledExceptionInUserOperation, method.DeclaringType.FullName, method.Name),

System\ServiceModel\Dispatcher\AsyncMethodInvoker.cs (3)

124this.beginMethod.DeclaringType.FullName, this.beginMethod.Name); 129this.beginMethod.DeclaringType.FullName, this.beginMethod.Name, 130this.endMethod.DeclaringType.FullName, this.endMethod.Name);

System\ServiceModel\Dispatcher\CodeGenerator.cs (4)

259EmitSourceInstruction("Callvirt " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); 265EmitSourceInstruction("Static Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); 271EmitSourceInstruction("Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); 279EmitSourceInstruction("Newobj " + constructor.ToString() + " on type " + constructor.DeclaringType.ToString());

System\ServiceModel\Dispatcher\DispatchOperationRuntime.cs (2)

869if (!method.DeclaringType.IsAssignableFrom(type)) 873method.DeclaringType.FullName);

System\ServiceModel\Dispatcher\ImmutableClientRuntime.cs (1)

242methodBase.DeclaringType.Name)));

System\ServiceModel\Dispatcher\InvokerUtil.cs (5)

135method.DeclaringType.FullName, 180method.DeclaringType.FullName, 227method.DeclaringType.FullName, 374return ctor != null && (!ctor.IsPublic || !IsTypeVisible(ctor.DeclaringType)) && ctor.Module != typeof(InvokerUtil).Module; 379return method != null && (!method.IsPublic || !IsTypeVisible(method.DeclaringType)) && method.Module != typeof(InvokerUtil).Module;

System\ServiceModel\Dispatcher\SyncMethodInvoker.cs (1)

166ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityExecuteMethod, this.method.DeclaringType.FullName, this.method.Name), ActivityType.ExecuteUserCode);

System\ServiceModel\Dispatcher\TaskMethodInvoker.cs (1)

210string activityName = SR.GetString(SR.ActivityExecuteMethod, this.taskMethod.DeclaringType.FullName, this.taskMethod.Name);

System.Transactions (1)

System\Transactions\Trace\DiagnosticTrace.cs (1)

739Type declaringType = stackFrame.GetMethod().DeclaringType;

System.Web (26)

Compilation\BuildManager.cs (3)

815return new HashSet<string>(methods.Select(m => m.DeclaringType.Assembly.FullName), StringComparer.OrdinalIgnoreCase); 895methodsToExecute = methodsToExecute.OrderBy(m => m.DeclaringType.AssemblyQualifiedName, StringComparer.OrdinalIgnoreCase) 909method.DeclaringType.FullName,

Compilation\CodeDOMUtility.cs (4)

105CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name); 112CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name); 133CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name); 149CodeObjectCreateExpression objectCreate = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName);

Compilation\PageCodeDomTreeGenerator.cs (1)

588if (methodInfo != null && methodInfo.DeclaringType != typeof(Page)) {

ErrorFormatter.cs (1)

1051Type declaringType = mb.DeclaringType;

parent\parent\parent\Misc\SecurityUtils.cs (3)

200Type type = field.DeclaringType; 216Type type = method.DeclaringType; 235Type type = ctor.DeclaringType;

UI\ControlBuilder.cs (2)

3086bool useCurrentControlType = propInfo.DeclaringType.IsAssignableFrom(_controlType); 3093propertyDescriptors = TargetFrameworkUtil.GetProperties(propInfo.DeclaringType);

UI\PropertyEntry.cs (1)

107return _propertyInfo.DeclaringType;

UI\TemplateControl.cs (2)

622if (f.GetMethod().DeclaringType != typeof(TemplateControl)) { 633combinedHashCode.AddObject(m.DeclaringType.AssemblyQualifiedName);

UI\WebControls\AdRotator.cs (1)

524if (methodInfo.DeclaringType != _adrotatorType) {

UI\WebControls\ModelDataSourceView.cs (2)

1252parameterInfo.Name, parameterInfo.ParameterType, methodInfo, methodInfo.DeclaringType); 1259parameterInfo.Name, methodInfo, methodInfo.DeclaringType, value.GetType(), parameterInfo.ParameterType);

UI\WebParts\PersonalizableTypeEntry.cs (2)

100Type declaringTypeX = ((PropertyInfo)x).DeclaringType; 101Type declaringTypeY = ((PropertyInfo)y).DeclaringType;

Util\AppVerifier.cs (1)

760&& thisFrame.GetMethod().DeclaringType.FullName.StartsWith("System.Web.Util.AppVerifier", StringComparison.Ordinal)) {

Util\FastPropertyAccessor.cs (2)

270declaringType = baseCheckMethodInfo.GetBaseDefinition().DeclaringType; 295declaringType = fieldInfo.DeclaringType;

Util\QueryableUtility.cs (1)

13if (call.Method.IsStatic && call.Method.DeclaringType == typeof(Queryable)) {

System.Web.DataVisualization (1)

Common\Utilities\XmlSerializer.cs (1)

641 if(pi.DeclaringType == currentType)

System.Web.DynamicData (1)

DynamicData\MetaTable.cs (1)

162_hasToStringOverride = (toStringMethod.DeclaringType != typeof(object));

System.Web.Extensions (3)

UI\WebControls\Dynamic.cs (3)

1192if (!IsPredefinedType(method.DeclaringType)) 1193throw ParseError(errorPos, AtlasWeb.ExpressionParser_MethodsAreInaccessible, GetTypeName(method.DeclaringType)); 1196id, GetTypeName(method.DeclaringType));

System.Web.Services (20)

System\Web\Services\Protocols\LogicalMethodInfo.cs (10)

98throw new InvalidOperationException(Res.GetString(Res.WebMethodMissingParams, beginMethodInfo.DeclaringType.FullName, beginMethodInfo.Name, 211get { return methodInfo.DeclaringType; } 321throw new InvalidOperationException(Res.GetString(Res.ContractOverride, methodInfo.Name, methodInfo.DeclaringType.FullName, declaration.DeclaringType.FullName, declaration.ToString(), implAttributes[0].ToString())); 416throw new InvalidOperationException(Res.GetString(Res.WebBadOutParameter, paramInfo.Name, methodInfo.DeclaringType.FullName, paramInfo.Name)); 439throw new InvalidOperationException(Res.GetString(Res.WebInOutParameter, paramInfo.Name, methodInfo.DeclaringType.FullName, paramInfo.Name)); 534throw new InvalidOperationException(Res.GetString(Res.WebAsyncMissingEnd, beginMethodInfo.DeclaringType.FullName, beginMethodInfo.Name, endName)); 555string key = methodInfo.DeclaringType.FullName + ":" + methodInfo.ToString(); 573throw new InvalidOperationException(Res.GetString(Res.ContractOverride, methodInfo.Name, methodInfo.DeclaringType.FullName, declaration.DeclaringType.FullName, declaration.ToString(), o.ToString()));

System\Web\Services\Protocols\SoapReflector.cs (1)

169importer.IncludeTypes(method.Declaration.DeclaringType);

System\Web\Services\WebMethodAttribute.cs (9)

237throw new InvalidOperationException(Res.GetString(Res.ContractOverride, implementation.Name, implementation.DeclaringType.FullName, declaration.DeclaringType.FullName, declaration.ToString(), "WebMethod.MessageName")); 275Type declaringType = methods[i].DeclaringType; 285object[] attrs = declaration.DeclaringType.GetCustomAttributes(typeof(WebServiceBindingAttribute), false); 288throw new ArgumentException(Res.GetString(Res.OnlyOneWebServiceBindingAttributeMayBeSpecified1, declaration.DeclaringType.FullName), "type"); 291binding.Name = declaration.DeclaringType.Name; 313if (method.DeclaringType.IsAssignableFrom(methods[i].DeclaringType)) { 331importer.IncludeTypes(method.Declaration.DeclaringType);

System.Windows.Forms (5)

misc\DbgUtil.cs (2)

misc\SecurityUtils.cs (3)

200Type type = field.DeclaringType; 216Type type = method.DeclaringType; 235Type type = ctor.DeclaringType;

System.Windows.Forms.DataVisualization (1)

Common\Utilities\XmlSerializer.cs (1)

641 if(pi.DeclaringType == currentType)

System.Workflow.Activities (40)

Common\Walker.cs (1)

269if (prop.DeclaringType == typeof(CompositeActivity) && string.Equals(prop.Name, "Activities", StringComparison.Ordinal))

CorrelationValidator.cs (8)

Designers\StateDesigner.cs (1)

2445return this.realPropertyInfo.DeclaringType;

Rules\CodeDomDecompiler.cs (1)

328DecompileType_Helper(sb, method.DeclaringType);

Rules\Design\Dialogs\IntellisenseTextBox.cs (1)

537toolTipText.Append(RuleDecompiler.DecompileType(ctorInfo.DeclaringType));

Rules\Expressions.cs (3)

371if (!ruleAttr.Validate(validation, method, method.DeclaringType, method.GetParameters())) 434CodeExpression targetObject = new CodeTypeReferenceExpression(method.DeclaringType); 1441invokeExpr.UserData[RuleUserDataKeys.QualifiedName] = mi.DeclaringType.AssemblyQualifiedName;

Rules\Parser\Parser.cs (16)

Rules\RuleAttributes.cs (1)

406AnalyzeInvokeAttribute(analysis, member.DeclaringType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions);

Rules\RuleValidation.cs (7)

152: base(ci.DeclaringType) 249get { return actualMethod.DeclaringType; } 366get { return actualMethod.DeclaringType; } 2289accessorMethod.DeclaringType.Assembly, RuleValidation.IsPrivate(accessorMethod), RuleValidation.IsInternal(accessorMethod), accessorMethod.IsStatic); 2297accessorMethod.DeclaringType.Assembly, RuleValidation.IsPrivate(accessorMethod), RuleValidation.IsInternal(accessorMethod), accessorMethod.IsStatic); 2722Type thisDeclaringType = this.Member.DeclaringType; 2723Type otherDeclaringType = other.Member.DeclaringType;

WebServiceReceive.cs (1)

833baseInvokeExpression.Parameters.Add(new CodeTypeOfExpression(methodInfo.DeclaringType));

System.Workflow.ComponentModel (27)

AuthoringOM\Compiler\TypeSystem\Helper.cs (4)

237baseMemberInfo = ((DesignTimeType)memberInfo.DeclaringType).GetBaseMember(memberInfo.GetType(), memberInfo.DeclaringType.BaseType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, new DesignTimeType.MemberSignature(memberInfo)); 274baseMemberInfo = ((DesignTimeType)memberInfo.DeclaringType).GetBaseMember(memberInfo.GetType(), memberInfo.DeclaringType.BaseType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, new DesignTimeType.MemberSignature(memberInfo));

AuthoringOM\Compiler\TypeSystem\ParameterInfo.cs (2)

48string type = DesignTimeType.GetTypeNameFromCodeTypeReference(this.codeParameterType, (this.Member.DeclaringType as DesignTimeType)); 51this.ClassImpl = (this.Member.DeclaringType as DesignTimeType).ResolveType(type);

AuthoringOM\Compiler\TypeSystem\RTTypeWrapper.cs (5)

841get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.ctorInfo.DeclaringType); } 912get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.fieldInfo.DeclaringType); } 1015get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.propertyInfo.DeclaringType); } 1133return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.methodInfo.DeclaringType); 1205get { return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.eventInfo.DeclaringType); }

AuthoringOM\Compiler\Validation\BindValidator.cs (3)

862if (typeof(WorkflowParameterBinding).IsAssignableFrom(memberInfo.DeclaringType)) 886DependencyProperty dependencyProperty = DependencyProperty.FromName(memberInfo.Name, memberInfo.DeclaringType); 900if (typeof(WorkflowParameterBinding).IsAssignableFrom(memberInfo.DeclaringType))

AuthoringOM\Compiler\Validation\Validator.cs (1)

54DependencyProperty dependencyProperty = DependencyProperty.FromName(args.CurrentProperty.Name, args.CurrentProperty.DeclaringType);

AuthoringOM\Design\ComponentSerializationService.cs (1)

817return this.realPropInfo.DeclaringType;

AuthoringOM\Design\PropertyDescriptors.cs (4)

472if (memberInfo.DeclaringType == typeof(System.Object) && (string.Equals(memberInfo.Name, "Equals", StringComparison.Ordinal) || string.Equals(memberInfo.Name, "ReferenceEquals", StringComparison.Ordinal))) 512if (memberInfo.DeclaringType != objectType && !isProtectedOrPublicMember && !(memberInfo.DeclaringType.Assembly == null && isInternalMember)) 592if ((matchingMember.DeclaringType == designedType || !isPrivate) &&

AuthoringOM\Design\WorkflowInlining.cs (5)

377if (parameterProperty.DeclaringType == typeof(DependencyObject) || 378parameterProperty.DeclaringType == typeof(Activity) || 379parameterProperty.DeclaringType == typeof(CompositeActivity) || 380((parameterProperty.DeclaringType == Type.GetType(DesignerHelpers.SequentialWorkflowTypeRef) || 381parameterProperty.DeclaringType == Type.GetType(DesignerHelpers.StateMachineWorkflowTypeRef)) &&

AuthoringOM\Serializer\ExtendedPropertyInfo.cs (1)

85return this.realPropertyInfo.DeclaringType;

Shared\Walker.cs (1)

268if (prop.DeclaringType == typeof(CompositeActivity) && string.Equals(prop.Name, "Activities", StringComparison.Ordinal))

System.Workflow.Runtime (8)

DebugEngine\DebugController.cs (1)

1117handlerMethod.Name = handlerMethodInfo.DeclaringType.FullName + "." + handlerMethodInfo.Name;

System\Activities\Statements\InteropEnvironment.cs (4)

351if (propertyInfo.DeclaringType.Equals(compositeActivityType) || 352propertyInfo.DeclaringType.Equals(dependencyObjectType)) 359if (propertyInfo.DeclaringType.Equals(activityType) && 375propertyInfo.DeclaringType);

WorkflowDefinitionDispenser.cs (3)

344if (!property.CanRead || property.DeclaringType == typeof(DependencyObject) || property.DeclaringType == typeof(Activity) || property.DeclaringType == typeof(CompositeActivity))

System.WorkflowServices (7)

System\ServiceModel\Dispatcher\WorkflowOperationInvoker.cs (1)

65staticQueueName = QueueNameHelper.Create(this.syncMethod.DeclaringType, operationDescription.Name);

System\Workflow\Activities\ContractMethodParameterInfo.cs (2)

39if (this.Member.DeclaringType is DesignTimeType) 41this.ClassImpl = (this.Member.DeclaringType as DesignTimeType).ResolveType(typeName);

System\Workflow\Activities\ReceiveActivity.cs (2)

706operationDeclaringType = methodInfo.DeclaringType; 1425this.baseQueueName = QueueNameHelper.Create(methodInfo.DeclaringType, this.operationName);

System\Workflow\Activities\ValidationHelper.cs (2)

203contractType = methodInfo.DeclaringType; 264if (methodInfo.DeclaringType != currentContractType)

System.Xml (20)

System\Xml\Serialization\CodeGenerator.cs (2)

611if (methodInfo.IsVirtual && !methodInfo.DeclaringType.IsValueType) 699Type currentType = propertyInfo.DeclaringType.BaseType;

System\Xml\Serialization\Mappings.cs (3)

1098throw new InvalidOperationException(Res.GetString(Res.XmlSerializableRootDupName, getSchemaMethod.DeclaringType.FullName, e.Name, elementNs)); 1170throw new InvalidOperationException(Res.GetString(Res.XmlGetSchemaInclude, xsiType.Namespace, getSchemaMethod.DeclaringType.FullName, getSchemaMethod.Name)); 1178throw new InvalidOperationException(Res.GetString(Res.XmlGetSchemaTypeMissing, getSchemaMethod.DeclaringType.FullName, getSchemaMethod.Name, xsiType.Name, xsiType.Namespace));

System\Xml\Serialization\Models.cs (6)

170throw new InvalidOperationException(Res.GetString(Res.XmlSerializerUnsupportedMember, member.DeclaringType.FullName + "." + member.Name, type.FullName), typeDesc.Exception); 179if (fieldInfo.DeclaringType != Type) return null; 190if (propertyInfo.DeclaringType != Type) return null; 249this.checkShouldPersistMethodInfo = memberInfo.DeclaringType.GetMethod("ShouldSerialize" + memberInfo.Name, new Type[0]); 252FieldInfo specifiedField = memberInfo.DeclaringType.GetField(memberInfo.Name + "Specified"); 261PropertyInfo specifiedProperty = memberInfo.DeclaringType.GetProperty(memberInfo.Name + "Specified");

System\Xml\Serialization\SoapReflectionImporter.cs (1)

174SoapAttributes attrs = attributeOverrides[memberInfo.DeclaringType, memberInfo.Name];

System\Xml\Serialization\Types.cs (5)

744arrayElementType = GetCollectionElementType(type, memberInfo == null ? null : memberInfo.DeclaringType.FullName + "." + memberInfo.Name); 802exception = new NotSupportedException(Res.GetString(Res.XmlUnsupportedInterfaceDetails, memberInfo.DeclaringType.FullName + "." + memberInfo.Name, type.FullName)); 967throw new InvalidOperationException(Res.GetString(Res.XmlReadOnlyPropertyError, propertyInfo.DeclaringType, propertyInfo.Name)); 1050Type typeToBeReplaced = memberInfoToBeReplaced.DeclaringType; 1177if (defaultProp.DeclaringType != t) continue;

System\Xml\Serialization\XmlReflectionImporter.cs (1)

229XmlAttributes attrs = attributeOverrides[memberInfo.DeclaringType, memberInfo.Name];

System\Xml\Xslt\XslCompiledTransform.cs (2)

317if (executeMethod.DeclaringType != null && !executeMethod.DeclaringType.IsVisible)

WindowsBase (5)

Base\MS\Internal\ComponentModel\DependencyObjectPropertyDescriptor.cs (2)

406if (methodObj == null || (method != null && !object.ReferenceEquals(method.DeclaringType, reflectionType))) { 573if (methodObj == null || (method != null && !object.ReferenceEquals(method.DeclaringType, reflectionType))) {

Base\System\Windows\DependencyObject.cs (1)

1693dp.OwnerType != metadata.CoerceValueCallback.Method.DeclaringType) // Need 2nd check to rule out derived class callback overrides.

Base\System\Windows\Markup\TypeConverterHelper.cs (1)

93memberInfo = methodInfo.DeclaringType.GetMethod(

Base\System\Windows\Threading\DispatcherOperation.cs (1)

310return _method.Method.DeclaringType + "." + _method.Method.Name;

XamlBuildTask (2)

Microsoft\Build\Tasks\Xaml\ClassGenerator.cs (2)

313if (cad.Constructor.DeclaringType == typeof(ComVisibleAttribute)) 334if (cad.Constructor.DeclaringType == typeof(ComVisibleAttribute))