public bool TryGetPropertyInitializer <TProperty>(string propertyName, out IPropertyInitializer <TMessage, TInput> initializer)
        {
            var inputPropertyInfo = typeof(TInput).GetProperty(propertyName);

            if (inputPropertyInfo != null)
            {
                var propertyType      = typeof(TProperty);
                var inputPropertyType = inputPropertyInfo.PropertyType;

                // exactly the same type, we just copy it over unmodified
                if (inputPropertyType == propertyType)
                {
                    initializer = new CopyPropertyInitializer <TMessage, TInput, TProperty>(propertyName);
                    return(true);
                }

                // can only copy to object, no idea what the destination type would/could be
                if (propertyType == typeof(object))
                {
                    var type = typeof(CopyObjectPropertyInitializer <, ,>).MakeGenericType(typeof(TMessage), typeof(TInput), inputPropertyType);
                    initializer = (IPropertyInitializer <TMessage, TInput>)Activator.CreateInstance(type, propertyName, propertyName);
                    return(true);
                }

                if (PropertyInitializerCache.TryGetFactory <TProperty>(inputPropertyType, out var propertyConverter))
                {
                    initializer = propertyConverter.CreatePropertyInitializer <TMessage, TInput>(propertyName);
                    return(true);
                }
            }

            initializer = null;
            return(false);
        }
        public bool TryGetHeaderInitializer <TProperty>(string propertyName, out IHeaderInitializer <TMessage, TInput> initializer)
        {
            // headers use a double underscore prefix

            string inputPropertyName = new StringBuilder(propertyName.Length + 2).Append("__").Append(propertyName).ToString();

            var inputPropertyInfo = typeof(TInput).GetProperty(inputPropertyName);

            if (inputPropertyInfo != null)
            {
                var propertyType      = typeof(TProperty);
                var inputPropertyType = inputPropertyInfo.PropertyType;

                // exactly the same type, we just copy it over unmodified
                if (inputPropertyType == propertyType)
                {
                    initializer = new CopyHeaderInitializer <TMessage, TInput, TProperty>(propertyName, inputPropertyName);
                    return(true);
                }

                if (PropertyInitializerCache.TryGetFactory <TProperty>(inputPropertyType, out var propertyConverter))
                {
                    initializer = propertyConverter.CreateHeaderInitializer <TMessage, TInput>(propertyName, inputPropertyName);
                    return(true);
                }
            }

            initializer = default;
            return(false);
        }
Beispiel #3
0
        public void Nullable_to_non_nullable()
        {
            Assert.That(PropertyInitializerCache.TryGetFactory <int>(typeof(int?), out var converter), Is.True);
            Assert.That(converter.IsPropertyTypeConverter <int?>(out var typeConverter), Is.True);
            Assert.That(typeConverter, Is.TypeOf <FromNullableTypeConverter <int> >());

            Assert.That(typeConverter.TryConvert(37, out int result), Is.True);
            Assert.That(result, Is.EqualTo(37));
        }
Beispiel #4
0
        public void Non_nullable_to_nullable_wider_type()
        {
            Assert.That(PropertyInitializerCache.TryGetFactory <long?>(typeof(int), out var converter), Is.True);
            Assert.That(converter.IsPropertyTypeConverter <int>(out var typeConverter), Is.True);
            Assert.That(typeConverter, Is.TypeOf <ToNullableTypeConverter <long, int> >());

            Assert.That(typeConverter.TryConvert(37, out long?result), Is.True);
            Assert.That(result.Value, Is.EqualTo(37));
        }
Beispiel #5
0
        public async Task Task_nullable_to_non_nullable()
        {
            Assert.That(PropertyInitializerCache.TryGetFactory <int>(typeof(Task <int?>), out var converter), Is.True);
            Assert.That(converter.IsMessagePropertyConverter <Task <int?> >(out var typeConverter), Is.True);
            Assert.That(typeConverter, Is.TypeOf <AsyncConvertPropertyConverter <int, int?> >());

            var context = MessageFactoryCache <SimpleRequest> .Factory.Create(new BaseInitializeContext(CancellationToken.None));

            var result = await typeConverter.Convert(context, Task.FromResult((int?)37));

            Assert.That(result, Is.EqualTo(37));
        }
Beispiel #6
0
 public void Non_nullable_to_wider_type()
 {
     Assert.That(PropertyInitializerCache.TryGetFactory <long>(typeof(int), out var converter), Is.True);
     Assert.That(converter.IsPropertyTypeConverter <int>(out var typeConverter), Is.True);
     Assert.That(typeConverter, Is.TypeOf <LongTypeConverter>());
 }
Beispiel #7
0
 public void No_converter_for_same_type()
 {
     Assert.That(PropertyInitializerCache.TryGetFactory <int>(typeof(int), out var converter), Is.False);
 }