I'm doing a multiplatform thing, but I'm not very good with OOP. Currently my code is:

    public interface IMessageBox {
        void Show(string Text);
        void Show(string Text, string Description, MessageBoxType Type);
        MessageBoxResult ShowYesNo(string Text, string Description, MessageBoxType Type);
        MessageBoxResult ShowYesNoCancel(string Text, string Description, MessageBoxType Type);
    }

    public class MessageBox : InstanceGenerator {
        public static void Show(string Text) {
            MessageBoxImpl.Show(Text);
        }

        public static void Show(string Text, string Description, MessageBoxType Type) {
            MessageBoxImpl.Show(Text, Description, Type);
        }
        public static MessageBoxResult ShowYesNo(string Text, string Description, MessageBoxType Type) {
            return MessageBoxImpl.ShowYesNo(Text, Description, Type);
        }
        public static MessageBoxResult ShowYesNoCancel(string Text, string Description, MessageBoxType Type) {
            return MessageBoxImpl.ShowYesNoCancel(Text, Description, Type);
        }
    }

protected class InstanceGenerator {
        public static IMessageBox MessageBoxImpl = null;
        public static IWindow WindowImpl = null;

        private static Assembly Instance = null;
        private static string InstanceName = null;

        private static Assembly LoadAssembly(string lib) {
            string AppPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            Assembly assembly = Assembly.LoadFile(Path.Combine(AppPath, lib + ".dll"));
            return assembly;
        }

        private static object CreateInstance(string @class) {
            Type type = Instance.GetType(InstanceName + "." + @class);
            return Activator.CreateInstance(type);
        }

        private static object CreateInstanceFromPath(string lib, string @class) {
            string AppPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            Assembly assembly = Assembly.LoadFile(Path.Combine(AppPath, lib + ".dll"));
            Type type = assembly.GetType(lib + "." + @class);
            return Activator.CreateInstance(type);
        }


        /// <summary>
        /// Inits the whole thing
        /// </summary>
        public static void Init() {
            if (CurrentOS.IsWindows)
                InstanceName = "Lib.Windows";
            else if (CurrentOS.IsMac)
                InstanceName = "Lib.MacOS";
            else if (CurrentOS.IsLinux)
                InstanceName = "Lib.Linux";
            else // no implementation for other OSes
                throw new Exception("No implementation of Lib for this OS");

            Instance = LoadAssembly(InstanceName);

            // initialize the classes
            MessageBoxImpl = (IMessageBox) CreateInstance("MessageBox");
        }
    }

EDIT:

Where InstanceGenerator returns an instance of the IMessageBox loaded from an assembly. Is there a better way to create/connect to an instance? Implementing all the same static methods looks not good soltution at all. Is there a more automatic way to wrap those interfaces with a class or I'm doing something wrong?

• c#
• .net
• oop
• interface

You're not currently implementing the interface. You can't use static methods to implement an interface. You have to use instance methods. You can call static methods within the implementation, of course, but that's a different matter.

It doesn't sound like MessageBox should derive from InstanceGenerator - I'd suggest that it should compose it:

public class MessageBox : IMessageBox {

    private readonly InstanceGenerator generator;

    public MessageBox(InstanceGenerator generator) {
        this.generator = generator;
    }

    public static void Show(string Text) {
        generator.MessageBoxImpl.Show(Text);
    }

    public static void Show(string text, string description, MessageBoxType type) {
        generator.MessageBoxImpl.Show(text, description, type);
    }

    public static MessageBoxResult ShowYesNo(string text, string description, 
                                             MessageBoxType type) {
        return generator.MessageBoxImpl.ShowYesNo(text, description, type);
    }

    public static MessageBoxResult ShowYesNoCancel(string text,
                                                   string description,
                                                   MessageBoxType type) {
        return generator.MessageBoxImpl.ShowYesNoCancel(text, description, type);
    }
}

I'm assuming that MessageBoxImpl doesn't already implement IMessageBox as otherwise all of this is pretty pointless...

Your implementation as it stands defines an interface that doesn't actually do anything. The point of an interface is to allow you to write code that says something like:

instance_implementing_interface.DoSomething();

You don't have that. Instead you're defining an interface, then rewriting everything it does using static methods. The idea of an interface is that whatever wants to use an instance to do its job can take any instance which implements that interface, and trust that it does what it says it does (unless you are in the habit of lying to yourself in your own API).

In fact having written the above, I realise that I might have assumed you to be more confused than you actually are - after several re-readings, you seem to understand everything I've said. Which leads me to bafflement as to why you've written the code you have. Could you explain why you've deliberately written static methods in MessageBox?