Reflective Code

using System;

class Program

{

    static void Main(string[] args)

    {

        int size = 512;

        int count = 1000;

        int[,] array = new int[size, size];

        int total = 0;

        var watch = System.Diagnostics.Stopwatch.StartNew();

        for (int i = 0; i < count; i++)

            for (int x = 0; x < size; x++)

                for (int y = 0; y < size; y++)

                    total += array[x, y];

        watch.Stop();

        Console.WriteLine(String.Format("Sequential access by [x,y]: {0}ms", watch.ElapsedMilliseconds));

        watch = System.Diagnostics.Stopwatch.StartNew();

        for (int i = 0; i < count; i++)

            for (int x = 0; x < size; x++)

                for (int y = 0; y < size; y++)

                    total += array[y, x];

        watch.Stop();

        Console.WriteLine(String.Format("Sequential access by [y,x]: {0}ms", watch.ElapsedMilliseconds));

        Console.WriteLine(total);

        Console.Read();

    }

}

Entity[] myCollection = LoadEntities();

WorkManager manager = new WorkManager();

manager.ForEach(myCollection, e => e.Process());

using System;

using IronPython.Hosting;

using Microsoft.Scripting;

using Microsoft.Scripting.Hosting;

public class Program

{

    // Delegate matching the signature of the factorial function

    delegate int FactorialDelegate(int n);

    static void Main(string[] args)

    {

        // Our factorial function

        string[] lines = {"def factorial(n):",

                          "  for i in range(1, n):",

                          "    n = n * i",

                          "  return n"};

        string code = String.Join("\r", lines);

        // Instantiate the IronPython environment

        ScriptEngine engine = Python.CreateEngine();

        // Create a scope/module to work in

        ScriptScope scope = engine.CreateScope();

        // A little preparation

        ScriptSource source = engine.CreateScriptSourceFromString(code, SourceCodeKind.Statements);

        // Compile the code

        CompiledCode compiled = source.Compile();

        // Execute the code in the scope

        compiled.Execute(scope);

        //Now the factorial function exists in the IronPython environment. Let's use it.

        // Set x = 5

        scope.SetVariable("x", 5);

        // print factorial(x)

        ScriptSource print = engine.CreateScriptSourceFromString("print factorial(x)", SourceCodeKind.SingleStatement);

        print.Execute(scope);       //outputs 120

        // Get the result from IronPython

        int result1 = scope.Execute<int>("factorial(6)");

        Console.WriteLine(result1); //outputs 720

        // We can also call the function directly from C#

        FactorialDelegate factorial = scope.GetVariable<FactorialDelegate>("factorial");

        int result2 = factorial(7);

        Console.WriteLine(result2); //outputs 5040

        Console.Read();

    }

}

Math.BigMul(Int32, Int32) : Int64

(long)a * (long)b

static void Main(string[] args)

{

    int a = 40993;

    int b = 69872;

    long c = 0;

    DateTime start;

    TimeSpan length;

    Console.WriteLine("Inline multiplication");

    start = DateTime.Now;

    for (int i = 0; i < 1000000000; i++)

        c = (long)a * (long)b;

    length = DateTime.Now - start;

    Console.WriteLine(c);

    Console.WriteLine(length.ToString());

    Console.WriteLine();

    Console.WriteLine("Math.BigMul");

    start = DateTime.Now;

    for (int i = 0; i < 1000000000; i++)

        c = Math.BigMul(a, b);

    length = DateTime.Now - start;

    Console.WriteLine(c);

    Console.WriteLine(length.ToString());

    Console.WriteLine();

    Console.Read();

}