public IStatisticsProcessor Create(IMetadataElement metadata)
 {
     var statisticsType = metadata.GetType().GenericTypeArguments[0];
     var processorType = typeof(StatisticsProcessor<>).MakeGenericType(statisticsType);
     var processor = _unityContainer.Resolve(processorType, new DependencyOverride(metadata.GetType(), metadata));
     return (IStatisticsProcessor)processor;
 }
 public IAggregateProcessor Create(IMetadataElement aggregateMetadata)
 {
     var aggregateType = aggregateMetadata.GetType().GenericTypeArguments[0];
     var processorType = typeof(AggregateProcessor<>).MakeGenericType(aggregateType);
     var processor = _unityContainer.Resolve(processorType, new DependencyOverride(aggregateMetadata.GetType(), aggregateMetadata));
     return (IAggregateProcessor)processor;
 }
 public IFactProcessor Create(IMetadataElement factMetadata)
 {
     var factType = factMetadata.GetType().GenericTypeArguments[0];
     var processorType = typeof(FactProcessor<>).MakeGenericType(factType);
     var processor = _unityContainer.Resolve(processorType, new DependencyOverride(factMetadata.GetType(), factMetadata));
     return (IFactProcessor)processor;
 }
        private DependencyOverride ResolveDataChangesDetectorDependency(IMetadataElement metadata)
        {
            var factory = (IAggregateDataChangesDetectorFactory)_unityContainer.Resolve(
                typeof(AggregateDataChangesDetectorFactory <,>).MakeGenericType(metadata.GetType().GetGenericArguments()),
                new DependencyOverride(metadata.GetType(), metadata));
            var detector = factory.Create();

            return(new DependencyOverride(detector.GetType(), detector));
        }
        private DependencyOverride ResolveAggregateFindSpecificationProvider(IMetadataElement metadata)
        {
            var aggregateType    = metadata.GetType().GenericTypeArguments[0];
            var aggregateKeyType = metadata.GetType().GenericTypeArguments[1];
            var metadataOverride = new DependencyOverride(metadata.GetType(), metadata);

            return(new DependencyOverride(
                       typeof(IFindSpecificationProvider <,>).MakeGenericType(aggregateType, typeof(AggregateOperation)),
                       _unityContainer.Resolve(typeof(AggregateFindSpecificationProvider <,>).MakeGenericType(aggregateType, aggregateKeyType), metadataOverride)));
        }
        public IAggregateProcessor Create(IMetadataElement metadata)
        {
            var aggregateType    = metadata.GetType().GenericTypeArguments[0];
            var aggregateKeyType = metadata.GetType().GenericTypeArguments[1];
            var processorType    = typeof(AggregateProcessor <,>).MakeGenericType(aggregateType, aggregateKeyType);

            var processor = _unityContainer.Resolve(
                processorType,
                ResolveDataChangesDetectorDependency(metadata),
                ResolveValueObjectProcessorsDepencency(metadata),
                ResolveAggregateFindSpecificationProvider(metadata));

            return((IAggregateProcessor)processor);
        }
Beispiel #7
0
        public IAggregateProcessor Create(IMetadataElement aggregateMetadata)
        {
            var aggregateType = aggregateMetadata.GetType().GenericTypeArguments[0];
            var processorType = typeof(AggregateProcessor <>).MakeGenericType(aggregateType);
            var processor     = _unityContainer.Resolve(processorType, new DependencyOverride(aggregateMetadata.GetType(), aggregateMetadata));

            return((IAggregateProcessor)processor);
        }
        public IFactProcessor Create(IMetadataElement factMetadata)
        {
            var factType      = factMetadata.GetType().GenericTypeArguments[0];
            var processorType = typeof(FactProcessor <>).MakeGenericType(factType);
            var processor     = _unityContainer.Resolve(processorType, new DependencyOverride(factMetadata.GetType(), factMetadata));

            return((IFactProcessor)processor);
        }
        public IStatisticsProcessor Create(IMetadataElement metadata)
        {
            var statisticsType = metadata.GetType().GenericTypeArguments[0];
            var processorType  = typeof(StatisticsProcessor <>).MakeGenericType(statisticsType);
            var processor      = _unityContainer.Resolve(processorType, new DependencyOverride(metadata.GetType(), metadata));

            return((IStatisticsProcessor)processor);
        }
Beispiel #10
0
        public IFactProcessor Create(IMetadataElement factMetadata)
        {
            var factType      = factMetadata.GetType().GenericTypeArguments[0];
            var processorType = typeof(FactProcessor <>).MakeGenericType(factType);
            var processor     = _unityContainer.Resolve(processorType,
                                                        ResolveDataChangesDetectorDependency(factMetadata),
                                                        ResolveDepencencyProcessorsDependency(factMetadata));

            return((IFactProcessor)processor);
        }
Beispiel #11
0
        IReadOnlyCollection <IBulkReplicator> IBulkReplicatorFactory.Create(IMetadataElement metadataElement)
        {
            var metadataElementType = metadataElement.GetType();

            Type factoryType;

            if (!RoutingDictionary.TryGetValue(metadataElementType.GetGenericTypeDefinition(), out factoryType))
            {
                throw new NotSupportedException($"Bulk replication is not supported for the mode described with {metadataElement}");
            }

            var objType = metadataElementType.GenericTypeArguments[0];
            var factory = (IBulkReplicatorFactory)Activator.CreateInstance(factoryType.MakeGenericType(objType), new LinqToDbQuery(_sourceDataConnection), _targetDataConnection);

            return(factory.Create(metadataElement));
        }