public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor definitionAccessor) { if (!(contract.ContractType.IsArray || contract.ContractType.IsConstructedGenericType && SupportedContractTypes.Contains(contract.ContractType.GetGenericTypeDefinition()))) { return(NoExportDescriptors); } string keyToOrderBy; CompositionContract orderUnwrappedContract; if (!contract.TryUnwrapMetadataConstraint(OrderByMetadataImportMetadataConstraintName, out keyToOrderBy, out orderUnwrappedContract)) { return(NoExportDescriptors); } var elementType = contract.ContractType.IsArray ? contract.ContractType.GetElementType() : contract.ContractType.GenericTypeArguments[0]; var elementContract = orderUnwrappedContract.ChangeType(elementType); var gimd = GetImportManyDefinitionMethod.MakeGenericMethod(elementType); return(new[] { (ExportDescriptorPromise)gimd.Invoke(null, new object[] { contract, elementContract, definitionAccessor, keyToOrderBy }) }); }
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor definitionAccessor) { if (!(contract.ContractType.IsArray || contract.ContractType.IsConstructedGenericType && SupportedContractTypes.Contains(contract.ContractType.GetGenericTypeDefinition()))) { return(NoExportDescriptors); } bool isImportMany; CompositionContract unwrapped; if (!contract.TryUnwrapMetadataConstraint(Constants.ImportManyImportMetadataConstraintName, out isImportMany, out unwrapped)) { return(NoExportDescriptors); } var elementType = contract.ContractType.IsArray ? contract.ContractType.GetElementType() : contract.ContractType.GenericTypeArguments[0]; var elementContract = unwrapped.ChangeType(elementType); var gimd = GetImportManyDefinitionMethod.MakeGenericMethod(elementType); var gimdm = gimd.CreateStaticDelegate <Func <CompositionContract, CompositionContract, DependencyAccessor, object> >(); return(new[] { (ExportDescriptorPromise)gimdm(contract, elementContract, definitionAccessor) }); }
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor) { if (!(contract.ContractType.IsConstructedGenericType && contract.ContractType.GetGenericTypeDefinition() == typeof(IDictionary <,>))) { return(NoExportDescriptors); } CompositionContract unwrapped; string keyByMetadataName; if (!contract.TryUnwrapMetadataConstraint(KeyByMetadataImportMetadataConstraintName, out keyByMetadataName, out unwrapped)) { return(NoExportDescriptors); } var args = contract.ContractType.GenericTypeArguments; var keyType = args[0]; var valueType = args[1]; var valueContract = unwrapped.ChangeType(valueType); var gdd = GetDictionaryDefinitionsMethod.MakeGenericMethod(keyType, valueType); return(new[] { (ExportDescriptorPromise)gdd.Invoke(null, new object[] { contract, valueContract, descriptorAccessor, keyByMetadataName }) }); }
static ExportDescriptorPromise[] GetExportFactoryDescriptors <TProduct>(CompositionContract exportFactoryContract, DependencyAccessor definitionAccessor) { var productContract = exportFactoryContract.ChangeType(typeof(TProduct)); var boundaries = new string[0]; IEnumerable <string> specifiedBoundaries; CompositionContract unwrapped; if (exportFactoryContract.TryUnwrapMetadataConstraint(Constants.SharingBoundaryImportMetadataConstraintName, out specifiedBoundaries, out unwrapped)) { productContract = unwrapped.ChangeType(typeof(TProduct)); boundaries = (specifiedBoundaries ?? new string[0]).ToArray(); } return(definitionAccessor.ResolveDependencies("product", productContract, false) .Select(d => new ExportDescriptorPromise( exportFactoryContract, Formatters.Format(typeof(ExportFactory <TProduct>)), false, () => new[] { d }, _ => { var dsc = d.Target.GetDescriptor(); var da = dsc.Activator; return ExportDescriptor.Create((c, o) => { return new ExportFactory <TProduct>(() => { var lifetimeContext = new LifetimeContext(c, boundaries); return Tuple.Create <TProduct, Action>((TProduct)CompositionOperation.Run(lifetimeContext, da), lifetimeContext.Dispose); }); }, dsc.Metadata); })) .ToArray()); }
public override IEnumerable<ExportDescriptorPromise> GetExportDescriptors( CompositionContract contract, DependencyAccessor dependencyAccessor) { if (contract == null) throw new ArgumentNullException("contract"); if (dependencyAccessor == null) throw new ArgumentNullException("dependencyAccessor"); string key; CompositionContract unwrapped; if (!contract.TryUnwrapMetadataConstraint(SettingKey, out key, out unwrapped) || !unwrapped.Equals(new CompositionContract(unwrapped.ContractType)) || !SupportedSettingTypes.Contains(unwrapped.ContractType) || !ConfigurationManager.AppSettings.AllKeys.Contains(key)) yield break; var value = ConfigurationManager.AppSettings.Get(key); var converted = Convert.ChangeType(value, contract.ContractType); yield return new ExportDescriptorPromise( contract, "System.Configuration.ConfigurationManager.AppSettings", true, NoDependencies, _ => ExportDescriptor.Create((c, o) => converted, NoMetadata)); }
/// <summary> /// <see cref="ILogger"/>生成処理 /// /// https://mef.codeplex.com/wikipage?title=ProgrammingModelExtensions&referringTitle=Documentation /// </summary> /// <param name="contract"></param> /// <param name="descriptorAccessor"></param> /// <returns></returns> public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor) { if (contract.ContractType == typeof(ILogger)) { string value = string.Empty; CompositionContract unwrap; contract.TryUnwrapMetadataConstraint("LogType", out value, out unwrap); string header = string.Format("[{0}] LogExportDescriptorProvider - ", value); return(new ExportDescriptorPromise[] { new ExportDescriptorPromise( contract, "ConsoleMef2 ILogger", true, NoDependencies, _ => ExportDescriptor.Create((c, o) => new Logger() { Header = header }, NoMetadata) ) }); } else { return(NoExportDescriptors); } }
/// <summary> /// <see cref="ILogger"/>生成処理 /// /// https://mef.codeplex.com/wikipage?title=ProgrammingModelExtensions&referringTitle=Documentation /// </summary> /// <param name="contract"></param> /// <param name="descriptorAccessor"></param> /// <returns></returns> public override IEnumerable<ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor) { if (contract.ContractType == typeof(ILogger)) { string value = string.Empty; CompositionContract unwrap; contract.TryUnwrapMetadataConstraint("LogType", out value, out unwrap); string header = string.Format("[{0}] LogExportDescriptorProvider - ", value); return new ExportDescriptorPromise[] { new ExportDescriptorPromise( contract, "ConsoleMef2 ILogger", true, NoDependencies, _ => ExportDescriptor.Create((c, o) => new Logger() { Header = header }, NoMetadata) ) }; } else return NoExportDescriptors; }
public override IEnumerable<ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor) { if (contract == null) throw new ArgumentNullException("contract"); if (descriptorAccessor == null) throw new ArgumentNullException("descriptorAccessor"); string name; CompositionContract unwrapped; var connectionStringSettings = ConfigurationManager.ConnectionStrings.OfType<ConnectionStringSettings>().ToArray(); if (!contract.TryUnwrapMetadataConstraint(NameKey, out name, out unwrapped) || !unwrapped.Equals(new CompositionContract(unwrapped.ContractType)) || !(unwrapped.ContractType == typeof(string) || typeof(DbConnectionStringBuilder).IsAssignableFrom(unwrapped.ContractType)) || !connectionStringSettings.Any(cs => cs.Name == name)) yield break; var stringValue = connectionStringSettings.Single(cs => cs.Name == name).ConnectionString; object value = stringValue; if (contract.ContractType != typeof(string)) { var stringBuilder = Activator.CreateInstance(contract.ContractType) as DbConnectionStringBuilder; if (stringBuilder == null) yield break; stringBuilder.ConnectionString = stringValue; value = stringBuilder; } yield return new ExportDescriptorPromise( contract, "System.Configuration.ConfigurationManager.ConnectionStrings", true, NoDependencies, _ => ExportDescriptor.Create((c, o) => value, NoMetadata)); }
public void TryUnwrapMetadataConstraint_NullConstraints_ReturnsFalse() { var contract = new CompositionContract(typeof(int)); Assert.False(contract.TryUnwrapMetadataConstraint("constraintName", out int constraintValue, out CompositionContract remainingContract)); Assert.Equal(0, constraintValue); Assert.Null(remainingContract); }
public void TryUnwrapMetadataConstraint_IncorrectConstraintNameType_ReturnsFalse() { var contract = new CompositionContract(typeof(int), "contractName", new Dictionary <string, object> { { "constraintName", "value" } }); Assert.False(contract.TryUnwrapMetadataConstraint("constraintName", out int constraintValue, out CompositionContract remainingContract)); Assert.Equal(0, constraintValue); Assert.Null(remainingContract); }
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor definitionAccessor) { string key; CompositionContract unwrapped; if (!contract.TryUnwrapMetadataConstraint(Constants.SettingKey, out key, out unwrapped)) { return(NoExportDescriptors); } if (!unwrapped.Equals(new CompositionContract(unwrapped.ContractType))) { return(NoExportDescriptors); } if (!SupportedSettingTypes.Contains(unwrapped.ContractType)) { return(NoExportDescriptors); } var value = ConfigurationManager.AppSettings.Get(key); if (value == null) { return(NoExportDescriptors); } var converted = Convert.ChangeType(value, contract.ContractType); return(new[] { new ExportDescriptorPromise( contract, "Application Configuration", true, NoDependencies, _ => ExportDescriptor.Create((c, o) => converted, NoMetadata)) }); }
public void TryUnwrapMetadataConstraint_UnwrapAllConstraints_ReturnsTrue() { var originalContract = new CompositionContract(typeof(int), "contractName", new Dictionary <string, object> { { "constraintName1", 1 }, { "constraintName2", 2 } }); Assert.True(originalContract.TryUnwrapMetadataConstraint("constraintName1", out int constraintValue1, out CompositionContract remainingContract1)); Assert.Equal(1, constraintValue1); Assert.Equal(originalContract.ContractType, remainingContract1.ContractType); Assert.Equal(originalContract.ContractName, remainingContract1.ContractName); Assert.Equal(new Dictionary <string, object> { { "constraintName2", 2 } }, remainingContract1.MetadataConstraints); Assert.NotEqual(originalContract.MetadataConstraints, remainingContract1.MetadataConstraints); Assert.True(remainingContract1.TryUnwrapMetadataConstraint("constraintName2", out int constraintValue2, out CompositionContract remainingContract2)); Assert.Equal(2, constraintValue2); Assert.Equal(originalContract.ContractType, remainingContract2.ContractType); Assert.Equal(originalContract.ContractName, remainingContract2.ContractName); Assert.Null(remainingContract2.MetadataConstraints); Assert.NotEqual(originalContract.MetadataConstraints, remainingContract2.MetadataConstraints); }
public void TryUnwrapMetadataConstraint_NullContractName_ThrowsArgumentNullException() { var contract = new CompositionContract(typeof(int)); AssertExtensions.Throws <ArgumentNullException>("constraintName", () => contract.TryUnwrapMetadataConstraint(null, out int unusedValue, out CompositionContract unusedContract)); }