Microsoft.Extensions.Configuration.ConfigurationBinder should support byte[]

[AceHack]

Description

byte[] is not supported with the current strongly typed Microsoft.Extensions.Configuration. Please support byte[].

Other information

It seems pretty simple and just supporting base64 format would be fine. This would work with all configuration providers such as in-memory, json, XML, ini, environment, command line, etc...

Thanks.

Tagging subscribers to this area: @safern
Notify danmosemsft if you want to be subscribed.

[ericstj]

So today the ConfigurationBinder relies on TypeConverter infrastructure to convert to target types. There is no built in typecoverter that does what you want, but you can register one.

See the following example:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using Microsoft.Extensions.Configuration;

namespace binder
{
    class Program
    {
        static void Main()
        {
            TypeDescriptor.AddAttributes(typeof(byte[]), new TypeConverterAttribute(typeof(Base64ByteArrayConverter)));

            var configuration = new ConfigurationBuilder()
                .AddInMemoryCollection(new Dictionary<string, string>()
                {
                    ["Bytes"] = "SGVsbG8="
                })
                .Build();

            var data = configuration.Get<Data>();
            Console.WriteLine(data.Bytes?.Length);
        }

        public class Data
        {
            public byte[] Bytes { get; set; }
        }

        public class Base64ByteArrayConverter : TypeConverter
        {
            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
            {
                if (sourceType == typeof(string))
                {
                    return true;
                }
                return base.CanConvertFrom(context, sourceType);
            }

            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
            {
                if (value is string base64)
                {
                    return Convert.FromBase64String(base64);
                }
                return base.ConvertFrom(context, culture, value);
            }

            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
            {
                if (destinationType == typeof(byte[]))
                {
                    return true;
                }
                return base.CanConvertTo(context, destinationType);
            }

            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
            {
                if (value is byte[] bytes)
                {
                    return Convert.ToBase64String(bytes);
                }
                return base.ConvertTo(context, culture, value, destinationType);
            }
        }
    }
}

/cc @maryamariyan @safern

[maryamariyan]

Fixed by PR #43150