Performance enhancements (TryParse, LCG, StopWatch) sample code

using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms;             // msgbox

using System.Diagnostics;               // Stopwatch

using System.Reflection;                // LCG (Light Weight CodeGen)

using System.Reflection.Emit;           // LCG (Light Weight CodeGen)


namespace Perf


    class Program


        static void Main(string[] args)


            //  Try-Parse

            // @"^-?\d+$" Int, Smallint, TinyInt




            //  StopWatch

            Stopwatch stopWatch;

            TimeSpan ts;

            stopWatch = new Stopwatch();

            String stringTimeFormat = "00:00:00.00";




            ts = stopWatch.Elapsed;

            stringTimeFormat = String.Format("{0:00}:{1:00}:{2:00}:{3:00}",

                ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds/10);

            MessageBox.Show("Formated Elapsed Time\n" + stringTimeFormat + "\nElapsed milliseconds\n" + ts.Milliseconds, "StopWatch");

        }   // void Main


        public static void TryandParse(string stringIn)



             * Throwing exceptions can negatively impact performance.





                         catch (Exception e)


                               throw new ShuttleException(@"Invalid Int32, " + e.Message);


             * For code that routinely fails, you can use design patterns to minimize performance issues.


            bool DoesConvert = false;

            int intValue = 0;



                DoesConvert = Int32.TryParse(stringIn, out intValue); // does not throw

                if (DoesConvert)

                    Trace.WriteLine(stringIn + ", String does convert to Int32");


                    Trace.WriteLine(stringIn + ", String does NOT convert to Int32");


            catch (Exception e)




        }   // TryandParse


        public static void ShowLCG()    // Lightweight Code Gen


            /*  DynamicMethod class is new in the .NET Framework version 2.0.

                Use the DynamicMethod class to generate and execute a method at run time

                without having to generate a dynamic assembly (AssemblyBuilder)

                and a dynamic type (DefineDynamicModule, DefineType)to contain the method.

                Dynamic methods are the most efficient way to generate and execute small amounts of code.


            DynamicMethod dynamicMethod = new DynamicMethod("HelloISV"  // Method name HelloISV

                , typeof(void)              // method void return type

                , new Type[] { }            // method parms

                , typeof(Program)           // Create the method in the class Program

                , false);

            // Get an ILGenerator and emit a body for the dynamic method,

            // using a stream size larger than the IL that will be

            // emitted.

            ILGenerator iLGenerator = dynamicMethod.GetILGenerator(256);

            // Load the first parameter, which is a string, onto the stack

            iLGenerator.Emit(OpCodes.Ldstr, "Hello! ISV/VAR/SI");

            // Call the Console.Writeline

            iLGenerator.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));

            iLGenerator.Emit(OpCodes.Ret);      // returns from the current method

            //Set next statement

            //Console.WriteLine("ENC");         // Check Tools options, Debugging, ENC enabled.

            dynamicMethod.Invoke(null, null);   // Break point here

        }   // void ShowLCG()


    }   // class Program

}   // namespace Perf


Comments (2)
  1. This was my first webcast, so please be patient through the beginning.  It gets much better there…

Comments are closed.

Skip to main content