Home/ Questions/Q 6682143
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-26T04:40:18+00:00

I have some nice, working edit-undo functionality in my winforms application. It works using

  • 0

I have some nice, working edit-undo functionality in my winforms application. It works using a CommandStack class, which is two Stack<IStateCommand>s (one for undo, one for redo). Each command has an Execute and an Undo method, and the CommandStack object itself has an event that is fired when the stacks are changed.

The CommandStack also works out if the LogCommand method is called from its own Undo function, and therefore adding it to the redo stack, rather than the undo stack. This is done by simply adding the current ManagingThreadId to a List<int> object, then removing it after the Undo command is completed (as opposed to using the stack trace, which I believe would be much slower and a bit dirty).

There is a lot of different commands within my application so this formula is sort of set in stone as it’ll take me a few days to redo all those IStateCommands implementations.

The only problem with this, currently, some UI events within also call other UI events, both of which log an IStateCommand to the undo history. Is there any way in C# that I can detect if the LogCommand function has already been called from the same UI event (Click, DragDrop, SelectedIndexChanged, TextChanged, etc), then I can combine the commands into one command (using my CommandList class, which also inherits IStateCommand)?

I’ve thought of saving the current time when the undo event was called, then if the next command is logged less than x milliseconds later, combine them in the history, but this seems a bit sloppy. I’ve also considered searching the stack trace, but I don’t really know what to look for to find the root UI event, nor do I know whether I would tell the different between one button click, then a different click on the same button.

It may also be helpful to know that all of these commands are being called from the UI thread from event handlers (mostly from events from custom user controls). The only part of my application that uses another thread runs after most UI events, after the undo history is logged.

Thanks!

Sort Version

The same method is being called twice from the same UI event (eg, MouseUp, DragDrop). The second time this method is called, how do I check that it has already been called once by the same UI event?

Edit: The solution (sort of)

It’s a bit of a dirty one as I don’t have the time to completely re-write this system. However I’ve implemented it in such a way that gives the option not to be so dirty in the future.

The solution is based on one of Erno’s comments on his answer (so I will mark his answer as accepted), where he suggests added a parameter. I added another overload to my LogCommand(IStackCommand) method in the CommandStack class, LogCommand(IStackCommand, string). The string is the actionId, which is stored for each command, and if this string is the same as the last, the commands are combined. This gives the option to go through each event and give a unique ID.

However, the dirty part – to get it working before we have to show the client, the actionId defaults to System.Windows.Forms.Cursor.Position.ToString(), ouch!! Since the cursor position is not changed while the UI thread is executing, this combines each command. It actually even combines TextChanged commands (as long as they don’t move their mouse!)

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    It might be an option to add a local stack of called-commands to a command.

    When a command executes other commands add the command to the local stack so you can undo the commands on this local stack when the command must be undone or redone.

    EDIT

    I am not quite sure what you don’t understand.

    I would simply add a CommandList property to the StateCommand. Everytime the StateCommand invokes/triggers another StateCommand it should add the new StateCommand to the CommandList. So the global CommandList keeps track of the Commands that can be undone from the UI and each StateCommand keeps track of the StateCommands it invoked (so these are not added to the global undo CommandList)

    EDIT 2

    If you can’t or do not want to change to that setup you would have to pass a parameter to the execution of the commands that links them together.

    • 0