private static bool TryGetExportName(ExportDefinition export, [NotNullWhen(returnValue: true)] out string?name) { if (!export.Metadata.TryGetValue("Name", out var nameObj) || nameObj is not string { Length : > 0 })
internal static object?GetExportedValueFromComposedPart(ImportEngine?engine, ComposablePart part, ExportDefinition definition) { if (engine != null) { try { engine.SatisfyImports(part); } catch (CompositionException ex) { throw ExceptionBuilder.CreateCannotGetExportedValue(part, definition, ex); } } try { return(part.GetExportedValue(definition)); } catch (ComposablePartException ex) { throw ExceptionBuilder.CreateCannotGetExportedValue(part, definition, ex); } }
public override bool IsConstraintSatisfiedBy(ExportDefinition exportDefinition) { Requires.NotNull(exportDefinition, nameof(exportDefinition)); return(_sourceDefinition.IsConstraintSatisfiedBy(exportDefinition)); }
public override object GetExportedValue(ExportDefinition definition) { throw new NotImplementedException(); }
public override object GetExportedValue(ExportDefinition definition) { Assert.Fail(); return(null); }
public PartCreatorExportDefinition(ExportDefinition productDefinition) : base() { _productDefinition = productDefinition; }
public NonSharedCatalogExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition definition) : base(catalogExportProvider, partDefinition, definition) { }
static PartCreator <T> CreatePartCreatorOfTWithMetadata <T, TMetadata>(ImportDefinition productImport, ExportProvider sourceProvider, ExportDefinition productDefinition) { Func <PartLifetimeContext <T> > creator = CreatePartLifetimeContextCreator <T>(productImport, sourceProvider, productDefinition); return(new PartCreator <T, TMetadata>(creator, AttributedModelServices.GetMetadataView <TMetadata>(productDefinition.Metadata))); }
static PartCreator <T> CreatePartCreatorOfT <T>(ImportDefinition productImport, ExportProvider sourceProvider, ExportDefinition productDefinition) { Func <PartLifetimeContext <T> > creator = CreatePartLifetimeContextCreator <T>(productImport, sourceProvider, productDefinition); return(new PartCreator <T>(creator)); }
public Export CreateMatchingExport(ExportDefinition exportDefinition, ExportProvider sourceProvider) { return(new Export( CreateMatchingExportDefinition(exportDefinition), () => CreatePartCreator(ExportedValueType, MetadataViewType, ProductImport, sourceProvider, exportDefinition))); }
static object CreatePartCreator(Type createdType, Type metadataViewType, ContractBasedImportDefinition productImport, ExportProvider sourceProvider, ExportDefinition productDefinition) { if (metadataViewType == null) { return(CreatePartCreatorMethod.MakeGenericMethod(createdType).Invoke(null, new object[] { productImport, sourceProvider, productDefinition })); } else { return(CreatePartCreatorWithMetadataMethod.MakeGenericMethod(createdType, metadataViewType).Invoke(null, new object[] { productImport, sourceProvider, productDefinition })); } }
public void Constructor2_NullAsMetadataArgument_ShouldSetMetadataPropertyToEmptyDictionary() { var definition = new ExportDefinition("Contract", (IDictionary <string, object>)null);; EnumerableAssert.IsEmpty(definition.Metadata); }
protected virtual bool IsMatch(ExportDefinition exportDefinition) { return(true); }
public override object GetExportedValue(ExportDefinition definition) { return(new CustomComposablePartProxy(Definition.ExportedInterface).GetTransparentProxy()); }
public static CompositionError CreateCannotGetExportedValue(ComposablePart part, ExportDefinition definition, Exception innerException) { if (part == null) { throw new ArgumentNullException(nameof(part)); } if (definition == null) { throw new ArgumentNullException(nameof(definition)); } if (innerException == null) { throw new ArgumentNullException(nameof(innerException)); } ICompositionElement element = definition.ToElement(); return(CompositionError.Create( CompositionErrorId.ImportEngine_PartCannotGetExportedValue, element, innerException, SR.ImportEngine_PartCannotGetExportedValue, element.DisplayName, part.ToElement().DisplayName)); }
static Func <PartLifetimeContext <T> > CreatePartLifetimeContextCreator <T>(ImportDefinition productImport, ExportProvider sourceProvider, ExportDefinition productDefinition) { Func <PartLifetimeContext <T> > creator = () => { var product = sourceProvider.GetExports(productImport).Single(e => e.Definition == productDefinition); return(new PartLifetimeContext <T>((T)(product.Value), () => { if (product is IDisposable) { ((IDisposable)product).Dispose(); } })); }; return(creator); }
private static ComposablePartDefinition CreatePartDefinition(IEnumerable <ImportDefinition> ctorImports, ExportDefinition contractExport, Type type) { ComposablePartDefinition originalPartDefinition = AttributedModelServices.CreatePartDefinition(type, null); if (originalPartDefinition == null) { throw new InvalidOperationException(); } IList <ImportDefinition> imports = originalPartDefinition.ImportDefinitions .Where(idef => !ReflectionModelServices.IsImportingParameter(idef)) .Concat(ctorImports) .ToList(); IList <ExportDefinition> exports = originalPartDefinition.ExportDefinitions .Append(contractExport) .ToList(); IDictionary <string, object> metadata = originalPartDefinition.Metadata; return(CreatePartDefinition(type, imports, exports, metadata)); }
public ExportDefinition CreateMatchingExportDefinition(ExportDefinition productExportDefinition) { return(new ExportDefinition(ContractName, GetPartCreatorExportMetadata(productExportDefinition.Metadata))); }
internal static bool IsProductConstraintSatisfiedBy(ImportDefinition productImportDefinition, ExportDefinition exportDefinition) { object productValue = null; if (exportDefinition.Metadata.TryGetValue(CompositionConstants.ProductDefinitionMetadataName, out productValue)) { ExportDefinition productDefinition = productValue as ExportDefinition; if (productDefinition != null) { return(productImportDefinition.IsConstraintSatisfiedBy(productDefinition)); } } return(false); }
static bool IsSharedInstance(ExportDefinition export) { return(IsSharedInstance(export.Metadata)); }
public static CatalogExport CreateExport(CatalogExportProvider catalogExportProvider, ComposablePartDefinition partDefinition, ExportDefinition definition, CreationPolicy importCreationPolicy) { CreationPolicy partPolicy = partDefinition.Metadata.GetValue <CreationPolicy>(CompositionConstants.PartCreationPolicyMetadataName); bool isSharedPart = ShouldUseSharedPart(partPolicy, importCreationPolicy); if (isSharedPart) { return(new CatalogExport(catalogExportProvider, partDefinition, definition)); } else { return(new NonSharedCatalogExport(catalogExportProvider, partDefinition, definition)); } }
private IQueryable <ComposablePartDefinition> GetPartDefinitions(ExportDefinition definition) { var partDefinition = PartDefinitionFactory.Create(null, () => null, Enumerable.Empty <ImportDefinition>(), new ExportDefinition[] { definition }); return(new ComposablePartDefinition[] { partDefinition }.AsQueryable()); }
static IEnumerable <Service> DefaultExposedServicesMapper(ExportDefinition ed) { yield return(MapService(ed)); }
private bool MatchesContract(ExportDefinition e, Type serviceType) { return(e.Metadata["ExportTypeIdentity"].ToString() == serviceType.FullName); }
public static CompositionError CreateCannotGetExportedValue(ComposablePart part, ExportDefinition definition, Exception innerException) { Assumes.NotNull(part, definition, innerException); ICompositionElement element = definition.ToElement(); return(CompositionError.Create( CompositionErrorId.ImportEngine_PartCannotGetExportedValue, element, innerException, SR.ImportEngine_PartCannotGetExportedValue, element.DisplayName, part.ToElement().DisplayName)); }
internal ScopeFactoryExport(ScopeManager scopeManager, CompositionScopeDefinition catalog, ComposablePartDefinition partDefinition, ExportDefinition exportDefinition) : base(partDefinition, exportDefinition) { _scopeManager = scopeManager; _catalog = catalog; }
private Export CreateScopeExport(CompositionScopeDefinition childCatalog, ComposablePartDefinition partDefinition, ExportDefinition exportDefinition) { return(new ScopeFactoryExport(this, childCatalog, partDefinition, exportDefinition)); }
public static ICompositionElement ToElement(this ExportDefinition definition) { return(ToElementCore(definition)); }
private Export CreateExport(ComposablePart part, ExportDefinition export) { return(new Export(export, () => GetExportedValue(part, export))); }
public static ComposableCatalog WithDocumentTextDifferencingService(this ComposableCatalog catalog) { var assemblyQualifiedServiceTypeName = "Microsoft.CodeAnalysis.IDocumentTextDifferencingService, " + typeof(Workspace).GetTypeInfo().Assembly.GetName().ToString(); // Check to see if IDocumentTextDifferencingService is exported foreach (var part in catalog.Parts) { foreach (var pair in part.ExportDefinitions) { var exportDefinition = pair.Value; if (exportDefinition.ContractName != "Microsoft.CodeAnalysis.Host.IWorkspaceService") { continue; } if (!exportDefinition.Metadata.TryGetValue("ServiceType", out var value) || !(value is string serviceType)) { continue; } if (serviceType != assemblyQualifiedServiceTypeName) { continue; } // The service is exported by default return(catalog); } } // If IDocumentTextDifferencingService is not exported by default, export it manually var manualExportDefinition = new ExportDefinition( typeof(IWorkspaceService).FullName, metadata: new Dictionary <string, object?> { { "ExportTypeIdentity", typeof(IWorkspaceService).FullName }, { nameof(ExportWorkspaceServiceAttribute.ServiceType), assemblyQualifiedServiceTypeName }, { nameof(ExportWorkspaceServiceAttribute.Layer), ServiceLayer.Default }, { typeof(CreationPolicy).FullName, CreationPolicy.Shared }, { "ContractType", typeof(IWorkspaceService) }, { "ContractName", null }, }); var serviceImplType = typeof(Workspace).GetTypeInfo().Assembly.GetType("Microsoft.CodeAnalysis.DefaultDocumentTextDifferencingService"); return(catalog.AddPart(new ComposablePartDefinition( TypeRef.Get(serviceImplType, Resolver.DefaultInstance), new Dictionary <string, object?> { { "SharingBoundary", null } }, new[] { manualExportDefinition }, new Dictionary <MemberRef, IReadOnlyCollection <ExportDefinition> >(), Enumerable.Empty <ImportDefinitionBinding>(), sharingBoundary: string.Empty, default(MethodRef), MethodRef.Get(serviceImplType.GetConstructors(BindingFlags.Instance | BindingFlags.Public).First(), Resolver.DefaultInstance), new List <ImportDefinitionBinding>(), CreationPolicy.Shared, new[] { typeof(Workspace).GetTypeInfo().Assembly.GetName() }, isSharingBoundaryInferred: false))); }