Question

I started a small app (C#, .Net4, console app) and it was a basic idea for moving files around at home based on rules.

This app has grown and become extremely useful. So my task is to break it into more reusable classes and smaller projects (class libraries).

I have a generic ‘Show’ function that accepts a string, and a error_level id. Based on that, I would output text to my console window in a certain colour. All is fine when it’s all in one big class, but I want to move a method to it’s own class libabry – however, I want it to report updates while it’s processing, to my UI (Console window, for now). When I move it to the class, obviously, class to my ‘Show’ method’, break.

Is there a way I can get messages sent from my class method, back to my UI? It’s messages like, ‘Opened Config file’, ‘Processing 12 new files’, ‘Success’.

And as it happens, the UI gets the messages and displays them, while the method finishes it’s job.

At the moment, it’s a Console App project. My plan is to rip out the working code, keeping the console app for testing, and later, change the ‘UI’ into a nice WPF desktop application. (I’m trying to learn WPF, and decided to use a small project I started ages ago, and ‘skin it’).

Answer 1

I would suggest that you add an interface, implement that interface in your UI, and pass a reference to the class that implements the interface to your new classes.

This approach should work if you are performing the work in a single thread or multiple threads.

For example, the interface:

public interface INotify
{
    void Notify(string Msg);
}

the UI:

public class Form1 : INotify
{
        // This is the method where you instantiate the new worker process
        public void DoSomeWork() {
            NewClass Worker = New NewClass(this);
        }

        public delegate void NotifyDelegate(string Msg);

    public void Notify(string Msg)
    {
        txtLog.Text += Msg + Environment.NewLine;
    }

    void INotify.Notify(string Msg)
    {
        this.INotify_Notify(Msg);
    }
    private void INotify_Notify(string Msg)
    {
        if (this.InvokeRequired)
        {
            this.Invoke(new NotifyDelegate(Notify), Msg);
        }
        else
        {
            this.Notify(Msg);
        }
    }
   }

and the new class (just call notify in this class to send the message):

public class NewClass
{
    private INotify m_Notifier;

    private void Notify(string Msg)
    {
        m_Notifier.Notify(Msg);
    }

    public NewClass(INotify oNotifier)
    {
        m_Notifier = oNotifier;
    }
}

Update with alternate implementation

An alternate implementation, which will work with static classes, is to implement a delegate.

For example, here is the delegate:

public delegate void NotifyDelegate(string Msg);

Here is the sample static class for the console app:

static class Program
{
    private static NotifyDelegate m_Notifier;
    static void Main(string[] args)
    {
        m_Notifier = new NotifyDelegate(Notify);

        NewClass oNewClass = new NewClass(m_Notifier);

        // Your work code here
    }
    static void Notify(string Msg)
    {
        Console.WriteLine(Msg);
    }
}

and a revised version of the work class:

public class NewClass
{
    private NotifyDelegate m_Notifier;

    public void Notify(string Msg)
    {
        m_Notifier.Invoke(Msg);
    }

    public NewClass(NotifyDelegate oNotifier)
    {
        m_Notifier = oNotifier;
    }
}