Learn APS.NET MVC

ScottGu  just made available a free downloadable eBook in PDF format as well as a simple and easy-to-understand sample project called Nerddinner.  This eBook is actually a chapter from his upcoming book on MVC, but it is an end-to-end tutorial that walks through building a small but complete ASP.NET MVC application from scratch.

Download eBook.

Download Nerddinner sample code.

C# 3.0 Automatic Properties

OK, so better later than never! Somehow I missed the automatic properties feature of C# 3.0, and just discovered it while I was reading up on something unrelated. It’s a nice feature of C# 3.0 that saves you a few key strokes hence enhances developer productivity as well as allows for more clear and concise code.

Using this new feature, instead of defining private variables and creating explicit getters and setters, you can create properties like this:

public class Employee { public string ID { get; set; } public string LastName { get; set; } public string FirstName { get; set; } }

Free Visual Studio 2008 Productivity Add-in

Developer Express and Microsoft provide a new version of CodeRush licensed exclusively for C# developers working in Visual Studio. The new product is called CodeRush Xpress, and it includes a slew of useful features to boost your productivity under Visual Studio.

You can download CodeRush Xpress here.

The Castle Project

In the last couple of years I have noticed a steadily growing interest in the .NET community around the Inversion of Control (IoC) and Dependency Injection (DI) patterns.  This is partly due to the fact that a number of excellent frameworks have emerged and gained popularity that allow us to use these designs in our applications relatively painlessly.  One such framework is the open source Castle Project.  In my opinion Castle is the best implementation of IoC and DI among many others that I have come across including Spring.NET, NInject, and ObjectBuilder.  This is however my opinion; which framework you use largely depends upon your requirements and your preferences.

If you are just getting started with Castle or are curious about why the heck one should use IoC and DI, I strongly suggest you check out the 3-part article series by Simone Busoli.  I just came across these articles and I can't stress enough how well they are written.

SQL Server Database Comparison and Synchronization

Since database are usually designed in development environments, migrating changes over to other environments (e.g. QA and production) is not a trivial task.  This is because SQL Server does not have any built-in tools to compare database schemas. 

There are quite a few third-party tools that would make your life easier, most notably, Red Gate's SQL Compare (reasonably priced around $300).

At times, buying a commercial tool is not really an option, so one must resort to googling for free tools.  There are three such tools that I am aware of:

1. SQLDBDiff by SQLDBTools
   A very decent tool that comes in both freeware and shareware versions.  Freeware version is not badly crippled; only advanced features such as multi-database comparison, data content comparison, etc. are disabled.
   
   
2. Database Schema Comparison Utility
   This is a Code Project article that comes with C# source code of a schema comparison utility.  The utility itself is pretty bare-bone, but gets the job done.
   
   
3. StarInix Free Database Compare 2.0
   I have not used this tool, but from the advertised feature list, it looks pretty good.  Most notably, in addition to SQL Server, this tool works with Access and MySQL databases.

JScript Eval Method In C#

JavaScript and JScript languages provide a convenient Eval method that allows for dynamic evaluation of expressions. This functionality can be duplicated in C# using Microsoft's JScript CodeDomProvider and Reflection. Following class automatically compiles an in-memory assembly using JScript CodeDomProvider. The Eval method uses this assembly to dynamically evaluate specified expressions: using System; using System.CodeDom.Compiler; using System.Reflection; using Microsoft.JScript; /// <summary> /// Implements JScript/JavaScript Eval like /// functionality in C# to allow dynamic evaluation /// of expressions. /// </summary> public static class ExpressionEvaluator { #region Private Members private static Type _evaluatorType; private static object _evaluatorInstance; private static readonly string _jscriptEvalClass = @"import System; class JScriptEvaluator { public static function Eval(expression : String) : String { return eval(expression); } }"; #endregion #region Private Methods /// <summary> /// Creates a dynamic in-memory assembly using JScript.NET /// to evaluate expressions. /// </summary> private static void Initialize() { CodeDomProvider compiler = new JScriptCodeProvider(); CompilerParameters parameters = new CompilerParameters(); parameters.GenerateInMemory = true; parameters.ReferencedAssemblies.Add("system.dll"); CompilerResults results = compiler.CompileAssemblyFromSource(parameters, _jscriptEvalClass); Assembly assembly = results.CompiledAssembly; _evaluatorType = assembly.GetType("JScriptEvaluator"); _evaluatorInstance = Activator.CreateInstance(_evaluatorType); } #endregion #region Public Methods /// <summary> /// Evaluates specified expression using reflection /// on the assembly generated in Initialize() method. /// </summary> /// <param name="expression">The expression.</param> /// <returns>A string representing evaluated expression.</returns> public static string Eval(string expression) { if (_evaluatorInstance == null) Initialize(); object result = _evaluatorType.InvokeMember( "Eval", BindingFlags.InvokeMethod, null, _evaluatorInstance, new object[] { expression } ); return (result == null) ? null : result.ToString(); } #endregion }

Using this class, we can execute statements such as:

Console.WriteLine(ExpressionEvaluator.Eval("2 + 9")); Console.WriteLine(ExpressionEvaluator.Eval("System.DateTime")); Console.WriteLine(ExpressionEvaluator.Eval("Environment.OSVersion.VersionString"));

Using IXmlSerializable To Overcome "not expected" Error On Derived Classes

This article extends upon Simon Hewitt's article on CodeProject. It is strongly recommended that you read Simon's article also in order to fully understand the concepts. BACKGROUND XML serialization is an indispensable technique that has built-in support for in the .NET Framework. Using XML serialization, objects can be serialized to XML streams that may be persisted to permanent storage such as files, as well as XML streams can be converted back to objects with exactly the same state as at the time of serialization. With .NET Framework's built-in support for XML serialization, all this can be achieved with only a few lines of code using the System.Xml.Serialization.XmlSerializer object. PROBLEM The problem with XmlSerializer is, however, that it works by generating an on-the-fly assembly behind the scenes at compilation time, that has logic for serialization and deserialization of a given type. For this reason, the exact (concrete) type of the object and it's public properties must be known to the compiler at the time of compilation. If we try to serialize an object that, for example, has a public member of a given base type, then at run-time we receive a System.InvalidOperationException if the public member was set to a derived type. WORKAROUND The workaround to above problem has generally been resorting to custom XML serialization, which can get pretty complicated at times. SOLUTION An ingenious solutions was discovered by Simon Hewitt using the System.Xml.Serialization.IXmlSerializable interface that allows us to mitigate the by-design issue of XmlSerializer object. While this solution works very well, it requires that a new class be created for each base class that we need serialization support for. Using C# generics, I took the liberty of extending Simon's solution, eliminating the need for such new classes, and encapsulating the grunt work into just one class. Once this class has been added to our project (our referenced from another assembly), all we really need to do is decorate any of our public members of base type (that may be substituted with derived types at runtime) with an attribute. using System; using System.Xml; using System.Xml.Schema; using System.Xml.Serialization; namespace Vocalsoft.Xml.Serialization { public class CustomSerializer<ItemType> : IXmlSerializable { #region Private Members /// <summary> /// Holds the object that this serializer operates on. /// </summary> private ItemType _parameters; #endregion #region Static Methods /// <summary> /// Implicit operators the specified p. /// </summary> /// <param name="p">The p.</param> /// <returns></returns> public static implicit operator CustomSerializer<ItemType>(ItemType p) { return p == null ? null : new CustomSerializer<ItemType>(p); } /// <summary> /// Implicit operators the specified p. /// </summary> /// <param name="p">The p.</param> /// <returns></returns> public static implicit operator ItemType(CustomSerializer<ItemType> p) { return p.Equals(default(ItemType)) ? default(ItemType) : p.Parameters; } #endregion Static #region Constructors /// <summary> /// Initializes a new instance of the <see cref="CustomSerializer<ItemType>"/> class. /// </summary> public CustomSerializer() { } /// <summary> /// Initializes a new instance of the <see cref="CustomSerializer<ItemType>"/> class. /// </summary> /// <param name="parameters">The parameters.</param> public CustomSerializer(ItemType parameters) { this._parameters = parameters; } #endregion Constructors #region Properties /// <summary> /// Gets parameters. /// </summary> /// <value>The parameters.</value> public ItemType Parameters { get { return _parameters; } } #endregion Properties #region IXmlSerializable Implementation /// <summary> /// Returns schema of the XML document representation of the object that is produced by the <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"></see> method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"></see> method. /// </summary> /// <returns> /// An <see cref="T:System.Xml.Schema.XmlSchema"></see> that describes the XML representation of the object that is produced by the <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"></see> method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"></see> method. /// </returns> XmlSchema IXmlSerializable.GetSchema() { return null; } /// <summary> /// Generates an object from its XML representation. /// </summary> /// <param name="reader">The <see cref="T:System.Xml.XmlReader"></see> stream from which the object is deserialized.</param> void IXmlSerializable.ReadXml(XmlReader reader) { // Get type from xml attribute Type type = Type.GetType(reader.GetAttribute("type")); // Deserialize reader.ReadStartElement(); this._parameters = (ItemType)new XmlSerializer(type).Deserialize(reader); reader.ReadEndElement(); } /// <summary> /// Converts an object into its XML representation. /// </summary> /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"></see> stream to which the object is serialized.</param> void IXmlSerializable.WriteXml(XmlWriter writer) { // Write type as xml attribute writer.WriteAttributeString("type", _parameters.GetType().ToString()); new XmlSerializer(_parameters.GetType()).Serialize(writer, _parameters); } #endregion IXmlSerializable Implementation } } Once the above class has been added to our project, all we need to do is add an attribute directly on the base class property as follows: [XmlElement(Type = typeof(CustomSerializer<baseclassname>))]

.NET 2.0: On-demand Configuration Encryption

In .NET 2.0, apsnet_regiis can encrypt and decrypt sections of web.config and machine.config using RSA, DPAPI, or any other custom encryption provider. However, how do we encrypt/decrypt a custom application configuration (e.g. app.config of a WinForms application)? We are in luck, since the System.Configuration namespace provides everything we need to accomplish this task. The following class, for example, can be used to encrypt/decrypt any .NET configuration file: /// <summary> /// Implements a utility class that enables encrypting / decrypting /// sections in .NET configuration files. /// </summary> internal static class ConfigEncryptionHelper { #region Encryption Methods /// <summary> /// Encrypts a section in a .NET configuration file using a named provider. /// </summary> /// <param name="configPath">Physical path of configuration file.</param> /// <param name="sectionName">Section name to encrypt.</param> /// <param name="protectionProviderName">Name of the encryption provider.</param> public static void EncryptConfigSection(string configPath, string sectionName, string protectionProviderName) { // Map the configuration file ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap(); fileMap.ExeConfigFilename = configPath; // Open configuration file Configuration config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); // Get the desired section ConfigurationSection section = config.GetSection(sectionName); // Encrypt the section if (!section.SectionInformation.IsProtected) section.SectionInformation.ProtectSection(protectionProviderName); // Save configuration file config.Save(); } /// <summary> /// Encrypts a section in a .NET configuration file using DataProtectionProvider. /// </summary> /// <param name="configPath">Physical path of configuration file.</param> /// <param name="sectionName">Section name to encrypt.</param> public static void EncryptConfigSection(string configPath, string sectionName) { EncryptConfigSection(configPath, sectionName, "DataProtectionConfigurationProvider"); } #endregion #region Decryption Methods /// <summary> /// Decrypts a section in a .NET configuration file. /// </summary> /// <param name="configPath">Physical path of configuration file.</param> /// <param name="sectionName">Section name to encrypt.</param> public static void DecryptConfigSection(string configPath, string sectionName) { // Map the configuration file ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap(); fileMap.ExeConfigFilename = configPath; // Open configuration file Configuration config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); // Get the desired section ConfigurationSection section = config.GetSection(sectionName); // Decrypt section if (section.SectionInformation.IsProtected) section.SectionInformation.UnprotectSection(); // Save configuration file config.Save(); } #endregion }

Adding Controls To ASP.NET GridView Pager Row

ASP.NET 2.0 GridView control contains the AllowPaging property. Setting this property to a value of true enables the paging feature of the GridView and displays data split across multiple pages if the number of rows in the underlying data source is greater than the PageSize property. By default ASP.NET automatically displays numeric paging controls at the bottom of the GridView. While automatic paging is a very handy feature of GridView, if you want to display any additional paging controls than those inherently supported by automatic paging, you must resort to specifying your own PagerTemplate and write some additional code to preform the same functionality that GridView would otherwise handle for you. In certain situations, a better option, however, is to simply inject your custom control(s) into the pager generated by the GridView. The following example shows how we can inject a "View All" LinkButton into GridView's pager row that allows users to view all rows in the underlying data source at the same time: protected void MyGridView_RowCreated(object sender, GridViewRowEventArgs e) { if (e.Row.RowType == DataControlRowType.Pager) { LiteralControl space = new LiteralControl(" "); LinkButton lb = new LinkButton(); lb.ID = "ViewAllLinkButton"; lb.Text = "View All"; lb.SkinID = "ProfessionalGridViewPagerViewAll"; lb.Click += new EventHandler(ViewAllLinkButton_Click); // Pager is rendered in a single cell as a table; // each page # is in a cell by it's own Table table = e.Row.Cells[0].Controls[0] as Table; // Add ViewAll linkbutton to the last cell TableCell parentCell = table.Rows[0].Cells[table.Rows[0].Cells.Count - 1]; parentCell.Controls.Add(space); parentCell.Controls.Add(lb); } } protected void ViewAllLinkButton_Click(object sender, EventArgs e) { MyGridView.AllowPaging = false; }

ASP.NET GridView And Conditional Images

Depending upon a value in the data source, we can conditionally display images in GridView columns. For example, the following TemplateField declaration conditionally displays approved.gif or unapproved.gif based on IsApproved flag in the DataSet that the GridView is bound to: <asp:TemplateField HeaderText="Approval Status"> <ItemTemplate> <asp:Image ID="ApprovalImage" runat="server" ImageUrl='<%# "~/Images/" + (((bool)Eval("IsApproved") == false) ? "Unapproved.gif" : "Approved.gif") %>' /> </ItemTemplate> <ItemStyle Width="25px" /> </asp:TemplateField>

Enumerating Cache Items

System.Web.Caching.Cache object implements the IDictionary interface, hence we can retreive a list of cached item keys as follows: protected ReadOnlyCollection<string> GetCacheItemList() { List<string> cacheItemList = new List<string>(Cache.Count); IDictionaryEnumerator cacheEnum = Cache.GetEnumerator(); while (cacheEnum.MoveNext()) { DictionaryEntry cacheItem = (DictionaryEntry)cacheEnum.Current; cacheItemList.Add(cacheItem.Key.ToString()); } return new ReadOnlyCollection<string>(cacheItemList); }

ADO.NET Calculated Columns

ADO.NET offers the capability to add calculated columns in typed DataSets and use the Expression property of the those columns to specify the formulae for calculations. What I did not realize is that you must use the Fill method of the adapter instead of the Get method for calculated columns to properly populate. For example: using (MyTableAdapter adapter = new MyTableAdapter()) { MyTypedDataSet.MyTable dt = new MyTypedDataSet.MyTable(true); adapter.FillData(dt, beginDate, endDate); }

DIP: Dependency Inversion Principle

The Dependency Inversion Principle deals with how to correctly design classes such that their dependency on one another causes the least amount of work in case of a change. Uncle Bob's definition of DIP states:

• High-level modules should not depend on low-level modules. Both should depend on abstractions.
• Abstractions should not depend on details. Details should depend on abstractions.

Essentially what this principle means is that in a tiered design, higher level modules and lower level modules should not directly depend on each other; instead they should only depend on abstractions. Moreover, abstractions should not have any knowledge of details (other classes in the system). This principle closely relates to some of the other design principles I discussed previously in that it yields a design that is highly decoupled ensuring that minor changes in one part of the application do not cause a domino effect in other parts of the application. Moreover such a design is extensible -- as new business entities are added, usually such as design scales well by requiring only new code to be added rather than existing code to be modified. ASP.NET 2.0's Provider Model is a great example of such a design that provides a default implementation for various sub-systems such as Membership, Personalization, Navigation, etc. but also allows developers to modify the default behavior by extending certain classes.

LSP: Liskov Substitution Principle

The Liskov Substitution Principle dictates when and where it is correct to derive a subtype from an existing supertype. As defined by Barbara Liskov and Jeannette Wing, it essentially states that:

Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T.

What it means is that if S is a subtype of T, then a function q(x) must behave in the same manner irrespective of the type of x whether it be S or T. In other words, if a piece of code behaves differently for a subtype than a supertype, then that code violates the LSP (and consequently the OCP). Let's say that we work for a bank and that we have a simple teller application. Currently the teller application works with checking and savings account types. public abstract class Account { public abstract double CurrentBalance { get; } public abstract void Deposit(double amount); } public class CheckingAccount : Account { private double _currentBalance; public override double CurrentBalance { get { return _currentBalance; } } public override void Deposit(double amount) { _currentBalance += amount; } } public class SavingsAccount : Account { /* Savings account implementation */ } Our bank just entered the mortgage business so we need to modify our teller application to support this new account type. During the short analysis phase we decide that since mortgage account is type of an account (IS-A relationship), we can simply create a new mortgage class deriving from the Account abstract class, override a method and a property, and we should be in business. We add a new class as follows: public class MortgageAccount : Account { private double _currentBalance; public override double CurrentBalance { get { return _currentBalance; } } public override void Deposit(double amount) { _currentBalance -= amount; } } Everything sounds logical, that is until we come across this code in the teller application: public class Bank { public void ReceiveMoney(Account account, double amount) { double oldBalance = account.CurrentBalance; account.Deposit(amount); Debug.Assert(account.CurrentBalance = oldBalance + amount); } } Based on our pre-existing code, the ReceiveMoney() method is making a reasonable assumption that the new balance should be equal to the old balance plus the newly deposited amount. This assumption is, however, violated if we pass an instance of the Mortgage class to this method. This is a clear violation of the LSP.

OCP Open-Closed Principle

Another fundemental principle of object-oriented software design is the Open-Closed Principle. According to Uncle Bob (Robert Martin), this principle states that:

Software entities (classes, modules, functions, etc.) should be
open for extension, but closed for modification.

Essentially, what this means is that software's design should be such that it's behavior can be modified by extending the existing source code rather than modifying it. Consider the following example: public class CheckingAccount { private double _currentBalance; public void ProcessDeposit(double amount) { _currentBalance += amount; } } public class MortgageAccount { private double _currentBalance; public void ProcessPayment(double amount) { _currentBalance -= amount; } } public class Bank { public void ReceiveMoney(object account, double amount) { if (account.GetType() == typeof(CheckingAccount)) { CheckingAccount checkingAccount = (CheckingAccount)account; checkingAccount.ProcessDeposit(amount); } else if (account.GetType() == typeof(MortgageAccount)) { MortgageAccount mortgageAccount = (MortgageAccount)account; mortgageAccount.ProcessPayment(amount); } } } Notice that the ReceiveMoney() method of the Bank class has to determine the type of account passed in. Only based on that information it can perform the appropriate business logic. Later if we add another account type then we may need to modify this code in order for it to work properly. The above code is, hence, in violation of the Open-Closed principle. So how can we revise our code to conform to the Open-Closed Principle? Abstraction is the answer. Let's take a look: public abstract class Account { public abstract void Deposit(double amount); } public class CheckingAccount : Account { private double _currentBalance; public override void Deposit(double amount) { _currentBalance += amount; } } public class MortgageAccount : Account { private double _currentBalance; public override void Deposit(double amount) { _currentBalance -= amount; } } public class Bank { public void ReceiveMoney(Account account, double amount) { account.Deposit(amount); } } Notice how we got rid of all conditional logic in the ReceiveMoney() method. Also notice that if we later add a new account type, the ReceiveMoney() method will work without any modifications. The revised version of our code above, hence, conforms to the Open-Closed Principle. Let's now consider what happens to our code if a new business rule is added that requires an e-mail notification to be sent to the account holder whenever a deposit is made. Obviously, we'll have to modify the ReceiveMoney() method to perform that logic. Since we can't account for all possible scenarios, we can never acheive perfect closure. With that in mind, design the simplest software that will do the job, and conform to OCP or other such design principles where you see the need.

Generic Collection<T> and ReadOnlyCollection<T> Are Actually Not Misplaced

Since I started using generic collections in .NET Framework 2.0, it always bothered me that Collection<T> and ReadOnlyCollection<T> objects reside in the System.Collections.ObjectModel namespace rather than where they actually belong in the System.Collections.Generic namespace. Today I came across this blog by Krzysztof Cwalina that explains why Microsoft made this decission. Now it makes good sense to me.

Get Table Schema Programatically

In order to retreive table schema programatically, we can use the GetSchemaTable method of the DataReader as follows: using (OleDbConnection cn = new OleDbConnection()) { OleDbCommand cmd; DataTable schemaTable; OleDbDataReader reader; cn.ConnectionString = @"Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=Northwind;Data Source=(local);"; cn.Open(); cmd = new OleDbCommand("Employees", cn); cmd.CommandType = CommandType.TableDirect; using (reader = cmd.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo)) { schemaTable = reader.GetSchemaTable(); foreach (DataRow row in schemaTable.Rows) { foreach (DataColumn col in schemaTable.Columns) Console.WriteLine(col.ColumnName + " = " + row[col].ToString()); Console.WriteLine(); } reader.Close(); } cn.Close(); }

Client Side Reports in Visual Studio 2005

Perhaps the best kept secret (or at least the least discussed feature) of Visual Studio 2005 is the client-side reports. Client-side reports consists of the Report Viewer Control and it's accompanying Report Designer that comes standard with Visual Studio 2005 Professional and up. This feature can be used to develop ASP.NET or WinForms solutions that sport SQL Server Reporting Services style reports, without having to deploy those reports to a Reporting Server. Reports are deployed as RDLC files with your solutions. In fact one doesn't even need SQL Server, since these reports can be programatically bound to objects such as DataSets, a huge plus for ditributed n-tier designs where the UI layer does not have direct access to the data store. This also means that one can use any imaginable back-end data store including XML and CSV files as long as data can be loaded into binable objects. The report viewer control is similar to Reporting Services report viewer, with nifty features such as paging, searching, and export (PDF, Excel, CSV) features. My only complain with the ASP.NET version of the report viewer is that it does not directly support printing. Reports have to be exported to PDF in order for one to print. This was a gotcha with the first versions of Reporting Services report viewer as well, but later they added printing support to the control (perhaps through ActiveX) in Reporting Services SP1. You can find more information about this feature at GotReportViewer.

Write Black and Blue Get Green Free

GhostDoc is a free Visual Studio add-in that automatically generates XML comments by intelligently deducing comments from member name and type or by using existing documentation written by someone else in a base class or an interface. This tool is purely intelligent and simply amazing. With tools such as this there simply is no excuse for developers whose code looks all black and blue to not add some green for free! Checkout this GhostDoc PDC demo video on Channel9.

Inherit With Care

I was asked to look at an ASP.NET 1.1 application that was designed with a distributed architecture using .NET Remoting. Over a period of a few hours of heavy usage, this production application would intermittently bring the Windows 2003 Server that it was being hosted on to a screeching halt. Cause unknown. No event log entries, nothing suspicious in IIS logs, nothing too special about the application that would indicate this behavior. Performance monitoring, however, indicated that the handles on the OS would gradually increase to dangerous levels of 50,000+ before the application would crash. Hmmm, what could be using so many handles and not releasing them? My first instinct was to make sure that all the remoting objects were disposed properly after use. Upon closer investigation, however, I found out that all ASP.NET pages in the application were inheriting from a custom base class. The base class was overriding the page's Init method, and guess what I found in that method? A call to RemotingConfiguration.Configure() method. At first I was surprised why would someone configure remoting every single time a page is instantiated? Soon it hit me why system handles were astronomically increasing. Once that line of code was moved to Application_Start event, the application hasn't crashed in weeks. Moral of the story? Inheritance is a good OO concept, but only we as developers can decide how badly we want to abuse it!