C#

Richard Deeming wrote:

I'd suggest using a separate method to avoid making the regular method slower:

public class ObjectCreateMethod
   {
       delegate object MethodInvoker();
       MethodInvoker methodHandler = null;

       public ObjectCreateMethod(Type type)
       {
           CreateMethod(type.GetConstructor(Type.EmptyTypes));
       }

       public ObjectCreateMethod(ConstructorInfo target)
       {
           CreateMethod(target);
       }

       void CreateMethod(ConstructorInfo target)
       {
           DynamicMethod dynamic = new DynamicMethod(string.Empty,
                       typeof(object),
                       new Type[0],
                       target.DeclaringType);
           ILGenerator il = dynamic.GetILGenerator();
           il.DeclareLocal(target.DeclaringType);
           il.Emit(OpCodes.Newobj, target);
           il.Emit(OpCodes.Stloc_0);
           il.Emit(OpCodes.Ldloc_0);
           il.Emit(OpCodes.Ret);

           methodHandler = (MethodInvoker)dynamic.CreateDelegate(typeof(MethodInvoker));
       }

       public object CreateInstance()
       {
           return methodHandler();
       }
   }

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var maxArrows = Link.ArrowMaximum;      // Calls static construxtor.
            var link = new Link();                  // Calls default construtor.

            IWeapon weapon = new KokiriSword();
            link = new Link(10);                    // Calls parameterized constructor without injection.
            link = new Link(weapon);                // Calls parameterized constructor with injection;
            link = new Link("Go to Lost woods");    // Calls internal constructor within this assembly only.

            var fierceDeityLink = new FierceDeityLink();    // Calls the protected constructor through the public constructor of the derivied class.
        }
    }

    public interface IWeapon
    {
        int Damage { get; }
    }

    public class NoWeapon : IWeapon
    {
        public int Damage { get; private set; }
        public NoWeapon()
        {
            Damage = 0;
        }
    }

    public class KokiriSword : IWeapon
    {
        public int Damage { get; private set; }
        public KokiriSword()
        {
            Damage = 1;
        }
    }

    public class BigGoronSword : IWeapon
    {
        public int Damage { get; private set; }
        public BigGoronSword()
        {
            Damage = 100;
        }
    }

    public class Link
    {
        public static int ArrowMaximum { get; private set; }
        public int Rupies { get; private set; }
        public bool RecuredZelda { get; private set; }
        public string HintFromNavi { get; private set; }
        public IWeapon Weapon { get; private set; }

        static Link()
        {
            // Static construxctor: Will run only run once when the class is first refereed in the code.
            ArrowMaximum = 100;
        }

        public Link()
        {
            // Default constructor: Initialize the property with the default value 5.
            Rupies = 5;
            Weapon = new NoWeapon();
        }

        private Link(bool recusedZelda)
        {
            // Private constructor: Must be called within the class itself.
            // Have never used this "feature" at all.
            RecuredZelda = recusedZelda;
        }

        public Link(int rupies)
        {
            // Parameterized constructor: Initialize the property with some value.
            Rupies = rupies;
        }

        public Link(IWeapon weapon)
        {
            // Parameterized constructor with injection.
            // Link will have a weapon.
            Weapon = weapon;
        }

        protected Link(int rupies, bool recuedZelda, IWeapon weapon) : this(rupies)
        {
            // Protected constructor: Will call the parametrized constructor with some values defined in the derivided class.
            // Showing two ways to initialize the properties in the class.
            RecuredZelda = recuedZelda;
            Weapon = weapon;
        }

        internal Link(string hintFromNavi)
        {
            // Internal constructor: This constructor is only available inside the assembly.
            HintFromNavi = hintFromNavi;
        }
    }

    public class FierceDeityLink : Link
    {
        public FierceDeityLink() : base (int.MaxValue, true, new BigGoronSword())
        {
            // You don't mess with Fierce Deity Link :)
        }
    }
}

Application_DispatcherUnhandledException

private void MyFunction()
   {
   HYSYSFetch hsf = new HYSYSFetch(...); // Fill in the details from your constructor
   string result = hsf.FetchSeparators(strPathToFile);
   }