<canvas id="canvas" width="600" height="480" style="margin-left:100px">
    <p>Your browser does not support the canvas element.</p>
</canvas>
<p><input id="reset" type="button" value="Reset" /></p>

<script>
var canvas = document.getElementById('canvas');
var context = canvas.getContext('2d');
var width = canvas.width ,height = canvas.height;    
var maxIterations = 100;
var minRe = -2.0;
var maxRe = 1.0;
var minIm = -1;
var maxIm = minIm+(maxRe-minRe)*height/width;

reset();

document.getElementById("reset").onclick = reset;

canvas.onmousedown = function (evt) {
    var x0 = evt.pageX - canvas.offsetLeft;
    var y0 = evt.pageY - canvas.offsetTop;

    var x1, y1, w, h;
    var imgd = context.getImageData(0, 0, width, height);

    update(evt);

    function update(evt) {
        x1 = evt.pageX - canvas.offsetLeft;
        y1 = evt.pageY - canvas.offsetTop;
        w = Math.abs(x1 - x0), h = Math.abs(y1 - y0);
    }

    function clear(evt) {
        if (w && h) {
            context.clearRect(0, 0, width, height);
            context.putImageData(imgd, 0, 0);
        }
    }

    canvas.onmousemove = function (evt) {
        clear(evt);
        update(evt);
        context.strokeStyle = "red";
        context.strokeRect(x0 < x1 ? x0 : x1, y0 < y1 ? y0 : y1, w, h);
    }

    canvas.onmouseup = function (evt) {
        clear(evt);
        canvas.onmousemove = canvas.onmouseup = null;

        minRe = minRe + (maxRe - minRe) / width * (x0 < x1 ? x0 : x1);
        maxRe = minRe + (maxRe - minRe) / width * w;
        minIm = minIm + (maxIm - minIm) / height * (y0 < y1 ? y0 : y1);
        maxIm = minIm + (maxIm - minIm) / height * h;

        draw();
    }
}

function reset() {
    minRe = -2.0;
    maxRe = 1.0;
    minIm = -1;
    maxIm = minIm + (maxRe - minRe) * height / width;
    draw();   
}

function draw() {
    context.fillRect(0, 0, width, height);
    var imgd = context.getImageData(0, 0, width, height)
    var pix = imgd.data;

    var drawPixel = function (x, y, itr) {
        var i = (y * width + x) * 4;

        pix[i] = pix[i + 1] = pix[i + 2] = Math.round(itr * 255 / maxIterations);
    }

    mandelbrot(width, height, drawPixel);
    context.putImageData(imgd, 0, 0);
}

function mandelbrot(imageWidth, imageHeight, drawPixel) {                
    var re_factor = (maxRe-minRe)/(imageWidth-1);
    var im_factor = (maxIm-minIm)/(imageHeight-1);

    for(var y=0; y<imageHeight; ++y)
    {
        var c_im = maxIm - y*im_factor;
        for(var x=0; x<imageWidth; ++x)
        {
            var c_re = minRe + x*re_factor;

            var z_re = c_re, z_im = c_im;
            var isInside = true;
            var n = 0;
            for(; n<maxIterations; ++n)
            {
                var z_re2 = z_re*z_re, z_im2 = z_im*z_im;
                if(z_re2 + z_im2 > 4)
                {
                    isInside = false;
                    break;
                }
                z_im = 2*z_re*z_im + c_im;
                z_re = z_re2 - z_im2 + c_re;
            }

            if (!isInside) { drawPixel(x, y, n); }
        }
    }
}    
</script>

class Student
{            
    public string Name { get; set; }
}

static double Test(int loop, Student stu, Func<Student, string> action)
{
    var watch = Stopwatch.StartNew();
    string s = null;
    for (var i = 0; i < loop; i++)
        s = action(stu);

    return watch.ElapsedTicks;
}

static Func<Student, string> NativeGetter()
{
    return s => s.Name;
}

static Func<Student, string> ReflectedGetter()
{
    var type = typeof (Student);
    var prop = type.GetProperty("Name");

    return s => (string)prop.GetValue(s, null);                       
}

static Func<Student, string> EmittedGetter()
{
    var dm = new DynamicMethod(name: "EmittedGetter", returnType: typeof(string), parameterTypes: new[] { typeof(Student) }, owner: typeof(Student));

    var type = typeof (Student);
    var prop = type.GetMethod("get_Name");
    var il = dm.GetILGenerator();
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Call, prop);
    il.Emit(OpCodes.Ret);

    return (Func<Student, string>)dm.CreateDelegate(typeof(Func<Student, string>));
}

static Func<Student, string> ExpressionGetter()
{
    var type = typeof(Student);
    var prop = type.GetMethod("get_Name");

    ParameterExpression pa = Expression.Parameter(typeof(Student));
    Expression body = Expression.Call(pa, prop);

    return Expression.Lambda<Func<Student, string>>(body, pa).Compile();
}

static Func<Student, string> DynamicGetter()
{
    return s => { dynamic d = s; return d.Name; };
}

[MethodImpl(MethodImplOptions.NoOptimization)]
public static void Run()
{
    const int loop = 5000000;

    var stu = new Student {Name = "Mike"};

    var dynamic =
        Test(loop, stu, DynamicGetter());

    var expression =
        Test(loop, stu, ExpressionGetter());

    var native = 
        Test(loop, stu, NativeGetter());

    var emitted =
        Test(loop, stu, EmittedGetter());                        
            
    var reflected =
        Test(loop, stu, ReflectedGetter());           

    Console.WriteLine("native:{0}\ndynamic:{1}\nemit:{2}\nexpression:{3}\nreflection:{4}", 1, dynamic / native, emitted / native, expression / native, reflected / native);

    Console.ReadKey();
}

private static int BinarySearch(T[] array, int index, int length, T value)
{
    int lo = index;
    int hi = index + length - 1;
    while (lo <= hi)
    {
        int i = lo + ((hi - lo) >> 1);
        int order;
        if (array[i] == null)
        {
            order = (value == null) ? 0 : -1;
        }
        else
        {
            order = array[i].CompareTo(value);
        }

        if (order == 0)
        {
            return i;
        }

        if (order < 0)
        {
            lo = i + 1;
        }
        else
        {
            hi = i - 1;
        }
    }

    return ~lo;
}