C#

private int selectedTab = 0;
private int newTab      = -1;
 
private void tabControl1_SelectedIndexChanged(object sender, System.EventArgs e)
{
    // Don't allow nesting in the handler
    if(tabControl1.SelectedIndex == selectedTab ||
        tabControl1.SelectedIndex == newTab)
        return;
 
    // Return tu current tab
    newTab = tabControl1.SelectedIndex;
    tabControl1.SelectedIndex = selectedTab;
 
    // Perform the validation
    if(DialogResult.Yes == MessageBox.Show(this, "Sure?", "??",
        MessageBoxButtons.YesNo))
    {
        // Validation passed, go to new tab
        tabControl1.SelectedIndex = newTab;
        selectedTab = tabControl1.SelectedIndex;
    }
 
    newTab = -1;
}

/// <summary>
/// Delegate that defines a handler for the SelectedIndexChanging event.
/// </summary>
public delegate void TabControlCancelEventHandler(object sender,
    TabControlCancelEventArgs e);
 
/// <summary>
/// Derived tab control that adds SelectedIndexChanging event.
/// </summary>
public class TabControlEx : TabControl
{
    /// <summary>
    /// Fired when the selected tab is about to change, allowing the
    /// receiver of the event to cancel.
    /// </summary>
    public event TabControlCancelEventHandler SelectedIndexChanging;
 
    /// <summary>
    /// Default constructor. Initializes a new TabControlEx object.
    /// </summary>
    public TabControlEx() 
    {
    }
 
    /// <summary>
    /// Called when index has changed. Raises SelectedIndexChanged event.
    /// </summary>
    /// <param name="e">Event arguments.</param>
    protected override void OnSelectedIndexChanged(EventArgs e)
    {
        // Disallow nesting of this event
        if(newTab != -1)
            return;
 
        try
        {
            // Save new tab, and return tu current tab
            newTab = SelectedIndex;
            SelectedIndex = selectedTab;
 
            // Raise SelectedIndexChanging event
            TabControlCancelEventArgs e2 = new TabControlCancelEventArgs(newTab);
            OnSelectedIndexChanging(e2);
 
            // If user chose to cancel, stay in current tab
            if(e2.Cancel)
                return;
 
            // Now we can select the requested tab
            SelectedIndex = newTab;
            selectedTab = SelectedIndex;
 
            // Finally call registered event handlers
            base.OnSelectedIndexChanged(e);
        }
        finally
        {
            newTab = -1;
        }
    }
 
    /// <summary>
    /// Raises SelectedIndexChanging event.
    /// </summary>
    /// <param name="e">Event arguments.</param>
    protected virtual void OnSelectedIndexChanging(TabControlCancelEventArgs e)
    {
        // If any handler is registered, raise the event
        if(SelectedIndexChanging != null)
            SelectedIndexChanging(this, e);
    }
 
    private int selectedTab = 0;
    private int newTab      = -1;
}
 
/// <summary>
/// Contain arguments for TabControlEx's SelectedIndexChanging event.
/// </summary>
public class TabControlCancelEventArgs : CancelEventArgs
{
    /// <summary>
    /// Constructor. Initializes a new TabControlCancelEventArgs.
    /// </summary>
    /// <param name="tab">Index of tab page that will be selected.</param>
    public TabControlCancelEventArgs(int tab)
        : base()
    {
        this.tab = tab;
    }
 
    /// <summary>
    /// Constructor. Initializes a new TabControlCancelEventArgs.
    /// </summary>
    /// <param name="tab">Index of tab page that will be selected.</param>
    /// <param name="cancel">true to cancel the selection change,
    /// false to allow it.</param>
    public TabControlCancelEventArgs(int tab, bool cancel)
        : base(cancel)
    {
        this.tab = tab;
    }
 
    /// <summary>
    /// Gets the index of the tab page that will be selected.
    /// </summary>
    public int Tab
    {
        get { return tab; }
    }
 
    private int tab;
}

myTab.SelectedIndexChanging += new TabControlCancelEventHandler(myTab_SelectedIndexChanging);

private void myTabSelectedIndexChanging(object sender, TabControlCancelEventArgs e)
{
    if(validation fails)
        e.Cancel = true;
}

namespace BlaBla {
    class MyForm : System.Windows.Forms.Form {
        cursor GetCursor {
            // Both ways will look for the recource: Cursor.ico

            // When you get a stream from the Assembly, you have to specify
            // the namespace also. But the constructor from the second example
            // does that for you.
            // NOTE: This is the way it works in VB, because you can give the whole
            //       project a default namespace (in this case BlaBla). I don't          
            //       know if this works this way in C#...
            IO.Stream stream = Reflection.Assembly.GetCurrentAssembly. 
                               GetManifestResourceStream("BlaBla.Cursor.ico")
            cur = new Cursor(stream);
            stream.Close();

            // This constructor gets the namespace from the first parameter,
            // so you don't have to specify the namespace also.
            Cursor cur = new cursor(this.GetType(), "Cursor.ico"); 
            
            return cur;
        }
    }
}

if(cursorMovingCol == null)<br />
  cursorMovingCol = new System.Windows.Forms.Cursor(GetType(), "DataListTest.movingCol.cur");

An unhandled exception of type 'System.ArgumentNullException' occurred in system.windows.forms.dll<br />
<br />
Additional information: Value cannot be null.

static Cursor Getcursor{<br />
   System.IO.Stream stream = System.Reflection.Assembly.GetExecutingAssembly.GetManifestResourceStream("movingCol.cur");<br />
   System.Windows.Forms.Cursor cur = new Cursor(stream);<br />
   stream.Close();<br />
   return cur;<br />
}

private static System.Windows.Forms.Cursor GetCursor()<br />
{<br />
  System.IO.Stream stream = System.Reflection.Assembly.GetExecutingAssembly()<br />
    .GetManifestResourceStream("movingCol.cur");<br />
  System.Windows.Forms.Cursor cur = new System.Windows.Forms.Cursor(stream);<br />
  stream.Close();<br />
  return cur;<br />
}