Customize a zone management

I have an idea, which comes from the Prism framework
In Prism framework, we often use it

  <Grid ="Left">
      <ContentControl  prism:="{x:Static region:}" />

 public class RegionNames
    {
        public static readonly string HeaderRegion = nameof(HeaderRegion);
        public static readonly string AsideRegion = nameof(AsideRegion);
        public static readonly string ContentRegion = nameof(ContentRegion);
        public static readonly string FooterRegion = nameof(FooterRegion);
        public static readonly string SettingsRegion = nameof(SettingsRegion);
        public static readonly string SettingsTabRegion = nameof(SettingsTabRegion);

    }

Because Prism has (, typeof(AsideView)); which can fill data into the interface, and its area management is very excellent, I have to write it as if I don't use the Prism framework.

<DataTemplate DataType="{x:Type viewModel:UniformGridViewModel}">
    <view:UniformGridView />
</DataTemplate> 
<ContentControl ="0" Content="{StaticResource UniformGridView}" />

Whether it is directly binding View or binding ViewModel to the ContentControl, it is not as easy as Prism. I suddenly had a whim. I used static binding in WPF native ContentControl. Since Content can bind object, I wrote it newly

<ContentControl ="4" Content="{x:Static region:}" />

 public class RegionNames
 {
     public const string Header = nameof(Header);
 }

It can be successfully bound, and then I found that someone transformed Grid on the Internet and it used it

[TypeConverter(typeof(GridLengthCollectionConverter))]
  public class GridLengthCollection : ReadOnlyCollection<GridLength>
  {
      public GridLengthCollection(IList<GridLength> list) : base(list)
      {
      }
  } and public class GridLengthCollectionConverter : TypeConverter
  {
      public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
      {
          if (sourceType == typeof(string))
              return true;
          return (context, sourceType);
      }

      public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
      {
          if (destinationType == typeof(string))
              return true;
          return (context, destinationType);
      }

      public override object ConvertFrom(ITypeDescriptorContext context, culture, object value)
      {
          string s = value as string;
          if (s != null)
              return ParseString(s, culture);
          return (context, culture, value);
      }

      public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
      {
          if (destinationType == typeof(string) && value is GridLengthCollection)
              return ToString((GridLengthCollection)value, culture);
          return (context, culture, value, destinationType);
      }

      private string ToString(GridLengthCollection value, CultureInfo culture)
      {
          var converter = new GridLengthConverter();
          return (",", (v => (v)));
      }

      private GridLengthCollection ParseString(string s, CultureInfo culture)
      {
          var converter = new GridLengthConverter();
          var lengths = (',').Select(p => (GridLength)(()));
          return new GridLengthCollection(());
      }
  }

I'm going to try the power of TypeConverter conversion. So I mentioned above that I combined Prism's idea, and I bind a static property to the Content of the ContentControl of the native WPF. Can I use TypeConverter to achieve the same way as the Prism framework, which is not a string but an interface, I started to encapsulate it.

public class RegionConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return sourceType == typeof(string);
    }

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        if (value is string regionName)
        {
            switch (regionName)
            {
                case :
                    return new HeaderView();
                case :
                    return new AsideView();
                case :
                    return new ContentView();
                default:
                    throw new ArgumentException($"Unknown region: {regionName}");
            }
        }
        throw new NotSupportedException();
    }
}

<>
         <!-- Register TypeConverter -->
         <local:RegionConverter x:Key="RegionConverter" />
     </>
     <Grid>
         <!-- Bind the region name and convert it to View using TypeConverter -->
         <ContentControl Content="{Binding Source={x:Static local:}, Converter={StaticResource RegionConverter}}" />
     </Grid>

However, the compilation fails and the operation fails.

I forced the program to report an error InvalidCastException: Unable to cast object of type 'Customize a region management.RegionConverter' to type ''.

While thinking about conversion, I thought that WPF's IValueConverter can also be converted, so I continue to try

public class RegionConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is string regionName)
        {
            switch (regionName)
            {
                case :
                    return new HeaderView();
                case :
                    return new AsideView();
                case :
                    return new ContentView();
                default:
                    throw new ArgumentException($"Unknown region: {regionName}");
            }
        }
        throw new NotSupportedException();
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotSupportedException();
    }
}

This problem is perfectly solved. In the future, there is no need to directly bind the View or ViewModel, and convert it through strings. You only need to bind the string in XAML.

<ContentControl Content="{Binding Source={x:Static region:}, Converter={StaticResource RegionConverter}}" />