/// <summary> /// Gets the instance. /// </summary> /// <param name="serviceType">Type of the service.</param> /// <param name="key"> The key.</param> /// <returns>Returns an instance of <see cref="System.Object"/>.</returns> /// <exception cref="System.Exception">This exception will be thrown when XXX.</exception> protected override object GetInstance(Type serviceType, string key) { string contract = ""; try { contract = string.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(serviceType) : key; var exports = _container.GetExportedValues <object>(contract).ToArray(); if (exports.Any()) { return(exports.First()); } } catch (Exception error) { int debug = 0; } throw new Exception(string.Format("Could not locate any instances of contract {0}.", contract)); }
public void GetExportContractName_should_return_contract_name_of_field_type_when_called_with_field_and_contract_name_and_type_are_null() { var member = ReflectionServices.GetField <FakePart>(x => x.Count); var convention = new ExportConvention { ContractName = null, ContractType = null, Members = x => new[] { member } }; var results = this.Service.GetExportContractName(convention, member); var expectedContractName = AttributedModelServices.GetContractName(member.FieldType); results.ShouldEqual(expectedContractName); }
private void LoadReader(string pluginDir) { var categ = new DirectoryCatalog(pluginDir); var cname = AttributedModelServices.GetContractName(typeof(IEMailReader)); Expression <Func <ExportDefinition, bool> > exp = a => a.ContractName == cname; var id = new ImportDefinition(exp, cname, ImportCardinality.ExactlyOne, true, true); var l = categ.GetExports(id).ToList(); if (l.Count == 1) { var cc = new CompositionContainer(categ); cc.ComposeParts(this); creader.Content = Reader; Reader.QueryThread = OnQueryThread; } else if (l.Count == 0) { creader.Visibility = Visibility.Collapsed; MessageBox.Show("Failed to find any plugin!"); } }
static IEnumerable <ExportDefinition> GetExportDefinitions(Type implementationType, Type contractType, string key = null) { var lazyMember = new LazyMemberInfo(implementationType); var contracName = key ?? AttributedModelServices.GetContractName(contractType); var metadata = new Lazy <IDictionary <string, object> >(() => { var md = new Dictionary <string, object> { { CompositionConstants.ExportTypeIdentityMetadataName, AttributedModelServices.GetTypeIdentity(contractType) } }; return(md); }); return(new[] { ReflectionModelServices.CreateExportDefinition(lazyMember, contracName, metadata, null), ReflectionModelServices.CreateExportDefinition(lazyMember, AttributedModelServices.GetContractName(contractType), metadata, null) }); }
public object TryGetService(Type serviceType) { var contract = AttributedModelServices.GetContractName(serviceType); var instance = AddToDisposables(TempContainer.GetExportedValueOrDefault <object>(contract)); if (instance != null) { return(instance); } var sp = initialized ? syncServiceProvider : asyncServiceProvider; try { instance = sp.GetService(serviceType); if (instance != null) { return(instance); } } catch (Exception ex) { log.Error(ex, "Error loading {ServiceType}", serviceType); } instance = AddToDisposables(ExportProvider.GetExportedValues <object>(contract).FirstOrDefault(x => contract.StartsWith("github.", StringComparison.OrdinalIgnoreCase) ? x.GetType().Assembly.GetName().Version == currentVersion : true)); if (instance != null) { return(instance); } instance = GitServiceProvider?.GetService(serviceType); if (instance != null) { return(instance); } return(null); }
protected override object GetInstance(Type service, string key) { this.logger.Info("GetInstance {0}, {1}", service, key); string contract = String.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(service) : key; IEnumerable <object> exports; try { exports = container.GetExportedValues <object>(contract); } catch (System.Exception ex) { this.logger.Error(ex); throw; } if (exports.Any()) { return(exports.First()); } throw new ArgumentException(String.Format("Could not locate any instances of contract {0}.", contract)); }
/// <summary> /// Gets the name used to persist the event in the event store. /// </summary> /// <remarks>By default, this is the event class's type name, with no namespace. This name can be specified by adding the EventNameAttribute to the class.</remarks> /// <returns>A string representing the class's name.</returns> public static string EventName(this Type eventType) { // TODO: (EventExtensions) differentiate these two methods in terms of use cases. it's potentially misleading since they can return different values return(eventNames2.GetOrAdd(eventType, t => t.GetCustomAttributes(false) .OfType <EventNameAttribute>() .FirstOrDefault() .IfNotNull() .Then(att => att.EventName) .Else(() => { if (t.IsGenericType) { var contractName = AttributedModelServices.GetContractName(t); // e.g. Microsoft.Its.Domain.Event(Microsoft.Its.SomeAggregate) --> Event(SomeAggregate) contractName = new Regex(@"([0-9\w\+]+\.)|([0-9\w\+]+\+)([\(\)]*)").Replace(contractName, "$3"); return contractName; } return t.Name; }))); }
public EMailAttachments() { InitializeComponent(); GBB.Header = Properties.Resources.AttachmentsWordQ; GBC.Header = Properties.Resources.PreviewWord; (LstAttach.View as GridView).Columns[0].Header = Properties.Resources.NameWord; var dir = Assembly.GetExecutingAssembly().CodeBase.Substring("file:///".Length).Replace('/', '\\'); dir = dir.Substring(0, dir.LastIndexOf('\\')); var categ = new DirectoryCatalog(dir); var cname = AttributedModelServices.GetContractName(typeof(IImageViewer)); Expression <Func <ExportDefinition, bool> > exp = a => a.ContractName == cname; var id = new ImportDefinition(exp, cname, ImportCardinality.ExactlyOne, true, true); var l = categ.GetExports(id).ToList(); if (l.Count == 1) { var cc = new CompositionContainer(categ); cc.ComposeParts(this); cviewer.Content = ImageViewer; } }
/// <summary> /// Removes a service from the catalog /// </summary> /// <param name="t">The type we want to remove</param> /// <param name="owner">The owner, which either has to match what was passed to AddService, /// or if it's null, the service will be removed without checking for ownership</param> public void RemoveService(Type t, object owner) { Guard.ArgumentNotNull(t, nameof(t)); string contract = AttributedModelServices.GetContractName(t); Debug.Assert(!string.IsNullOrEmpty(contract), "Every type must have a contract name"); OwnedComposablePart part; if (tempParts.TryGetValue(contract, out part)) { if (owner != null && part.Owner != owner) { return; } tempParts.Remove(contract); var batch = new CompositionBatch(); batch.RemovePart(part.Part); TempContainer.Compose(batch); } }
protected override IEnumerable <Export> GetExportsCoreExactlyOne(ImportDefinition definition, AtomicComposition atomicComposition) { // replace ZeroOrOne with ZeroOrMore to prevent errors down the chain; we'll grab the first var export = GetExportsCoreZeroOrMore(new ImportDefinition( definition.Constraint, definition.ContractName, ImportCardinality.ZeroOrMore, definition.IsRecomposable, definition.IsPrerequisite, definition.Metadata), atomicComposition) .FirstOrDefault(); if (export != null) { yield return(export); } if (definition.ContractName == AttributedModelServices.GetContractName(typeof(IFileSystemReader))) { yield return(new Export(definition.ContractName, () => new DefaultFileSystemReader())); } }
public void RemoveService(Type t) { if (!Initialized) { log.Error("ExportProvider is not initialized, cannot remove service."); return; } string contract = AttributedModelServices.GetContractName(t); Debug.Assert(!string.IsNullOrEmpty(contract), "Every type must have a contract name"); ComposablePart part; if (tempParts.TryGetValue(contract, out part)) { tempParts.Remove(contract); var batch = new CompositionBatch(); batch.RemovePart(part); tempContainer.Compose(batch); } }
public IronPythonComposablePart(IronPythonTypeWrapper typeWrapper, IEnumerable <Type> exports, IEnumerable <KeyValuePair <string, IronPythonImportDefinition> > imports, IDictionary <object, object> exportMetadatas) { _typeWrapper = typeWrapper; _instance = typeWrapper.Activator(); _exports = new List <ExportDefinition>(exports.Count()); _imports = new Dictionary <string, ImportDefinition>(imports.Count()); foreach (var export in exports) { var metadata = new Dictionary <string, object>() { { "ExportTypeIdentity", AttributedModelServices.GetTypeIdentity(export) } }; if (exportMetadatas != null) { foreach (var data in exportMetadatas) { metadata.Add(data.Key.ToString(), data.Value); } } var contractName = AttributedModelServices.GetContractName(export); _exports.Add(new ExportDefinition(contractName, metadata)); } foreach (var import in imports) { var contractName = AttributedModelServices.GetContractName(import.Value.Type); var metadata = new Dictionary <string, Type>(); _imports[import.Key] = new IronPythonContractBasedImportDefinition( import.Key, contractName, AttributedModelServices.GetTypeIdentity(import.Value.Type), metadata.ToList(), import.Value.Cardinality, import.Value.IsRecomposable, import.Value.IsPrerequisite, CreationPolicy.Any); } }
private IEnumerable <ImportDefinition> GetImportDefinitions(Type implementationType) { var imports = new List <ImportDefinition>(); var defaultConstructor = implementationType.GetConstructors().FirstOrDefault(); if (defaultConstructor != null) { foreach (var param in defaultConstructor.GetParameters()) { imports.Add( ReflectionModelServices.CreateImportDefinition( new Lazy <ParameterInfo>(() => param), AttributedModelServices.GetContractName(param.ParameterType), AttributedModelServices.GetTypeIdentity(param.ParameterType), Enumerable.Empty <KeyValuePair <string, Type> >(), ImportCardinality.ExactlyOne, CreationPolicy.Any, null)); } } return(imports); }
public static object GetExportedValueByType(this CompositionContainer container, Type type) { foreach (var partDef in container.Catalog.Parts) { foreach (var exportDef in partDef.ExportDefinitions) { if (exportDef.ContractName != type.FullName) { continue; } var contract = AttributedModelServices.GetContractName(type); var definition = new ContractBasedImportDefinition(contract, contract, null, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any); var firstOrDefault = container.GetExports(definition).FirstOrDefault(); if (firstOrDefault != null) { return(firstOrDefault.Value); } } } return(null); }
/// <summary> /// IOC容器获取实例的方法 /// </summary> /// <param name="service"></param> /// <param name="key"></param> /// <returns></returns> protected override object GetInstance(Type service, string key) { //try //{ // var obj = service?.Assembly.CreateInstance(service.FullName); // return obj; //} //catch (Exception ex) //{ // return null; //} string contract = string.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(service) : key; var exports = m_container.GetExportedValues <object>(contract); var exportList = exports.ToList();//避免直接用exports时 调用2次IEnumerable操作 if (exportList.Any()) { return(exportList.First()); } throw new Exception(string.Format("Could not locate any instances of contract {0}.", contract)); }
public static object GetService(Type serviceType) { if (typeof(IEnumerable).IsAssignableFrom(serviceType) && serviceType.GenericTypeArguments.Length == 1) { var itemType = serviceType.GenericTypeArguments.First(); var contractName = AttributedModelServices.GetContractName(itemType); var items = container.GetExportedValues <object>(contractName); var listGenericType = typeof(List <>); var list = listGenericType.MakeGenericType(itemType); var ci = list.GetConstructor(new Type[] { typeof(int) }); var instance = ci.Invoke(new object[] { items.Count(), }) as IList; foreach (var item in items) { instance.Add(item); } return(instance); } else { var contractName = AttributedModelServices.GetContractName(serviceType); return(container.GetExportedValue <object>(contractName)); } }
public void AddService(Type t, object owner, object instance) { if (!Initialized) { log.Error("ExportProvider is not initialized, cannot add service."); return; } string contract = AttributedModelServices.GetContractName(t); Debug.Assert(!string.IsNullOrEmpty(contract), "Every type must have a contract name"); // we want to remove stale instances of a service, if they exist, regardless of who put them there RemoveService(t, null); var batch = new CompositionBatch(); var part = batch.AddExportedValue(contract, instance); Debug.Assert(part != null, "Adding an exported value must return a non-null part"); tempParts.Add(contract, new OwnedComposablePart { Owner = owner, Part = part }); tempContainer.Compose(batch); }
private IEnumerable <Export> GetExportsCore(Type type, Type metadataViewType, string contractName, ImportCardinality cardinality) { // Only 'type' cannot be null - the other parameters have sensible defaults. Requires.NotNull(type, nameof(type)); if (string.IsNullOrEmpty(contractName)) { contractName = AttributedModelServices.GetContractName(type); } if (metadataViewType == null) { metadataViewType = ExportServices.DefaultMetadataViewType; } if (!MetadataViewProvider.IsViewTypeValid(metadataViewType)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, SR.InvalidMetadataView, metadataViewType.Name)); } ImportDefinition importDefinition = BuildImportDefinition(type, metadataViewType, contractName, cardinality); return(GetExports(importDefinition, null)); }
public object TryGetService(Type serviceType) { var contract = AttributedModelServices.GetContractName(serviceType); var instance = AddToDisposables(TempContainer.GetExportedValueOrDefault <object>(contract)); if (instance != null) { return(instance); } var sp = _initialized ? _syncServiceProvider : _asyncServiceProvider; try { instance = sp.GetService(serviceType); if (instance != null) { return(instance); } } catch { } instance = AddToDisposables(ExportProvider.GetExportedValues <object>(contract).FirstOrDefault(x => !contract.StartsWith("SharperCryptoApiAnalysis.", StringComparison.OrdinalIgnoreCase) || x.GetType().Assembly.GetName().Version == _currentVersion)); if (instance != null) { return(instance); } instance = ServiceProvider?.GetService(serviceType); return(instance); }
/// <summary> /// /// </summary> /// <see cref="ServiceLocatorBase.OnGetInstance(Type, object)" /> protected override object OnGetInstance(Type serviceType, object key) { var strKey = key.AsString(true); var container = this._PROVIDER as CompositionContainer; if (container != null) { // handle as extended composition container return(InvokeGetExportedValueMethod(c => c.GetExportedValue <object>(), container, serviceType, strKey)); } // old skool ... if (strKey == null) { strKey = AttributedModelServices.GetContractName(serviceType); } var lazyInstance = this._PROVIDER .GetExports <object>(strKey) .FirstOrDefault(); if (lazyInstance != null) { // found return(lazyInstance.Value); } // not found return(null); }
public void when_retrieving_exports_then_reports_duplicate_services(Type serviceType) { var componentModel = GlobalServices.GetService <SComponentModel, IComponentModel>(); var contractName = AttributedModelServices.GetContractName(serviceType); var components = componentModel.DefaultExportProvider .GetExports <object, IDictionary <string, object> >(contractName) .ToArray(); if (components.Length != 1) { var info = new CompositionInfo(componentModel.DefaultCatalog, componentModel.DefaultExportProvider); var log = Path.GetTempFileName(); using (var writer = new StreamWriter(log)) { CompositionInfoTextFormatter.Write(info, writer); writer.Flush(); } output.WriteLine(log); // Process.Start(new ProcessStartInfo("notepad", log) { UseShellExecute = true }); Assert.False(true, $"Expected only one component of {serviceType.Name}. Composition log at {log}"); } }
/// <summary> /// Initializes a new instance. /// </summary> public NancyRegistrationBuilder() : base() { // export FuncFactory as an open generic instance; but more importantly, export its CreateExport function // as an appropriate Func<T> contract. ForType(typeof(FuncFactory <>)) .AddMetadata(NancyMetadataKeys.RegistrationBuilder, this) .Export(i => i .AsContractType(typeof(FuncFactory <>))) .ExportProperties(i => i == ExportFuncPropertyInfo, (i, j) => j .AsContractType(typeof(Func <>)) .AsContractName("FuncFactory:" + AttributedModelServices.GetContractName(typeof(Func <>)))); // export any exportable parts ForTypesMatching(i => IsExportableNancyPart(i)) .AddMetadata(NancyMetadataKeys.RegistrationBuilder, this) .Export() .ExportInterfaces(i => IsNancyContract(i), (i, j) => j .AsContractType(i)) .SelectConstructor(i => SelectConstructor(i), (i, j) => BuildParameter(i, j)); }
public object GetService(Type serviceType) { string contractName = AttributedModelServices.GetContractName(serviceType); try { return(Container.GetExportedValueOrDefault <object>(contractName)); } catch (Exception ex) { if (ex is System.Reflection.ReflectionTypeLoadException) { var typeLoadException = ex as ReflectionTypeLoadException; var loaderExceptions = typeLoadException.LoaderExceptions; string message = string.Empty; foreach (var item in loaderExceptions) { message += item.Message + ";"; } throw new Exception(message); } throw; } }
public void GetImportContractName_should_return_contract_name_for_property_type_when_called_with_property_and_contract_name_and_type_are_null() { var member = ReflectionServices.GetProperty <FakePart>(x => x.Name); var convention = new ImportConvention() { ContractName = null, ContractType = null, Members = x => new[] { member } }; var service = GetServiceWithoutDefaultConventions(); var results = service.GetImportContractName(convention, member); var expectedContractName = AttributedModelServices.GetContractName(member.PropertyType); results.ShouldEqual(expectedContractName); }
protected override IEnumerable <object> GetAllInstances(Type service) { return(m_Container.GetExportedValues <object>(AttributedModelServices.GetContractName(service))); }
protected override object GetInstance(Type serviceType, string key) { string contract = string.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(serviceType) : key; return(_container.GetExportedValue <object>(contract)); }
private static string CreateDisplayNameExpectationFromContractName(ReflectionParameterImportDefinition definition, Type type) { string contractName = AttributedModelServices.GetContractName(type); return(string.Format("{0} (Parameter=\"\", ContractName=\"{1}\")", definition.ImportingLazyParameter.Value.Member.GetDisplayName(), contractName)); }
private static ReflectionParameterImportDefinition CreateReflectionParameterImportDefinition(ParameterInfo parameter) { return(new ReflectionParameterImportDefinition( parameter.AsLazy(), AttributedModelServices.GetContractName(parameter.ParameterType), (string)null, null, ImportCardinality.ZeroOrMore, CreationPolicy.NonShared, null, null)); }
/// <summary> /// Extension method to searches the composition container for an export that has a matching type name. This function /// will first try to match on Type.AssemblyQualifiedName, then Type.FullName, and finally on Type.Name /// /// This method will not throw if multiple types are found matching the name, it will just return the first one it finds. /// </summary> /// <typeparam name="T">The type of the export</typeparam> /// <param name="typeName">The name of the type to find. This can be an assembly qualified name, a full name, or just the type's name</param> /// <returns>The export instance</returns> public T GetExportedValueByTypeName <T>(string typeName) where T : class { try { lock (_exportedValuesLockObject) { T instance; IEnumerable values; var type = typeof(T); if (_exportedValues.TryGetValue(type, out values)) { // if we've alread loaded this part, then just reserve the same one instance = values.OfType <T>().FirstOrDefault(x => x.GetType().MatchesTypeName(typeName)); if (instance != null) { return(instance); } } // we want to get the requested part without instantiating each one of that type var selectedPart = _compositionContainer.Catalog.Parts .Select(x => new { part = x, Type = ReflectionModelServices.GetPartType(x).Value }) .Where(x => type.IsAssignableFrom(x.Type)) .Where(x => x.Type.MatchesTypeName(typeName)) .Select(x => x.part) .FirstOrDefault(); if (selectedPart == null) { throw new ArgumentException( "Unable to locate any exports matching the requested typeName: " + typeName, "typeName"); } var exportDefinition = selectedPart.ExportDefinitions.First( x => x.ContractName == AttributedModelServices.GetContractName(type)); instance = (T)selectedPart.CreatePart().GetExportedValue(exportDefinition); // cache the new value for next time if (values == null) { values = new List <T> { instance }; _exportedValues[type] = values; } else { ((List <T>)values).Add(instance); } return(instance); } } catch (ReflectionTypeLoadException err) { foreach (var exception in err.LoaderExceptions) { Log.Error(exception); Log.Error(exception.ToString()); } if (err.InnerException != null) { Log.Error(err.InnerException); } throw; } }
/// <summary> /// Locate all of the MEF exports registered as supplying contract type T. /// </summary> /// <typeparam name="T">The contract type.</typeparam> /// <param name="context">The context to resolve exports from.</param> /// <returns>A list of exports.</returns> public static IEnumerable <Export> ResolveExports <T>(this IComponentContext context) { return(context.ResolveExports <T>(AttributedModelServices.GetContractName(typeof(T)))); }