public void TargetBaseType()
        {
            var registry = new RegistryTypeConverter();
            registry.Register<string, Enum>(LambdaTypeConverter.Create((x, convertTo) => Enum.Parse(convertTo, (string)x)));

            var result = registry.ConvertTo<TestEnum>(TypeConversionContext.None, "Value1");
            Assert.AreEqual(TestEnum.Value1, result);
        }
        public void SourceBaseType()
        {
            var registry = new RegistryTypeConverter();
            registry.Register<Enum, string>(LambdaTypeConverter.Create(x => x.ToString()));

            var result = registry.ConvertTo<string>(TypeConversionContext.None, TestEnum.Value1);
            Assert.AreEqual("Value1", result);
        }
        public void DirectConversion()
        {
            var registry = new RegistryTypeConverter();
            registry.Register(typeof(string), typeof(int), LambdaTypeConverter.Create(x => int.Parse((string)x)));

            var result = registry.ConvertTo<int>(TypeConversionContext.None, "5");
            Assert.AreEqual(5, result);
        }
        public void ArrayToBaseElementType()
        {
            var registry = new RegistryTypeConverter();
            registry.Register<Array, string[]>(LambdaTypeConverter.Create(value => ((Array)value).Cast<object>().Select(x => x.ToString()).ToArray()));

            var result = registry.ConvertTo<string[]>(TypeConversionContext.None, new[] { 2, 3 });
            Assert.AreEqual("2", result[0]);
            Assert.AreEqual("3", result[1]);
        }
        public void TargetBaseType()
        {
            var registry = new RegistryTypeConverter();

            registry.Register <string, Enum>(LambdaTypeConverter.Create((x, convertTo) => Enum.Parse(convertTo, (string)x)));

            var result = registry.ConvertTo <TestEnum>(TypeConversionContext.None, "Value1");

            Assert.AreEqual(TestEnum.Value1, result);
        }
        public void SourceBaseType()
        {
            var registry = new RegistryTypeConverter();

            registry.Register <Enum, string>(LambdaTypeConverter.Create(x => x.ToString()));

            var result = registry.ConvertTo <string>(TypeConversionContext.None, TestEnum.Value1);

            Assert.AreEqual("Value1", result);
        }
        public void DirectConversion()
        {
            var registry = new RegistryTypeConverter();

            registry.Register(typeof(string), typeof(int), LambdaTypeConverter.Create(x => int.Parse((string)x)));

            var result = registry.ConvertTo <int>(TypeConversionContext.None, "5");

            Assert.AreEqual(5, result);
        }
        public void ArrayToBaseElementType()
        {
            var registry = new RegistryTypeConverter();

            registry.Register <Array, string[]>(LambdaTypeConverter.Create(value => ((Array)value).Cast <object>().Select(x => x.ToString()).ToArray()));

            var result = registry.ConvertTo <string[]>(TypeConversionContext.None, new[] { 2, 3 });

            Assert.AreEqual("2", result[0]);
            Assert.AreEqual("3", result[1]);
        }
Пример #9
0
        public static DefaultTypeConverter Create()
        {
            var registry = new RegistryTypeConverter();
            var result = new DefaultTypeConverter(registry, new IdentityTypeConverter(), new ElementToArrayTypeConverter(), new SystemConvertTypeConverter());

            registry.Register<object, JToken>(LambdaTypeConverter.Create(x => x == null ? null : JToken.FromObject(x)));
            registry.Register<JToken, object>(LambdaTypeConverter.Create((x, type) => ((JToken)x).ToObject(type)));
            registry.Register<string, HttpBody>(LambdaTypeConverter.Create(x => new StringHttpBody((string)x)));
            registry.Register<byte[], HttpBody>(LambdaTypeConverter.Create(x => new ByteArrayHttpBody((byte[])x)));
            registry.Register<Stream, HttpBody>(LambdaTypeConverter.Create(x => new StreamHttpBody((Stream)x)));
            registry.Register<Array, Array>(new ArrayTypeConverter());

            return result;
        }