C# – How to you add acknowledgement functionality to a Command pattern, given the response from receiver is gotten asynchronously on Server

asp.netcsockets

I have a scenario where I will implement Command pattern like described in this article.

Actually from an Asp.Net MVC view, some user will invoke different commands/actions like Start Live Video, Start Live Image, Start Recording etc.
A Web Socket Server will then receive these commands and dispatch them to a Receiver (a Windows based application). The receiver before executing the requested command, will first acknowledge the received command and will confirm back to sender that the sent command has been received for processing.

Note: The acknowledgement and/or the actual response will be returned to the Web Socket Server always in an asynchronous manner and then accordingly dispatched to the sender. Means whole system is event driven based.

So my question is:

Given the Command pattern described in the article, now which best way I could add Command Acknowledgement to it and will the returned acknowledgment and/or actual response be also in the form of some command/message or something else?

If we are to go something different for dispatching the Acknowledgement or response, then which pattern to use for it?

Best Answer

I think that you are on the correct path way. You could modify the command pattern to pass a callback reference which will be used to notify the Invoker for the execution of the Command.

The abstract receiver would have an added ExecuteAndNotify hook method. This method would call the already existing Execute method on the ConcreteCommand and then execute the another added method called Notify. This Notify method would use the callback reference to notify the Invoker of the succesful execution of the command.

The callback reference could be a function pointer if the Invoker and the Receiver are classes in the same application. If they are parts of another service, it could be a URL of a "service".

Hope I helped!

Related Solutions

C# – Async network programming using Reactive Extensions

...I would like to simplify my work by creating an object that I can simply instantiate, tell it on which IPEndpoint to listen and have it tell me whenever something of interest is going on...

After reading that statement I immediately thought "actors". Actors are very similar to objects except they only have a single input where you pass it the message (instead of directly calling the object's methods) and they operate asynchronously. In a very simplified example... you would create the actor and send it a message with the IPEndpoint and the address of the actor to send the result to. It goes off and does it work in the background. You only hear back from it when "something of interest" happens. You can instantiate as many actors as you need to handle the load.

I am not familiar with any actors libraries in .Net although I know there are some. I am familiar with the TPL Dataflow library (there will be a section covering it in my book http://DataflowBook.com) and it should be easy to implement a simple actor model with that library.

C# – How to use the “Non-Member Functions Improve Encapsulation” pattern from C#

Use the following rules:

For any non-static method of a class which a) does not access private fields directly and b) only calls public methods, move the method to a static helper class and turn it into an extension method.
Any public static method can also be moved to a helper class.

By convention, a helper is a new static class with the same name as the original class but with the word Helper appended to it.

Example:

ORIGINAL CODE:

public class Foo
{
    int _intField;

    public void Method1()
    {
        doing something with _intField;
    }

    public void Method2()
    {
        Method1();
    }

    public static void Method3()
    {
        ....
    }

    private void Method4()
    {
        ....
    }

    public void Method5()
    {
        Method4();
    }
}

PROPOSED TRANSOFORMATION:

public class Foo
{
    int _intField;

    public void Method1()
    {
        doing something with _intField;
    }

    private void Method4()
    {
        ....
    }

    public void Method5()
    {
        Method4();
    }
}

public static class FooHelper
{
    public static void Method2(this Foo foo)
    {
        foo.Method1();
    }

    public static void Method3()
    {
        ....
    }
}

Method 1 cannot move because it's using a private field
Method 2 can move because it's not using a private field and it's calling a public method. It can be turned into an extension method.
Method 3 can be moved because it's a static public method
Method 4 cannot move because it's a private method
Method 5 cannot move because it's calling a private method.