How to Interact with UIElement in WPF Using Behavior

Utilizing Behaviors in WPF Applications

In WPF (Windows Presentation Foundation) using C#, behavior pertains to the functionality or actions associated with user interaction or events in a graphical user interface (GUI). In WPF, behaviors enable you to encapsulate and reuse specific actions or functionalities across various UI elements without the need to directly subclass or modify those elements.

Behaviors are commonly used

Attach Event Handlers: You'll be able to utilize behaviors to connect occasion handlers to UI components. For this case, you might make a behavior that handles the Press occasion of a Button.
Actualize Interactivity: Behaviors empower you to include intuitive highlights to UI components. This might incorporate drag-and-drop usefulness, resizing, or movements activated by client activities.
Encapsulate Functionality: Behaviors typify particular usefulness or activities, advancing seclusion and reusability in your application. This will lead to cleaner and more viable code.

Behaviors in WPF offer a few benefits, counting

Partition of Concerns: Behaviors permit you to typify and partition the rationale related to client intuitive or visual impacts from the UI controls themselves. This advances cleaner and more viable code by keeping the UI rationale isolated from the see.
Reusability: Behaviors can be connected to different UI components, advancing code reuse over distinctive parts of your application. Once characterized, a behavior can be effortlessly connected to any consistent control, diminishing the requirement for copy code.
Extensibility: Behaviors can be customized and expanded to suit particular prerequisites. You'll be able to make custom behaviors custom-fitted to your application's needs, upgrading the usefulness of UI components without adjusting their fundamental structure.
Simpler Testing: Behaviors encourage unit testing by confining UI-related rationale into isolated components. This permits you to test behavior usefulness freely of the UI controls, driving to more vigorous and testable code.
Blendability: Behaviors are completely consistent with design tools like Microsoft Mix. You'll be able to use Blend to outwardly plan and connect with behaviors, making it simpler to make wealthy client encounters without composing broad code.
Consistency: Behaviors empower the steady application of interaction designs and visual impacts over your UI components. By characterizing behaviors for common scenarios (such as approval, drag-and-drop, or movement), you guarantee reliable client involvement all through your application.
Decoupling: Behaviors help decouple UI rationale from trade rationale, advancing way better partition of concerns. This partition makes it less demanding to preserve and advance your application over time, as changes to one angle of the UI are less likely to affect other parts of the application.

By and large, behaviors are a capable device in WPF advancement that can upgrade code viability, reusability, and testability, while moreover advancing a reliable and natural client involvement.

Implementation of UIElement in WPF

Step 1. Install the NuGet package Microsoft.Xaml.Behaviors in your project as shown below.

Microsoft

Step 2. Incorporate this interactive feature to enhance the connection between user actions and the window form. This feature can be integrated with any UIElement in WPF, as well as with "UserControl" or "Window" forms, providing users with control over the entire visual tree components if desired.

Window

Step 3. In the following example, I am associating behavior with the Window frame at the root level.

Interaction

Step 4. To connect a behavior class to a WPF window, you must create a behavior class that inherits from Behavior<Window> and customize its methods as required. Below is an example illustrating how to create a basic behavior class and link it to a WPF window form.

using Microsoft.Xaml.Behaviors;
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;

namespace WpfApp3.Behaviors
{
    public class WpfBehavior : Behavior<Window>
    {
        protected override void OnAttached()
        {
            base.OnAttached();
            AssociatedObject.Loaded += AssociatedObject_Loaded;
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();
            AssociatedObject.Loaded -= AssociatedObject_Loaded;
        }

        private void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
        {
            var textBoxName = AssociatedObject.FindName("TxtBoxName") as TextBox;
            if (textBoxName != null)
            {
                textBoxName.TextChanged += TextBoxName_TextChanged;
            }
        }

        private void TextBoxName_TextChanged(object sender, TextChangedEventArgs e)
        {
            if (sender != null)
            {
                Console.WriteLine("TextBox Value: " + ((TextBox)sender).Text);
            }
        }
    }
}

Step 5. Attaching behavior empowers users with complete control over the elements to which the behavior is linked. Seek to grasp the fundamental advantage of utilizing behavior. Consider a scenario where we need to implement functionality upon the text change event of a particular textbox. This can be achieved through two approaches: either by creating an event in the ViewModel and linking it with the textbox controls, or by directly coding in the code-behind file. However, when adhering to the MVVM pattern, direct coding in the code-behind file is not feasible.

In such instances, behaviors come into play, allowing us to maintain control over the elements defined on the form without resorting to code-behind implementation. Consequently, we can exert control over the elements without compromising the principles of MVVM architecture.

Definition

Below is an example of how to write code in the behavior file for handling the textbox change event.

private void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
{
    var textBoxName = AssociatedObject.FindName("TxtBoxName") as TextBox;
    if (textBoxName != null)
    {
        textBoxName.TextChanged += TextBoxName_TextChanged;
    }
}

private void TextBoxName_TextChanged(object sender, TextChangedEventArgs e)
{
    if (sender != null)
    {
        Console.WriteLine("TextBox Value: " + ((TextBox)sender).Text);
    }
}

This code snippet resides within the behavior class.