Interface Event between two projects in one solution and Event Handlers

Question

I have separated two projects in my solution because they each require libraries targeting different CPU. In one of my project, I just have classes that respond to clicks (let's call it ProjectClick 64 bits libraries), the other one is a sort of UI with an MVVM implementation (ProjectUser 32 bits libraries).

The thing I am searching for is a way to let the ProjectUser know that the click has been performed by the ProjectClick, without the Project Click knowing anything else.

What I have tried so far

I have been scattering the web and books to understand a bit more about C#. From what I understood, to communicate, the best way is to create a Interface. I have been looking at this subject for an answer, and have been trying to implement a third project with an interface between the two.

Ok, here goes the code, (this is a purposely simplified code, I hope it is clear enough)

First the Interface (in a console application)

namespace LinkApplication
{
    public interface IEvent
    {

        bool CompareClick { get; set; }
    }

 }

Then, the project clicking which is a wpf

namespace ProjectClick

public partial class MainWindow : Window, IEvent

{

    public MainWindow()
    {

        try { InitializeComponent(); }
        catch (Exception e)
        {
            Console.WriteLine(e.InnerException);
        }
    }
    private void Button_Click(object sender, RoutedEventArgs e)
    {
         CompareClick = true;
    }
    private void Button_Leave(object sender, RoutedEventArgs e)
    {
         CompareClick = false;
    }


}

Finally the UI

namespace ProjectUser
{


public partial class MainWindow : Window, IEvent, INotifyPropertyChanged
{

    public MainWindow()
    {
        InitializeComponent();

        this.WindowStartupLocation = WindowStartupLocation.CenterScreen;    //start the window at the centre of the screen
        DataContext = this;

    }

    public bool CompareClick { get; set; }

    public bool ClickCheck
    {
        get { return CompareClick; }
        set
        {
            if (value != CompareClick)
            {
                CompareClick = value;
                OnPropertyChanged("ClickCheck");
            }
        }
    }

You can see the realted Label here in the Window

<Label Content="{Binding ClickCheck}" HorizontalAlignment="Left" Margin="690,358,0,0" VerticalAlignment="Top"/>

Here, the value always stays at false, and I don't really understand the logic of the changing value. I am still learning, and I have seen several other ideas on the web like a custom EventHandler, but I don't really understand the implementation between two projects not knowing each others. I will be glad if someone could route me towards a possible solution, or a better way to perform.

Edit I would preferably like to avoid referring the Project Click in the ProjectUser to keep the privileges of different CPU targeting. The other way around is not a problem.

Thank you for your kind answers.

Answer 1

I have been greatly advised and have looked into Inter Process Communication between instances. I have looked into different things but the most satisfying answer of all was on Omegaman's blog (bit thanks to this subject).

So basically, I have tried to avoid localhost information, thinking there would be a more straightforward solution. But since we have not thought of anything better, I think this is what I was looking for.

What I have found

So now, the solution here was to use a WCF service with NamedPipes. By creating a Sender and Receiver actions, the two process ProjectUser and ProjectClick never encounter each other directly. You have instead a pipe controlled by the WCF. You can see more details on the blog on how to communicate, I just adapted (without great change) what he did by changing the passing information.

One thing to note however

The processes cannot both start at the same time, and the receiver must start first to listen to the information coming through. Basically, the sender has to start afterwards.

I created two windows in WPF, and a WCFServiceLibrary. When the button is clicked, there is an incrementation, and it shows the number on the second screen.

A little bit of code

You can see a lot on Omegaman's blog, and I will just post what I have changed.

On the ProjectUser side, supposed to receive, the label is updated as follows Receiver pipe = new Receiver(); public MainWindow() { InitializeComponent();

        //this.WindowStartupLocation = WindowStartupLocation.CenterScreen; //start the window at the centre of the screen
        DataContext = this;
        pipe.Data += new PipeLink.PipeService.DataIsReady(DataBeingRecieved);
        if (pipe.ServiceOn() == false)
            MessageBox.Show(pipe.error.Message);

        label1.Content = "Listening to Pipe: " + pipe.CurrentPipeName + Environment.NewLine;
    }

    void DataBeingRecieved(int data)
    {
        Dispatcher.Invoke(new Action(delegate()
        {
            label1.Content += string.Join(Environment.NewLine, data);
            label1.Content += Environment.NewLine;
        }));
    }

On the ProjectClick side, supposed to send, the button click updates as follows

 int i;
    public MainWindow()
    {
         try { InitializeComponent(); }
        catch (Exception e)
        {
            Console.WriteLine(e.InnerException);
        }
         i = 0;

    }

    private void Button_Click_1(object sender, RoutedEventArgs e)
    {
        int messages;

        i++;

        Stopwatch stoop = new Stopwatch();
        stoop.Start();
        messages = i;
        try
        {
            PipeLink.Sender.SendMessage(messages);
            stoop.Stop();
            Console.WriteLine(stoop.ElapsedMilliseconds + " ms");

        }
        catch (Exception u)
        {
            Console.WriteLine(u);
        }
    }

The important part of the code, is the creation of the pipe itself, using NetNamedPipeBinding. This is where the whole communication will take place

You can see it in the PipeService code :

public class PipeService : IPipeService
{

    public static string URI
       = "net.pipe://localhost/Pipe";

    // This is when we used the HTTP bindings.
    // = "http://localhost:8000/Pipe";

    #region IPipeService Members

    public void PipeIn(int data)
    {
        if (DataReady != null)
            DataReady(data);
    }

    public delegate void DataIsReady(int hotData);
    public DataIsReady DataReady = null;

    #endregion
}

What about the speed?

I was afraid simple data may take longer to arrive than on a simple click. I was mistaken : the first number took longer than the others because of the first connection, so about a second. But after that, for clicking about a 100 times, I had a, average of 10 ms (I know it is not significant data, still I thought it was good to test it a couple of times).

I am pushing everything on the GitHub used with Andreas, for anyone who might be interested.

I still do not know if the code is optimized though. Should you have a better solution, I will happily read it.

Answer 2

As others pointed out your concept of interfaces is wrong still. However i get what you're trying to do.

Try this:

namespace LinkApplication
{
    public interface IEventReceiver
    {
        void Receive<T>(T arg) where T : EventArgs;
    }

    public class SomeUniqueEvent : EventArgs
    {
        public bool Clicked { get; set; }

        public SomeUniqueEvent(bool clicked)
        {
            Clicked = clicked;
        }
    }

    public static class EventTunnel
    {
        private static readonly List<IEventReceiver> _receivers = new List<IEventReceiver>();
        public static void Publish<T>(T arg) where T : EventArgs
        {
            foreach (var receiver in _receivers)
            {
                receiver.Receive(arg);
            }
        }

        public static void Subscribe(IEventReceiver subscriber)
        {
            _receivers.Add(subscriber);
        }
    }
}

namespace ProjectClick
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {

            try { InitializeComponent(); }
            catch (Exception e)
            {
                Console.WriteLine(e.InnerException);
            }
        }
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            LinkApplication.EventTunnel.Publish(new LinkApplication.SomeUniqueEvent(true));
        }
        private void Button_Leave(object sender, RoutedEventArgs e)
        {
            LinkApplication.EventTunnel.Publish(new LinkApplication.SomeUniqueEvent(false));
        }
    }
}

namespace ProjectUser
{

    public partial class MainWindow : Window, LinkApplication.IEventReceiver, INotifyPropertyChanged
    {

        public MainWindow()
        {
            InitializeComponent();

            this.WindowStartupLocation = WindowStartupLocation.CenterScreen; //start the window at the centre of the screen
            DataContext = this;
            LinkApplication.EventTunnel.Subscribe(this);

        }

        public bool CompareClick { get; set; }

        public bool ClickCheck
        {
            get { return CompareClick; }
            set
            {
                if (value != CompareClick)
                {
                    CompareClick = value;
                    OnPropertyChanged("ClickCheck");
                }
            }
        }

        public void Receive<T>(T arg) where T : EventArgs
        {
            var casted = arg as SomeUniqueEvent;
            if (casted != null)
            {
                ClickCheck = casted.Clicked;
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }
}

Answer 3

Here, you misunderstand what an interface is. Every implementation of an interface is a different one. When you click the button, CompareClick property of ProjectClick project's MainWindow changes value. But that doesn't change the ProjectUser project's MainWindow. They are two completely different objects! The best way that I can think of now, is to make the button public. Alternatively, you can create a method in the MainWindow class of the ProjectClick. Use this method to subscribe to the click event. Something like this:

public void SubscribeToClickEvent (EventHandler handler) {
    this.Button.Click += handler //whatever your button is called
}

If you want to encapsulate Button, use the method above. If you don't, then just make it public.

And you ask, how can I access an instance of MainWindow to use the method? The only way I can think of is to make MainWindow a singleton.