Using delegates to communicate between forms and networkcommunicator class
My suggestions:

If the NetworkCommunicator exists only once per application, you should create a singelton. Code sample:

    /// &lt;summary&gt;
    /// Provides a base class for singeltons.
    /// &lt;/summary&gt;
    /// &lt;typeparam name="T"&gt;The class that act as a singelton.&lt;/typeparam&gt;
    public abstract class Singleton&lt;T&gt;
        where T : class
    {
        protected Singleton()
        {
        }

        /// &lt;summary&gt;
        /// Gets the singelton instance.
        /// &lt;/summary&gt;
        public static T Instance
        {
            get { return Nested._instance; }
        }

        private sealed class Nested
        {
            /// &lt;summary&gt;
            /// Creates the nested instance class.
            /// &lt;/summary&gt;
            /// 
            /// &lt;remarks&gt;
            /// Explicit static constructor to tell the compiler
            //  not to mark type as beforefieldinit.
            /// &lt;/remarks&gt;
            static Nested()
            {
                ConstructorInfo constructor = typeof (T).GetConstructor(Type.EmptyTypes) ??
                                              typeof(T).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);

                if (constructor == null)
                    throw new InvalidOperationException("Class has no private nor public constructor");

                _instance = (T)constructor.Invoke(null);
            }

            internal static readonly T _instance;
        }
    }


If someone has any suggestion about my singelton implementation, let me know it..

The delegate makes the code more complex and violates the KISS OOP principle: Keep It Simple and Stupid. Make it as easy as possible first.