Stacking of Pop-Up Notification in WPF

<UserControl x:Class="NotificationControls.NotificationView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:NotificationControls"
             xmlns:draw="clr-namespace:System.Drawing;assembly=System.Drawing.Common"
             mc:Ignorable="d" 
             x:Name="notificationView">
    <UserControl.Resources>
        <local:IconToImageSourceConverter x:Key="IconToImageSourceConverter"/>
    </UserControl.Resources>
    <StackPanel Orientation="Horizontal">
        <Image Source="{Binding ElementName=notificationView, Path=IconKind, Converter={StaticResource IconToImageSourceConverter}, Mode=OneWay}" Width="25" Height="25"/>
        <TextBlock Margin="2 0" Grid.Column="1" TextWrapping="WrapWithOverflow" Text="{Binding ElementName=notificationView, Path=Message}"
                   VerticalAlignment="Center" HorizontalAlignment="Left"/>
    </StackPanel>
</UserControl>

using System;
using System.Drawing;
using System.Threading.Tasks;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;

namespace NotificationControls
{
    /// <summary>
    /// Interaction logic for Notification.xaml
    /// </summary>
    public partial class NotificationView : UserControl
    {
        // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty IconKindProperty =
            DependencyProperty.Register(nameof(IconKind), typeof(Icon), typeof(NotificationView), new PropertyMetadata(SystemIcons.Error));

        // Using a DependencyProperty as the backing store for Message.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty MessageProperty =
            DependencyProperty.Register(nameof(Message), typeof(string), typeof(NotificationView), new PropertyMetadata(string.Empty));

        public NotificationView()
        {
            InitializeComponent();
            Loaded += NotificationView_Loaded;
        }

        public event Action Closed;

        private void NotificationView_Loaded(object sender, RoutedEventArgs e)
        {
            var task = Task.Delay(TimeSpan.FromSeconds(5));
            _ = task.ContinueWith(t => Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, () => Closed?.Invoke()));
        }

        public Icon IconKind
        {
            get { return (Icon)GetValue(IconKindProperty); }
            set { SetValue(IconKindProperty, value); }
        }

        public string Message
        {
            get { return (string)GetValue(MessageProperty); }
            set { SetValue(MessageProperty, value); }
        }
    }
}

public class IconToImageSourceConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            var icon = value as Icon;
            if (icon == null)
                return null;

            ImageSource imageSource = Imaging.CreateBitmapSourceFromHIcon(
                icon.Handle,
                Int32Rect.Empty,
                BitmapSizeOptions.FromEmptyOptions());
            return imageSource;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return DependencyProperty.UnsetValue;
        }
    }

using NotificationControls;
using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;

namespace CompanionWindows.Views.Controls
{
    public class StackedNoifications : StackPanel
    {
        // Using a DependencyProperty as the backing store for Message.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty NotificationMessageProperty =
            DependencyProperty.Register(nameof(NotificationMessage), typeof(Notification),
                typeof(StackedNoifications), new PropertyMetadata(null, OnMessageChanged));

        public Notification NotificationMessage
        {
            get => (Notification)GetValue(NotificationMessageProperty);
            set => SetValue(NotificationMessageProperty, value);
        }
        private static void OnMessageChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            try
            {
                var stackednotification = (StackedNoifications)d;
                if (e.NewValue is Notification newMessage)
                {
                    stackednotification.Push(newMessage);
                }
            }
            catch (Exception)
            {
                // ignore
            }
        }

        private NotificationView CreateNotificationView(Notification newMessage)
        {
            var view = new NotificationView
            {
                Message = newMessage.Message,
                Margin = new Thickness(0, 0, 0, 8),
                IconKind = newMessage.IconKind
            };

            return view;
        }

        private void Push(Notification newMessage)
        {
            var alertPopupViews = Children.OfType<NotificationView>().ToList();

            if (!alertPopupViews.Any(v => v.Message == newMessage.Message))
            {
                var notificationView = CreateNotificationView(newMessage);
                notificationView.Closed += () => Pop(notificationView);

                Children.Add(notificationView);
            }
        }
        public void Pop(NotificationView view) => Children.Remove(view);
    }
}