Why does my animation task duplicate when I change my axaml?

[Shadowblitz16]

Every time I change my axaml I get another Draw! printing and the old one doesn't stop.

This means everytime I update my axaml it alocates a new animation task and the old one isn't canceled.

I am using rider 2025.1.3.

The worker class was my last attempt to fix it before I posted here.
I was using a private Dispose method and the finalizer of Sprite to cancel the task, but again same issue.

<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             xmlns:vm="clr-namespace:EditorX.ViewModels"
             mc:Ignorable="d" d:DesignWidth="{Binding Width}" d:DesignHeight="{Binding Height}"
             x:Class="EditorX.Controls.SpriteView"
             x:DataType="vm:Sprite"
             ClipToBounds="True"
             Background="Transparent"
             Width="{Binding Width}" Height="{Binding Height}">
    
    <Design.DataContext>
        <!-- This only sets the DataContext for the previewer in an IDE,
             to set the actual DataContext for runtime, set the DataContext property in code (look at App.axaml.cs) -->
        <vm:Sprite ImageSource="avares://EditorX/Assets/npc-131.png" FrameCount="2" IsGfxRectVisible="True" IsHitRectVisible="True" Width="16" Height="16"/>
        
    </Design.DataContext>
    <Canvas Background="Transparent">
        <Image Source="{Binding Frame}" Canvas.Left="{Binding GfxSourceX}" Canvas.Top="{Binding GfxSourceY}" Width="{Binding GfxWidth}" Height="{Binding GfxHeight}"/>
        <Rectangle StrokeThickness="1" Stroke="Aqua"    Canvas.Left="{Binding GfxSourceX}" Canvas.Top="{Binding GfxSourceY}" Width="{Binding GfxWidth}" Height="{Binding GfxHeight}" IsVisible="{Binding IsGfxRectVisible}"/>
        <Rectangle StrokeThickness="1" Stroke="Yellow"  Canvas.Left="{Binding HitSourceX}" Canvas.Top="{Binding HitSourceY}" Width="{Binding HitWidth}" Height="{Binding HitHeight}" IsVisible="{Binding IsHitRectVisible}"/>
    </Canvas>
</UserControl>

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Avalonia;
using Avalonia.Media;
using Avalonia.Media.Imaging;
using Avalonia.Platform;
using Avalonia.Threading;
using CommunityToolkit.Mvvm.ComponentModel;


namespace EditorX.ViewModels;

public partial class Sprite : BaseViewModel, ISprite
{
    private Worker _animationWorker;
    private bool _animationPaused;
    
    private Bitmap?    _image;
    private string     _imageSource = string.Empty;
    public  string      ImageSource
    {
        get => _imageSource;
        set
        {
            if (_imageSource != value)
            {
                _image?.Dispose();
                _image       = null;
                _imageSource = value;
                
                if (AssetLoader.Exists(new Uri(_imageSource))) 
                    _image = new Bitmap(AssetLoader.Open(new Uri(_imageSource)));
                
                OnPropertyChanged();
                OnPropertyChanged(nameof(Frame));
            }
        }
    }


    public Sprite()
    {
        _animationWorker = new Worker(UpdateAnimation);
    }
    private async Task UpdateAnimation(CancellationTokenSource source)
    {
        while (source.Token.IsCancellationRequested == false)
        {
            await Task.Delay(TimeSpan.FromSeconds(FrameSpeed / 60d), source.Token);
            if (_animationPaused) continue;
            
            var min           = 0;
            var max      = min + FrameCount;
            var direction = int.Sign(FrameSpeed);
            
            if      (direction < 0 && FrameIndex <= min) FrameIndex += FrameCount;
            else if (direction > 0 && FrameIndex >= max) FrameIndex -= FrameCount;
            Console.WriteLine("Draw!");
        }
    }

    public IImage? Frame
    {
        get
        {
            if (_image != null)
            {
                // Create a new image, copy the old one, and then add a new rectangle to it
                // using the current marquee and color
                var frame     = new RenderTargetBitmap(_image.PixelSize, _image.Dpi);
                var frameRect = GetFrameRects()[FrameIndex];
                
                using var context = frame.CreateDrawingContext();
                context.DrawImage(_image, new Rect(frameRect.X, frameRect.Y, frameRect.W, frameRect.H), new Rect(GfxSourceX, GfxSourceY, GfxWidth, GfxHeight));

                return frame;
            }
            return null;
        }
    }
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))] private uint       _frameIndex  = 0;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))] private uint       _frameCount  = 1;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))] private  int       _frameSpeed  = 60;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))] private FrameStyle _frameStyle  = FrameStyle.OneDirNoFlip;
    
    public uint Width 
    {
        get => uint.Max(GfxWidth, HitWidth);
        set 
        {
            if (Width != value)
            {
                GfxWidth = value;
                HitWidth = value;
                OnPropertyChanged();
            }
        }
    }
    public uint Height
    {
        get => uint.Max(GfxHeight, HitHeight);
        set 
        {
            if (Height != value)
            {
                GfxHeight = value;
                HitHeight = value;
            }
        }
    }
    
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))][NotifyPropertyChangedFor(nameof(Width ), nameof(GfxSourceX))] private uint _gfxWidth   = 16;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))][NotifyPropertyChangedFor(nameof(Height), nameof(GfxSourceY))] private uint _gfxHeight  = 16;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame), nameof(GfxSourceX))] private int  _gfxOffsetX = 0;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame), nameof(GfxSourceY))] private int  _gfxOffsetY = 0;
    
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))][NotifyPropertyChangedFor(nameof(Width ), nameof(HitSourceX))] private uint _hitWidth   = 16;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))][NotifyPropertyChangedFor(nameof(Height), nameof(HitSourceY))] private uint _hitHeight  = 16;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame), nameof(HitSourceX))] private int  _hitOffsetX = 0;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame), nameof(HitSourceY))] private int  _hitOffsetY = 0;
    
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))] private bool _isFlippedX = false;
    [ObservableProperty][NotifyPropertyChangedFor(nameof(Frame))] private bool _isFlippedY = false;

    [ObservableProperty] private bool _isGfxRectVisible;
    [ObservableProperty] private bool _isHitRectVisible;

    public int GfxSourceX
    {
        get => ((int)(Width - GfxWidth) / 2) +  GfxOffsetX;
    }
    public int GfxSourceY
    {
        get => ((int)(Height - GfxHeight) / 2) +  GfxOffsetY;
    }
    public int HitSourceX
    {
        get => ((int)(Width - HitWidth) / 2) +  HitOffsetX;
    }
    public int HitSourceY
    {
        get => ((int)(Height - HitHeight) / 2) +  HitOffsetY;
    }


    
    public void Play   ()
    {
        _animationPaused = false;

    }
    public void Reset  ()
    {
        FrameIndex = 0;
    }
    public void Stop   ()
    {
        Pause();
        FrameIndex = 0;
    }
    public void Pause  ()
    {
        _animationPaused = true;
    }



    public FrameRect[]  GetFrameRects()
    {
        var offset = GetFrameStyle() switch
        {
            FrameStyle.OneDirNoFlip => (uint)0,
            FrameStyle.TwoDirNoFlip => (uint)1,
            FrameStyle.OneDirFlip   => (uint)2,
            FrameStyle.TwoDirFlip   => (uint)3,
            _ => (uint)0,
        };

        var start = offset * FrameCount;
        var end   = start  + FrameCount;

        var frames = new FrameRect[FrameCount];
        for (var i = start; i < end; i++)
        {
            var frameW =  GfxWidth;
            var frameH =  GfxHeight;
            var frameX     =  0;
            var frameY = (GfxHeight * i);
            //Console.WriteLine($"{frameX},{frameY},{frameW},{frameH}");
            frames[i] = new FrameRect((int)frameX, (int)frameY, frameW, frameH);
        }
        
        return frames;
    }
    public FrameStyle   GetFrameStyle()
    {

        var flipX = IsFlippedX && IsFlippableX();
        var flipY = IsFlippedY && IsFlippableY();

        return flipX switch
        {
            true  when  flipY => FrameStyle.TwoDirFlip,
            false when  flipY => FrameStyle.OneDirFlip,
            true  when !flipY => FrameStyle.TwoDirNoFlip,
            false when !flipY => FrameStyle.OneDirNoFlip,
            _                 => FrameStyle.TwoDirNoFlip
        };

    }
    public bool         IsFlippableX()
    {
        return FrameStyle switch
        {
            FrameStyle.OneDirNoFlip => false,
            FrameStyle.OneDirFlip => false,
            FrameStyle.TwoDirNoFlip => true,
            FrameStyle.TwoDirFlip => true,
            _ => false
        };
    }
    public bool         IsFlippableY()
    {
        return FrameStyle switch
        {
            FrameStyle.OneDirNoFlip => true,
            FrameStyle.OneDirFlip => false,
            FrameStyle.TwoDirNoFlip => true,
            FrameStyle.TwoDirFlip => false,
            _ => false
        };
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using Avalonia.Media.Imaging;

namespace EditorX.ViewModels;

public sealed class Worker : IAsyncDisposable
{
    private readonly CancellationTokenSource _source = new();
    private readonly Task _task;
    
    public Worker(Func<CancellationTokenSource, Task> action)
    {
        _task = Task.Run(async () => await action(_source), _source.Token);
    }

    ~Worker()
    {
        _source.Cancel();
    }

    public ValueTask DisposeAsync()
    {
        _source.Cancel();
        _source.Dispose();
        GC.SuppressFinalize(this);
        return new ValueTask(_task);
    }
}

[Shadowblitz16]

https://stackoverflow.com/questions/34683948/better-solution-for-timer-in-viewmodel
Here is the same issue, none of the answers solved it though.

[LaurentInSeattle]

This will not answer directly your question, sorry about that, but I think you are on the wrong track for your sprite rendering system.

You should possibly consider using "CroppedBitmap"s and take a look at this project, here:
https://github.com/BradBergstrom/AvaloniaSpriteRendering

HTH

[Shadowblitz16]

@LaurentInSeattle I already know about that. It doesn't really help.