C#

Object objVariable;
if(!String.IsNullOrEmpty(objVariable))

Object objVariable;
if(objVariable !=null && objVariable.ToString() !="")

internal static class UtilityMethods
{
    internal static bool IsEmpty(this object o)
    {
        return o == null;
    }
}

Object objVariable;
if(!objVariable.IsEmpty())
{
    // bla!
}

I are Troll

///
/// This class extends the the DataGridView so row numbers will
/// automatically appear in the row header cells. In this
/// implementation, the width of the column that contains the row
/// header cells is automatically adjusted to accomodate the row
/// numbering.
///
class MyDGV : DataGridView
{
    public MyDGV()
    {
        //perform any necessary customization initialization here

    } //end default constructor

    protected override void OnRowPostPaint(DataGridViewRowPostPaintEventArgs e)
    {
      //this method overrides the DataGridView's RowPostPaint event
      //in order to automatically draw numbers on the row header cells
      //and to automatically adjust the width of the column containing
      //the row header cells so that it can accommodate the new row
      //numbers,

        //store a string representation of the row number in 'strRowNumber'
        string strRowNumber = (e.RowIndex + 1).ToString();

        //prepend leading zeros to the string if necessary to improve
        //appearance. For example, if there are ten rows in the grid,
        //row seven will be numbered as "07" instead of "7". Similarly, if
        //there are 100 rows in the grid, row seven will be numbered as "007".
        while (strRowNumber.Length < this.RowCount.ToString().Length) strRowNumber = "0" + strRowNumber;

        //determine the display size of the row number string using
        //the DataGridView's current font.
        SizeF size = e.Graphics.MeasureString(strRowNumber, this.Font);

        //adjust the width of the column that contains the row header cells
        //if necessary
        if (this.RowHeadersWidth < (int)(size.Width + 20)) this.RowHeadersWidth = (int)(size.Width + 20);

        //this brush will be used to draw the row number string on the
        //row header cell using the system's current ControlText color
        Brush b = SystemBrushes.ControlText;

        //draw the row number string on the current row header cell using
        //the brush defined above and the DataGridView's default font
        e.Graphics.DrawString(strRowNumber, this.Font, b, e.RowBounds.Location.X + 15, e.RowBounds.Location.Y + ((e.RowBounds.Height - size.Height) / 2));

        //call the base object's OnRowPostPaint method
        base.OnRowPostPaint(e);
    } //end OnRowPostPaint method
} //end class

double prev;
double dim1;

private void txtDim1_Leave(object sender, EventArgs e)
{
    prev = dim1;
    dim1 = ValidateEntry(txtDim1);

    if (dim1 != 0.0 & prev != dim1)
    {
        MessageBox.Show("Event Fired");
    }

}

private double ValidateEntry(TextBox MyTextBox)
{
    try
    {
        return Double.Parse(MyTextBox.Text);
    }
    catch (FormatException ex)
    {
        MessageBox.Show("Enter a valid numeric value" + ex.Message);
        MyTextBox.Focus(); return 0.0;
    }
}

private void txtDim1_KeyPress(object sender, KeyPressEventArgs e)
{
    if (e.KeyChar == 13) { txtDim2.Focus(); }
}

// Range.cs
using System;

namespace DaveyM69
{
    [Serializable]
    public struct Range : IEquatable<Range>
    {
        // ToDo: Make struct designer friendly!

        public static readonly Range Empty = new Range();
        public static readonly Range MaxRange = new Range(int.MinValue, int.MaxValue);
        public static readonly Range Percentage = new Range(0, 100);

        private int lower;
        private int upper;

        public Range(int lower, int upper)
        {
            if (lower > upper)
            {
                int newUpper = lower;
                lower = upper;
                upper = newUpper;
            }
            this.lower = lower;
            this.upper = upper;
        }

        public static bool operator ==(Range rangeA, Range rangeB)
        {
            return (rangeA.lower == rangeB.lower) && (rangeA.upper == rangeB.upper);
        }
        public static bool operator !=(Range rangeA, Range rangeB)
        {
            return !(rangeA == rangeB);
        }

        public int Lower
        {
            get { return lower; }
        }
        public int Upper
        {
            get { return upper; }
        }

        public Range Adjust(int offset)
        {
            return new Range(lower + offset, upper + offset);
        }
        public int Contain(int value)
        {
            return Contain(value, false);
        }
        public int Contain(int value, bool excludeExtremities)
        {
            Range testRange = excludeExtremities ? this.Expand(-1) : this;
            if (value < testRange.lower)
                return testRange.lower;
            if (value > testRange.upper)
                return testRange.upper;
            return value;
        }
        public Range Contain(Range range)
        {
            return Contain(range, false);
        }
        public Range Contain(Range range, bool excludeExtremities)
        {
            if (Contains(range, excludeExtremities))
                return range;
            int newLower = range.lower;
            int newUpper = range.upper;
            if (!Contains(range.lower, excludeExtremities))
            {
                newLower = lower;
                if (excludeExtremities)
                    newLower++;
            }
            if (!Contains(range.upper, excludeExtremities))
            {
                newUpper = upper;
                if (excludeExtremities)
                    newUpper--;
            }
            Range result = new Range(newLower, newUpper);
            if (!Contains(result, excludeExtremities))
                throw new InvalidOperationException("The span of this range is too small to contain another range");
            return result;
        }
        public bool Contains(Range range)
        {
            return Contains(range, false);
        }
        public bool Contains(Range range, bool excludeExtremities)
        {
            return Contains(range.lower, excludeExtremities) && Contains(range.upper, excludeExtremities);
        }
        public bool Contains(int value)
        {
            return Contains(value, false);
        }
        public bool Contains(int value, bool excludeExtremities)
        {
            Range testRange = excludeExtremities ? this.Expand(-1) : this;
            if (testRange.lower < lower)
                throw new InvalidOperationException("The span of the specified range is too small to contain another range");
            return (value >= testRange.lower) && (value <= testRange.upper);
        }
        public Range Expand()
        {
            return Expand(1);
        }
        public Range Expand(int value)
        {
            return new Range(lower - value, upper + value);
        }
        public override bool Equals(object obj)
        {
            return obj is Range && this == (Range)obj;
        }
        public bool Equals(Range other)
        {
            return this == other;
        }
        public override int GetHashCode()
        {
            return lower ^ upper;
        }
        public override string ToString()
        {
            return string.Format("{0}, {1}", lower, upper);
        }
    }
}

// RangeControl.cs
using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;

namespace DaveyM69.Windows.Forms
{
    public class RangeControl : Control
    {
        private static readonly Size Default_Size = new Size(200, 50);

        [Category("Range")]
        public event EventHandler ExcludeExtremitiesChanged;
        [Category("Range")]
        public event EventHandler InnerRangeChanged;
        [Category("Range")]
        public event EventHandler OuterRangeChanged;
        [Category("Range")]
        public event EventHandler ValueChanged;
        
        private bool excludeExtremities;
        private Range innerRange;
        private Range outerRange;
        private int value;

        public RangeControl()
        {
            SetStyle(
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.ResizeRedraw |
                ControlStyles.Selectable |
                ControlStyles.SupportsTransparentBackColor |
                ControlStyles.UserPaint, true);
            excludeExtremities = false;
            innerRange = new Range(25, 75);
            outerRange = Range.Percentage;
            value = 50;
        }

        protected override Size DefaultSize
        {
            get { return Default_Size; }
        }
        [Category("Range"),
        DefaultValue(false)]
        public bool ExcludeExtremities
        {
            get { return excludeExtremities; }
            set
            {
                if (excludeExtremities != value)
                {
                    excludeExtremities = value;
                    OnExcludeExtremitiesChanged(EventArgs.Empty);
                    InnerRange = innerRange; // Force refresh
                    Value = this.value; // Force refresh. This needs refactoring as if InnerRange changes this will have already been done!
                }
            }
        }
        [Category("Range"),
        DefaultValue(typeof(Range), "25, 75")]
        public Range InnerRange
        {
            get { return innerRange; }
            set
            {
                value = outerRange.Contain(value, excludeExtremities);
                if (innerRange != value)
                {
                    innerRange = value;
                    Invalidate();
                    OnInnerRangeChanged(EventArgs.Empty);
                    Value = this.value; // Force refresh
                }
            }
        }
        [Category("Range"),
        DefaultValue(typeof(Range), "0, 100")]
        public Range OuterRange
        {
            get { return outerRange; }
            set
            {
                if (outerRange != value)
                {
                    outerRange = value;
                    OnOuterRangeChanged(EventArgs.Empty);
                    InnerRange = innerRange; // Force refresh
                }
            }
        }
        [Category("Range"),
        DefaultValue(50)]
        public int Value
        {
            get { return value; }
            set
            {
                value = innerRange.Contain(value, excludeExtremities);
                if (this.value != value)
                {
                    this.value = value;
                    Invalidate();
                    OnValueChanged(EventArgs.Empty);
                }
            }
        }

        protected virtual void OnExcludeExtremitiesChanged(EventArgs e)
        {
            EventHandler eh = ExcludeExtremitiesChanged;
            if (eh != null)
                eh(this, e);
        }
        protected virtual void OnInnerRangeChanged(EventArgs e)
        {
            EventHandler eh = InnerRangeChanged;
            if (eh != null)
                eh(this, e);
        }
        protected override void OnMouseDown(MouseEventArgs e)
        {
            // ToDo: MouseDown
            base.OnMouseDown(e);
        }
        protected override void OnMouseUp(MouseEventArgs e)
        {
            // ToDo: MouseUp
            base.OnMouseUp(e);
        }
        protected virtual void OnOuterRangeChanged(EventArgs e)
        {
            EventHandler eh = OuterRangeChanged;
            if (eh != null)
                eh(this, e);
        }
        protected override void OnPaint(PaintEventArgs e)
        {
            // ToDo: Paint
            base.OnPaint(e);
        }
        protected virtual void OnValueChanged(EventArgs e)
        {
            EventHandler eh = ValueChanged;
            if (eh != null)
                eh(this, e);
        }
    }
}