Chart does not update , even if the fetched data are updated

[toshiVon]

this snip that i made does not update my chart, despite of having the updateData able to fetch the latest data from the database.
I needed to restart my app in order for the new one to be shown.

using LiveChartsCore;
using LiveChartsCore.Defaults;
using LiveChartsCore.SkiaSharpView;
using LiveChartsCore.SkiaSharpView.WPF;
using System.ComponentModel;
using System.Data.SqlClient;
using System.Runtime.CompilerServices;

namespace Smart_Facilities.Functions
{
internal class MonthlyMhiClass : IDisposable
{
private readonly string connectionString;
private readonly CartesianChart chart;
private readonly Timer timer;

    private List<ChillerMHI> daddy_chill = new List<ChillerMHI>();


    public MonthlyMhiClass(CartesianChart chart, string connection)
    {
        this.chart = chart;
        connectionString = connection;

        GetLineData();
        LoadLineChart();
      
        
        // Start timer to periodically update data (simulated for demonstration)
        timer = new Timer(CheckForChanges, null, TimeSpan.Zero, TimeSpan.FromSeconds(.5));
    }

 

    private void CheckForChanges(object? state)
    {
        GetLineData();
    }

/Query data from the database/
private void GetLineData()
{
var newDaddy = new List();

        string query = @"Select date, machine, tr from chiller_mhi order by date asc ";

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            using (SqlCommand cmd = new SqlCommand(query, connection))
            {
                connection.Open();

                using (SqlDataReader reader = cmd.ExecuteReader())
                {
                    while (reader.Read())
                    {

                        newDaddy.Add(new ChillerMHI
                        {
                            Date = reader.GetDateTime(reader.GetOrdinal("date")),
                            Machine = reader.GetString(reader.GetOrdinal("machine")),
                            Tr = reader.GetFloat(reader.GetOrdinal("tr"))
                        });
                    }
                }
            };
        }
        UpdateData(daddy_chill, newDaddy);
    }

/Check sizes for both/
private void UpdateData(List daddy_chill, List newDaddy)
{
int oldCount = daddy_chill.Count();
int newCount = newDaddy.Count();

        for (int i = 0; i < Math.Min(oldCount, newCount); i++)
        {
            daddy_chill[i] = newDaddy[i];   
        }
        if (newCount > oldCount)
        {
            daddy_chill.AddRange(newDaddy.Skip(oldCount));
        }
        else if (newCount < oldCount)
        {
            daddy_chill.RemoveRange(newCount, oldCount - newCount);
        }

     
    }
    public void LoadLineChart()
    {
        var dates = daddy_chill.Select(item => item.Date).Distinct().OrderBy(date => date).ToList();
        var machines = daddy_chill.Select(item => item.Machine).Distinct().ToList();

        var series = new List<ISeries>();

       
        foreach(var machine in machines)
        {
            var values = new List<ObservableValue>();

            foreach(var date in dates)
            {
                var value = daddy_chill.Where(item => item.Machine == machine && item.Date == date).Sum(item => item.Tr);
                
                values.Add(new ObservableValue(value));
            }

            var columns = new StackedColumnSeries<ObservableValue>
            {
                Name = machine, 
                Values = values.ToArray(),
            };

            series.Add(columns);

        }
       
        chart.Series = series;
        chart.CoreChart.Update(new LiveChartsCore.Kernel.ChartUpdateParams { IsAutomaticUpdate = true, Throttling = true });

        chart.XAxes = new List<Axis>
        {
            new()
            {
               Labels = dates.Select(d => d.Date.ToString("MMM-dd")).ToArray()
            }
        };

    }
    public void Dispose()
    {
        throw new NotImplementedException();
    }
}
public class ChillerMHI : INotifyPropertyChanged
{
    private DateTime date;
    private string? machineName;
    private float? tr;

    public DateTime Date { get => date; set { date = value; OnPropertyChanged(); } }
    public string? Machine{ get => machineName; set { machineName = value; OnPropertyChanged(); } }
    public float? Tr{ get => tr; set { tr = value; OnPropertyChanged(); } }

    public event PropertyChangedEventHandler? PropertyChanged;
    private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(propertyName, new PropertyChangedEventArgs(propertyName));
    }

}

}

[MINT-KISS]

I'm not sure, but it might be because you should use ObservableCollection instead of List