/// <inheritdoc/> public IMemberForwarded Resolve(MemberRef memberRef) { if (memberRef == null) return null; var method = memberRef.Class as MethodDef; if (method != null) return method; var declaringType = GetDeclaringType(memberRef); return declaringType == null ? null : declaringType.Resolve(memberRef); }
TypeDef GetDeclaringType(MemberRef memberRef) { if (memberRef == null) return null; var parent = memberRef.Class; if (parent == null) return null; var declaringTypeDef = parent as TypeDef; if (declaringTypeDef != null) return declaringTypeDef; var declaringTypeRef = parent as TypeRef; if (declaringTypeRef != null) return Resolve(declaringTypeRef); // A module ref is used to reference the global type of a module in the same // assembly as the current module. var moduleRef = parent as ModuleRef; if (moduleRef != null) { var module = memberRef.Module; if (module == null) return null; TypeDef globalType = null; if (new SigComparer(0).Equals(module, moduleRef)) globalType = module.GlobalType; if (globalType == null && module.Assembly != null) { var moduleDef = module.Assembly.FindModule(moduleRef.Name); if (moduleDef != null) globalType = moduleDef.GlobalType; } return globalType; } var method = parent as MethodDef; if (method != null) return method.DeclaringType; var ts = parent as TypeSpec; if (ts != null) { var git = ts.TypeSig as GenericInstSig; if (git != null) { var td = git.GenericType.TypeDef; if (td != null) return td; var tr = git.GenericType.TypeRef; if (tr != null) return Resolve(tr); } return null; } return null; }
/// <summary> /// Resolves a field /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A field reference</param> /// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> /// <exception cref="MemberRefResolveException">If the field couldn't be resolved</exception> public static FieldDef ResolveFieldThrow(this IMemberRefResolver self, MemberRef memberRef) { var field = self.Resolve(memberRef) as FieldDef; if (field != null) return field; throw new MemberRefResolveException(string.Format("Could not resolve field: {0}", memberRef)); }
/// <summary> /// Resolves a method /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A method reference</param> /// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> /// <exception cref="MemberRefResolveException">If the method couldn't be resolved</exception> public static MethodDef ResolveMethodThrow(this IMemberRefResolver self, MemberRef memberRef) { var method = self.Resolve(memberRef) as MethodDef; if (method != null) return method; throw new MemberRefResolveException(string.Format("Could not resolve method: {0} ({1})", memberRef, memberRef == null ? null : memberRef.GetDefinitionAssembly())); }
/// <inheritdoc/> protected override uint AddMemberRef(MemberRef mr) { if (mr == null) { Error("MemberRef is null"); return 0; } uint rid; if (memberRefInfos.TryGetRid(mr, out rid)) return rid; var row = new RawMemberRefRow(AddMemberRefParent(mr.Class), stringsHeap.Add(mr.Name), GetSignature(mr.Signature)); rid = tablesHeap.MemberRefTable.Add(row); memberRefInfos.Add(mr, rid); AddCustomAttributes(Table.MemberRef, rid, mr); return rid; }
/// <summary> /// Creates a new instruction with a method/field operand /// </summary> /// <param name="opCode">The opcode</param> /// <param name="mr">The method/field</param> /// <returns>A new <see cref="Instruction"/> instance</returns> public static Instruction Create(OpCode opCode, MemberRef mr) { if (opCode.OperandType != OperandType.InlineField && opCode.OperandType != OperandType.InlineMethod && opCode.OperandType != OperandType.InlineTok) throw new ArgumentException("Opcode does not have a field operand", "opCode"); return new Instruction(opCode, mr); }
private static void AddImportReference(INameService service, ICollection <ModuleDefMD> modules, ModuleDef module, MethodDef method, MemberRef methodRef) { if (method.Module != module && modules.Contains((ModuleDefMD)module)) { var declType = (TypeRef)methodRef.DeclaringType.ScopeType; service.AddReference(method.DeclaringType, new TypeRefReference(declType, method.DeclaringType)); service.AddReference(method, new MemberRefReference(methodRef, method)); var typeRefs = methodRef.MethodSig.Params.SelectMany(param => param.FindTypeRefs()).ToList(); typeRefs.AddRange(methodRef.MethodSig.RetType.FindTypeRefs()); typeRefs.AddRange(methodRef.DeclaringType.ToTypeSig().FindTypeRefs()); foreach (var typeRef in typeRefs) { SetupTypeReference(service, modules, module, typeRef); } } }
/// <inheritdoc/> public IMemberForwarded Resolve(MemberRef memberRef) { return null; }
public RuntimeImport(MemberRef importingMemberRef, TypeRef importingSiteTypeRef, TypeRef importingSiteTypeWithoutCollectionRef, ImportCardinality cardinality, IReadOnlyList <RuntimeExport> satisfyingExports, bool isNonSharedInstanceRequired, bool isExportFactory, IReadOnlyDictionary <string, object> metadata, IReadOnlyCollection <string> exportFactorySharingBoundaries) : this(importingSiteTypeRef, importingSiteTypeWithoutCollectionRef, cardinality, satisfyingExports, isNonSharedInstanceRequired, isExportFactory, metadata, exportFactorySharingBoundaries) { this.ImportingMemberRef = importingMemberRef; }
private static RuntimeExport CreateRuntimeExport(ExportDefinition exportDefinition, Type partType, MemberRef exportingMemberRef, Resolver resolver) { Requires.NotNull(exportDefinition, nameof(exportDefinition)); var exportingMember = exportingMemberRef?.MemberInfo; return(new RuntimeExport( exportDefinition.ContractName, TypeRef.Get(partType, resolver), exportingMemberRef, TypeRef.Get(ReflectionHelpers.GetExportedValueType(partType, exportingMember), resolver), exportDefinition.Metadata)); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { foreach (ModuleDef module in parameters.Targets.OfType <ModuleDef>()) { foreach (TypeDef type in module.Types.ToArray()) { foreach (MethodDef method in type.Methods.ToArray()) { if (method.HasBody) { if (method.Body.HasInstructions) { if (method.FullName.Contains("My.")) { continue; } if (method.FullName.Contains(".My")) { continue; } if (method.FullName.Contains("Costura")) { continue; } if (method.IsConstructor) { continue; } if (method.DeclaringType.IsGlobalModuleType) { continue; } for (int i = 0; i < method.Body.Instructions.Count - 1; i++) { try { if (method.Body.Instructions[i].ToString().Contains("ISupportInitialize")) { continue; } if (method.Body.Instructions[i].OpCode == OpCodes.Call || method.Body.Instructions[i].OpCode == OpCodes.Callvirt /* || method.Body.Instructions[i].OpCode == OpCodes.Ldloc_S*/) { try { MemberRef membertocalli = (MemberRef)method.Body.Instructions[i].Operand; method.Body.Instructions[i].OpCode = OpCodes.Calli; method.Body.Instructions[i].Operand = membertocalli.MethodSig; method.Body.Instructions.Insert(i, Instruction.Create(OpCodes.Ldftn, membertocalli)); } catch (Exception ex) { string str = ex.Message; } } } catch { } } } else { } } } foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); break; } } } } }
private void AddImportsFromMembers(PropertyInfo[] declaredProperties, FieldInfo[] declaredFields, TypeRef partTypeRef, IList <ImportDefinitionBinding> imports) { Requires.NotNull(declaredProperties, nameof(declaredProperties)); Requires.NotNull(declaredFields, nameof(declaredFields)); Requires.NotNull(partTypeRef, nameof(partTypeRef)); Requires.NotNull(imports, nameof(imports)); foreach (var member in declaredFields.Concat <MemberInfo>(declaredProperties)) { if (!member.IsStatic()) { ImportDefinition importDefinition; if (this.TryCreateImportDefinition(ReflectionHelpers.GetMemberType(member), member, out importDefinition)) { imports.Add(new ImportDefinitionBinding(importDefinition, partTypeRef, MemberRef.Get(member, this.Resolver))); } } } }
/// <summary> /// Resolves a method /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A method reference</param> /// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> public static MethodDef ResolveMethod(this IMemberRefResolver self, MemberRef memberRef) => self.Resolve(memberRef) as MethodDef;
/// <summary> /// Resolves a field /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A field reference</param> /// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> public static FieldDef ResolveField(this IMemberRefResolver self, MemberRef memberRef) => self.Resolve(memberRef) as FieldDef;
/// <summary> /// Resolves a method /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A method reference</param> /// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> /// <exception cref="MemberRefResolveException">If the method couldn't be resolved</exception> public static MethodDef ResolveMethodThrow(this IMemberRefResolver self, MemberRef memberRef) { var method = self.Resolve(memberRef) as MethodDef; if (method != null) return method; throw new MemberRefResolveException(string.Format("Could not resolve method: {0}", memberRef)); }
/// <summary> /// Resolves a field /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A field reference</param> /// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> public static FieldDef ResolveField(this IMemberRefResolver self, MemberRef memberRef) { return self.Resolve(memberRef) as FieldDef; }
/// <summary> /// Creates a new instruction with a method/field operand /// </summary> /// <param name="mr">The method/field</param> /// <returns>A new <see cref="Instruction"/> instance</returns> public Instruction ToInstruction(MemberRef mr) { return(Instruction.Create(this, mr)); }
void AddImportReference(ConfuserContext context, INameService service, ModuleDef module, MethodDef method, MemberRef methodRef) { if (method.Module != module && context.Modules.Contains((ModuleDefMD)method.Module)) { var declType = (TypeRef)methodRef.DeclaringType.ScopeType; service.AddReference(method.DeclaringType, new TypeRefReference(declType, method.DeclaringType)); service.AddReference(method, new MemberRefReference(methodRef, method)); var typeRefs = methodRef.MethodSig.Params.SelectMany(param => param.FindTypeRefs()).ToList(); typeRefs.AddRange(methodRef.MethodSig.RetType.FindTypeRefs()); foreach (var typeRef in typeRefs) { var def = typeRef.ResolveTypeDefThrow(); if (def.Module != module && context.Modules.Contains((ModuleDefMD)def.Module)) { service.AddReference(def, new TypeRefReference((TypeRef)typeRef, def)); } } } }
private static void AnalyzeMemberRef(ICollection <ModuleDefMD> modules, INameService service, MemberRef memberRef) { ITypeDefOrRef declType = memberRef.DeclaringType; var typeSpec = declType as TypeSpec; if (typeSpec == null || typeSpec.TypeSig.IsArray || typeSpec.TypeSig.IsSZArray) { return; } TypeSig sig = typeSpec.TypeSig; while (sig.Next != null) { sig = sig.Next; } Debug.Assert(sig is TypeDefOrRefSig || sig is GenericInstSig || sig is GenericSig); if (sig is GenericInstSig) { var inst = (GenericInstSig)sig; Debug.Assert(!(inst.GenericType.TypeDefOrRef is TypeSpec)); TypeDef openType = inst.GenericType.TypeDefOrRef.ResolveTypeDefThrow(); if (!modules.Contains((ModuleDefMD)openType.Module) || memberRef.IsArrayAccessors()) { return; } IMemberDef member; if (memberRef.IsFieldRef) { member = memberRef.ResolveFieldThrow(); } else if (memberRef.IsMethodRef) { member = memberRef.ResolveMethodThrow(); } else { throw new UnreachableException(); } service.AddReference(member, new MemberRefReference(memberRef, member)); } }
public abstract InvalidInfo ImplementableMemberRef(MessageContext ctxt, RootEnvironment rootEnv, MemberRef memberRef);
/// <summary> /// Resolves a field /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A field reference</param> /// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> public static FieldDef ResolveField(this IMemberRefResolver self, MemberRef memberRef) { return(self.Resolve(memberRef) as FieldDef); }
/// <summary> /// Resolves a method /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A method reference</param> /// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> public static MethodDef ResolveMethod(this IMemberRefResolver self, MemberRef memberRef) { return(self.Resolve(memberRef) as MethodDef); }
public MemberRefReference(MemberRef memberRef, IDnlibDef memberDef) { this.memberRef = memberRef; this.memberDef = memberDef; }
/// <inheritdoc/> public override uint GetRid(MemberRef mr) { uint rid; memberRefInfos.TryGetRid(mr, out rid); return rid; }
public static TypeConstraint Type(MemberRef constrainedType) => new TypeConstraint(ConstraintType.Type, constrainedType, default);
/// <summary> /// Resolves a field /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A field reference</param> /// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> /// <exception cref="MemberRefResolveException">If the field couldn't be resolved</exception> public static FieldDef ResolveFieldThrow(this IMemberRefResolver self, MemberRef memberRef) { var field = self.Resolve(memberRef) as FieldDef; if (field != null) return field; throw new MemberRefResolveException(string.Format("Could not resolve field: {0} ({1})", memberRef, memberRef == null ? null : memberRef.GetDefinitionAssembly())); }
/// <summary> /// Creates a new instruction with a method/field operand /// </summary> /// <param name="mr">The method/field</param> /// <returns>A new <see cref="Instruction"/> instance</returns> public Instruction ToInstruction(MemberRef mr) => Instruction.Create(this, mr);
/// <summary> /// Resolves a method or a field /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A method/field reference</param> /// <returns>A <see cref="MethodDef"/> or a <see cref="FieldDef"/> instance</returns> /// <exception cref="MemberRefResolveException">If the method/field couldn't be resolved</exception> public static IMemberForwarded ResolveThrow(this IMemberRefResolver self, MemberRef memberRef) { var memberDef = self.Resolve(memberRef); if (memberDef != null) return memberDef; throw new MemberRefResolveException(string.Format("Could not resolve method/field: {0} ({1})", memberRef, memberRef == null ? null : memberRef.GetDefinitionAssembly())); }
/// <inheritdoc/> public IMemberForwarded Resolve(MemberRef memberRef) { return(null); }
/// <summary> /// Resolves a method /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A method reference</param> /// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns> public static MethodDef ResolveMethod(this IMemberRefResolver self, MemberRef memberRef) { return self.Resolve(memberRef) as MethodDef; }
public MemberRefInfo(MemberRef mr) { this.MemberRef = mr; this.OrigName = mr.Name; }
/// <summary> /// Resolves a method or a field /// </summary> /// <param name="self">this</param> /// <param name="memberRef">A method/field reference</param> /// <returns>A <see cref="MethodDef"/> or a <see cref="FieldDef"/> instance</returns> /// <exception cref="MemberRefResolveException">If the method/field couldn't be resolved</exception> public static IMemberForwarded ResolveThrow(this IMemberRefResolver self, MemberRef memberRef) { var memberDef = self.Resolve(memberRef); if (memberDef != null) return memberDef; throw new MemberRefResolveException(string.Format("Could not resolve method/field: {0}", memberRef)); }
protected override ComposablePartDefinition CreatePart(Type partType, bool typeExplicitlyRequested) { Requires.NotNull(partType, nameof(partType)); var partTypeInfo = partType.GetTypeInfo(); if (!typeExplicitlyRequested) { bool isPublic = partType.IsNested ? partTypeInfo.IsNestedPublic : partTypeInfo.IsPublic; if (!this.IsNonPublicSupported && !isPublic) { // Skip non-public types. return(null); } } var declaredProperties = partTypeInfo.GetProperties(BindingFlags.Instance | this.PublicVsNonPublicFlags); var exportingProperties = from member in declaredProperties from export in member.GetAttributes <ExportAttribute>() select new KeyValuePair <MemberInfo, ExportAttribute>(member, export); var exportedTypes = from export in partTypeInfo.GetAttributes <ExportAttribute>() select new KeyValuePair <MemberInfo, ExportAttribute>(partTypeInfo, export); var exportsByMember = (from export in exportingProperties.Concat(exportedTypes) group export.Value by export.Key into exportsByType select exportsByType).Select(g => new KeyValuePair <MemberInfo, ExportAttribute[]>(g.Key, g.ToArray())).ToArray(); if (exportsByMember.Length == 0) { return(null); } // Check for PartNotDiscoverable only after we've established it's an interesting part. // This optimizes for the fact that most types have no exports, in which case it's not a discoverable // part anyway. Checking for the PartNotDiscoverableAttribute first, which is rarely defined, // doesn't usually pay for itself in terms of short-circuiting. But it does add an extra // attribute to look for that we don't need to find for all the types that have no export attributes either. if (!typeExplicitlyRequested && partTypeInfo.IsAttributeDefined <PartNotDiscoverableAttribute>()) { return(null); } TypeRef partTypeRef = TypeRef.Get(partType, this.Resolver); Type partTypeAsGenericTypeDefinition = partTypeInfo.IsGenericType ? partType.GetGenericTypeDefinition() : null; string sharingBoundary = null; var sharedAttribute = partTypeInfo.GetFirstAttribute <SharedAttribute>(); if (sharedAttribute != null) { sharingBoundary = sharedAttribute.SharingBoundary ?? string.Empty; } CreationPolicy partCreationPolicy = sharingBoundary != null ? CreationPolicy.Shared : CreationPolicy.NonShared; var allExportsMetadata = ImmutableDictionary.CreateRange(PartCreationPolicyConstraint.GetExportMetadata(partCreationPolicy)); var exportsOnType = ImmutableList.CreateBuilder <ExportDefinition>(); var exportsOnMembers = ImmutableDictionary.CreateBuilder <MemberRef, IReadOnlyCollection <ExportDefinition> >(); var imports = ImmutableList.CreateBuilder <ImportDefinitionBinding>(); foreach (var export in exportsByMember) { var member = export.Key; var memberExportMetadata = allExportsMetadata.AddRange(this.GetExportMetadata(member)); if (member is TypeInfo) { foreach (var exportAttribute in export.Value) { Type exportedType = exportAttribute.ContractType ?? partTypeAsGenericTypeDefinition ?? partType; ExportDefinition exportDefinition = CreateExportDefinition(memberExportMetadata, exportAttribute, exportedType); exportsOnType.Add(exportDefinition); } } else // property { var property = (PropertyInfo)member; Verify.Operation(!partTypeInfo.IsGenericTypeDefinition, Strings.ExportsOnMembersNotAllowedWhenDeclaringTypeGeneric); var exportDefinitions = ImmutableList.CreateBuilder <ExportDefinition>(); foreach (var exportAttribute in export.Value) { Type exportedType = exportAttribute.ContractType ?? property.PropertyType; ExportDefinition exportDefinition = CreateExportDefinition(memberExportMetadata, exportAttribute, exportedType); exportDefinitions.Add(exportDefinition); } exportsOnMembers.Add(MemberRef.Get(member, this.Resolver), exportDefinitions.ToImmutable()); } } foreach (var member in declaredProperties) { var importAttribute = member.GetFirstAttribute <ImportAttribute>(); var importManyAttribute = member.GetFirstAttribute <ImportManyAttribute>(); Requires.Argument(!(importAttribute != null && importManyAttribute != null), "partType", Strings.MemberContainsBothImportAndImportMany, member.Name); var importConstraints = GetImportConstraints(member); ImportDefinition importDefinition; if (this.TryCreateImportDefinition(ReflectionHelpers.GetMemberType(member), member, importConstraints, out importDefinition)) { var importDefinitionBinding = new ImportDefinitionBinding( importDefinition, TypeRef.Get(partType, this.Resolver), MemberRef.Get(member, this.Resolver), TypeRef.Get(member.PropertyType, this.Resolver), TypeRef.Get(GetImportingSiteTypeWithoutCollection(importDefinition, member.PropertyType), this.Resolver)); imports.Add(importDefinitionBinding); } } MethodInfo onImportsSatisfied = null; foreach (var method in partTypeInfo.GetMethods(this.PublicVsNonPublicFlags | BindingFlags.Instance)) { if (method.IsAttributeDefined <OnImportsSatisfiedAttribute>()) { Verify.Operation(method.GetParameters().Length == 0, Strings.OnImportsSatisfiedTakeNoParameters); Verify.Operation(onImportsSatisfied == null, Strings.OnlyOneOnImportsSatisfiedMethodIsSupported); onImportsSatisfied = method; } } var importingConstructorParameters = ImmutableList.CreateBuilder <ImportDefinitionBinding>(); var importingCtor = GetImportingConstructor <ImportingConstructorAttribute>(partType, publicOnly: !this.IsNonPublicSupported); Verify.Operation(importingCtor != null, Strings.NoImportingConstructorFound); foreach (var parameter in importingCtor.GetParameters()) { var import = this.CreateImport(parameter, GetImportConstraints(parameter)); if (import.ImportDefinition.Cardinality == ImportCardinality.ZeroOrMore) { Verify.Operation(PartDiscovery.IsImportManyCollectionTypeCreateable(import), Strings.CollectionMustBePublicAndPublicCtorWhenUsingImportingCtor); } importingConstructorParameters.Add(import); } var partMetadata = ImmutableDictionary.CreateBuilder <string, object>(); foreach (var partMetadataAttribute in partTypeInfo.GetAttributes <PartMetadataAttribute>()) { partMetadata[partMetadataAttribute.Name] = partMetadataAttribute.Value; } var assemblyNamesForMetadataAttributes = ImmutableHashSet.CreateBuilder <AssemblyName>(ByValueEquality.AssemblyName); foreach (var export in exportsByMember) { GetAssemblyNamesFromMetadataAttributes <MetadataAttributeAttribute>(export.Key, assemblyNamesForMetadataAttributes); } return(new ComposablePartDefinition( TypeRef.Get(partType, this.Resolver), partMetadata.ToImmutable(), exportsOnType.ToImmutable(), exportsOnMembers.ToImmutable(), imports.ToImmutable(), sharingBoundary, MethodRef.Get(onImportsSatisfied, this.Resolver), MethodRef.Get(importingCtor, this.Resolver), importingConstructorParameters.ToImmutable(), partCreationPolicy, assemblyNamesForMetadataAttributes)); }
/// <summary> /// Creates a new instruction with a method/field operand /// </summary> /// <param name="mr">The method/field</param> /// <returns>A new <see cref="Instruction"/> instance</returns> public Instruction ToInstruction(MemberRef mr) { return Instruction.Create(this, mr); }
protected override ComposablePartDefinition?CreatePart(Type partType, bool typeExplicitlyRequested) { Requires.NotNull(partType, nameof(partType)); var partTypeInfo = partType.GetTypeInfo(); // We want to ignore abstract classes, but we want to consider static classes. // Static classes claim to be both abstract and sealed. So to ignore just abstract // ones, we check that they are not sealed. if (partTypeInfo.IsAbstract && !partTypeInfo.IsSealed) { return(null); } BindingFlags everythingLocal = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; BindingFlags instanceLocal = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; // If the type is abstract only find local static exports var exportBindingFlags = everythingLocal; if (partTypeInfo.IsAbstract) { exportBindingFlags &= ~BindingFlags.Instance; } var declaredMethods = partType.GetMethods(exportBindingFlags); // methods can only export, not import var declaredProperties = partType.GetProperties(everythingLocal); var declaredFields = partType.GetFields(everythingLocal); var allLocalMembers = declaredMethods.Concat <MemberInfo>(declaredProperties).Concat(declaredFields); var exportingMembers = from member in allLocalMembers from export in member.GetAttributes <ExportAttribute>() select new KeyValuePair <MemberInfo, ExportAttribute>(member, export); var exportedTypes = from export in partTypeInfo.GetAttributes <ExportAttribute>() select new KeyValuePair <MemberInfo, ExportAttribute>(partTypeInfo, export); var inheritedExportedTypes = from baseTypeOrInterface in partType.GetInterfaces().Concat(partType.EnumTypeAndBaseTypes().Skip(1)) where baseTypeOrInterface != typeof(object) from export in baseTypeOrInterface.GetTypeInfo().GetAttributes <InheritedExportAttribute>() select new KeyValuePair <MemberInfo, ExportAttribute>(baseTypeOrInterface.GetTypeInfo(), export); var exportsByMember = (from export in exportingMembers.Concat(exportedTypes).Concat(inheritedExportedTypes) group export.Value by export.Key into exportsByType select exportsByType).Select(g => new KeyValuePair <MemberInfo, ExportAttribute[]>(g.Key, g.ToArray())).ToArray(); if (exportsByMember.Length == 0) { return(null); } // Check for PartNotDiscoverable only after we've established it's an interesting part. // This optimizes for the fact that most types have no exports, in which case it's not a discoverable // part anyway. Checking for the PartNotDiscoverableAttribute first, which is rarely defined, // doesn't usually pay for itself in terms of short-circuiting. But it does add an extra // attribute to look for that we don't need to find for all the types that have no export attributes either. if (!typeExplicitlyRequested && partTypeInfo.IsAttributeDefined <PartNotDiscoverableAttribute>()) { return(null); } foreach (var exportingMember in exportsByMember) { this.ThrowOnInvalidExportingMember(exportingMember.Key); } TypeRef partTypeRef = TypeRef.Get(partType, this.Resolver); Type? partTypeAsGenericTypeDefinition = partTypeInfo.IsGenericType ? partType.GetGenericTypeDefinition() : null; // Collect information for all imports. var imports = ImmutableList.CreateBuilder <ImportDefinitionBinding>(); this.AddImportsFromMembers(declaredProperties, declaredFields, partTypeRef, imports); Type?baseType = partTypeInfo.BaseType; while (baseType != null && baseType != typeof(object)) { this.AddImportsFromMembers(baseType.GetProperties(instanceLocal), baseType.GetFields(instanceLocal), partTypeRef, imports); baseType = baseType.GetTypeInfo().BaseType; } var partCreationPolicy = CreationPolicy.Any; var partCreationPolicyAttribute = partTypeInfo.GetFirstAttribute <PartCreationPolicyAttribute>(); if (partCreationPolicyAttribute != null) { partCreationPolicy = (CreationPolicy)partCreationPolicyAttribute.CreationPolicy; } var allExportsMetadata = ImmutableDictionary.CreateRange(PartCreationPolicyConstraint.GetExportMetadata(partCreationPolicy)); var inheritedExportContractNamesFromNonInterfaces = ImmutableHashSet.CreateBuilder <string>(); var exportDefinitions = ImmutableList.CreateBuilder <KeyValuePair <MemberInfo, ExportDefinition> >(); foreach (var export in exportsByMember) { var memberExportMetadata = allExportsMetadata.AddRange(GetExportMetadata(export.Key)); if (export.Key is MethodInfo method) { var exportAttributes = export.Value; if (exportAttributes.Any()) { foreach (var exportAttribute in exportAttributes) { Type exportedType = exportAttribute.ContractType ?? ReflectionHelpers.GetContractTypeForDelegate(method); string contractName = string.IsNullOrEmpty(exportAttribute.ContractName) ? GetContractName(exportedType) : exportAttribute.ContractName !; var exportMetadata = memberExportMetadata .Add(CompositionConstants.ExportTypeIdentityMetadataName, ContractNameServices.GetTypeIdentity(exportedType)); var exportDefinition = new ExportDefinition(contractName, exportMetadata); exportDefinitions.Add(new KeyValuePair <MemberInfo, ExportDefinition>(export.Key, exportDefinition)); } } } else { MemberInfo exportingTypeOrPropertyOrField = export.Key; Verify.Operation(export.Key is TypeInfo || !partTypeInfo.IsGenericTypeDefinition, Strings.ExportsOnMembersNotAllowedWhenDeclaringTypeGeneric); Type exportSiteType = ReflectionHelpers.GetMemberType(exportingTypeOrPropertyOrField); foreach (var exportAttribute in export.Value) { Type exportedType = exportAttribute.ContractType ?? partTypeAsGenericTypeDefinition ?? exportSiteType; string contractName = string.IsNullOrEmpty(exportAttribute.ContractName) ? GetContractName(exportedType) : exportAttribute.ContractName !; if (export.Key is TypeInfo && exportAttribute is InheritedExportAttribute) { if (inheritedExportContractNamesFromNonInterfaces.Contains(contractName)) { // We already have an export with this contract name on this type (from a more derived type) // using InheritedExportAttribute. continue; } if (!((TypeInfo)export.Key).IsInterface) { inheritedExportContractNamesFromNonInterfaces.Add(contractName); } } var exportMetadata = memberExportMetadata .Add(CompositionConstants.ExportTypeIdentityMetadataName, ContractNameServices.GetTypeIdentity(exportedType)); var exportDefinition = new ExportDefinition(contractName, exportMetadata); exportDefinitions.Add(new KeyValuePair <MemberInfo, ExportDefinition>(export.Key, exportDefinition)); } } } MethodInfo?onImportsSatisfied = null; if (typeof(IPartImportsSatisfiedNotification).IsAssignableFrom(partType)) { onImportsSatisfied = OnImportsSatisfiedMethodInfo; } var importingConstructorParameters = ImmutableList.CreateBuilder <ImportDefinitionBinding>(); var importingCtor = GetImportingConstructor <ImportingConstructorAttribute>(partType, publicOnly: false); if (importingCtor != null) // some parts have exports merely for metadata -- they can't be instantiated { foreach (var parameter in importingCtor.GetParameters()) { var import = this.CreateImport(parameter); if (import.ImportDefinition.Cardinality == ImportCardinality.ZeroOrMore) { Verify.Operation(PartDiscovery.IsImportManyCollectionTypeCreateable(import), Strings.CollectionMustBePublicAndPublicCtorWhenUsingImportingCtor); } importingConstructorParameters.Add(import); } } var partMetadata = ImmutableDictionary.CreateBuilder <string, object?>(); foreach (var partMetadataAttribute in partTypeInfo.GetAttributes <PartMetadataAttribute>()) { partMetadata[partMetadataAttribute.Name] = partMetadataAttribute.Value; } var exportsOnType = exportDefinitions.Where(kv => kv.Key is TypeInfo).Select(kv => kv.Value).ToArray(); var exportsOnMembers = (from kv in exportDefinitions where !(kv.Key is TypeInfo) group kv.Value by kv.Key into byMember select byMember).ToDictionary(g => MemberRef.Get(g.Key, this.Resolver), g => (IReadOnlyCollection <ExportDefinition>)g.ToArray()); var assemblyNamesForMetadataAttributes = ImmutableHashSet.CreateBuilder <AssemblyName>(ByValueEquality.AssemblyName); foreach (var export in exportsByMember) { GetAssemblyNamesFromMetadataAttributes <MetadataAttributeAttribute>(export.Key, assemblyNamesForMetadataAttributes); } return(new ComposablePartDefinition( TypeRef.Get(partType, this.Resolver), partMetadata.ToImmutable(), exportsOnType, exportsOnMembers, imports.ToImmutable(), partCreationPolicy != CreationPolicy.NonShared ? string.Empty : null, onImportsSatisfied is object?ImmutableList.Create(MethodRef.Get(onImportsSatisfied, this.Resolver)) : ImmutableList <MethodRef> .Empty, MethodRef.Get(importingCtor, this.Resolver), importingCtor != null ? importingConstructorParameters.ToImmutable() : null, // some MEF parts are only for metadata partCreationPolicy, partCreationPolicy != CreationPolicy.NonShared, assemblyNamesForMetadataAttributes)); }
public InvalidMemberRef(MessageContext ctxt, MemberRef member, string message) : base(ctxt, Severity.Warning, "1024") { Member = member; Message = message; }
/// <summary> /// Constructor /// </summary> /// <param name="field">Field ref</param> protected FieldReferenceNode(MemberRef field) { Debug.Assert(field.IsFieldRef); FieldRef = field ?? throw new ArgumentNullException(nameof(field)); }