private Type GetDecoratorTypeFromDecoratorFactory(Type requestedServiceType,
DecoratorPredicateContext context)
{
Type decoratorType = this.data.DecoratorTypeFactory(context);
if (decoratorType.Info().ContainsGenericParameters)
{
if (!requestedServiceType.Info().IsGenericType)
{
throw new ActivationException(
StringResources.TheDecoratorReturnedFromTheFactoryShouldNotBeOpenGeneric(
requestedServiceType, decoratorType));
}
Requires.TypeFactoryReturnedTypeThatDoesNotContainUnresolvableTypeArguments(
requestedServiceType, decoratorType);
var builder = new GenericTypeBuilder(requestedServiceType, decoratorType);
decoratorType = builder.BuildClosedGenericImplementation().ClosedGenericImplementation;
// decoratorType == null when type constraints don't match.
if (decoratorType != null)
{
Requires.HasFactoryCreatedDecorator(this.data.Container, requestedServiceType, decoratorType);
}
}
else
{
Requires.FactoryReturnsATypeThatIsAssignableFromServiceType(requestedServiceType, decoratorType);
}
return(decoratorType);
}
private GenericTypeBuilder.BuildResult BuildClosedGenericImplementation(
Type serviceType, Type decoratorTypeDefinition)
{
var builder = new GenericTypeBuilder(serviceType, decoratorTypeDefinition);
return(builder.BuildClosedGenericImplementation());
}
private IEnumerable <string> ValidateFixedSettings()
{
string repoType = _settings.CertificateStore?.Repository?.Type;
if (!GenericTypeBuilder.CanResolveTypeThatImplements <ICertificateRepository>(repoType))
{
yield return($"Certificate store type: {repoType} cannot be resolved");
}
}
private static T CreateInstance <T>(string typeString, params object[] args) where T : class
{
if (!GenericTypeBuilder.CanResolveTypeThatImplements <IStep>(typeString))
{
throw new InvalidOperationException(
$"Cannot resolve a valid {nameof(IStep)} implementation for the {typeString} fully-qualified assembly name");
}
return(GenericTypeBuilder.FromType(typeString).SetArgs(args).Build <T>());
}
public void ThenBuilderFailsToCreateTypeForAssemblyName()
{
// Arrange
const string typeString =
"Eu.EDelivery.AS4.Transformers.InvalidTransformer, Eu.EDelivery.AS4.Transformers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
// Act
Assert.Throws <TypeLoadException>(
() => GenericTypeBuilder.FromType(typeString));
}
public void ThenBuilderCreatesValidType()
{
// Arrange
string typeString = typeof(object).FullName;
// Act
var instance = GenericTypeBuilder.FromType(typeString).Build <object>();
// Assert
Assert.NotNull(instance);
Assert.IsType <object>(instance);
}
private static ICertificateRepository ResolveCertificateRepository(string typeString)
{
if (!GenericTypeBuilder.CanResolveTypeThatImplements <ICertificateRepository>(typeString))
{
throw new InvalidOperationException(
$"Cannot resolve a valid {nameof(ICertificateRepository)} implementation for the {typeString} fully-qualified assembly name");
}
return(GenericTypeBuilder
.FromType(typeString)
.Build <ICertificateRepository>());
}
public void NotCreateOtherElements()
{
CompilerContext cc = new CompilerContext();
GenericTypeBuilder gtb = new GenericTypeBuilder();
TypeBuilder tb = new TypeBuilder();
Testdata.ClassA classa = new Testdata.ClassA();
System.Reflection.ReflectionClass rc = new System.Reflection.ReflectionClass();
Assert.IsNull(TreeElementCreator.CreateFromObject("cc", cc));
Assert.IsNull(TreeElementCreator.CreateFromObject("gtb", gtb));
Assert.IsNull(TreeElementCreator.CreateFromObject("tb", tb));
Assert.IsNull(TreeElementCreator.CreateFromObject("rc", rc));
}
/// <summary>
/// Creates a <see cref="ITransformer"/> implementation based on the given <paramref name="config"/>.
/// </summary>
/// <param name="config">The configuration which contains the type and the optional settings for the <see cref="ITransformer"/> implementation.</param>
/// <returns></returns>
public static ITransformer FromTransformerConfig(Transformer config)
{
GenericTypeBuilder builder = GenericTypeBuilder.FromType(config.Type);
var transformer = builder.Build <ITransformer>();
if (config.Setting == null)
{
return(transformer);
}
transformer.Configure(config.Setting.ToDictionary(s => s.Key, s => s.Value, StringComparer.OrdinalIgnoreCase));
return(transformer);
}
internal static void OpenGenericTypeDoesNotContainUnresolvableTypeArguments(
Type serviceType, Type implementationType, string parameterName)
{
if (serviceType.ContainsGenericParameters() && implementationType.ContainsGenericParameters())
{
var builder = new GenericTypeBuilder(serviceType, implementationType);
if (!builder.OpenGenericImplementationCanBeAppliedToServiceType())
{
string error =
StringResources.OpenGenericTypeContainsUnresolvableTypeArguments(implementationType);
throw new ArgumentException(error, parameterName);
}
}
}
private static IEnumerable <string> ValidateAgentSettings(AgentSettings settings)
{
if (settings.Receiver?.Type == null)
{
yield return($"Agent: {settings.Name} hasn't got a Receiver type configured");
}
else if (!GenericTypeBuilder.CanResolveTypeThatImplements <IReceiver>(settings.Receiver.Type))
{
yield return($"Agent: {settings.Name} Receiver type: {settings.Receiver.Type} cannot be resolved");
}
if (settings.Transformer?.Type == null)
{
yield return($"Agent: {settings.Name} hasn't got a Transformer type configured");
}
else if (!GenericTypeBuilder.CanResolveTypeThatImplements <ITransformer>(settings.Transformer.Type))
{
yield return($"Agent: {settings.Name} Transformer type: {settings.Transformer.Type} cannot be resolved");
}
if (settings.StepConfiguration?.NormalPipeline == null)
{
yield return($"Agent: {settings.Name} hasn't got a Steps.NormalPipeline Step type(s) configured");
}
else
{
foreach (Step s in settings.StepConfiguration.NormalPipeline)
{
if (!GenericTypeBuilder.CanResolveTypeThatImplements <IStep>(s.Type))
{
yield return($"Agent: {settings.Name} has a Step in the NormalPipeline with type: {s.Type ?? "<null>"} that cannot be resolved");
}
}
}
if (settings.StepConfiguration?.ErrorPipeline != null)
{
foreach (Step s in settings.StepConfiguration.ErrorPipeline)
{
if (!GenericTypeBuilder.CanResolveTypeThatImplements <IStep>(s.Type))
{
yield return($"Agent: {settings.Name} has a Step in the NormalPipeline with type: {s.Type ?? "<null>"} that cannot be resolved");
}
}
}
}
/// <summary>
/// Build the <see cref="IReceiver"/> implementation
/// </summary>
/// <returns></returns>
public IReceiver Build()
{
if (!GenericTypeBuilder.CanResolveTypeThatImplements <IReceiver>(_settingReceiver.Type))
{
throw new InvalidOperationException(
$"Cannot resolve a valid {nameof(IReceiver)} implementation for the {_settingReceiver.Type} fully-qualified assembly name");
}
var receiver = GenericTypeBuilder.FromType(_settingReceiver.Type).Build <IReceiver>();
if (_settingReceiver.Setting != null)
{
receiver.Configure(_settingReceiver.Setting);
}
return(receiver);
}
private static IDynamicDiscoveryProfile ResolveDynamicDiscoveryProfile(string smpProfile)
{
if (smpProfile == null)
{
Logger.Debug($"SendingPMode doesn't specify DynamicDiscovery.SmpProfile element, using default: {nameof(LocalDynamicDiscoveryProfile)}");
return(new LocalDynamicDiscoveryProfile());
}
if (!GenericTypeBuilder.CanResolveTypeThatImplements <IDynamicDiscoveryProfile>(smpProfile))
{
Logger.Error(
"SendingPMode.DynamicDiscovery.SmpProfile element doesn't have a fully-qualified assembly name "
+ $"that can be used to resolve a instance that implements the {nameof(IDynamicDiscoveryProfile)} interface");
throw new InvalidOperationException(
"Dynamic Discovery process was not correctly configured");
}
Logger.Debug($"SendingPMode specifies a DynamicDiscovery.SmpProfile element, resolve using: {smpProfile}");
return(GenericTypeBuilder
.FromType(smpProfile)
.Build <IDynamicDiscoveryProfile>());
}
