How to delete the old notification to show only one?

[ComptonAlvaro]

I would like to use a service in a foreground service. This service, run a PeriodicTimer() that every 5 seconds notify with an event a text to the foreground service. Then the foreground service update the notification in the status bar.

The next that the service notify is a count with the number of times that it is execute the timer.

I can stop the foreground service and start again.

The problem is that when I stop the foregroud and start again, I can see the two notifications. One continues counting the first notificacion and the second starts to count from one.

So supose that I start the foreground and i let it goes until 10.
I stop the foreground.
I start the foreground again.
I see a first notification that shows 1 and after this, another notification with the value of 11.

So it seems that still exists the first notification, and when I update the notification with NotificationManager, it updates the two notifications.

I would like to have only one notification and Update it, not create a new notification each time the service notify to update the notification.

I am following this documenation:

The code of my foreground service class is this:

The Foreground Service:

using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;




namespace App;


[Service]
public class MyForegroundService : Service, IMyForegroundService, IDisposable
{
    private MyTimerService _myTimerService;

    private string NOTIFICATION_CHANNEL_ID = "1000";
    private int NOTIFICATION_ID = 1;
    private string NOTIFICATION_CHANNEL_NAME = "notification";

    private NotificationManager _notificationManager;
    private Notification _notification;




    public MyForegroundService()
    {
        _myTimerService = new MyTimerService();
        _servicioAlarmas.ItIsNeededToNotifyEvent += OnNeededNotify;
    }



    private void StartForegroundService()
    {
        _notificationManager = (GetSystemService(Context.NotificationService) as NotificationManager)!;

        createNotificationChannel(_notificationManager);

        Notification notification = new Notification.Builder(this, NOTIFICATION_CHANNEL_ID)
            .SetAutoCancel(false)
            .SetOngoing(true)
            .Build();
        StartForeground(NOTIFICATION_ID, notification);
    }


    private NotificationChannel? createNotificationChannel(NotificationManager notificationMnaManager)
    {
        if (Build.VERSION.SdkInt < BuildVersionCodes.O) return null;

        NotificationChannel channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, NOTIFICATION_CHANNEL_NAME, NotificationImportance.Default);
        notificationMnaManager.CreateNotificationChannel(channel);

        return channel;
    }

    public override IBinder OnBind(Intent intent)
    {
        return null;
    }


    [return: GeneratedEnum]
    public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
    {
        StartForegroundService();

        _myTimerService.Start();

        return StartCommandResult.NotSticky;
    }





    public void Start()
    {
        Intent intent = new Intent(Android.App.Application.Context, typeof(AlarmasForegroundService));
        Android.App.Application.Context.StartForegroundService(intent);
    }



    public void Stop()
    {
        var intent = new Intent(Android.App.Application.Context, typeof(AlarmasForegroundService));
        Android.App.Application.Context.StopService(intent);
    }





    public new void Dispose()
    {
        _myTimerService.NotificacionNecesariaEvent -= OnNeededNotify;
    }





    private void OnNeededNotify(string paramStrMessage)
    {
        Notification notification = new Notification.Builder(this, NOTIFICATION_CHANNEL_ID)
            .SetContentTitle("Foreground Service is working")
            .SetContentText(paramStrMessage)
            .SetSmallIcon(Resource.Drawable.abc_ab_share_pack_mtrl_alpha)
            .SetAutoCancel(false)
            .SetOngoing(true)
            .Build();

        _notificationManager.Notify(NOTIFICATION_ID, notification);
    }
}

The service with the timer:

public class MyService
{
    private Task? _taskTimer;
    private readonly PeriodicTimer _timer;
    private readonly CancellationTokenSource _cts = new CancellationTokenSource();

    private int _notificationNumber = 0;


    public MyService()
    {
        _timer = new PeriodicTimer(TimeSpan.FromSeconds(5));
    }



    public delegate void NeededNotificationEventHandler(string paramStrMessage);
    public event NeededNotificatioEventHandler NeededNotificatioEvent;

    private void OnNeededNotificatio(string paramStrMessage)
    {
        NeededNotificatioEvent?.Invoke(paramStrMessage);
    }


    public void Start()
    {
        _taskTimer = DoWorkAsync();
    }


    public async void StopAsync()
    {
        if (_taskTimer == null) return;


        _cts.Cancel();
        await _taskTimer;
        _cts.Dispose();
    }




    private async Task DoWorkAsync()
    {
        try
        {
            while (await _timer.WaitForNextTickAsync(_cts.Token))
            {
                OnNeededNotificatio($"Número Notificacion: {_notificationNumber}.");
            }
        }
        catch (OperationCanceledException ex)
        {
        }
    }
}

In the foreground service, where I update the notification with NotificationManager.Notify(); I have tried to use StartForeground(NOTIFICATION_ID, notification) instead to use NotificationManager.

This works I expected, but I don't know what it does really. does it create a new foreground service? Does it just update the notification? Does it create a new notification and dispose the actual notification?. Really I don't know what this methods does.

Thanks so much.