如何在WPF UserControl中参数化绑定？

Question

I have a wpf Window ( MyWindow ) with its DataContext set to the MyViewModel view model class:

MyWindow.xaml

<Window x:Class="MyProject.MyWindow"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      mc:Ignorable="d">

      <MyUserControl Text="{Binding MyText, Mode=TwoWay}" />
</Window>

MyWindow.xaml.cs

public class MyWindow : Window
{
    MyWindow()
    {
       InitializeComponent();
       DataContext = new MyViewModel();
    }
}

MyViewModel.cs

// MyViewModel implements IPropertyChanged
public class MyViewModel : INotifyPropertyChanged
{
    public string MyText { get { ... } set { ... } }

    ...
}

I would like to pass the binding of the MyText property from MyWindow to the following UserControl ( MyUserControl ):

MyUserControl.xaml

<UserControl x:Class="MyProject.MyUserControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d">
    <StackPanel>
        <TextBox
            Name="MainTextBox"
            Text="{Binding Text, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True, NotifyOnValidationError=True}"  
        />
    </StackPanel>
</UserControl>

MyUserControl.xaml.cs

public partial class MyUserControl : UserControl
    {
        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
            "Text",
            typeof(string),
            typeof(MyUserControl),
            new UIPropertyMetadata(TextPropertyChangedHandler)
        );

        public static void TextPropertyChangedHandler(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var MyUserControl = sender as MyUserControl;

            MyUserControl.Text = (string)e.NewValue;
        }

        public string Text
        {
            get
            {
                return (string)GetValue(TextProperty);
            }
            set
            {
                SetValue(TextProperty, value);
            }
        }


        public MyUserControl()
        {
            InitializeComponent();
        }
    }

I would like to get the content typed in the Textbox under MyUserControl into MyViewModel.MyText . How can this be achieved?

I tried to bind MyText to the Text property in MyUserControl and then subsequently binding Text in TextBox to Text from MyUserControl but this does not work.

Answer 1

get rid of TextPropertyChangedHandler .

DP needs only BindsTwoWayByDefault flag, without callback

public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
    "Text",
    typeof(string),
    typeof(MyUserControl),
    new FrameworkPropertyMetadata(null,
        FrameworkPropertyMetadataOptions.BindsTwoWayByDefault)
);

TextBox.Text should bind to MyUserControl.Text

<UserControl x:Class="MyProject.MyUserControl" x:Name="self"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d">
    <StackPanel>
        <TextBox Text="{Binding Text, Mode=TwoWay, ElementName=self}"  />
    </StackPanel>
</UserControl>

validation properties should go to binding in Window:

<MyUserControl Text="{Binding MyText, Mode=TwoWay, ValidatesOnDataErrors=True, NotifyOnValidationError=True}" />

Answer 2

I finally managed to bind to the property in the view model from the UserControl programatically.

The MyUserControl is used as follows:

<UserControls:MyUserControl TargetPropertyName="TestId"/>

I just pass the name of the property of the View Model that I wish to bind to inside the user control.

Then inside the user control I make sure to programatically bind the property by name on the MainTextBox (here in the BindTextPropertyToTargetPropertyNameOnce ):

public partial class MyUserControl : UserControl
    {
        public static readonly DependencyProperty TargetPropertyNameProperty = DependencyProperty.Register(
            "TargetPropertyName",
            typeof(string),
            typeof(MyUserControl),
            new UIPropertyMetadata(TargetPropertyNamePropertyChangedHandler)
        );

        public static void TargetPropertyNamePropertyChangedHandler(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var MyUserControl = sender as MyUserControl;

            MyUserControl.TargetPropertyName = (string)e.NewValue;
        }

        public string TargetPropertyName
        {
            get
            {
                return (string)GetValue(TargetPropertyNameProperty);
            }
            set
            {
                SetValue(TargetPropertyNameProperty, value);
                BindTextPropertyToTargetPropertyNameOnce()
            }
        }

        public MyUserControl()
        {
            InitializeComponent();
        }

        private bool _firstRun = true;

        private void BindTextPropertyToTargetPropertyNameOnce()
        {
            if (_firstRun)
            {
                _firstRun = false;
                var binding = new Binding(TargetPropertyName)
                {
                    Mode = BindingMode.TwoWay,
                    UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged,
                    ValidatesOnDataErrors = true,
                    NotifyOnValidationError = true
                };

                MainTextBox.SetBinding(TextBox.TextProperty, binding);
            }
        }
    }

But still I consider this to be a workaround, there must be a better solution.