DelegatingConversionStep ApplyConverter(MappingStep mapping, bool withFallback) { dynamic instance = null; try { instance = conversionPatternRepository.LeaseConversionPatternFor(mapping.SourceValueType, mapping.TargetValueType); if (ReferenceEquals((object)instance, null) == false) { var expression = instance.BuildConversionExpression(mapping) as LambdaExpression; if (expression != null) { return(new DelegatingConversionStep(expression)); } } } finally { conversionPatternRepository.Recycle((object)instance); } if (withFallback == false || mapping.TargetValueType.IsAssignableFrom(mapping.SourceValueType)) { return(null); } // fallabck behavior instance = Activator.CreateInstance(typeof(MapConversionPattern <>).MakeGenericType(mapping.TargetValueType)); return(new DelegatingConversionStep(instance.BuildConversionExpression(mapping) as LambdaExpression)); }
public static IServiceCollection AddBookingPipelines(this IServiceCollection services) { var sp = services.BuildServiceProvider(); // Create each step of the pipeline var mapping = new MappingStep(sp.GetRequiredService <ILogger <MappingStep> >()); var getRequest = new GetRequestStep(sp.GetRequiredService <ILogger <GetRequestStep> >()); var getResponse = new GetResponseStep(sp.GetRequiredService <ILogger <GetResponseStep> >()); var aggregate = new AggregateStep(sp.GetRequiredService <ILogger <AggregateStep> >()); var dedupe = new DedupeStep(sp.GetRequiredService <ILogger <DedupeStep> >()); // Build the pipeline using the steps, in the desired order var searchPipeline = new Pipeline <HubRequest, HubResponse>(hubRq => hubRq .AddStep(mapping) // Sub-pipeline with three steps, two of them also use the input from parent .AddStep(new Pipeline <ConnectorRequest, ConnectorResponse>(connRq => connRq .AddStep(getRequest, hubRq) .AddStep(getResponse, hubRq) .AddStep(aggregate)) ) .AddStep(dedupe)); // Inject this pipeline to the service provider (it is used in the controller) return(services.AddSingleton <IPipelineStep <HubRequest, HubResponse> >(searchPipeline)); }
public void WillNotReplaceValuesNotMapped() { var input = "this will not be replaced"; var step = new MappingStep(MappingTable.Create(Tables.B_1)); var output = step.Run(input); Assert.Equal(input, output); }
public void WillNotReplaceValuesNotMapped() { const string input = "this will not be replaced"; var step = new MappingStep(MappingTable.Create(Mapping.B1)); var output = step.Run(input); output.ShouldBe(input); }
public void WillReplaceValuesMappedToNothing() { var input = "this value: " + Convert.ToChar(0x180B) + " will be replaced"; var expected = "this value: will be replaced"; var step = new MappingStep(MappingTable.Create(Tables.B_1)); var output = step.Run(input); Assert.Equal(expected, output); }
public void WillReplaceValuesWithMultipleReplacements() { var input = "this value: " + Convert.ToChar(0x00DF) + " will be replaced"; var expected = "this value: " + Convert.ToChar(0x0073) + Convert.ToChar(0x0073) + " will be replaced"; var step = new MappingStep(MappingTable.Create(Tables.B_2)); var output = step.Run(input); Assert.Equal(expected, output); }
public void WillReplaceValues() { var input = $"this value: {Convert.ToChar(0x0041)} will be replaced"; var expected = $"this value: {Convert.ToChar(0x0061)} will be replaced"; var step = new MappingStep(MappingTable.Create(Mapping.B2)); var output = step.Run(input); output.ShouldBe(expected); }
public void WillReplaceWithMultipleCharacters() { var input = $"this value: {Convert.ToChar(0x00DF)} will be replaced"; var expected = $"this value: {Convert.ToChar(0x0073)}{Convert.ToChar(0x0073)} will be replaced"; var step = new MappingStep(MappingTable.Create(Mapping.B2)); var output = step.Run(input); output.ShouldBe(expected); }
public void WillReplaceValuesMappedToNothing() { var input = $"this value: {Convert.ToChar(0x180B)} will be replaced"; const string expected = "this value: will be replaced"; var step = new MappingStep(MappingTable.Create(Mapping.B1)); var output = step.Run(input); output.ShouldBe(expected); }
public Expression <Func <T?, IMapper, MappingContext, T> > BuildConversionExpression(MappingStep mapping) { return((d, m, c) => d.GetValueOrDefault()); }
public Expression <Func <DateTime, IMapper, MappingContext, DateTime> > BuildConversionExpression(MappingStep mapping) { return((s, m, c) => TimeZoneInfo.ConvertTime(s, c.Argument <TimeZoneInfo>()).Date); }
public Expression <Func <IHasId, IMapper, MappingContext, Identifier> > BuildConversionExpression(MappingStep mapping) { return((s, m, c) => new Identifier(s.ItemId, s.LastModified)); }
public Expression <Func <T1?, IMapper, MappingContext, T2?> > BuildConversionExpression(MappingStep mapping) { return((d, m, c) => d.HasValue ? m.Convert <T2>(d.Value) : default(T2)); }
public Expression <Func <T, IMapper, MappingContext, T?> > BuildConversionExpression(MappingStep mapping) { if (mapping.SourceValueType == typeof(T?)) { return(null); } return((d, m, c) => d); //implicit conversion }
public Expression <Func <T, IMapper, MappingContext, T> > BuildConversionExpression(MappingStep mapping) { return((d, m, c) => d); }
public Expression <Func <decimal, IMapper, MappingContext, decimal> > BuildConversionExpression(MappingStep mapping) { return((d, m, c) => Decimal.Round(d, 2)); }
static Expression BuildParameterExpression(MappingStep step, MappingStrategy strategy) { var map = step.Apply(strategy, step.Conversion); return(map); }
public Expression <Func <IEnumerable, IMapper, MappingContext, TTargetItem[]> > BuildConversionExpression(MappingStep mapping) { return((source, mapper, context) => CollectionConversionHelper.MapCollection <TTargetItem>(source, context)); }
public Expression <Func <object, IMapper, MappingContext, TTo> > BuildConversionExpression(MappingStep mapping) { if (mapping.SourceValueType.Is(mapping.TargetValueType)) { // no conversion needed return(null); } return((source, mapper, context) => mapper.Convert <TTo>(source)); }
public void AddMappingStep(MappingStep mappingStep) { mappingSteps.Add(mappingStep); }
public Expression <Func <TSource, IMapper, MappingContext, TTarget> > BuildConversionExpression(MappingStep mapping) { return((d, m, c) => (TTarget)Convert.ChangeType(d, typeof(TTarget))); }
public Expression <Func <T, IMapper, MappingContext, string> > BuildConversionExpression(MappingStep mapping) { return((d, m, c) => d.ToString()); }