Interesting idea but I see a few potential problems:
-Consumers are still tightly coupled with commands the they rely on
Yes although I can't think where I've ever needed to replace the command with something else. If it became necessary to have that level of flexibility, sure I'd take a different approach - but _only_ when it became necessary. Due to the way the commands are executed elsewhere, things can still be tested easily.
-Consumers still need to construct each command (including supplying of dependencies). If those dependencies also have dependencies then your code will get messy very quickly
Actually, the dependencies are supplied by the command runner. The class creating the command will just provide its basic parameters, there is a little bit of logic in the runner to supply dependencies where needed (such as data access components). Typically there will not be many different types of dependencies so this logic is very straight forward. It just depends on how you have set up your application.
-If an I*Service would normally expose 2+ methods, then this would presumably be 2+ commands? How would state that would have been encapsulated by said service be encapsulated across multiple commands?
Hm the state is really held in whatever the commands are operating on, so most likely they will have a shared dependency. If you are describing a transaction across multiple calls to your service, then this entire transaction could be either encapsulated within a command or just within the method that is creating these commands depending on the level of reuse required.
-Can't easily restrict the number of instances of a particular command
You don't need this with the commands, they are extremely light weight. You don't need to share state or anything like that, they are disposed of as soon as they are executed. The commands are more like delegates but with the benefit that they all follow the same basic interface and can have dependencies injected into them just before they are executed.
The dependencies might be longer lived and I expect these to be managed by a factory or IoC container but the commands themselves represent tiny bits of logic to perform updates and are not holding onto resources any longer than their execute method takes to run.
Although I mention dependencies being injected into commands you still end up with a much simpler configuration because you don't have to deal with entity specific services like IUserUpdateService, IUserDeletionService etc, just a few abstractions like ICommand, IDatabase (or data context), IEmailService which are more general.
It's worked for me on a few projects and they're all easy to maintain looking back. Like with all things though it depends on your requirements. For my own projects it's mostly about keeping the number of layers to a minimum and the number of abstractions per layer to a minimum as well.
Edit: by the way this isn't something I've come up with myself, it's actually from a series of blog posts by Ayende: h ttps://ayende.com/blog/154209/limit-your-abstractions-refactoring-toward-reduced-abstractions - which I believe is well worth the read if you haven't already.