Установите Grid.Column и Grid.Row для управления внутри DataTemplate

Я пишу приложение в WPF. У меня есть пользовательский элемент управления Grid:

<UserControl x:Class = "App.Controls.DynamicGrid"
             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:App.Controls"
             mc:Ignorable = "d" 
             d:DesignHeight = "450" d:DesignWidth = "800">
    <Grid x:Name = "BaseGrid"/>
</UserControl>

namespace App.Controls
{
    public partial class DynamicGrid : UserControl
    {
        #region PROPERTIES

        private static DependencyProperty ColumnsProperty = DependencyProperty.Register("Columns", typeof(int), typeof(DynamicGrid), new PropertyMetadata(0, new PropertyChangedCallback(OnPropertyChanged)));
        public int Columns
        {
            get => (int)GetValue(ColumnsProperty);
            set => SetValue(ColumnsProperty, value);
        }

        private static DependencyProperty RowsProperty = DependencyProperty.Register("Rows", typeof(int), typeof(DynamicGrid), new PropertyMetadata(0, new PropertyChangedCallback(OnPropertyChanged)));
        public int Rows
        {
            get => (int)GetValue(RowsProperty);
            set => SetValue(RowsProperty, value);
        }

        private static DependencyProperty ColumnHeadersSourceProperty = DependencyProperty.Register("ColumnHeadersSource", typeof(IEnumerable), typeof(DynamicGrid), new PropertyMetadata(new PropertyChangedCallback(OnPropertyChanged)));
        public IEnumerable ColumnHeadersSource
        {
            get => (IEnumerable)GetValue(ColumnHeadersSourceProperty);
            set => SetValue(ColumnHeadersSourceProperty, value);
        }

        private static DependencyProperty RowHeadersSourceProperty = DependencyProperty.Register("RowHeadersSource", typeof(IEnumerable), typeof(DynamicGrid), new PropertyMetadata(new PropertyChangedCallback(OnPropertyChanged)));
        public IEnumerable RowHeadersSource
        {
            get => (IEnumerable)GetValue(RowHeadersSourceProperty);
            set => SetValue(RowHeadersSourceProperty, value);
        }

        private static DependencyProperty ItemsSourceProperty = DependencyProperty.Register("ItemsSource", typeof(IEnumerable), typeof(DynamicGrid), new PropertyMetadata(new PropertyChangedCallback(OnPropertyChanged)));
        public IEnumerable ItemsSource
        {
            get => (IEnumerable)GetValue(ItemsSourceProperty);
            set => SetValue(ItemsSourceProperty, value);
        }

        private static DependencyProperty ColumnHeadersTemplateProperty = DependencyProperty.Register("ColumnHeadersTemplate", typeof(DataTemplate), typeof(DynamicGrid), new PropertyMetadata(new PropertyChangedCallback(OnPropertyChanged)));
        public DataTemplate ColumnHeadersTemplate
        {
            get => (DataTemplate)GetValue(ColumnHeadersTemplateProperty);
            set => SetValue(ColumnHeadersTemplateProperty, value);
        }

        private static DependencyProperty RowHeadersTemplateProperty = DependencyProperty.Register("RowHeadersTemplate", typeof(DataTemplate), typeof(DynamicGrid), new PropertyMetadata(new PropertyChangedCallback(OnPropertyChanged)));
        public DataTemplate RowHeadersTemplate
        {
            get => (DataTemplate)GetValue(RowHeadersTemplateProperty);
            set => SetValue(RowHeadersTemplateProperty, value);
        }

        private static DependencyProperty ItemTemplateProperty = DependencyProperty.Register("ItemTemplate", typeof(DataTemplate), typeof(DynamicGrid), new PropertyMetadata(new PropertyChangedCallback(OnPropertyChanged)));
        public DataTemplate ItemTemplate
        {
            get => (DataTemplate)GetValue(ItemTemplateProperty);
            set => SetValue(ItemTemplateProperty, value);
        }

        private static DependencyProperty CellBorderThicknessProperty = DependencyProperty.Register("CellBorderThickness", typeof(Thickness), typeof(DynamicGrid), new PropertyMetadata(new Thickness(0), new PropertyChangedCallback(OnPropertyChanged)));
        public Thickness CellBorderThickness
        {
            get => (Thickness)GetValue(CellBorderThicknessProperty);
            set => SetValue(CellBorderThicknessProperty, value);
        }

        private static DependencyProperty CellBorderBrushProperty = DependencyProperty.Register("CellBorderBrush", typeof(Brush), typeof(DynamicGrid), new PropertyMetadata(Brushes.Black, new PropertyChangedCallback(OnPropertyChanged)));
        public Brush CellBorderBrush
        {
            get => (Brush)GetValue(CellBorderBrushProperty);
            set => SetValue(CellBorderBrushProperty, value);
        }

        #endregion



        #region CONSTRUCTORS

        public DynamicGrid()
        {
            InitializeComponent();
        }

        #endregion



        #region PRIVATE METHODS

        private void Refresh()
        {
            BaseGrid.Children.Clear();
            BaseGrid.ColumnDefinitions.Clear();
            BaseGrid.RowDefinitions.Clear();

            if (Columns != 0 && Rows != 0)
            {
                bool columnHeaders = ColumnHeadersSource != null && ColumnHeadersSource.Cast<object>().Count() > 0;
                int columnHeadersInt = Convert.ToInt32(columnHeaders);
                bool rowHeaders = RowHeadersSource != null && RowHeadersSource.Cast<object>().Count() > 0;
                int rowHeadersInt = Convert.ToInt32(rowHeaders);

                if (columnHeaders) 
                {
                    BaseGrid.RowDefinitions.Add(new RowDefinition());

                    for (int column = columnHeadersInt; column < Columns + columnHeadersInt; column++)
                    {
                        Border border = new Border()
                        {
                            BorderBrush = CellBorderBrush,
                            BorderThickness = CellBorderThickness,
                        };
                        Grid.SetColumn(border, column);
                        Grid.SetRow(border, 0);
                        BaseGrid.Children.Add(border);

                        if (ColumnHeadersSource.Cast<object>().Count() > column - 1)
                        {
                            object columnHeaderItem = ColumnHeadersSource.Cast<object>().ElementAt(column - 1);
                            FrameworkElement control;
                            if (ColumnHeadersTemplate is not null)
                            {
                                control = ColumnHeadersTemplate.LoadContent() as FrameworkElement;
                                control.DataContext = columnHeaderItem;
                            }
                            else
                            {
                                control = new Label()
                                {
                                    Content = columnHeaderItem.ToString()
                                };
                            }
                            border.Child = control;
                        }
                    }
                }

                if (rowHeaders)
                {
                    BaseGrid.ColumnDefinitions.Add(new ColumnDefinition());

                    for (int row = rowHeadersInt; row < Rows + rowHeadersInt; row++)
                    {
                        Border border = new Border()
                        {
                            BorderBrush = CellBorderBrush,
                            BorderThickness = CellBorderThickness,
                        };
                        Grid.SetColumn(border, 0);
                        Grid.SetRow(border, row);
                        BaseGrid.Children.Add(border);

                        if (RowHeadersSource.Cast<object>().Count() > row - 1)
                        {
                            object rowHeaderItem = RowHeadersSource.Cast<object>().ElementAt(row - 1);
                            FrameworkElement control;
                            if (RowHeadersTemplate is not null)
                            {
                                control = RowHeadersTemplate.LoadContent() as FrameworkElement;
                                control.DataContext = rowHeaderItem;
                            }
                            else
                            {
                                control = new Label()
                                {
                                    Content = rowHeaderItem.ToString()
                                };
                            }
                            border.Child = control;
                        }
                    }
                }

                for (int _ = 0 ; _ < Rows; _++)
                {
                    BaseGrid.RowDefinitions.Add(new RowDefinition());
                }
                for (int _ = 0; _ < Columns; _++)
                {
                    BaseGrid.ColumnDefinitions.Add(new ColumnDefinition());
                }

                Border[,] borderMatrix = new Border[Rows, Columns];
                for (int row = columnHeadersInt; row < Rows + columnHeadersInt; row++)
                {
                    for (int column = rowHeadersInt; column < Columns + rowHeadersInt; column++)
                    {
                        Border border = new Border()
                        {
                            BorderBrush = CellBorderBrush,
                            BorderThickness = CellBorderThickness,
                        };
                        Grid.SetColumn(border, column);
                        Grid.SetRow(border, row);
                        BaseGrid.Children.Add(border);
                        borderMatrix[row - columnHeadersInt, column - rowHeadersInt] = border;
                    }
                }

                if (ItemsSource is not null)
                {
                    foreach (object item in ItemsSource.Cast<object>())
                    {
                        FrameworkElement control;
                        if (ItemTemplate is not null)
                        {
                            control = ItemTemplate.LoadContent() as FrameworkElement;
                            control.DataContext = item;
                        }
                        else
                        {
                            control = new Label()
                            {
                                Content = item.ToString()
                            };
                        }
                        borderMatrix[GetRow(control), GetColumn(control)].Child = control;
                    }
                }
            }
        }

        private static void OnPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args) => ((DynamicGrid)obj).Refresh();

        #endregion



        #region COLUMN/ROW SET/GET STATIC METHODS

        private static DependencyProperty ColumnProperty = DependencyProperty.RegisterAttached("Column", typeof(int), typeof(DynamicGrid), new PropertyMetadata(0));
        public static int GetColumn(UIElement element) => (int)element.GetValue(ColumnProperty);
        public static void SetColumn(UIElement element, int value) => element.SetValue(ColumnProperty, value);

        private static DependencyProperty RowProperty = DependencyProperty.RegisterAttached("Row", typeof(int), typeof(DynamicGrid), new PropertyMetadata(0));
        public static int GetRow(UIElement element) => (int)element.GetValue(RowProperty);
        public static void SetRow(UIElement element, int value) => element.SetValue(RowProperty, value);

        #endregion
    }
}

Я использую его в Window следующим образом:

<c:DynamicGrid Grid.Column = "0" 
               Columns = "{Binding Columns.Count}" 
               Rows = "{Binding Rows.Count}"
               ColumnHeadersSource = "{Binding Columns}"
               RowHeadersSource = "{Binding Rows}"
               ItemsSource = "{Binding Test}"
               CellBorderThickness = "1">
    <c:DynamicGrid.ColumnHeadersTemplate>
        <DataTemplate>
            <Label Content = "{Binding Text}"/>
        </DataTemplate>
    </c:DynamicGrid.ColumnHeadersTemplate>
    <c:DynamicGrid.RowHeadersTemplate>
        <DataTemplate>
            <Label Content = "{Binding Text}"/>
        </DataTemplate>
    </c:DynamicGrid.RowHeadersTemplate>
    <c:DynamicGrid.ItemTemplate>
        <DataTemplate>
            <Label Content = "{Binding Label}" c:DynamicGrid.Column = "{Binding Column}" c:DynamicGrid.Row = "{Binding Row}"/>
        </DataTemplate>
    </c:DynamicGrid.ItemTemplate>
</c:DynamicGrid>

Где Test — это ObservableCollection объектов класса Cell:

public class Cell
{
    public int Row { get; set; }
    public int Column { get; set; }
    public string Label { get; set; }
}

Проблема в том, что независимо от того, какое значение имеют свойства Row и Column, все элементы помещаются в первую строку и первый столбец.

В этом примере "aaaaaaaaa" должно быть размещено в третьей строке ("10:00 - 11:00") и во втором столбце ("Вторник").

Test.Add(new Cell()
{
    Row = 3,
    Column = 2,
    Label = "aaaaaaaaa"
});