Utilizing the Attached Dependency Property in WPF using C#

Within WPF (Windows Presentation Foundation) using C#, attached dependency properties serve as a robust concept enabling the attachment of custom properties to current WPF controls or elements.

Within WPF (Windows Presentation Foundation) using C#, attached dependency properties serve as a robust concept enabling the attachment of custom properties to current WPF controls or elements. These properties offer the ability to enhance the functionality or behavior of these controls without the need for subclassing, below outline of the process of creating and utilizing an attached dependency property.

Advantages of attached dependency property in WPF

1. Flexibility: Attached dependency properties in WPF using C# enhance the flexibility of WPF applications by enabling the extension of existing controls without the need for subclassing. This facilitates the addition of custom properties and behaviors to controls while maintaining modularity and promoting code reuse.
2. Scalability: Custom properties can be attached to any `DependencyObject`, not limited to controls, allowing for the customization of layout panels, shapes, and other UI elements. This scalability ensures that custom properties can be added to various elements within the application.
3. Declarative Customization: Attached properties can be easily manipulated in XAML, offering a declarative approach to customizing UI elements. This simplifies collaboration between designers and developers, as designers can set properties in XAML while developers implement corresponding behavior in C#.
4. Simplified Management: Encapsulating related functionality into a single unit through attached properties streamlines the management of complex UI behaviors. This organizational approach aids in maintaining an organized codebase and reduces the risk of code duplication.
5. Enhanced Features: Leveraging the dependency property system of WPF, attached dependency properties support advanced features like data binding, styles, templates, animations, and property value inheritance. These features empower the creation of dynamic and interactive user interfaces.
6. Architectural Clarity: By separating property definitions from control implementations, attached properties promote a clear separation of concerns. This separation enhances the architectural design of the application, making it more comprehensible and easier to maintain.
7. Runtime Flexibility: The dynamic nature of attached properties, being dependency properties, allows for real-time changes to their values. This dynamic behavior enables developers to adjust properties during runtime, enhancing the application's adaptability and responsiveness.

Implementation of the attached dependency property

Please adhere to the guidelines provided below in order to carry out the complete procedure.

Step 1. Xaml View

<Window x:Class="AttachedDependencyExample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:AttachedDependencyExample"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <TextBox Padding="2,10,0,0" HorizontalContentAlignment="Left" x:Name="TxtbxWatermark" local:AttachedTextBoxProperty.WatermarkText="Enter text here...." Height="40" Margin="20"/>
        <Button Content="Get TextBox Value" Height="30" Margin="20,100,20,0" Click="Button_Click"/>
    </Grid>
</Window>

Code Behind implementation

using System.Windows;

namespace AttachedDependencyExample
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            // Access the attached property value programmatically
            string propertyValue = AttachedTextBoxProperty.GetWatermarkText(TxtbxWatermark);
            MessageBox.Show(propertyValue);
        }
    }
}

Step 2. Create a custom class for an attached property

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows;

namespace AttachedDependencyExample
{
    public static class AttachedTextBoxProperty
    {
        public static readonly DependencyProperty WatermarkTextProperty =
            DependencyProperty.RegisterAttached(
                "WatermarkText",
                typeof(string),
                typeof(AttachedTextBoxProperty),
                new FrameworkPropertyMetadata(string.Empty, OnWatermarkTextChanged));

        public static string GetWatermarkText(DependencyObject obj)
        {
            if (obj is TextBox textBox)
            {
                return textBox.Text;
            }
            return null;
        }

        public static void SetWatermarkText(DependencyObject obj, string value)
        {
            obj.SetValue(WatermarkTextProperty, value);
        }

        private static void OnWatermarkTextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            TextBox textBox = d as TextBox;
            if (textBox == null) return;

            string watermarkText = e.NewValue as string;
            if (!string.IsNullOrEmpty(watermarkText))
            {
                textBox.GotFocus += (sender, args) =>
                {
                    if (textBox.Text == watermarkText)
                    {
                        textBox.Text = string.Empty;
                    }
                };

                textBox.LostFocus += (sender, args) =>
                {
                    if (string.IsNullOrEmpty(textBox.Text))
                    {
                        textBox.Text = watermarkText;
                    }
                };

                textBox.TextChanged += (sender, args) =>
                {
                    string newText = textBox.Text;
                    Console.WriteLine("New text entered: " + newText);
                };

                textBox.Text = watermarkText;
            }
        }
    }
}

Step 3. Final Result View