protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { if (definition.Cardinality != ImportCardinality.ExactlyOne) { return Enumerable.Empty<Export>(); } ExportSource exportSource; if (_exactlyOneExports.TryGetValue(definition.ContractName, out exportSource)) { AddMemberType(exportSource, definition); return new[] { exportSource.Export }; } string typeName = ImportDefinitionConstraintAnalyser.GetRequiredTypeIdentity(definition.Constraint); Type type = GetType(typeName); if (!CanHandleType(type)) { return Enumerable.Empty<Export>(); } exportSource = new ExportSource(definition.ContractName, definition.Metadata); exportSource.AddType(type); AddMemberType(exportSource, definition); _exactlyOneExports[definition.ContractName] = exportSource; return new[] { exportSource.Export }; }
public override System.Collections.Generic.IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition) { var exports = base.GetExports(definition); if (GalaSoft.MvvmLight.ViewModelBase.IsInDesignModeStatic) { var designExports = exports.Where(export => (export.Item2.Metadata.ContainsKey(DesignTimeExportAttribute.DesignTimeMetadataName) && ((bool)export.Item2.Metadata[DesignTimeExportAttribute.DesignTimeMetadataName]) == true)); if (designExports.Count() > 0) { exports = designExports; } else { exports = from export in exports let ed = export.Item2 where !ed.Metadata.ContainsKey(DesignTimeExportAttribute.DesignTimeMetadataName) select export; } } else { exports = from export in exports let ed = export.Item2 where !ed.Metadata.ContainsKey(DesignTimeExportAttribute.DesignTimeMetadataName) || ((bool)ed.Metadata[DesignTimeExportAttribute.DesignTimeMetadataName]) == false select export; } var a = exports.ToArray(); return exports; }
public override IEnumerable<TempTuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition) { LambdaExpression lambda = definition.Constraint; if (lambda.Body is BinaryExpression) { BinaryExpression binaryExpression = (BinaryExpression)lambda.Body; if (binaryExpression.Left is MemberExpression && ((MemberExpression)binaryExpression.Left).Member.Name == "ContractName") { IList<IService> services = resolver.Resolve((string)((ConstantExpression)binaryExpression.Right).Value, TimeOut, definition.Cardinality == ImportCardinality.ZeroOrOne ? 0 : 1, definition.Cardinality == ImportCardinality.ZeroOrMore ? int.MaxValue : 1); foreach (IService service in services) resolver_ServiceFound(service); } } var exports = new List<TempTuple<ComposablePartDefinition, ExportDefinition>>(); foreach (var part in this.Parts.ToArray()) { foreach (var export in part.ExportDefinitions) { if (definition.Constraint.Compile().Invoke(export)) { exports.Add(new TempTuple<ComposablePartDefinition, ExportDefinition>(part, export)); } } } return exports; }
protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { var contractName = definition.ContractName; if (contractName != SettingsConstants.SettingsContract) yield break; if (definition.Cardinality == ImportCardinality.ZeroOrMore) yield break; // TODO can't figure out how to get data injected into the Metadata collection //string settingsKey = definition.Metadata[SettingsConstants.SettingsMetadataKey] as string; LazyMemberInfo lazyMember = ReflectionModelServices.GetImportingMember(definition); MemberInfo member = lazyMember.GetAccessors().First(); MethodInfo getterOrSetter = (MethodInfo)member; // HACK this is pretty evil PropertyInfo propInfo = getterOrSetter.DeclaringType.GetProperty(getterOrSetter.Name.Substring(4)); ImportSettingAttribute settingsAttr = propInfo.GetCustomAttribute<ImportSettingAttribute>(); if (settingsAttr == null) yield break; object value; if (!this._settingsProvider.TryGetValue(settingsAttr.SettingsKey, out value)) yield break; yield return new Export(SettingsConstants.SettingsContract, () => value); }
public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports) { if (definition == null) throw new ArgumentNullException("definition"); if (exports == null) throw new ArgumentNullException("exports"); InterceptedPart.SetImport(definition, exports); }
public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports) { Contract.Requires(definition != null); Contract.Requires(exports != null); throw new NotImplementedException(); }
/// <summary> /// Method which can filter exports for given <see cref="ImportDefinition"/> or produce new exports. /// </summary> /// <param name="definition"><see cref="ImportDefinition"/> instance.</param> /// <param name="exports">A collection of <see cref="ExportDefinition"/> /// instances along with their <see cref="ComposablePartDefinition"/> instances which match given <see cref="ImportDefinition"/>.</param> /// <returns>A collection of <see cref="ExportDefinition"/> /// instances along with their <see cref="ComposablePartDefinition"/> instances which match given <see cref="ImportDefinition"/>.</returns> public IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition, IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> exports) { if (exports.Any()) { return exports; } if (!CompositionServices.IsReflectionImportDefinition(definition)) { return Enumerable.Empty<Tuple<ComposablePartDefinition, ExportDefinition>>(); } var returnedExports = new List<Tuple<ComposablePartDefinition, ExportDefinition>>(); var importDefinitionType = CompositionServices.GetImportDefinitionType(definition); if (TypeHelper.IsGenericCollection(importDefinitionType)) { importDefinitionType = TypeHelper.GetGenericCollectionParameter(importDefinitionType); } if (this.manufacturedParts.Contains(importDefinitionType)) { returnedExports.AddRange(this.aggregateCatalog.GetExports(definition)); } else if (TypeHelper.ShouldCreateClosedGenericPart(importDefinitionType)) { CreateGenericParts(importDefinitionType); returnedExports.AddRange(this.aggregateCatalog.GetExports(definition)); } return returnedExports; }
public IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition, IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> exports) { var contractDef = (ContractBasedImportDefinition)definition; var returnedExports = new List<Tuple<ComposablePartDefinition, ExportDefinition>>(); var importDefinitionType = TypeHelper.GetImportDefinitionType(definition); if (exports.Any()) { return exports; } returnedExports.Concat(exports); if (this.manufacturedParts.Contains(importDefinitionType)) { returnedExports.AddRange(this.catalog.GetExports(definition)); } else if (TypeHelper.ShouldCreateClosedGenericPart(contractDef, importDefinitionType)) { CreateGenericPart(importDefinitionType); returnedExports.AddRange(this.catalog.GetExports(definition)); } return returnedExports; }
public IDictionary<string, object> CacheImportDefinition(ComposablePartDefinition owner, ImportDefinition importDefinition) { ContractBasedImportDefinition contractBasedImport = importDefinition as ContractBasedImportDefinition; Assumes.NotNull(contractBasedImport); return CompositionCacheServices.WriteImportDefinition(owner, contractBasedImport); }
protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { List<Export> exports = new List<Export>(); ImportDefinition queryImport = TranslateImport(definition); if (queryImport == null) { return exports; } // go through the catalogs and see if there's anything there of interest foreach (CompositionScopeDefinition childCatalog in this._scopeDefinition.Children) { foreach (var partDefinitionAndExportDefinition in childCatalog.GetExportsFromPublicSurface(queryImport)) { using (var container = this.CreateChildContainer(childCatalog)) { // We create a nested AtomicComposition() because the container will be Disposed and // the RevertActions need to operate before we Dispose the child container using (var ac = new AtomicComposition(atomicComposition)) { var childCatalogExportProvider = container.CatalogExportProvider; if (!childCatalogExportProvider.DetermineRejection(partDefinitionAndExportDefinition.Item1, ac)) { exports.Add(this.CreateScopeExport(childCatalog, partDefinitionAndExportDefinition.Item1, partDefinitionAndExportDefinition.Item2)); } } } } } return exports; }
protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { if (definition == null) throw new ArgumentNullException("definition"); if (SourceProvider == null) throw new InvalidOperationException("SourceProvider must be set."); var cbid = definition as ContractBasedImportDefinition; if (cbid == null || !cbid.RequiredTypeIdentity.StartsWith(PartCreatorContractPrefix)) return EmptyExports; var importInfo = _importDefinitionCache.GetOrCreate( cbid, () => new ExportFactoryImport(cbid)); var sourceExports = SourceProvider .GetExports(importInfo.ProductImport, atomicComposition); var result = sourceExports .Select(e => importInfo.CreateMatchingExport(e.Definition, SourceProvider)) .ToArray(); foreach (var e in sourceExports.OfType<IDisposable>()) e.Dispose(); return result; }
protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { var serviceTypeName = definition.ContractName; if (serviceTypeName.IndexOf('.') == -1 || serviceTypeName.StartsWith("System.") || serviceTypeName.StartsWith("Clide.")) return Enumerable.Empty<Export>(); return serviceExports.GetOrAdd (serviceTypeName, contractName => { var serviceType = typeMap.GetOrAdd(contractName, typeName => MapType(typeName)); if (serviceType == null) return Enumerable.Empty<Export>(); // NOTE: if we can retrieve a valid instance of the service at least once, we // assume we'll be able to retrieve it later on. Note also that we don't return // the single retrieved instance from the export, but rather provide a function // that does the GetService call every time, since we're caching the export but // we don't know if the service can be safely cached. var service = services.GetService(serviceType); if (service == null) return Enumerable.Empty<Export>(); return new Export[] { new Export(serviceTypeName, () => services.GetService(serviceType)) }; }); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="definition"></param> /// <param name="import"></param> /// <param name="exports"></param> /// <param name="composablePart"></param> public ImportableInfo(System.ComponentModel.Composition.Primitives.ImportDefinition definition, ProviderImportDefinition import, IEnumerable <Export> exports, ProviderComposablePart composablePart) { _definition = definition; _import = import; _exports = exports; _composablePart = composablePart; }
private static ImportDefinition TranslateImport(ImportDefinition import, ComposablePartDefinition part) { ContractBasedImportDefinition contractBasedImport = import as ContractBasedImportDefinition; if (contractBasedImport == null) { return import; } int[] importParametersOrder = contractBasedImport.Metadata.GetValue<int[]>(CompositionConstants.GenericImportParametersOrderMetadataName); if (importParametersOrder == null) { return import; } int partArity = part.Metadata.GetValue<int>(CompositionConstants.GenericPartArityMetadataName); if (partArity == 0) { return import; } string contractName = GenericServices.GetGenericName(contractBasedImport.ContractName, importParametersOrder, partArity); string requiredTypeIdentity = GenericServices.GetGenericName(contractBasedImport.RequiredTypeIdentity, importParametersOrder, partArity); return new ContractBasedImportDefinition( contractName, requiredTypeIdentity, contractBasedImport.RequiredMetadata, contractBasedImport.Cardinality, contractBasedImport.IsRecomposable, false, contractBasedImport.RequiredCreationPolicy, contractBasedImport.Metadata); }
/// <summary> /// Gets the available set of exports for the given import definition. /// </summary> /// <param name="definition">The defintion of the import.</param> /// <param name="atomicComposition">The atomic composition of the import.</param> /// <returns>The available set of exports for the given import definition.</returns> protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { Throw.IfArgumentNull(definition, "definition"); if (SourceProvider == null) Throw.InvalidOperation( string.Format( CultureInfo.CurrentUICulture, Resources.Exceptions.PropertyCannotBeNull, "Sourceprovider")); var contractDefinition = definition as ContractBasedImportDefinition; if (contractDefinition == null || !contractDefinition.RequiredTypeIdentity.StartsWith(PartFactoryContractPrefix)) return EmptyExports; var info = _definitionCache.Fetch(contractDefinition, () => new PartFactoryImport(contractDefinition)); var exports = SourceProvider.GetExports(info.ImportDefinition, atomicComposition); var result = exports .Select(e => info.CreateMatchingExport(e.Definition, SourceProvider)) .ToArray(); foreach (var export in exports.OfType<IDisposable>()) export.Dispose(); return result; }
/// <summary> /// Returns the available exports for the specified import definition. /// </summary> /// <param name="definition">The import definition.</param> /// <returns>The set of matching exports.</returns> public override IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition) { var definitions = _catalog.GetExports(definition); var list = HttpContext.Current.ModelList<ImportDescriptor>("MEF-Imports"); var model = new ImportDescriptor { Cardinality = definition.Cardinality.ToString(), ContractName = definition.ContractName, Prerequisite = definition.IsPrerequisite, Recomposable = definition.IsRecomposable }; foreach (var def in definitions) { var meta = def.Item2.Metadata.Keys .Where(k => k != CreationPolicyTypeName) .ToDictionary(key => key, key => def.Item2.Metadata[key].ToString()); string policy = null; if (def.Item2.Metadata.ContainsKey(CreationPolicyTypeName)) policy = def.Item2.Metadata[CreationPolicyTypeName].ToString(); var export = new ExportDescriptor { CreationPolicy = policy, DisplayName = def.Item1.ToString(), Metadata = meta }; model.Exports.Add(export); } list.Add(model); return definitions; }
public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports) { Requires.NotNull(definition, "definition"); Requires.NotNullOrNullElements(exports, "exports"); throw ExceptionBuilder.CreateImportDefinitionNotOnThisComposablePart("definition"); }
protected override System.Collections.Generic.IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { var type = Type.GetType(definition.ContractName); Export e; var exports = base.GetExportsCore(definition, atomicComposition); return exports; }
public static CompositionError PreventedByExistingImport(ComposablePart part, ImportDefinition import) { return CompositionError.Create( CompositionErrorId.ImportEngine_PreventedByExistingImport, Strings.ImportEngine_PreventedByExistingImport, import.ToElement().DisplayName, part.ToElement().DisplayName); }
public void TestSetUp() { ConcreteTypeHandler = new ConcreteTypeExportHandler(); var typeCatalog = new TypeCatalog(typeof(CustomerProcessor)); var orderProcessorContract = AttributedModelServices.GetContractName(typeof(CustomerProcessor)); var orderProcessPartDefinition = typeCatalog.Parts.Single(p => p.ExportDefinitions.Any(d => d.ContractName == orderProcessorContract)); RepositoryImportDefinition = orderProcessPartDefinition.ImportDefinitions.First(); }
public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports) { if (_composablePart.IsValueCreated || _imports == null) { _composablePart.Value.SetImport(definition, exports); } else { _imports.Add(definition, exports); } }
/// <summary> /// Gets the <see cref="Type"/> of the requested import. /// </summary> /// <param name="definition">The <see cref="ImportDefinition"/> instance.</param> /// <returns>A <see cref="Type"/> of the requested import.</returns> /// <remarks>Works only for reflection model import definitions.</remarks> public static Type GetImportDefinitionType(ImportDefinition definition) { var importDefinitionType = ReflectionModelServices.IsImportingParameter(definition) ? GetParameterType(definition) : GetMethodType(definition); return importDefinitionType; }
/// <summary> /// Checks if the given <see cref="ImportDefinition"/> is based on reflection model. /// </summary> /// <param name="definition">The <see cref="ImportDefinition"/> instance.</param> /// <returns><c>True</c> if the given import definition is based on the /// reflection model. <c>False</c> otherwise.</returns> public static bool IsReflectionImportDefinition(ImportDefinition definition) { if (definition == null) throw new ArgumentNullException("definition"); var name = definition.GetType().Name; return name == "ReflectionMemberImportDefinition" || name == "ReflectionParameterImportDefinition"; }
public static Type GetParameterType(ImportDefinition definition) { var importingParameter = ReflectionModelServices.GetImportingParameter(definition); var parameterInfo = importingParameter.Value; var importDefinitionType = parameterInfo.ParameterType; return importDefinitionType; }
protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { if (definition.ContractName.Equals(typeof(ILogger).FullName)) { yield return new Export(definition.ContractName, () => new Logger() { Header = "Factory - " }); } }
protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { if (definition.ContractName == _textUndoHistoryRegistryContractName || definition.ContractName == _basicUndoHistoryRegistryContractName) { yield return _export; } }
public IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports( ImportDefinition definition, IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> exports) { return from export in exports where Filter(export.Item1) select export; }
/// <summary> /// Invokes TryGetExports, returning the output as a collection. /// </summary> /// <param name="provider"></param> /// <param name="definition"></param> /// <param name="atomicComposition"></param> /// <returns></returns> public static IEnumerable<Export> TryGetExports(this ExportProvider provider, ImportDefinition definition, AtomicComposition atomicComposition) { Contract.Requires<ArgumentNullException>(provider != null); Contract.Requires<ArgumentNullException>(definition != null); IEnumerable<Export> exports; provider.TryGetExports(definition, atomicComposition, out exports); return exports; }
/// <summary> /// Returns all exports that match the constraint defined by the specified definition. /// </summary> /// <param name="definition">The <see cref="T:System.ComponentModel.Composition.Primitives.ImportDefinition"/> that defines the conditions of the /// <see cref="T:System.ComponentModel.Composition.Primitives.Export"/> objects to return.</param> /// <param name="atomicComposition"></param> /// <returns></returns> /// <result> /// An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:System.ComponentModel.Composition.Primitives.Export"/> objects that match /// the conditions defined by <see cref="T:System.ComponentModel.Composition.Primitives.ImportDefinition"/>, if found; otherwise, an /// empty <see cref="T:System.Collections.Generic.IEnumerable`1"/>. /// </result> protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { List<Export> exports = new List<Export>(); if (_exportsDictionary.ContainsKey(definition.ContractName)) { exports.Add(_exportsDictionary[definition.ContractName]); } return exports; }
private object GetInstance(ImportDefinition definition, Type type, string configvalue) { if (typeof(ConfigurationItem).IsAssignableFrom(type) && type.IsGenericType) { return Activator.CreateInstance(type, definition.ContractName, this.Source); } return configvalue.ParseTo<object, string>(type); }
public override IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ImportDefinition definition) { var exports = _catalog.GetExports(definition); if (!exports.Any() && TypeHelper.IsReflectionMemberImportDefinition(definition)) exports = CreateDynamicExport(definition); return exports; }
public virtual IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition) { ThrowIfDisposed(); Requires.NotNull(definition, nameof(definition)); Contract.Ensures(Contract.Result <IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > >() != null); List <Tuple <ComposablePartDefinition, ExportDefinition> > exports = null; var candidateParts = GetCandidateParts(definition); if (candidateParts != null) { foreach (var part in candidateParts) { Tuple <ComposablePartDefinition, ExportDefinition> singleMatch; IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > multipleMatches; if (part.TryGetExports(definition, out singleMatch, out multipleMatches)) { exports = exports.FastAppendToListAllowNulls(singleMatch, multipleMatches); } } } return(exports ?? _EmptyExportsList); }
public virtual IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition) { this.ThrowIfDisposed(); Requires.NotNull(definition, "definition"); var exports = new List <Tuple <ComposablePartDefinition, ExportDefinition> >(); foreach (var part in this.Parts) { foreach (var export in part.ExportDefinitions) { if (definition.IsConstraintSatisfiedBy(export)) { exports.Add(new Tuple <ComposablePartDefinition, ExportDefinition>(part, export)); } } } return(exports); }
/// <summary> /// Returns the export definitions that match the constraint defined by the specified definition. /// </summary> /// <param name="definition"> /// The <see cref="ImportDefinition"/> that defines the conditions of the /// <see cref="ExportDefinition"/> objects to return. /// </param> /// <returns> /// An <see cref="IEnumerable{T}"/> of <see cref="Tuple{T1, T2}"/> containing the /// <see cref="ExportDefinition"/> objects and their associated /// <see cref="ComposablePartDefinition"/> for objects that match the constraint defined /// by <paramref name="definition"/>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="definition"/> is <see langword="null"/>. /// </exception> /// <exception cref="ObjectDisposedException"> /// The <see cref="ComposablePartCatalog"/> has been disposed of. /// </exception> /// <remarks> /// <note type="inheritinfo"> /// Overriders of this property should never return <see langword="null"/>, if no /// <see cref="ExportDefinition"/> match the conditions defined by /// <paramref name="definition"/>, return an empty <see cref="IEnumerable{T}"/>. /// </note> /// </remarks> public virtual IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition) { ThrowIfDisposed(); Requires.NotNull(definition, nameof(definition)); List <Tuple <ComposablePartDefinition, ExportDefinition> >?exports = null; var candidateParts = GetCandidateParts(definition); if (candidateParts != null) { foreach (var part in candidateParts) { if (part.TryGetExports(definition, out Tuple <ComposablePartDefinition, ExportDefinition>?singleMatch, out IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> >?multipleMatches)) { exports = exports.FastAppendToListAllowNulls(singleMatch, multipleMatches); } } } Debug.Assert(exports != null || _EmptyExportsList != null); return(exports ?? _EmptyExportsList); }
public static ICompositionElement ToElement(this ImportDefinition definition) { return(ToElementCore(definition)); }
/// <summary> /// Sets the import described by the specified definition with the specified exports. /// </summary> /// <param name="definition"> /// One of the <see cref="ImportDefinition"/> objects from the /// <see cref="ImportDefinitions"/> property describing the import to be set. /// </param> /// <param name="exports"> /// An <see cref="IEnumerable{T}"/> of <see cref="Export"/> objects of which /// to set the import described by <paramref name="definition"/>. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="definition"/> is <see langword="null"/>. /// <para> /// -or- /// </para> /// <paramref name="exports"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="definition"/> did not originate from the <see cref="ImportDefinitions"/> /// property on the <see cref="ComposablePart"/>. /// <para> /// -or- /// </para> /// <paramref name="exports"/> contains an element that is <see langword="null"/>. /// <para> /// -or- /// </para> /// <paramref name="exports"/> is empty and <see cref="ImportDefinition.Cardinality"/> is /// <see cref="ImportCardinality.ExactlyOne"/>. /// <para> /// -or- /// </para> /// <paramref name="exports"/> contains more than one element and /// <see cref="ImportDefinition.Cardinality"/> is <see cref="ImportCardinality.ZeroOrOne"/> or /// <see cref="ImportCardinality.ExactlyOne"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// <see cref="Activate"/> has been previously called and /// <see cref="ImportDefinition.IsRecomposable"/> is <see langword="false"/>. /// </exception> /// <exception cref="ObjectDisposedException"> /// The <see cref="ComposablePart"/> has been disposed of. /// </exception> /// <exception cref="ComposablePartException"> /// An error occurred setting the import described by the <see cref="ImportDefinition"/>. /// </exception> public abstract void SetImport(ImportDefinition definition, IEnumerable <Export> exports);
public virtual new IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition) { return(default(IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> >)); }
/// <summary> /// Define o import. /// </summary> /// <param name="definition"></param> /// <param name="exports"></param> /// <exception cref="InvalidOperationException">The supplied import definition was of an unknown type.</exception> public override void SetImport(System.ComponentModel.Composition.Primitives.ImportDefinition definition, IEnumerable <Export> exports) { ProviderImportDefinition import = definition as ProviderImportDefinition; this.ImportedValues[definition] = new ImportableInfo(definition, import, exports, this); }
public virtual IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition) { this.ThrowIfDisposed(); Requires.NotNull(definition, "definition"); Contract.Ensures(Contract.Result <IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > >() != null); List <Tuple <ComposablePartDefinition, ExportDefinition> > exports = null; var candidateParts = this.GetCandidateParts(definition); if (candidateParts != null) { foreach (var part in candidateParts) { var partExports = part.GetExports(definition); if (partExports != ComposablePartDefinition._EmptyExports) { exports = exports.FastAppendToListAllowNulls(partExports); } } } return(exports ?? _EmptyExportsList); }
internal virtual IEnumerable <ComposablePartDefinition> GetCandidateParts(ImportDefinition definition) { return(this); }
/// <summary> /// Retourne une collection de tous les exports qui correspondent aux conditions spécifiées dans l'<see cref="T:System.ComponentModel.Composition.Primitives.ImportDefinition"/>. /// </summary> /// <param name="definition">un objet définissant les conditions d'export</param> /// <param name="atomicComposition">La transaction de composition à utiliser.</param> /// <returns> /// Une collection des exports dans ce conteneur correspondant aux conditions de la définition. /// </returns> protected override IEnumerable <System.ComponentModel.Composition.Primitives.Export> GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition definition, AtomicComposition atomicComposition) { return(base.GetExportsCore(AdaptDefinition(definition), atomicComposition)); }
internal virtual IEnumerable <Tuple <ComposablePartDefinition, ExportDefinition> > GetExports(ImportDefinition definition) { List <Tuple <ComposablePartDefinition, ExportDefinition> > exports = null; foreach (var export in this.ExportDefinitions) { if (definition.IsConstraintSatisfiedBy(export)) { if (exports == null) { exports = new List <Tuple <ComposablePartDefinition, ExportDefinition> >(); } exports.Add(new Tuple <ComposablePartDefinition, ExportDefinition>(this, export)); } } return(exports ?? _EmptyExports); }