Pre-compile (pre-JIT) your assembly on the fly, or trigger JIT compilation ahead-of-time

...
var attributes =
	method.GetCustomAttributes(
	typeof( DllImportAttribute ), false );
 
// Ignore DllImport attributes.
if ( attributes == null || attributes.Length <= 0 )
{
	RuntimeHelpers.PrepareMethod( method.MethodHandle );
}
...

• My personal 24/7 webcam - Always live
• Holiday Season special – zeta producer Desktop 8 (CMS) including all modules for only $129!
• Zeta Uploader - Easily send large files by e-mail. Windows and web client available.

Chris Richner wrote:

http://www.codeproject.com/script/Forums/View.aspx?fid=783605&msg=2831349[^]

Thread jitter = new Thread(delegate()
 {
    foreach (System.Reflection.AssemblyName an in 
        System.Reflection.Assembly.GetEntryAssembly().GetReferencedAssemblies())
    {
    System.Reflection.Assembly asmb = System.Reflection.Assembly.Load(an);
    if (!asmb.GlobalAssemblyCache)
    {
        foreach (Type type in asmb.GetTypes())
        {
            if (!type.IsInterface && !type.IsGenericTypeDefinition)
            {
            //must initiate only classes without static constractors
                System.Reflection.ConstructorInfo ci = type.GetConstructor(
                System.Reflection.BindingFlags.Static | 
                System.Reflection.BindingFlags.Public | 
                System.Reflection.BindingFlags.NonPublic, null, Type.EmptyTypes, null);
            if (ci == null)
            {
                foreach (System.Reflection.MethodInfo method in type.GetMethods(
                    System.Reflection.BindingFlags.DeclaredOnly |
                    System.Reflection.BindingFlags.NonPublic |
                    System.Reflection.BindingFlags.Public |
                    System.Reflection.BindingFlags.Instance |
                    System.Reflection.BindingFlags.Static))
                    {
                        if (!method.IsAbstract && !method.IsGenericMethodDefinition && 
                        !method.ContainsGenericParameters)
                    System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(method.MethodHandle);
                    }
                }
            }
        }
    }
}
});
jitter.Priority = ThreadPriority.Lowest;
jitter.Start();

namespace PreCompile
{
    class Program
    {
        static void Main(string[] args)
        {
            /* run it once with "true" and once with "false"... */
            bool prepareMethod = false;
            /*
             when true:
                Starting... (with prepareMethod == True)
                ClassWithStaticConstructor lives!!!
                Started
                Ended
             
             when false:
                Starting... (with prepareMethod == False)
                Started
                ClassWithStaticConstructor lives!!!
                Ended
             */
            Console.WriteLine("Starting... (with prepareMethod == {0})", prepareMethod);
            foreach (Type type in Assembly.GetEntryAssembly().GetTypes())
            {
                if (!type.IsInterface && !type.IsGenericTypeDefinition)
                {
                    foreach (MethodInfo method in type.GetMethods(
                        BindingFlags.DeclaredOnly |
                        BindingFlags.NonPublic |
                        BindingFlags.Public |
                        BindingFlags.Instance |
                        BindingFlags.Static))
                    {
                        if (!method.IsAbstract && !method.IsGenericMethodDefinition &&
                            !method.ContainsGenericParameters)
                        {
                            if (prepareMethod)
                                RuntimeHelpers.PrepareMethod(method.MethodHandle);
                        }
                    }
                }
            }
            Console.WriteLine("Started");
            ClassWithStaticConstructor.WakeUp();
            Console.WriteLine("Ended");
            Console.ReadKey();
        }
    }
 
    public class ClassWithStaticConstructor
    {
        static ClassWithStaticConstructor()
        {
            Console.WriteLine("ClassWithStaticConstructor lives!!!");
        }
        public static void WakeUp()
        {
        }
    }
}

List<assemblyname> assemblynames = new List<assemblyname>(Assembly.GetEntryAssembly().GetReferencedAssemblies());
assemblynames.Add(Assembly.GetEntryAssembly().GetName());
foreach (AssemblyName an in assemblynames) {
    ...
}
</assemblyname></assemblyname>