protected virtual void SomeMethod() { ... } 

}

Overdiding and seal a method in a derived class.

public class DerivedClass : MyClass { 

  protected override sealed void SomeMethod () { ... } 

}

Avoid unnecessary virtual members – Virtual members are more expensive to call because of the virtual lookup table and don’t work for certain runtime optimizations.

Use overloaded methods – Instead of using a method with a variable number of parameters, use overloaded methods instead. Just be aware that COM clients can’t work with overloaded methods. In that case use methods with different names.

//method taking variable number of arguments

void GetCustomers (params object [] filterCriteria)

//overloaded methods

void GetCustomers (int countryId, int regionId)

void GetCustomers (int countryId, int regionId, int CustomerType)

Overriding the Equals method – overriding the Equals method that is provided by System.Object can further improve performance. An Equals method that is specific to your value type can do a comparison much more cheaply then using the standard implementation which uses Reflection to perform the comparison.

public struct Rectangle{

  public double Length;

  public double Breadth;

  public override bool Equals (object ob) {

  if(ob is Rectangle)

    return Equals((Rectangle)ob);

  else

    return false;

  }

  private bool Equals(Rectangle rect) {

    return this.Length == rect.Length && this.Breadth==rect.Breadth;

  }

}

Accessing a Class Property – Properties look like fields but they are not and have a hidden cost. Be aware that if you access a property additional code might be executed and accessing a property might be slower than accessing a field directly. Of course, the additional code behind a property is generally there for good reason; for example, to validate data.

If your object is designed for remote access, use methods with multiple parameters instead of requiring the client to set multiple properties or fields, reducing round trips. Also, it is considered bad practice to use properties that hide complex business rules or other costly operations; callers of properties generally expect the cost to be inexpensive.

Private vs. Public Member Variables - Avoid unnecessary public members to prevent any serialization overhead when you use the XmlSerializer class. As you well know, this class serializes all public members by default.

Limit the Use of Volatile Fields – Limit the use of the volatile keyword because volatile fields restrict the way the compiler reads and writes the contents of the field. The compiler generates the code that always reads from the field’s memory location instead of reading from a register that may have loaded the field’s value. This means that accessing volatile fields is slower than nonvolatile ones because the system is forced to use memory addresses rather than registers.

These are the most important class design considerations that can help you to optimize your managed code. In our next article we’ll focus on Garbage Collection.