How to bind multiple properties in a UserControl

Let's say we have a UserControl:

<UserControl x:Class="...>
    <StackPanel>
        <TextBlock Name="TextBlock1" />
        <TextBlock Name="TextBlock2" />
        <TextBlock Name="TextBlock3" />
        ...
        <TextBlock Name="TextBlock10" />
    </StackPanel>
</UserControl>

      

        
        
        
      

    

And we have properties defined like this:

public string Text1 { get; set; }
public string Text2 { get; set; }
public string Text3 { get; set; }
...
public string Text10 { get; set; }

      

        
        
        
      

    

And I know that I want to bind all these TextBlocks to all of these properties. Obviously there are several ways to do this, and I am wondering about the (dis-) benefits of different ones. Let's make a list:

• My first approach:

  <TextBlock Name="TextBlock1" Text="{Binding Path=Text1, RelativeSource={RelativeSource AncestorType=UserControl}}" />
  
        
  
          
          
          
        
  
      

  It works and is quite simple, but a lot of redundant code if I need to type it for all text blocks. In this example, we could just copy-paste, but the UserControl might be more complex.

• When I was looking for the problem I found this solution:

  <UserControl ...
      DataContext="{Binding RelativeSource={RelativeSource Self}}">
      <TextBlock Name="TextBlock1" Text="{Binding Path=Text1}" />
  
        
  
          
          
          
        
  
      

  This looks pretty clean in xaml, however the DataContext can be used differently. So if someone uses this UserControl and changes the DataContext, we are screwed.

• Another common solution seems to be the following:

  <UserControl ...
      x:Name="MyUserControl">
      <TextBlock Name="TextBlock1" Text="{Binding Path=Text1, ElementName=MyUserControl}" />
  
        
  
          
          
          
        
  
      

  This has the same problem as 2. although the name can be set from somewhere else.

• What if we write our own MarkupExtension?

  public class UserControlBindingExtension : MarkupExtension
  {
      public UserControlBindingExtension() { }
  
      public UserControlBindingExtension(string path)
      {
          this.Path = path;
      }
  
      private Binding binding = null;
  
      private string path;
  
      [ConstructorArgument("path")] 
      public string Path
      {
          get
          {
              return path;
          }
          set
          {
              this.path = value;
              binding = new Binding(this.path);
              binding.RelativeSource = new RelativeSource(RelativeSourceMode.FindAncestor, typeof(UserControl), 1);
          }
      }
  
      public override object ProvideValue(IServiceProvider serviceProvider)
      {
          if(binding == null)
              return null;
  
          return binding.ProvideValue(serviceProvider);
      }
  }
  
        
  
          
          
          
        
  
      

  Now we can do something like this:

  <UserControl ...
      xmlns:self="clr-namespace:MyProject">
      <TextBlock Name="TextBlock1" Text="{self:UserControlBinding Path=Text1}"
  
        
  
          
          
          
        
  
      

  Well appointed! But I'm not sure if my implementation is bulletproof and I'd rather not write my own MarkupExtension.

• Likewise 4. we could do this:

  public class UserControlBindingHelper : MarkupExtension
  {
      public UserControlBindingHelper() { }
  
      public UserControlBindingHelper(Binding binding)
      {
          this.Binding = binding;
      }
  
      private Binding binding;
      [ConstructorArgument("binding")]
      public Binding Binding
      {
          get
          {
              return binding;
          }
          set
          {
              binding = value;
              binding.RelativeSource = new RelativeSource(RelativeSourceMode.FindAncestor, typeof(UserControl), 1);
          }
      }
  
      public override object ProvideValue(IServiceProvider serviceProvider)
      {
          if (binding == null)
              return null;
  
          return binding.ProvideValue(serviceProvider);
      }
  }
  
        
  
          
          
          
        
  
      

  This will lead to the following code:

  <TextBlock Name="TextBlock1" Text="{self:UserControlBindingHelper {Binding Text1}}" />
  
        
  
          
          
          
        
  
      

• We could do it in code!

  private void setBindingToUserControl(FrameworkElement element, DependencyProperty dp, string path)
  {
      Binding binding = new Binding(path);
      binding.RelativeSource = new RelativeSource(RelativeSourceMode.FindAncestor, typeof(StateBar), 1);
      element.SetBinding(dp, binding);
  }
  
        
  
          
          
          
        
  
      

  And then we do this:

  setBindingToUserControl(this.TextBlock1, TextBlock.Text, "Text1");
  
        
  
          
          
          
        
  
      

  Pretty nice, but it makes the xaml easier to read as there is no bind information now.

• What other good / interesting options are there?

So what is the way to go in this situation? Am I wrong somewhere?
To ask the question:
Are all of these methods correct? Are some superior to others?