WPF Привязка данных XAML к переменным и свойствам

[ContentProperty("Text")]
public class OutlinedTextBlock : FrameworkElement
{
    public static readonly DependencyProperty FillProperty = DependencyProperty.Register(
        "Fill",
        typeof(Brush),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(Brushes.Black, FrameworkPropertyMetadataOptions.AffectsRender));
 
    public static readonly DependencyProperty StrokeProperty = DependencyProperty.Register(
        "Stroke",
        typeof(Brush),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(Brushes.Black, FrameworkPropertyMetadataOptions.AffectsRender));
 
    public static readonly DependencyProperty StrokeThicknessProperty = DependencyProperty.Register(
        "StrokeThickness",
        typeof(double),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(1d, FrameworkPropertyMetadataOptions.AffectsRender));
 
    public static readonly DependencyProperty FontFamilyProperty = TextElement.FontFamilyProperty.AddOwner(
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty FontSizeProperty = TextElement.FontSizeProperty.AddOwner(
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty FontStretchProperty = TextElement.FontStretchProperty.AddOwner(
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty FontStyleProperty = TextElement.FontStyleProperty.AddOwner(
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty FontWeightProperty = TextElement.FontWeightProperty.AddOwner(
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
        "Text",
        typeof(string),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextInvalidated));
 
    public static readonly DependencyProperty TextAlignmentProperty = DependencyProperty.Register(
        "TextAlignment",
        typeof(TextAlignment),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty TextDecorationsProperty = DependencyProperty.Register(
        "TextDecorations",
        typeof(TextDecorationCollection),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty TextTrimmingProperty = DependencyProperty.Register(
        "TextTrimming",
        typeof(TextTrimming),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(OnFormattedTextUpdated));
 
    public static readonly DependencyProperty TextWrappingProperty = DependencyProperty.Register(
        "TextWrapping",
        typeof(TextWrapping),
        typeof(OutlinedTextBlock),
        new FrameworkPropertyMetadata(TextWrapping.NoWrap, OnFormattedTextUpdated));
 
    private FormattedText formattedText;
    private Geometry textGeometry;
 
    public OutlinedTextBlock()
    {
        this.TextDecorations = new TextDecorationCollection();
    }
 
    public Brush Fill
    {
        get { return (Brush)GetValue(FillProperty); }
        set { SetValue(FillProperty, value); }
    }
 
    public FontFamily FontFamily
    {
        get { return (FontFamily)GetValue(FontFamilyProperty); }
        set { SetValue(FontFamilyProperty, value); }
    }
 
    [TypeConverter(typeof(FontSizeConverter))]
    public double FontSize
    {
        get { return (double)GetValue(FontSizeProperty); }
        set { SetValue(FontSizeProperty, value); }
    }
 
    public FontStretch FontStretch
    {
        get { return (FontStretch)GetValue(FontStretchProperty); }
        set { SetValue(FontStretchProperty, value); }
    }
 
    public FontStyle FontStyle
    {
        get { return (FontStyle)GetValue(FontStyleProperty); }
        set { SetValue(FontStyleProperty, value); }
    }
 
    public FontWeight FontWeight
    {
        get { return (FontWeight)GetValue(FontWeightProperty); }
        set { SetValue(FontWeightProperty, value); }
    }
 
    public Brush Stroke
    {
        get { return (Brush)GetValue(StrokeProperty); }
        set { SetValue(StrokeProperty, value); }
    }
 
    public double StrokeThickness
    {
        get { return (double)GetValue(StrokeThicknessProperty); }
        set { SetValue(StrokeThicknessProperty, value); }
    }
 
    public string Text
    {
        get { return (string)GetValue(TextProperty); }
        set { SetValue(TextProperty, value); }
    }
 
    public TextAlignment TextAlignment
    {
        get { return (TextAlignment)GetValue(TextAlignmentProperty); }
        set { SetValue(TextAlignmentProperty, value); }
    }
 
    public TextDecorationCollection TextDecorations
    {
        get { return (TextDecorationCollection)this.GetValue(TextDecorationsProperty); }
        set { this.SetValue(TextDecorationsProperty, value); }
    }
 
    public TextTrimming TextTrimming
    {
        get { return (TextTrimming)GetValue(TextTrimmingProperty); }
        set { SetValue(TextTrimmingProperty, value); }
    }
 
    public TextWrapping TextWrapping
    {
        get { return (TextWrapping)GetValue(TextWrappingProperty); }
        set { SetValue(TextWrappingProperty, value); }
    }
 
    protected override void OnRender(DrawingContext drawingContext)
    {
        this.EnsureGeometry();
 
        drawingContext.DrawGeometry(this.Fill, new Pen(this.Stroke, this.StrokeThickness), this.textGeometry);
    }
 
    protected override Size MeasureOverride(Size availableSize)
    {
        this.EnsureFormattedText();
 
        // constrain the formatted text according to the available size
        // the Math.Min call is important - without this constraint (which seems arbitrary, but is the maximum allowable text width), things blow up when availableSize is infinite in both directions
        // the Math.Max call is to ensure we don't hit zero, which will cause MaxTextHeight to throw
        this.formattedText.MaxTextWidth = Math.Min(3579139, availableSize.Width);
        this.formattedText.MaxTextHeight = Math.Max(0.0001d, availableSize.Height);
 
        // return the desired size
        return new Size(this.formattedText.Width, this.formattedText.Height);
    }
 
    protected override Size ArrangeOverride(Size finalSize)
    {
        this.EnsureFormattedText();
 
        // update the formatted text with the final size
        this.formattedText.MaxTextWidth = finalSize.Width;
        this.formattedText.MaxTextHeight = finalSize.Height;
 
        // need to re-generate the geometry now that the dimensions have changed
        this.textGeometry = null;
 
        return finalSize;
    }
 
    private static void OnFormattedTextInvalidated(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
    {
        var outlinedTextBlock = (OutlinedTextBlock)dependencyObject;
        outlinedTextBlock.formattedText = null;
        outlinedTextBlock.textGeometry = null;
 
        outlinedTextBlock.InvalidateMeasure();
        outlinedTextBlock.InvalidateVisual();
    }
 
    private static void OnFormattedTextUpdated(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
    {
        var outlinedTextBlock = (OutlinedTextBlock)dependencyObject;
        outlinedTextBlock.UpdateFormattedText();
        outlinedTextBlock.textGeometry = null;
 
        outlinedTextBlock.InvalidateMeasure();
        outlinedTextBlock.InvalidateVisual();
    }
 
    private void EnsureFormattedText()
    {
        if (this.formattedText != null || this.Text == null)
        {
            return;
        }
 
        this.formattedText = new FormattedText(
            this.Text,
            CultureInfo.CurrentUICulture,
            this.FlowDirection,
            new Typeface(this.FontFamily, this.FontStyle, this.FontWeight, FontStretches.Normal),
            this.FontSize,
            Brushes.Black, VisualTreeHelper.GetDpi(this).PixelsPerDip);
 
        this.UpdateFormattedText();
    }
 
    private void UpdateFormattedText()
    {
        if (this.formattedText == null)
        {
            return;
        }
 
        this.formattedText.MaxLineCount = this.TextWrapping == TextWrapping.NoWrap ? 1 : int.MaxValue;
        this.formattedText.TextAlignment = this.TextAlignment;
        this.formattedText.Trimming = this.TextTrimming;
 
        this.formattedText.SetFontSize(this.FontSize);
        this.formattedText.SetFontStyle(this.FontStyle);
        this.formattedText.SetFontWeight(this.FontWeight);
        this.formattedText.SetFontFamily(this.FontFamily);
        this.formattedText.SetFontStretch(this.FontStretch);
        this.formattedText.SetTextDecorations(this.TextDecorations);
    }
 
    private void EnsureGeometry()
    {
        if (this.textGeometry != null)
        {
            return;
        }
 
        this.EnsureFormattedText();
        this.textGeometry = this.formattedText.BuildGeometry(new Point(0, 0));
    }
}

public class Settings
{
  public Url Site { get; set; }
  public TimeSpan Interval { get; set; }
}

public class Settings : INotifyPropertyChanged
{
  private Url url;
  private TimeSpan interval;
 
  public Url Site { get => url; set => Set(ref url, value); }
  public TimeSpan Interval { get = > interval; set = > Set(ref interval, value); }
 
  public event PropertyChangedEventHandler? PropertyChanged;
 
  protected void Set<T>(ref T propertyField, in T newValue, [CallerMemberName] in string? propertyName = null)
  {
    propertyField = newValue;
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
  }
}

public class Settings : INotifyPropertyChanged
{
  private Url url;
  private TimeSpan interval;
 
  public Url Site { get => url; set => Set(ref url, value); }
  public TimeSpan Interval { get = > interval; set = > Set(ref interval, value); }
  // добавленная команда
  public ICommand Save { get; set; }
 
  public event PropertyChangedEventHandler? PropertyChanged;
 
  protected void Set<T>(ref T propertyField, in T newValue, [CallerMemberName] in string? propertyName = null)
  {
    propertyField = newValue;
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
  }
}

public class Settings : INotifyPropertyChanged
{
  private Url url;
  private TimeSpan interval;
 
  public Url Site { get => url; set => Set(ref url, value); }
  public TimeSpan Interval { get = > interval; set = > Set(ref interval, value); }
  public TimeSpan[] Intervals { get; } = [ TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(5) ];
  public ICommand Save { get; set; }
 
  public event PropertyChangedEventHandler? PropertyChanged;
 
  protected void Set<T>(ref T propertyField, in T newValue, [CallerMemberName] in string? propertyName = null)
  {
    propertyField = newValue;
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
  }
}

public class Settings
{
  public Url Site { get; set; }
  public TimeSpan Interval { get; set; }
}
 
public class SettingsViewModel : INotifyPropertyChanged
{
  private Settings settings {}
 
  public Url Site { get => settings.Url; set => Set(() => settings.Url = value); }
  public TimeSpan Interval { get = > interval; set = > Set(() => settings.Interval = value); }
  public TimeSpan[] Intervals { get; } = [ TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(5) ];
  public ICommand Save { get; set; }
 
  public event PropertyChangedEventHandler? PropertyChanged;
 
  protected void Set<T>(Action setter, [CallerMemberName] in string? propertyName = null)
  {
    setter();
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
  }
}

        protected override Size MeasureOverride(Size availableSize)
        {
            this.EnsureFormattedText();
 
            // constrain the formatted text according to the available size
            // the Math.Min call is important - without this constraint (which seems arbitrary, but is the maximum allowable text width), things blow up when availableSize is infinite in both directions
            // the Math.Max call is to ensure we don't hit zero, which will cause MaxTextHeight to throw
            if (this.formattedText is object)
            {
                this.formattedText.MaxTextWidth = Math.Min(3579139, availableSize.Width);
                this.formattedText.MaxTextHeight = Math.Max(0.0001d, availableSize.Height);
 
                // return the desired size
                return new Size(this.formattedText.Width, this.formattedText.Height);
            }
            return new Size(100, 100);
        }
 
        protected override Size ArrangeOverride(Size finalSize)
        {
            this.EnsureFormattedText();
 
            // update the formatted text with the final size
            if (this.formattedText is object)
            {
                this.formattedText.MaxTextWidth = finalSize.Width;
                this.formattedText.MaxTextHeight = finalSize.Height;
            }
            // need to re-generate the geometry now that the dimensions have changed
            this.textGeometry = null;
 
            return finalSize;
        }

        private void EnsureGeometry()
        {
            if (this.textGeometry != null)
            {
                return;
            }
 
            this.EnsureFormattedText();
            if (this.formattedText is object)
                this.textGeometry = this.formattedText.BuildGeometry(new Point(0, 0));
        }