I'm not sure I like either method.  Checking for the actual user would
seem to make things pretty hard to maintain.  What kinds of things are
you looking to do different?  There is almost certainly a better way to
accomplish what you want...

--
Tom Shelton

Hi Gideon,

I prefer to place that logic in the event handler, or if the logic is complex
and dynamic then a business object.  i.e., if the logic in the event handler
may be configured for each user and changed at a later time based on database
properties, for example, then that complexity may warrant the use of a more
complex system as well to prevent code bloat in the event handler method and
to encapsulate the logic so it can be reused in other UI components and
systems.

Here's a simple BO model that you might want to adopt if you have "dynamic"
needs, such as the one I mentioned above:

this.dataGridView2.CellBeginEdit += dataGridView2_CellBeginEdit;

void dataGridView2_CellBeginEdit(object sender, SomeEventArgs e)
{
   // you should ensure that your application assigns the User.Current
   // property before it is queried here, or you can make the property a
   // singleton field and initialize it automatically upon first request
using a
   // type constructor (static).

   User.Current.BeginCellEdit(sender, e);
}

class User
{
   private static User current;
   public static User Current { get { return current; } set { current=
value; } }

   public UserUICapabilities Caps { get { return caps; } }

   private readonly UserUICapabilities caps;
   private readonly int id;

   public User(int id)
   {
       this.id = id;
       caps = new UserUICapabilities(this);
   }

   public void BeginCellEdit(object sender, SomeEventArgs e)
   {
       caps.BeginCellEdit(sender, e);
   }
}

class UserUICapabilities
{
   private readonly User user;
   private bool initialized;    // lazy initialization

   public UserUICapabilities(User user)
   {
       this.user = user;
   }

   void EnsureInitialized()
   {
       if (initialized)
           return;

       // TODO: load user caps from database

       initialized = true;
   }

   public void BeginCellEdit(object sender, SomeEventArgs e)
   {
       EnsureInitialized();

       // Each User object with a distinct "id" will have an
       // instance of a UserCapabilities object that can provide a
       // different implementation here.

       // TODO: begin cell edit based on the "user" field in this class
   }
}

If the BeginCellEdit method needs more information about the UI elements that
it can manipulate, then you can create a data context class.  An instance of
your data context class may be passed to BeginCellEdit instead of the sender
and event args:

class BeginCellEditContext
{
   private DataGridView grid;
   private DataGridView Grid { get { return grid; } }

   private Label label;
   private Label Label { get { return label; } }

   public BeginCellEditContext(DataGridView grid, Label label)
   {
       this.grid = grid;
       this.label = label;
   }
}

That class may be the only argument to the BeginCellEdit method:

public void BeginCellEdit(BeginCellEditContext context)  { ... }

The method may be called as such:

BeginCellEditContext context = new BeginCellEditContext(theGrid, theLabel);

User.Current.BeginCellEdit(context);

Another option is to use an MVP architecture, but that's going to add even
more complexity.  You'll have to create command objects for every possible
task that the BeginCellEdit method may perform.

The simplest approach that meets all your needs will be the best one; in some
cases that is just a simple event handler routine, so choose wisely :)