WPF

public class Item
{
    public string Name { get; set; }

    public Item(string name)
    {
        Name=name;
    }
}

public class ItemsList
{
 public List<Item> Items
 {
   get; private set;
 }

 public ItemsList()
 {
   Items = new List<Item>
   {
     new Item("a"),
     new Item("b"),
     new Item("c")
   };
 }
}

public class MyModel
{
    private readonly ItemsList _list;

    public List<Item> Items => _list.Items;

    public MyModel()
    {
        _list = new ItemsList();
    }
}

protected override void OnStartup(StartupEventArgs e)
{
    MainWindow = new MainWindow()
    {
        DataContext = new MyModel()
    };

    MainWindow.Show();
    base.OnStartup(e);

}

<Grid>
    <!-- here ... pass the datacontext to my component. --> 
    <components:MyListView DataContext="MyModel"/> 
</Grid>

<Grid>
    <!-- here ... what binding source should I put in ? --> 
    <ListView Margin="10" ItemsSource="{Binding Items}"/>
</Grid>

private void ButtonImport_Click(object sender, RoutedEventArgs e)
{
    // Import

    string initdir = @"H:\mp3\";

    Cursor cu = this.Cursor;
    this.Cursor = Cursors.Wait;
    string errtxt = "";
    // delete all existing database entries
    ToolStripStatusLabel1.Text = "deleting ..."
    try
    {
        SQLiteCommand dbCom = new SQLiteCommand("DELETE FROM Dateien", dbConn);
        dbCom.ExecuteNonQuery();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "delete error", MessageBoxButton.OK, MessageBoxImage.Error);
        return;
    }
    sPfad = initdir;
    // import
    DateTime t1 = DateTime.Now;
    int z = 0;
    loopDir(sPfad);
    DateTime t2 = DateTime.Now;
    txt = "";
    txt += z.ToString() + " files saved in ";
    txt += ((t2 - t1).TotalSeconds / 60).ToString("0.0") + " min.";
    txt += errtxt != "" ? Environment.NewLine + Environment.NewLine + errtxt : "";
    this.Cursor = cu;
    MessageBox.Show(txt, "Import", MessageBoxButton.OK, MessageBoxImage.Information);
}


private void loopDir(string strPath)
{
    // read directories and files
    string dn = "";
    DirectoryInfo ofs = new DirectoryInfo(strPath);
    bool f = false;
    int n = 0;
    try
    {
        n = ofs.GetDirectories().Length;
    }
    catch (Exception ex)
    {
        f = true;
        errtxt += ex.Message + Environment.NewLine;
    }
    if (f == false)
    {
        foreach (DirectoryInfo d in ofs.GetDirectories())
        {
            dn = strPath + "\\" + d.Name;
            dn = dn.Replace("\\\\", "\\");
            loopDir(dn);  // recursive call
        }
        // file loop
        bool ok = false;
        foreach (FileInfo fl in ofs.GetFiles())
        {
            ok = false;
            for (int i = 0; i < fext.Length; i++)   // only files with spec. extensions
            {
                if (fl.Name.ToLower().EndsWith(fext[i]))
                    ok = true;
            }
            if (ok == true)
            {
                string sqls = "";
                sqls += "INSERT INTO Dateien (Pfad, Datei) VALUES (";
                sqls += "'" + sqlready(strPath).ToString().Substring(2) + "\\', ";
                sqls += "'" + sqlready(fl.Name) + "')";
                try
                {
                    SQLiteCommand dbCom = new SQLiteCommand(sqls, dbConn);
                    dbCom.ExecuteNonQuery();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "database save error", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
                z++;
            }
        }
    }
}

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

    <SolidColorBrush x:Key="hyperlinkMouseOverBrush" Color="Green"/>

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

        <Setter Property="FontSize" Value="60" />
        <Setter Property="Hyperlink.TextDecorations" Value="None" />

        <Setter Property="Template">

            <Setter.Value>

                <ControlTemplate>

                    <TextBlock>

                            <Hyperlink>

                                <TextBlock Text="{Binding LinkText, RelativeSource={RelativeSource TemplatedParent}}"
                                           FontSize="{TemplateBinding FontSize}"/>

                            </Hyperlink>

                        </TextBlock>

                </ControlTemplate>

            </Setter.Value>

        </Setter>

        <Style.Triggers>

            <Trigger Property="IsMouseOver" Value="true">
                <Setter Property="Hyperlink.Foreground" Value="{StaticResource hyperlinkMouseOverBrush}" />
                <Setter Property="Hyperlink.TextDecorations" Value="Underline" />
            </Trigger>

            <Trigger Property="IsEnabled" Value="false">
                <Setter Property="Hyperlink.Foreground" Value="Gray" />
                <Setter Property="Hyperlink.TextDecorations" Value="None" />
            </Trigger>

        </Style.Triggers>

    </Style>

</ResourceDictionary>

using System.Windows;
using System.Windows.Media;

namespace Marois.Framework.Core.WPF.Controls
{
    public class MaroisHyperlink : ControlBase
    {
        #region DP's
        #region DP HoverBrush
        public static readonly DependencyProperty HoverBrushProperty =
                    DependencyProperty.Register("HoverBrush",
                    typeof(SolidColorBrush),
                    typeof(MaroisHyperlink),
                    new PropertyMetadata(new SolidColorBrush(Colors.Black)));

        public SolidColorBrush HoverBrush
        {
            get { return (SolidColorBrush)GetValue(HoverBrushProperty); }
            set { SetValue(HoverBrushProperty, value); }
        }
        #endregion

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

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

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

        }
        #endregion
    }
}

<Window x:Class="Marois.Framework.Core.WPF.Controls.Demo.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:i="http://schemas.microsoft.com/xaml/behaviors"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:marois="clr-namespace:Marois.Framework.Core.WPF.Controls;assembly=Marois.Framework.Core.WPF.Controls"
        mc:Ignorable="d"
        WindowStartupLocation="CenterScreen"
        Title="MainWindow" 
        Height="450" 
        Width="800">

    <Window.Resources>

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

            <Setter Property="Foreground" Value="DarkTurquoise"/>
            <Setter Property="HoverBrush" Value="Brown"/>
            <Setter Property="FontSize" Value="18"/>

        </Style>

    </Window.Resources>

    <Grid>

        <marois:MaroisHyperlink Grid.Row="0" 
                                Grid.Column="0"
                                LinkText="Click me!"
                                Margin="5">

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

        </marois:MaroisHyperlink>

    </Grid>

</Window>

<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.