Disable IUpdater from another App - UIControlledApplication

[Sean_Page]

I have two different add-ins, and each of them have IUpdaters in them. Currently they reference each other tp share some methods but I would like to be able to disable the updaters in one of the apps.

1. I have a static method that works fine within the app to do this.

internal static Result EnableUpdaters(UIControlledApplication UIApp, string name)
		{
			try
			{
				if(name == "room" || name == "all")
				{
					Updaters.RoomCreationUpdater roomUpdater = new Updaters.RoomCreationUpdater(UIApp.ActiveAddInId);
					UpdaterRegistry.EnableUpdater(roomUpdater.GetUpdaterId());
				}
				return Result.Succeeded;
			}
			catch(Exception ex)
			{
				MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
				return Result.Failed;
			}
		}

2. I have a public static method to call the Enable and Disable updater calls

public class SetUpdaters
    {
        public static void UpdaterOn(UIControlledApplication UIApp, string name)
        {
            App.EnableUpdaters(UIApp, name);
        }

        public static void UpdaterOff(UIControlledApplication UIApp, string name)
        {
            App.DisableUpdaters(UIApp, name);
        }
    }

3. Here is the call from the app. This call is using a control ID for the UIControlApp inside this app and passing it to the other. This is where I think I may be off, but when trying to use the static variable stored in the other app in lieu of passing it, that doesn't work either and I get the same error message.

OtherApp.Controls.SetUpdaters.UpdaterOff(ControlParams.application,"room");

4. When I make the call between apps, I get an error saying that "Updater with this Id is not currently registered," but then of course the updater fires immediately following closure for that dialog so I know its working, and the updater does what it is supposed to do, I am just trying to keep it from doing it.

Is there something fundamental here I am just overlooking?

[jeremy_tammik]

I vaguely seem to remember in the far distant past that the Revit API could sometimes be picky with external command and external application instances. I think back then that Revit would sometimes pass you a new (re-instantiated) instance of one of these classes that was not identical to the original instance that you used for some persistent purpose, e.g., setting up the updater, and that could cause some kind of problem.

I think possibly my specific case back then had to do with subscribing and unsubscribing to certain events.

You have two different external applications in this scenario, don't you? Have you kept hold of static references to both in some global variables, so that you can guarantee that you always use the same two references to these two objects?

[aignatovich]

Hi!

In this case these two application (does not matter, db application, ui application, ui control application) objects would be different. You can check it via ActiveAddInId. You can't control app#1 updaters from app#2.

See remarks in UpdaterRegistry class:

The registry is an application-wide singleton. It maintains all dynamic updaters currently registered, and also invokes them per their respective trigger condition during subsequent transactions.

Please note that only the application (an add-in, typically) which registered an updater is allowed to modify it later, including unregistering it. Also, an application is not allowed to register an updater with an Id, that is based on another application's Id.

In your case you could share application state somewhere and check if you should or should not do some actions in IUpdater.Execute method

[Sean_Page]

Thanks Jeremy, and yes that is what I confusing me. I use a static variable reference to the UIControlledApp in both of them (set on startup) to make calls to disable several updaters on a regular basis, that is why I am confused why it isn't working in this case. The obvious difference being the outside call, but I don't know why that would affect the static variable within the app I am calling since I am not directly trying to register, enable, disable or unregister it from another app, but just within itself.

[Sean_Page]

Thanks for your reply @aignatovich. I had assumed this (without researching) and had originally tried to get this to work without passing the UIContApp, but when that didn't work I tried to pass it and it didn't work either. I understand what you are saying, but what I don't know is why it won't Disable / Enable within the app.

App #1:

1. OnStartUp
   1. Set global Static Variable for the UIContApp
   2. Register Updater using global variable
2. Updater register fine
3. Enable / Disable calls using Static Variable work fine internally
4. Created two public static methods to Disable / Enable updaters USING the global Static Variable

App #2

1. When running code that would trigger updater, makes call to App #1
   1. Calls Static method to Disable / Enable Updaters in App #1
      1. Static Variable for UIContApp is WITHIN App #1, not passed by App #2
      2. I receive the same message about the AddInId being wrong / missing
   2. If I call this same static method from within App #1, say in an event handler for synchronizing, it works fine and no error is thrown.

In short, it seems like the static variable in App #1 is not "holding" the value or at least isn't giving the correct value when used in the call from App #2.

As you mentioned, I have been using a simple bool switch for now, but that didn't seem elegant and also means the updater still "fires" just doesn't do anything. On some of the larger models this could be working on it may still lag and that is what I was trying to avoid.

[aignatovich · Accepted solution]

Yep, I also don't like those flags. It seems. I've found a solution for you.

So, we have this chain:

Invoke method (app #2 context) -> ... -> UpdaterRegistry.EnableUpdater [still in context of app #2]

Let's try to break it with external events. IExternalEventHandler should be invoked in app#1 context.

So I introduced UpdaterController:

using Autodesk.Revit.DB;
using Autodesk.Revit.UI;

namespace RevitAddin1
{
    public class UpdaterController : IExternalEventHandler
    {
        private readonly UpdaterId updaterId;
        private readonly ExternalEvent externalEvent;
        private bool isEnabled = true;

        private UpdaterController(UpdaterId updaterId)
        {
            this.updaterId = updaterId;
            externalEvent = ExternalEvent.Create(this);
        }

        public static UpdaterController Instance { get; private set; }

        public static void Initialize(UpdaterId updaterId) => Instance = new UpdaterController(updaterId);

        public void Toggle() => externalEvent.Raise();

        public void Execute(UIApplication app)
        {
            if (isEnabled)
                UpdaterRegistry.DisableUpdater(updaterId);
            else
                UpdaterRegistry.EnableUpdater(updaterId);

            isEnabled = !isEnabled;
        }

        public string GetName() => nameof(UpdaterController);
    }
}

In app#1 onStartup method register an updater and initialize UpdaterController:

        public Result OnStartup(UIControlledApplication a)
        {
            var updater = new MyUpdater(a);

            UpdaterRegistry.RegisterUpdater(updater);

            UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), new ElementClassFilter(typeof(Wall)), Element.GetChangeTypeElementAddition());

            UpdaterController.Initialize(updater.GetUpdaterId());

            return Result.Succeeded;
        }

I was too lazy to create a new project in Visual Studio, sorry, so I controlled my application from Iron Python Shell:

import System
clr.ImportExtensions(System.Linq)

assembly = System.AppDomain.CurrentDomain.GetAssemblies().Single(lambda x: x.GetName().Name == "RevitAddin1")

controllerType = assembly.GetType("RevitAddin1.UpdaterController")

prop = controllerType.GetProperty("Instance").GetValue(None)

method = controllerType.GetMethod("Toggle")

method.Invoke(prop, None)

And it works!

[Sean_Page]

Thanks again for this solution. It does work to Disable and Enable the updater as anticipated, however it does not fire in the correct (immediate) sequence and therefore is not effective in turning it off and on during a method.

Expected: WPF From OK Button --> Turn Off Updater --> Do work --> Turn On Updater --> Return Result.

Experienced: WPF From OK Button  --> Do work --> Turn Off Updater (First Call only)--> Return Result.

Is there a way to force it to raise immediately in line?

[Sean_Page]

I am accepting the solution from @aignatovich because it did achieve what I was trying to do quite nicely, however I believe the sequencing was a matter of API limitations that I don't think I can get past.

Because of that, I decided to refactor my entire updater and actually port it to App #2. Its not the end of the world, but it does limit some functionality of App #1 when standalone but for now the best answer to my situation.

[jeremy_tammik]

I love Alexanders nice implementation and his kind testing!

Sorry to hear that the solution has a drawback fro you.

I see no need whatsoever to accept that so.

How about refactoring the common functionality into a separate class library that is referenced and shared by both app 1 and 2?

[Sean_Page]

Thanks @jeremy_tammik, and yes I greatly appreciate the help. I think the drawback here is that the External command does not fire while I am in the command / on form in App #2. It only seems to fire once after the form closes. I suppose I could go modeless and transition everything to ExternalEvents, but my path for now is moving from App #1 to App #2. May move it back and use a book flag as previously noted, but I'd really like to avoid that for performance. 

I did also try changing when the call happened to the initial command, form initialization, Load, and the button with no change. Again, I just don't think the API will let me force the Raise() while in a method like I'd like.

I also like your idea of an App #3, but I can't even get 2 to work 😂. 

[jeremy_tammik]

I don't mean an app #3, I meant a class library that provides the functionality used by apps #1 and #2.

[Sean_Page]

Ah, yes that makes sense, but in some cases we use them at the same time, but we also have them split apart at times as well which is how I got to two initially, but I will think more about that an there may be a way to do that.

Thanks again, and really what I would love to see is a way to Raise the ExternalEvent immediately!

[jeremy_tammik]

There is no question about it, and it is common practice, very basic:

• Common.dll implements common functionality
• App_1.dll references Common.dll
• App_2.dll references Common.dll

You can deploy either app alone or together and use them individually and simultaneously with no limitations whatsoever.

This is standard usage!

[Sean_Page]

Thanks Jeremy, I think I may be using the terminology wrong, but what you are describing if effectively what I am doing now and App #1.dll is a Reference to App #2.dll and and that is how I am calling between them now. I have several calls between them leveraging different parts of each, and I could be wrong, but my issue seems to be the specific functionality isn't working like I want.

App #2.dll

1. Primary App or "Common" for this discussion
   1. Has App #1 is a reference in App #2
2. Code Creates multiple Rooms
   1. Need to Disable App#1 IUpdater While doing it

App #1.dll

1. Has an IUpdater for Rooms
2. Implemented ExternalEventHandler code here to Enable / Disable Updater (per @aignatovich)
   1. Method executes, but only AFTER the method from App #2 is done and not in line therefore the updater still fires for each new room.
      
      1. After App #2 form closes, the IUpdater in #1 is turned off so again the code is working, just not in sequence from what it appears. I have confirmed this with a task dialog that only fires once although it should fire each time the ExternalEvent is called by App #2.
   2. I did create a test command that singularly uses the external event to disable / enable the IUpdater and it works great, just as a single execution.

Again, I do apologize if I am mixing things up here and there is something I am just not understanding at the core programming level. I can easily admit I am no pro, but I "think" I am approaching this correctly.

Also, I do really appreciate the help and thank you for taking your time to respond thus far!

[jeremy_tammik]

You say, I have several calls between them.

That sounds complicated to me, too complicated for my little human brain.

I prefer not to have calls between things, if I can avoid it, but just from one thing to another.

That is why I continue to suggest isolating everything basic into a basic class library that provides functionality and is not an external application or known to Revit in any way whatsoever.

Then, you can build both app 1 and 2 making use of the common functionality and try to avoid all calls between the two.

If you think you need any, rethink!

(I believe) You can solve it in such a manner that both of them only call the base functionality, and never each other.

I (believe I can) guarantee that will simplify things.

KISS.