WPF

<ctrls:MaroisHyperlink LinkText="Forgot Password?"
                        Foreground="SteelBlue"
                        Margin="30,0,0,0"
                        Height="20">

    <i:Interaction.Triggers>
        <i:EventTrigger EventName="LinkClicked">
            <i:InvokeCommandAction Command="{Binding ForgotPasswordClickedCommand}"
                                    CommandParameter="True"/>
        </i:EventTrigger>
    </i:Interaction.Triggers>

</ctrls:MaroisHyperlink>

namespace Marois.Framework.Core.Utilities
{
    public class RelayCommand<T> : ICommand
    {
        private readonly Action<T> execute;

        private readonly Func<T, bool> canExecute;

        public RelayCommand(Action<T> execute)
            : this(execute, null)
        {
        }

        public RelayCommand(Action<T> execute, Func<T, bool> canExecute)
        {
            ArgumentNullException.ThrowIfNull(execute);

            this.execute = execute;
            this.canExecute = canExecute;
            this.RaiseCanExecuteChangedAction = RaiseCanExecuteChanged;

            SimpleCommandManager.AddRaiseCanExecuteChangedAction(ref RaiseCanExecuteChangedAction);
        }

        ~RelayCommand()
        {
            RemoveCommand();
        }

        public void RemoveCommand()
        {
            SimpleCommandManager.RemoveRaiseCanExecuteChangedAction(RaiseCanExecuteChangedAction);
        }

        bool ICommand.CanExecute(object? parameter)
        {
            return canExecute((T)parameter);
        }

        public void Execute(object? parameter)
        {
            if (CanExecute(parameter))
            {
                execute((T)parameter);
            }
        }

        public bool CanExecute(object? parameter)
        {
            return canExecute == null ? true : canExecute((T)parameter);
        }

        public void RaiseCanExecuteChanged()
        {
            var handler = CanExecuteChanged;
            if (handler != null)
            {
                handler(this, new EventArgs());
            }
        }

        private readonly Action RaiseCanExecuteChangedAction;

        public event EventHandler CanExecuteChanged;
    }

    public static class SimpleCommandManager
    {
        private static List<Action> _raiseCanExecuteChangedActions = new List<Action>();

        public static void AddRaiseCanExecuteChangedAction(ref Action raiseCanExecuteChangedAction)
        {
            _raiseCanExecuteChangedActions.Add(raiseCanExecuteChangedAction);
        }

        public static void RemoveRaiseCanExecuteChangedAction(Action raiseCanExecuteChangedAction)
        {
            _raiseCanExecuteChangedActions.Remove(raiseCanExecuteChangedAction);
        }

        public static void AssignOnPropertyChanged(ref PropertyChangedEventHandler propertyEventHandler)
        {
            propertyEventHandler += OnPropertyChanged;
        }

        private static void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            // this if clause is to prevent an infinity loop
            if (e.PropertyName != "CanExecute")
            {
                RefreshCommandStates();
            }
        }

        public static void RefreshCommandStates()
        {
            for (var i = 0; i < _raiseCanExecuteChangedActions.Count; i++)
            {
                var raiseCanExecuteChangedAction = _raiseCanExecuteChangedActions[i];
                if (raiseCanExecuteChangedAction != null)
                {
                    raiseCanExecuteChangedAction.Invoke();
                }
            }
        }
    }

}

private ICommand? _ForgotPasswordClickedCommand;
public ICommand ForgotPasswordClickedCommand
{
    get
    {
        if (_ForgotPasswordClickedCommand == null)
            _ForgotPasswordClickedCommand = new RelayCommand<bool>(p => ForgotPasswordLinkClickedExecuted(p), a => ForgotPasswordCanExecute(a));
        return _ForgotPasswordClickedCommand;
    }
}

private bool ForgotPasswordCanExecute(bool args)
{
    return true;
}

private void ForgotPasswordLinkClickedExecuted(bool args)
{
}

'Unable to cast object of type 'System.String' to type 'System.Boolean'.'

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                    xmlns:local="clr-namespace:MaroisHyperlink"
                    xmlns:i="http://schemas.microsoft.com/xaml/behaviors">

<pre>
<Style TargetType="{x:Type local:MaroisHyperlink}">

    <Setter Property="Template">

        <Setter.Value>

            <ControlTemplate>

                <Border Background="{TemplateBinding Background}"
                        BorderBrush="{TemplateBinding BorderBrush}"
                        BorderThickness="{TemplateBinding BorderThickness}">

                    <TextBlock>

                        <Hyperlink>

                             <TextBlock Text="{Binding LinkText}"/>

                            <i:Interaction.Triggers>
                                <i:EventTrigger EventName="Click">
                                    <i:InvokeCommandAction Command="{Binding LinkClickedCommand}"/>
                                </i:EventTrigger>
                            </i:Interaction.Triggers>

                        </Hyperlink>

                    </TextBlock>

                </Border>

            </ControlTemplate>

        </Setter.Value>

    </Setter>

</Style>

using Marois.Framework.Core.Utilities;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace MaroisHyperlink
{
    public class MaroisHyperlink : Control
    {
        #region Commands
        private ICommand? _LinkClickedCommand;
        public ICommand LinkClickedCommand
        {
            get
            {
                if (_LinkClickedCommand == null)
                    _LinkClickedCommand = new RelayCommand(LinkClickedExecuted, LinkClickedCanExecute);
                return _LinkClickedCommand;
            }
        }
        #endregion

        #region DP LinkText
        public static readonly DependencyProperty LinkTextProperty =
                    DependencyProperty.Register("LinkText",
                    typeof(string),
                    typeof(MaroisHyperlink),
                    new PropertyMetadata("", new PropertyChangedCallback(OnLinkTextChanged)));

        public string LinkText
        {
            get { return (string)GetValue(LinkTextProperty); }
            set { SetValue(LinkTextProperty, value); }
        }

        private static void OnLinkTextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            //var control = (MaroisHyperlink)d;
        }
        #endregion

        #region LinkClickedEvent
        public static readonly RoutedEvent LinkClickedEvent =
                    EventManager.RegisterRoutedEvent("LinkClicked",
                    RoutingStrategy.Bubble,
                    typeof(RoutedEventHandler),
                    typeof(MaroisHyperlink));

        public event RoutedEventHandler LinkClicked
        {
            add { AddHandler(LinkClickedEvent, value); }
            remove { RemoveHandler(LinkClickedEvent, value); }
        }

        private void RaiseLinkClickedEvent()
        {
            RaiseEvent(new RoutedEventArgs(LinkClickedEvent));
        }
        #endregion

        #region CTOR
        static MaroisHyperlink()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(MaroisHyperlink),
                new FrameworkPropertyMetadata(typeof(MaroisHyperlink)));
        }
        #endregion

        #region Private Methods
        private bool LinkClickedCanExecute()
        {
            return IsEnabled;
        }

        private void LinkClickedExecuted()
        {
            RaiseLinkClickedEvent();
        }
        #endregion
    }
}

<Window x:Class="HyperlinkDemo.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:link="clr-namespace:MaroisHyperlink;assembly=MaroisHyperlink"
        WindowStartupLocation="CenterScreen"
        mc:Ignorable="d"
        Title="MainWindow" 
        Height="300" 
        Width="500">

<pre>
<Grid>

    <link:MaroisHyperlink LinkText="Click This Link!"
                          HorizontalAlignment="Center"
                          VerticalAlignment="Center"
                          FontSize="16"/>

</Grid>

<TextBlock>

<pre>
<Hyperlink>

    <TextBlock Text="THIS SHOWS UP"/>

</Hyperlink>

<i:Interaction.Triggers>
    <i:EventTrigger EventName="Click">
        <i:InvokeCommandAction Command="{Binding LinkClickedCommand}"/>
    </i:EventTrigger>
</i:Interaction.Triggers>

The type 'Interaction' was not found. Verify that you are not missing an assembly reference and that all referenced assemblies have been built.

<FontFamily x:Key="Font.Family.Default">Segoe UI</FontFamily>
<sys:Double x:Key="Font.Size.Header1">18</sys:Double>
<sys:Double x:Key="Font.Size.Header2">16</sys:Double>
<sys:Double x:Key="Font.Size.Header3">14</sys:Double>
<sys:Double x:Key="Font.Size.Normal">12</sys:Double>

<SolidColorBrush x:Key="TextBlock.Static.Background" Color="Transparent"/>
<SolidColorBrush x:Key="TextBlock.Static.Foreground" Color="DarkGray"/>

<Style x:Key="ControlBase" TargetType="{x:Type Control}">

    <Setter Property="Control.FontSize" Value="{StaticResource Font.Size.Normal}"/>
    <Setter Property="Control.FontFamily" Value="{StaticResource Font.Family.Default}"/>
    <Setter Property="Control.HorizontalAlignment" Value="Center"/>
    <Setter Property="Control.VerticalAlignment" Value="Center"/>

</Style>

<Style TargetType="{x:Type TextBlock}"
        BasedOn="{StaticResource ControlBase}">

    <Setter Property="Background" Value="{StaticResource TextBlock.Static.Background}"/>
    <Setter Property="Foreground" Value="{StaticResource TextBlock.Static.Foreground}"/>

</Style>

<TextBlock Grid.Row="0" 
            Grid.Column="0"
            Text="Test"
            Margin="22,0,0,0"/>

System.Windows.Markup.XamlParseException
  Message='Initialization of 'System.Windows.Controls.TextBlock' threw an exception.' Line number '56' and line position '20'.

    Inner Exception 1:
    InvalidOperationException: Can only base on a Style with target type that is base type 'TextBlock'.

<Style TargetType="TextBlock">

    <Setter Property="Foreground" Value="{DynamicResource textForegroundBrush}"/>
    <Setter Property="FontSize" Value="14"/>

</Style>

<Window.Resources>

    <Style x:Key="headerTextStyle" 
            TargetType="TextBox">

        <Setter Property="FontSize" Value="24"/>

    </Style>

</Window.Resources>

using ...

namespace Gewicht
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public string[] dbFile = { @"H:\Daten\C#WPF\Gewicht\GewichtDaten.xml", @"H:\Daten\C#WPF\Gewicht\GewichtDaten.xsd" };
        public DataTable dbDataTbl = new DataTable();

        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            if (!System.IO.File.Exists(dbFile[0]) | !System.IO.File.Exists(dbFile[1]))
                {
                SystemSounds.Beep.Play();
                MessageBox.Show("Die Datei" + Environment.NewLine + "   " + dbFile[0] + Environment.NewLine + "und/oder" + Environment.NewLine + "   " + dbFile[1] + Environment.NewLine + "fehlt." + Environment.NewLine + "Das Programm wird beendet.", "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
                Environment.Exit(0);
            }
            DataGrid1.CanUserAddRows = false;
            DataGrid1.CanUserDeleteRows = false;
            OpenData();
        }


        private void DataGrid1_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
        {
            // edit
            // ... ???????????????????????? ...
        }


        private void OpenData()
        {
            // open data

            dbDataTbl.Columns.Clear();
            dbDataTbl.Rows.Clear();
            dbDataTbl = new DataTable("ich");
            dbDataTbl.ReadXmlSchema(dbFile[1]);
            dbDataTbl.ReadXml(dbFile[0]);
            // DataGrid
            DataSet dataSet = new DataSet();
            dataSet.ReadXml(dbFile[0]);
            DataView dataView = new DataView(dataSet.Tables[0]);
            DataGrid1.ItemsSource = dataView;
            // format columns
            Style style = new Style();               // creates object of style class   
            style.TargetType = typeof(DataGridCell); // sets target type as DataGrid cell
            Setter setter = new Setter();            // create objects of setter class   
            setter.Property = DataGridCell.ForegroundProperty;
            setter.Value = Brushes.LightGray;
            style.Setters.Add(setter);
            DataGrid1.Columns[0].CellStyle = style;
            style = new Style();
            setter = new Setter();
            setter.Property = DataGridCell.HorizontalContentAlignmentProperty;
            setter.Value = HorizontalAlignment.Right;
            DataGrid1.Columns[2].CellStyle = style;
        }

    }
}