Afaik, you cannot chain them directly, but you can easily achieve the same effect:
- Subscribe to the Idling event and attach handlerA
- In handlerA, unsubscribe from the Idling event, then subscribe to the Idling event and attach handlerB
Depending on other factors, Revit may or may not execute other actions in between the two event handler calls, but their relative order should be preserved.
You say, I cannot assign a new handler because I don't have a valid API context.
Why not? Within the Idling event handler, I thought you do have a valid Revit API context.
Question: why do the actions A and B have to be executed separately? Can't you just execute them both within the same Idling event handler?
Developer Advocacy and Support + The Building Coder + Autodesk Developer Network + ADN Open
You should create a queue service for that, subscribing and unsubscribing Revit events in your App as static.
Something like this maybe helps: https://gist.github.com/ricaun/11b272c5bec46f05c3fe49525fcc3fdf
You can register the service in your IExternalApplication.
public class App : IExternalApplication
{
public static IdlingQueueService IdlingActionService { get; private set; }
public Result OnStartup(UIControlledApplication application)
{
IdlingActionService = new IdlingQueueService(application);
return Result.Succeeded;
}
public Result OnShutdown(UIControlledApplication application)
{
IdlingActionService?.Dispose();
return Result.Succeeded;
}
}
Then you could add some Action to run on the Idling Event, each one gonna run in a different Idling Event.
[Transaction(TransactionMode.Manual)]
public class Command : IExternalCommand
{
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elementSet)
{
App.IdlingActionService.Add((uiapp) => { System.Windows.MessageBox.Show("1"); });
App.IdlingActionService.Add((uiapp) => { System.Windows.MessageBox.Show("2"); });
return Result.Succeeded;
}
}
I hope this helps.
You forgot to explain that you are using 'await' functions.
Revit does not like async stuff, and your code looks odd. How can you add an await without an async method...
To work with async and Revit use the Revit.Async package, so the package gonna manage the Idling stuff.
One thing that is important is that when an IExternalCommand is running the Idling is not gonna trigger until the command ends. The Idling means the Revit is not busy doing something and is ready to receive some user interaction.
I guess the best approach in your case should be to use Revit.Async package with something like this.
public async Task Execute()
{
await func1;
await func2;
await RevitTask.RunAsync(func3); //THIS IS THE ONLY REVIT INTERACTION
}
Using the RevitTask you can run the func3 in Revit context.
One correct, reliable and effective approach to address the situation you describe is to implement an external event:
https://thebuildingcoder.typepad.com/blog/about-the-author.html#5.28
In the event handler, simply run the code to execute func3.
All the rest has nothing to do with Revit and does not require the Revit API.
Therefore, you can execute it independently, externally, and simply raise the external event after func1 and func2 have completed successfully.
Developer Advocacy and Support + The Building Coder + Autodesk Developer Network + ADN Open
Oh dear. I just noticed your statement:
> Func1 and Func2 are async functions which is why I am/was trying to run them in idling events.
Well, that is just about the opposite of what you could or should do. Or at least it is not intended, afaict.
Revit and its API is single threaded. The Idling event handler is single threaded. So, as long as that event handler is busy executing, e.g., your func1 and func2, it will block Revit from doing anything else.
The purpose of the Idling event is to enable you to execute some action as soon as Revit has stopped being occupied with and therefore blocked by other tasks.
This confirms my preceding answer: it seems to me that an appropriate way to handle this would be to disconnect func1 and func2 from Revit and your add-in as much as possible, and let them trigger an external event when they are completed, to execute func3.
Developer Advocacy and Support + The Building Coder + Autodesk Developer Network + ADN Open
Yes, this is a standard situation, and I described the standard solution above. No need for async anything, just create an external event X, raise the event when func1 and func2 have completed, and execute func3 in the external event X handler. No Idling needed, no async needed.
Developer Advocacy and Support + The Building Coder + Autodesk Developer Network + ADN Open
In the context of the Revit. API, I would recommend scrapping async completely. That will totally simplify things.
Developer Advocacy and Support + The Building Coder + Autodesk Developer Network + ADN Open
Well, I did myself, many times, connecting desktop and cloud:
https://github.com/jeremytammik/FireRatingCloud
Not very long ago, async did not exist. Push and pull functionality was up and running for decades before async was invented in the form you know it:
https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-version-history
Developer Advocacy and Support + The Building Coder + Autodesk Developer Network + ADN Open
Many thanks to everybody for the interesting discussion and valuable contributions, especially to Kennan for implementing and sharing Revit.Async. I summarised the discussion for posterity on the blog:
https://thebuildingcoder.typepad.com/blog/2022/10/can-you-avoid-chaining-idling.html#6
Developer Advocacy and Support + The Building Coder + Autodesk Developer Network + ADN Open
