How do I handle a background thread being orphaned by parent destruction?

Question

5.00/5 (1 vote)

See more:

When I lived in the C++ world, I found the subject of threading intuitive. Here in C#, I find I get completely lost, because there seems to be so many ways to do things.

Task is probably the best choice most of the time but these are now so flexible that it is hard to know the best way.

I have what seems like a simple use case. I have an audio player that contains a function to fade the volume over a period of time. Because I don't want to block the calling code, I need the call to be fire-and-forget, so it seems like a case where it needs to do its thing on a separate thread. The problem is that the parent audio player can be disposed of while a volume fade is in progress.

I would be extremely grateful for any tips about how to best handle this.

The outline of the code could not be simpler:

public class AudioPlayer
{
	public void FadeVolume( double targetVolume, double fadeTimeSeconds )
	{
	}
}

What I have tried:

I've tried a menagerie of Task, await, Wait(), Task.Run(), and probably most of the rest of the available Task function calls, but I still don't seem to be able to find a way to handle this without some nasty exception or other.

Note that I do realise I may have to accept some kinds of exception (e.g. TaskCanceledException), which I aim to simply catch, maybe log, and then forget.

Mostly what I am concerned about is simply that I am handling things safely.

Posted 28-Oct-21 0:18am

Patrick Skelton

Updated 28-Oct-21 22:48pm

Add a Solution

Comments

BillWoodruff 28-Oct-21 6:49am

what version of .NET are you using ?

Patrick Skelton 28-Oct-21 6:54am

Sorry, forgot that little detail. It's a Xamarin.Forms application. The platform-independent chunk of the code is .NETStandard2.0 but the target framework in the iOS project - where this audio player is implemented - is blank. I'm guessing the same?

BillWoodruff 28-Oct-21 7:14am

This use scenario is so far outside my experience with threading i can't be helpful.

In .NET 5 and Core 3, you've now got: public void Kill (bool entireProcessTree);

See this about changes in usage of Thread.Abort:

https://blog.ndepend.com/on-replacing-thread-abort-in-net-6-net-5-and-net-core/

cheers, Bill

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard Deeming · Accepted Answer · 2021-10-28T22:48:00

How about something like this?

C#

public class AudioPlayer : IDisposable
{
    private CancellationTokenSource _tokenSource;
    
    private void CancelFade(CancellationTokenSource newTokenSource)
    {
        var oldTokenSource = Interlocked.Exchange(ref _tokenSource, newTokenSource);
        if (oldTokenSource != null)
        {
            oldTokenSource.Cancel();
            oldTokenSource.Dispose();
        }
    }
    
    public void Dispose()
    {
        CancelFade(null);
    }
    
    public Task FadeVolume(double targetVolume, double fadeTimeSeconds)
    {
        var newTokenSource = new CancellationTokenSource();
        CancelFade(newTokenSource);
        
        var fadeTime = TimeSpan.FromSeconds(fadeTimeSeconds);
        return FadeVolumeCore(targetVolume, fadeTime, newTokenSource.Token);
    }
    
    private async Task FadeVolumeCore(double targetVolume, TimeSpan fadeTime, CancellationToken cancellationToken)
    {
        var delay = TimeSpan.FromMilliseconds(100);
        int steps = (int)Math.Floor(fadeTime.TotalMilliseconds / delay.TotalMilliseconds);

        for (int i = 0; i < steps; i++)
        {
            if (cancellationToken.IsCancellationRequested) return;
            await Task.Delay(delay, cancellationToken);
            
            // Adjust the volume...
        }
    }
}

When the class is disposed, or the FadeVolume method is called again, any existing fade task will be cancelled.