Doubts about Design Patterns - Idempotency Messages

This function does not do what you specified, but is closer to reaching your goal. It tries to execute the action function a certain number of times. If the action completes within the specified time then the value is returned. Adapt the feature to meet your additional requirement to complete a previous call.

static async Task<T> Retry<T>(Func<T> action, TimeSpan timeout, int? attempts = 3){
    for(int i = 0; i < attempts; ++i){
        var task = Task.Factory
            .FromAsync(action.BeginInvoke(null, null), r => action.EndInvoke(r));
        var timeoutTask = Task.Delay(timeout);
        var completedTask = await Task.WhenAny(task, timeoutTask);
        if(completedTask == task){
            return task.Result; 
        }
    }
    throw new InvalidOperationException(
        $"Was not able to execute the task within {attempts} attempts");
}

To use:

Retry(() => 4, TimeSpan.FromSeconds(1)).Result.Dump();
Retry(() => 4, TimeSpan.FromMilliseconds(1)).Result.Dump();
Retry(() => {Thread.Sleep(500); return 4;}, TimeSpan.FromMilliseconds(500)).Result.Dump();
Retry(() => {Thread.Sleep(500); return 4;}, TimeSpan.FromMilliseconds(1)).Result.Dump();

Requests for clarification of comments:

  

How can I identify which action is being performed

A task is running if its status is equal to Running

var task = Task.Delay(500);
task.Status == TaskStatus.Running // está a ser executada

Another less correct way is to assume that your Task is running until it completes await whether it exits by exception, or by complete process

var task = Task.Delay(500);
await task; //a task está a ser executada até á próxima instrucao
Debug.Assert(task.Status == TaskStatus.RanToCompletion) // a task completou

So checking to see if a process has finished in 10 minutes can be done as follows:

async Task<bool> Timeout(Action action, TimeSpan timeout){
    var task = Task.Factory
        .FromAsync(action.BeginInvoke(null, null), r => action.EndInvoke(r));
    var timeoutTask = Task.Delay(timeout);
    var completedTask = await Task.WhenAny(task, timeoutTask);
    return completedTask == task;
}

Timeout(()=> Thread.Sleep(TimeSpan.FromSeconds(5)), TimeSpan.FromMinutes(10)).Result.Dump();

If you watched, you saw that the code is similar to the code I showed earlier for Retry .

  

I just want to run again if I did not have anything I was doing   of that same action

I do not know what that means. If you had a task executed then, from the moment it enters the TaskStatus.Running state, it has already executed something.

In other words, you will never have to execute anything again because something has already been executed.

It seems that the question has changed a lot, but criticism aside ...

  

The problem is that I do not know how to create an identifier for   each process store its status and after the determiner time   verify the process by the identifier.

The only way I know of solving this problem is to create an identifier when creating the process and provide this identifier to the API consumer.

Minimalist example:

/*********** API ***********/
private Dictionary<string, Task<int>> tarefas = new Dictionary<string, Task<int>>();
private Random r = new Random();

private async Task<int> Tarefa(){
    await Task.Delay(TimeSpan.FromSeconds(5));
    return r.Next();
}

public string CriaTarefa(){
    var id = Guid.NewGuid().ToString();
    tarefas.Add(id, Tarefa());
    return id;
}

public int? VerificaTarefa(string id){
    Task<int> tarefa;
    if(!tarefas.TryGetValue(id, out tarefa)){
        return null;
    }
    if(!tarefa.IsCompleted){
        return null;
    }
    return tarefa.Result;
}

/*********** Cliente ***********/
var id = CriaTarefa();

while(VerificaTarefa(id) == null){
    Thread.Sleep(500);
}

VerificaTarefa(id).Dump();

There are better techniques that prevent polling from the operation

Instead of checking the process, what you should do is create an event that allows the client to be notified.

/*********** API ***********/   
public class Tarefa{
    public event EventHandler<int> OperationCompleted;
    private Random r = new Random();

    public async void CriaTarefa(){
        await Task.Delay(TimeSpan.FromSeconds(5));
        OperationCompleted?.Invoke(this, r.Next());
    }

}

/*********** Cliente ***********/
var tarefa = new Tarefa();
tarefa.OperationCompleted += (ctx, r) => r.Dump();
tarefa.CriaTarefa();
Thread.Sleep(TimeSpan.FromSeconds(6));