public IHandlerActivator GetActivator()
{
_handlerTypesToRegister
.SelectMany(type => GetHandlerInterfaces(type)
.Select(handlerType =>
new
{
HandlerType = handlerType,
ConcreteType = type
}))
.GroupBy(a => a.HandlerType)
.ForEach(a =>
{
var serviceType = a.Key;
Console.WriteLine("Registering {0} => {1}", serviceType, string.Join(", ", a));
_container.RegisterCollection(serviceType, a.Select(g => g.ConcreteType));
});
_handlerTypesToRegister.Clear();
var containerAdapter = new SimpleInjectorContainerAdapter(_container);
_disposables.Add(containerAdapter);
return(containerAdapter);
}
public async Task Should_Invoke_Registered_Query_Handler_In_Container_When_Dispatched_Multiple_Times()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
const string data1 = "Test message 1.";
const string data2 = "Test message 2.";
const int data3 = 1;
var dispatcher = new QueryDispatcher(resolver);
var result1 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data1));
var result2 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data2));
var result3 = dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(data3));
await Task.WhenAll(result1, result2, result3);
Assert.Equal(data1, await result1);
Assert.Equal(data2, await result2);
Assert.Equal(data3, await result3);
}
public async Task Should_Store_Registered_Query_Handler_In_Container()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
const string data = nameof(Should_Store_Registered_Query_Handler_In_Container);
QueryHandlerDelegate <string> queryHandlerDelegate = resolver.ResolveQueryHandler <QuerySomething, string>();
Assert.NotNull(queryHandlerDelegate);
var registeredQueryHandler = container.GetInstance <IQueryAsyncHandler <QuerySomething, string> >();
var query = new QuerySomething(data);
var result1 = await queryHandlerDelegate.Invoke(query);
var result2 = await registeredQueryHandler.HandleAsync(query);
Assert.Equal(data, result1);
Assert.Equal(data, result2);
Assert.Equal(result1, result2);
}
public void Should_Resolve_All_Event_Handlers()
{
Assembly assembly = typeof(TestEvent1).Assembly;
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), assembly);
container.RegisterCollection(typeof(IEventHandler <>), assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
IEnumerable <EventHandlerDelegate> eventHandlerDelegates = eventHandlerResolver.ResolveEventHandlers <TestEvent1>();
// Get all handlers in assembly.
int asyncHandlerCount = assembly.DefinedTypes.Count(t =>
!t.IsAbstract && !t.IsInterface &&
t.ImplementedInterfaces.Any(i =>
i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEventAsyncHandler <>)));
int syncHandlerCount = assembly.DefinedTypes.Count(t =>
!t.IsAbstract && !t.IsInterface &&
t.ImplementedInterfaces.Any(i =>
i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEventHandler <>)));
int totalHandlerCount = asyncHandlerCount + syncHandlerCount;
// Important Note: This should equal all handlers in this assembly.
Assert.Equal(totalHandlerCount, eventHandlerDelegates.Count());
}
public async Task ShouldInvokeRegisteredQueryHandlerInContainerWhenDispatchedMultipleTimes()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
const string data1 = "Test message 1.";
const string data2 = "Test message 2.";
const int data3 = 1;
var dispatcher = new QueryDispatcher(resolver);
var result1 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data1));
var result2 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data2));
var result3 = dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(data3));
await Task.WhenAll(result1, result2, result3);
(await result1).Should().Be(data1);
(await result2).Should().Be(data2);
(await result3).Should().Be(data3);
}
public async Task ShouldResolveQueryHandlersFromContainer()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
const string data = nameof(ShouldResolveQueryHandlersFromContainer);
QueryHandlerDelegate <string> queryHandlerDelegate = resolver.ResolveQueryHandler <QuerySomething, string>();
queryHandlerDelegate.Should().NotBeNull();
var registeredQueryHandler = container.GetInstance <IQueryAsyncHandler <QuerySomething, string> >();
var query = new QuerySomething(data);
var result1 = await queryHandlerDelegate.Invoke(query);
var result2 = await registeredQueryHandler.HandleAsync(query);
result1.Should().Be(data);
result2.Should().Be(data);
result1.Should().Be(result1);
}
public static void RegistrationByConvention(this Container container,
BehaviorConfiguration configuration,
Action<IConventionBuilderSyntax<Lifestyle, Container>> convention)
{
if (configuration == null)
{
configuration = BehaviorConfiguration.Default;
}
var logger = new DiagnosticLogger(configuration);
var serviceMappingTracker = new ServiceMappingTracker(logger);
var implementationFilter = new ImplementationFilter();
var adapter = new SimpleInjectorContainerAdapter(container, serviceMappingTracker, implementationFilter);
var configServiceFilter = ((IBehaviorConfiguration)configuration).GetServiceFilter();
var asmSelector = new AssemblySelector();
var serviceExtractor = new ServiceExtractor();
var containerDecorator = new ContainerLogger<Lifestyle>(adapter, logger);
var serviceFilterAggregator = new ServiceFilterAggregator(new IServiceFilter[] { configServiceFilter, implementationFilter, serviceExtractor, serviceMappingTracker });
using (var builder = new ConventionBuilder<Lifestyle>(containerDecorator,
asmSelector,
serviceFilterAggregator,
serviceExtractor))
{
var importer = new ConventionBuilderSyntaxDecorator<Lifestyle, Container>(builder, container, implementationFilter, asmSelector);
convention(importer);
}
}
public void CanVerifyContainer()
{
var container = new Container();
var adapter = new SimpleInjectorContainerAdapter(container);
adapter.SetBus(new FakeBus());
container.Verify();
}
public async Task ShouldNotThrowIfNoEventHandlerIsRegisteredInContainer()
{
var container = new Container();
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var delegator = new EventDelegator(eventHandlerResolver);
await delegator.SendAsync(new TestEvent1());
}
public void CanVerifyContainer()
{
var container = new Container {
Options = { DefaultScopedLifestyle = ScopedLifestyle.Flowing }
};
var adapter = new SimpleInjectorContainerAdapter(container);
adapter.SetBus(new FakeBus());
container.Verify();
}
public void ShouldThrowWhenNoRegisteredQueryHandlerInContainerIsFound()
{
var container = new Container();
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryHandlerResolver(containerAdapter); // Sync handler resolver
var dispatcher = new LoggingQueryDispatcher(new QueryDispatcher(resolver), _outputHelper);
const string data = nameof(ShouldThrowWhenNoRegisteredAttributeQueryHandlerIsFound);
Action action = () => dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
action.Should().Throw <NoQueryHandlerResolvedException>();
}
public void ShouldThrowWhenNoRegisteredCommandHandlerIsFoundInContainer()
{
var container = new Container();
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var delegator = new LoggingCommandDelegator(
new CommandDelegator(new ContainerCommandHandlerResolver(containerAdapter)), // Sync handler resolver
_outputHelper
);
Func <Task> sendAsyncAction = async() => await delegator.SendAsync(new TestCommand());
sendAsyncAction.Should().Throw <NoMessageHandlerResolvedException>();
}
public async Task Should_Be_Good_If_No_Event_Handler_Is_Registered_In_Container()
{
var container = new Container();
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new TestEvent1());
}
public async Task Should_Invoke_Registered_Command_Handler_In_Container()
{
var commandHandler = new TestCommandHandler(_outputHelper);
var container = new Container();
container.Register <ICommandHandler <DoSomethingCommand> >(() => commandHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var dispatcher = new CommandDispatcher(new ContainerCommandHandlerResolver(containerAdapter)); // Sync handler resolver
await dispatcher.DispatchAsync(new DoSomethingCommand());
Assert.Equal(1, commandHandler.HandledCommands.Count);
Assert.Contains(commandHandler.HandledCommands, c => c is DoSomethingCommand);
}
public void ShouldAllowRegisteredQueryHandlersInContainerWithNonReferenceTypeQueryResults()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(1973));
result.Should().Be(1973);
}
public void Should_Allow_Registered_Query_Handlers_In_Container_With_Non_Reference_Type_Query_Results()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter); // Async handler resolver
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(1973));
Assert.Equal(1973, result);
}
public void ShouldInvokeRegisteredQueryHandlerInContainer()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryHandlerResolver(containerAdapter); // Sync handler resolver
const string data = nameof(ShouldInvokeRegisteredQueryHandlerInContainer);
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
result.Should().Be(data);
}
public void Should_Invoke_Registered_Query_Handler_In_Container()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryHandlerResolver(containerAdapter); // Sync handler resolver
const string data = nameof(Should_Invoke_Registered_Query_Handler_In_Container);
var dispatcher = new QueryDispatcher(resolver);
var result = dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
Assert.Equal(data, result);
}
public async Task Should_Invoke_Registered_Query_Handler_In_Container_With_Cancellation_Token()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithDelay, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
var dispatcher = new QueryDispatcher(resolver);
var cts = new CancellationTokenSource();
const string data = nameof(Should_Invoke_Registered_Attribute_Query_Handler_With_Cancellation_Token);
var result = await dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay(data, 500), cts.Token);
Assert.Equal(data, result);
}
public async Task ShouldInvokeRegisteredQueryHandlerInContainerWithCancellationToken()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithDelay, string> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
var dispatcher = new QueryDispatcher(resolver);
var cts = new CancellationTokenSource();
const string data = nameof(ShouldInvokeRegisteredAttributeQueryHandlerWithCancellationToken);
var result = await dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay(data, 500), cts.Token);
result.Should().Be(data);
}
public void Should_Throw_When_No_Registered_Command_Handler_In_Container_Is_Found()
{
Assert.Throws <NoCommandHandlerResolvedException>(() =>
{
var container = new Container();
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var dispatcher = new CommandDispatcher(new ContainerCommandAsyncHandlerResolver(containerAdapter)); // Async handler resolver
try
{
dispatcher.Dispatch(new DoSomethingCommand());
}
catch (Exception ex)
{
_outputHelper.WriteLine(ex.ToString());
throw;
}
});
}
public async Task Should_Invoke_Registered_Command_Handler_With_Composite_Resolver()
{
var commandHandler = new TestCommandHandler(_outputHelper);
var container = new Container();
container.Register <ICommandHandler <DoSomethingCommand> >(() => commandHandler, Lifestyle.Singleton);
container.Register <ICommandAsyncHandler <DoSomethingWithCancellationCommand> >(() => commandHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var containerAsyncHandlerResolver = new ContainerCommandAsyncHandlerResolver(containerAdapter);
var containerHandlerResolver = new ContainerCommandHandlerResolver(containerAdapter);
Func <Exception, bool> exceptionHandler = (ex) =>
{
var exception = ex as NoCommandHandlerResolvedException;
if (exception != null)
{
_outputHelper.WriteLine($"Ignoring encountered exception while trying to resolve command handler for {exception.CommandType.Name}...");
// Notify as handled if no command handler is resolved from other resolvers.
return(true);
}
return(false);
};
var compositeResolver = new CompositeCommandHandlerResolver(new List <ICommandHandlerResolver>()
{
containerAsyncHandlerResolver,
containerHandlerResolver
}, exceptionHandler); // Pass in an exception handler.
var dispatcher = new CommandDispatcher(compositeResolver); // Composite resolver
await dispatcher.DispatchAsync(new DoSomethingCommand());
await dispatcher.DispatchAsync(new DoSomethingWithCancellationCommand());
Assert.Equal(2, commandHandler.HandledCommands.Count);
Assert.Contains(commandHandler.HandledCommands, c => c is DoSomethingCommand);
Assert.Contains(commandHandler.HandledCommands, c => c is DoSomethingWithCancellationCommand);
}
public void Should_Register_All_Command_Handlers()
{
var container = new Container();
container.Register <ICommandHandler <DoSomethingCommand> >(() => new TestCommandHandler(_testOutputHelper), Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerCommandHandlerResolver(containerAdapter);
CommandHandlerDelegate commandHandlerDelegate = resolver.ResolveCommandHandler <DoSomethingCommand>();
// Delegate should invoke the actual command handler - TestCommandHandler.
commandHandlerDelegate.Invoke(new DoSomethingCommand());
// Get instance from container to see if it was invoked.
var registeredCommandHandler = (TestCommandHandler)container.GetInstance <ICommandHandler <DoSomethingCommand> >();
Assert.Equal(1, registeredCommandHandler.HandledCommands.Count);
Assert.Contains(registeredCommandHandler.HandledCommands, c => c is DoSomethingCommand);
}
public async Task ShouldInvokeRegisteredQueryHandlerWithCompositeResolver()
{
var commandHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => commandHandler, Lifestyle.Singleton);
container.Register <IQueryHandler <QuerySomething, string> >(() => commandHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var containerAsyncHandlerResolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
var containerHandlerResolver = new ContainerQueryHandlerResolver(containerAdapter);
Func <Exception, bool> exceptionHandler = (ex) =>
{
var exception = ex as NoQueryHandlerResolvedException;
if (exception != null)
{
_outputHelper.WriteLine($"Ignoring encountered exception while trying to resolve query handler for {exception.QueryType.Name}...");
// Notify as handled if no command handler is resolved from other resolvers.
return(true);
}
return(false);
};
var compositeResolver = new CompositeQueryHandlerResolver(new List <IQueryHandlerResolver>()
{
containerAsyncHandlerResolver,
containerHandlerResolver
}, exceptionHandler); // Pass in an exception handler.
var dispatcher = new QueryDispatcher(compositeResolver); // Composite resolver
int result1 = await dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(1973));
string result2 = await dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething("1973"));
result1.Should().Be(1973);
result2.Should().Be("1973");
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Container()
{
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), typeof(TestEvent1).Assembly);
container.RegisterCollection(typeof(IEventHandler <>), typeof(TestEvent1).Assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
Assert.IsType <TestEventHandlerException>(ex);
};
await publisher.PublishAsync(new TestEvent1());
}
public void ShouldResolveCommandHandlerFromCompositeResolver()
{
var commandHandler = new TestCommandHandler(_outputHelper);
var container = new Container();
container.RegisterSingleton <ICommandHandler <TestCommand> >(commandHandler);
container.RegisterSingleton <ICommandAsyncHandler <CancellableTestCommand> >(commandHandler);
// Exception handler will log and ignore exception.
Func <Exception, bool> exceptionHandler = (ex) =>
{
if (ex != null)
{
_outputHelper.WriteLine($"Ignoring encountered exception while trying to resolve command handler: {ex.Message}");
// Notify as handled if no command handler is resolved from other resolvers.
return(true);
}
return(false);
};
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var containerAsyncHandlerResolver = new ContainerCommandAsyncHandlerResolver(containerAdapter, exceptionHandler);
var containerHandlerResolver = new ContainerCommandHandlerResolver(containerAdapter, exceptionHandler);
CompositeMessageHandlerResolver compositeResolver = CompositeMessageHandlerResolver.Compose(
containerAsyncHandlerResolver,
containerHandlerResolver);
MessageHandlerDelegate testCommandHandlerDelegate = compositeResolver.ResolveMessageHandler(typeof(TestCommand));
MessageHandlerDelegate cancellableTestCommandHandlerDelegate = compositeResolver.ResolveMessageHandler(typeof(CancellableTestCommand));
testCommandHandlerDelegate?.Invoke(new TestCommand());
cancellableTestCommandHandlerDelegate?.Invoke(new CancellableTestCommand());
commandHandler.HandledCommands.Should().HaveCount(2);
commandHandler.HasHandledCommand <TestCommand>().Should().BeTrue();
commandHandler.HasHandledCommand <CancellableTestCommand>().Should().BeTrue();
}
public void Should_Throw_When_No_Registered_Query_Handler_In_Container_Is_Found()
{
Assert.Throws <NoQueryHandlerResolvedException>(() =>
{
var container = new Container();
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryHandlerResolver(containerAdapter); // Sync handler resolver
var dispatcher = new QueryDispatcher(resolver);
const string data = nameof(Should_Throw_When_No_Registered_Attribute_Query_Handler_Is_Found);
try
{
var result = dispatcher.Dispatch <QuerySomething, string>(new QuerySomething(data));
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.ToString());
throw;
}
});
}
public async Task Should_Invoke_All_Registered_Event_Handlers_In_Container_For_Each_Events()
{
var container = new Container();
container.RegisterCollection(typeof(IEventAsyncHandler <>), typeof(TestEvent1).Assembly);
container.RegisterCollection(typeof(IEventHandler <>), typeof(TestEvent1).Assembly);
container.Register(() => _testOutputHelper);
var adapter = new SimpleInjectorContainerAdapter(container);
var eventHandlerResolver = new ContainerEventHandlerResolver(adapter);
var publisher = new EventPublisher(eventHandlerResolver);
publisher.OnError += (@event, ex) =>
{
_testOutputHelper.WriteLine(ex.Message);
};
await publisher.PublishAsync(new List <IEvent> {
new TestEvent1(), new TestEvent2(), new TestEvent3()
});
// Event may not have yet been handled in background.
await Task.Delay(500);
}
public void Init()
{
var emptyContainer = new Container();
containerAdapter = new SimpleInjectorContainerAdapter(emptyContainer);
}
