C#

Pete O'Hanlon wrote:

For continuations, I find it best to use the explicit continuation that suits that particular status.

Kevin Marois wrote:

What benefit does it provide?

1. I can have my tasks attached to different schedulers - some of the stuff I deal with uses very complex scheduling.
2. I'm not mixing code. Each continuation has a single responsibility
3. This makes it very easy for me to provide general purpose continuation handlers - for instance, I could have a single OnlyOnFaulted handler that any Task calls.
4. This reduces the cyclomatic complexity of your code

public static class TaskExtensions
{
  public static void OnFaulted(this Task task)
  {
    task.ContinueWith(()=>{ /* do something here */ }, TaskContinuationOptions.OnlyOnFaulted);
  }
}

Task.Factory.StartNew(()=> { }).OnFaulted();

Task task = Task.Factory.StartNew(() =>
{
    service.Start();

}, TaskCreationOptions.LongRunning, service.CancellationTokenSource.Token);

Delegate 'Action<object>' does not take 0 arguments

Pete O'Hanlon wrote:

// If you haven't reached this point, then you don't have a current App Dispatcher...

    Task task = Task.Factory.StartNew(() =>
    {
        service.Start();

    }, service.CancellationTokenSource.Token);

    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' completed", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' cancelled", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnCanceled);

    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' errored", service.ServiceId));
        AddStatus(task.Exception.ToString());

    }, TaskContinuationOptions.OnlyOnFaulted);

    task.ContinueWith(antecedent => {

        // Remove the service
        App.Current.Dispatcher.Invoke(() =>
        {
            // Remove the model from the UI
            Services.Remove(SelectedService);
            SelectedService = null;
            // If you haven't reached this point, then you don't have a current App Dispatcher...
            AddStatus("Removed from the dispatcher");
        });

        _services.Remove(service);
    });
}

throw null;

Services.Remove(SelectedService);

var serviceModel = Services.FirstOrDefault(x => x.ServiceId == service.ServiceId);
Services.Remove(serviceModel);

private void AddService()
{
    // Create an instance of a service and add it to the list of services
    MyService service = new MyService();
    _services.Add(service);

    // Subscribe to the services' status event
    service.StatusChanged += Service_StatusChanged;

    // Write a message to the UI
    AddStatus(string.Format("Service '{0}' created", service.ServiceId));

    // Start the task
    Task task = Task.Factory.StartNew(() =>
    {
        service.Start();

    }, service.CancellationTokenSource.Token);

    // Handle task completion
    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' completed", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    // Handle task cancellation
    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' cancelled", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnCanceled);

    // Handle task faulted
    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' errored", service.ServiceId));
        AddStatus(task.Exception.ToString());

    }, TaskContinuationOptions.OnlyOnFaulted);

    // Task is finished
    task.ContinueWith(antecedent =>
    {
        // Remove the service
        App.Current.Dispatcher.Invoke(() =>
        {
            var serviceModel = Services.FirstOrDefault(x => x.ServiceId == service.ServiceId);
            Services.Remove(serviceModel);

            // Remove the model from the UI
            SelectedService = null;

            AddStatus("Service removed");
        });

        _services.Remove(service);
    });
}

private void Stopped()
{
    IsStopped = true;

    foreach (var service in _runningServices)
    {
        service.Stop();
    }

    _runningServices.Clear();
}

private void AddService()
{
    // Create an instance of a service and add it to the list of services
    MyService service = new MyService();
    _services.Add(service);

    // Start the task
    Task task = Task.Factory.StartNew(() =>
    {
        service.Start();

    }, service.CancellationTokenSource.Token);

    /*
      ... ContinueWith code omitted
    */

}

public void StopAllServices()
{
    // This I already have. Call Stop on each service. _services are classes I created that I run in a task
    foreach (var service in _services)
    {
        service.Stop();
    }

    //<==== This I would need to add...
    Task waitAllTask = Task.WhenAll(_tasks.ToArray());     
    try
    {
        waitAllTask.Wait();
    }
    catch { }
}

// 'FormWithBtn ... in the Form with the Button
public Action<Button> BtnAction = null;

private void SomeButton_Click(object sender, EventArgs e)
{
   if(BtnAction != null) BtnAction(sender as Button);
}

private FormWithButton FWBInstance = new FormWithButton();

private void Form1_Load(object sender, EventArgs e)
{ 
    FWBInstance.BtnAction = FWBButtonHandler;
} 

private void FWBButtonHandler(Button btn)
{
    // do whatever
}

Regequion wrote:

One problem is that if you modify something in one class and switch to another class, it takes a long time to notice the changes. It is a problem, because you can see a red line of error for quite some time and you are left wondering what the problem is and suddenly it is solved because it has detected the change. I can find dozens of suggestions to make easily but the years pass and from one version to another things do not improve.

mahdiiiiyeh wrote:

"2(The system cannot find the file specified.)"