Creating class libraries

I was recently called onto a project to add features to existing applications. To me, this is one of the most challenging aspects of being a developer because the existing application strips away much of your control.

My project encompasses three applications that are similar in many ways. I quickly noticed that much of the code was redundant since the applications shared many functions. A lot of the duplicate code was in classes, so my first step was to create a class library to reduce maintenance headaches and ease the current task at hand: adding functionality.

Class libraries
You use class libraries when you're developing any type of .NET application. The .NET Framework includes the .NET Framework Class Library, an extensive collection of thousands of types (i.e., classes, interfaces, structures, delegates, and enumerations) that aim to encapsulate the functionality of core system and application services in order to make application programming easier and faster.

There are classes that you can use to manipulate the file system, access databases, serialize objects, and launch and synchronize multiple threads of execution, to name a few. To make working with these classes easy, you can group classes with similar functionality together in namespaces. When developing applications utilizing XML, the System.XML namespace is a necessity; it's also a class library. The .NET Framework compiles class libraries into DLLs, so the System.XML class library exists within the System.XML.dll file.

If you're using Visual Studio .NET, you may include a namespace (the DLL file) in the project's references section. Once you add a reference to an assembly, you can access any of the types in its namespaces by providing a fully qualified reference to the type. Typing the fully qualified name of each .NET type quickly becomes rather tiresome, particularly for types that are nested deep within a hierarchical namespace. You can, however, use the Imports (VB.NET) and using (C#) directives to utilize a particular namespace. This allows the compiler to resolve a particular type reference, thus eliminating the need to provide a fully qualified path.

Develop your own class libraries
In addition to the vast number of class libraries included with the .NET Framework, you can create your own. This allows you to create a collection of classes that you may use in multiple applications, and easily make them available to other developers. Additionally, it provides a central location for class maintenance. It reduces the need to include code in multiple projects with multiple maintenance access points.

To create a class library in Visual Studio .NET, select File | New | Project | Visual C# Projects | Class Library. Select your project name and the appropriate directory using the Browse button and click OK. Visual Studio .NET adds two classes to your project: AssemblyInfo and Class1. The AssemblyInfo class file contains details of the project (assembly information) such as name, copyright, version information, and so on. Class1 is the default name given to a class with subsequent classes incrementing the numeric suffix. You can easily rename this class (and namespace) to suit your needs.

The following code listing shows the default class added to a C# class library project, minus the default comment lines:

using System; namespace ClassLibrary { public class Class1 { public Class1() { } } }

Here's the VB.NET equivalent:

Public Class Class1 End Class

Or, you may decide to create your code using a simple text editor. Saving a file with the appropriate code extension (cs for C# and vb for VB.NET) makes it appear as a source code file. You can use the command-line compiler for your language to create the resulting DLL file.

Example
Now you're ready to create your own class library. I'll use code from a previous .NET newsletter that demonstrated extending the System.Web.UI.Page class. We'll create this class within its own class library. The class performs these tasks:

• Extends the System.Web.UI.Page class
• Disables caching
• Creates a hidden field called statusFlag with a value of zero
• Adds a JavaScript function to the head portion of the page
• Executes JavaScript code upon page startup/load

The class library code follows:

using System; using System.Web; using System.Web.UI; namespace BuilderClassLibrary { public class BaseClass : Page { public BaseClass() { } private void Page_Load(object sender, System.EventArgs e) { Response.Cache.SetCacheability(HttpCacheability.NoCache); this.RegisterHiddenField("statusFlag","0"); this.RegisterClientScriptBlock("ExampleScript", @" <script language=""JavaScript"" type=""text/javascript""> <!-- function displayWindow() { alert(""Sample JavaScript""); } //--> </script> "); this.RegisterStartupScript("startupScript",@"<script language=""javascript"">alert('hello');</script>"); } override protected void OnInit(EventArgs e) { InitializeComponent(); base.OnInit(e); } private void InitializeComponent() { this.Load += new System.EventHandler(this.Page_Load); } } }

Notice that the code is created within the BuilderClassLibrary namespace. Once you create and compile this class library, a DLL file, BuilderClassLibrary.dll, is available for use within other applications. You may use the library in other applications by adding a reference to it. You can achieve this in the reference list within Visual Studio .NET, and the reference (/r) switch when using a command-line compiler. I'll demonstrate this momentarily.

The next step is using your class library in another application. The following code listings show a basic ASP.NET Web form (the code behind file) that takes advantage of the class library. The Web form's class is derived from the BaseClass in the class library.

using System; using System.Collections; using System.ComponentModel; using System.Data; using System.Drawing; using System.Web; using System.Web.SessionState; using System.Web.UI; using System.Web.UI.WebControls; using System.Web.UI.HtmlControls; namespace BuilderExtendPageClassCSharp { public class WebForm1 : BuilderClassLibrary.BaseClass { private void Page_Load(object sender, System.EventArgs e) { if (!this.IsPostBack) { Session["Test"] = "Test"; } } override protected void OnInit(EventArgs e) { InitializeComponent(); base.OnInit(e); } private void InitializeComponent() { this.Load += new System.EventHandler(this.Page_Load); } } }

Since the code needs to be compiled, I use the C# command-line compiler. It uses the \out switch to tell the system where to place the output, as well as in what file. The reference switch (\r) is used to include the class library, the Web form's source code (WebForm1.aspx.cs) and the application's global file (Global.asax.cs) in the resulting dll.

csc /target:library /out:bin\BuilderExtendPageClass.dll
/r:BuilderClassLibrary.dll Global.asax.cs WebForm1.aspx.cs

For consistency, the Web form's aspx file follows:

<%@ Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false" Inherits="BuilderExtendPageClassCSharp.WebForm1" %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" > <html><head> <title>WebForm1</title> </script></head> <body MS_POSITIONING="GridLayout"> <form id="Form1" method="post" runat="server"></form> </body></html>

VB.NET equivalent
Up to this point, I've used C# as the language of choice, but VB.NET (or any other .NET language) could have been used. The VB.NET equivalent for the class library follows:

Imports System Imports System.Web Imports System.Web.UI Public Class BaseClass Inherits Page Public Sub BaseClass() End Sub Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) _ Handles MyBase.Load Response.Cache.SetCacheability(HttpCacheability.NoCache) Me.RegisterHiddenField("statusFlag", "0") Me.RegisterClientScriptBlock("ExampleScript", " " + _ "<script language=""JavaScript"" type=""text/javascript"">" + _ "<!--" + _ "function displayWindow() { " + _ "alert(""Sample JavaScript"");" + _ "}" + _ "//-->" + _ "</script>") Me.RegisterStartupScript("startupScript", "<script language=""javascript"">alert('hello');</script>") End Sub <System.Diagnostics.DebuggerStepThrough()> Private Sub InitializeComponent() End Sub Private designerPlaceholderDeclaration As System.Object Private Sub Page_Init(ByVal sender As System.Object, ByVal e As System.EventArgs)_ Handles MyBase.Init InitializeComponent() End Sub End Class

Here's the command-line option when using the VB.NET compiler:

vbc /target:library /out:bin\BuilderExtendPageClass.dll
/r:BuilderClassLibrary.dll Global.asax.vb WebForm1.aspx.vb

And, here's the Web form's .aspx file when VB.NET is used in the code behind file:

<%@ Page Language="vb" AutoEventWireup="false" Codebehind="WebForm1.aspx.vb" Inherits="BuilderExtendsPageClassVBNet.WebForm1"%>

The code that utilizes the VB.NET class is the same as the C# listing. That is a great aspect of using class libraries; you may build a library in VB.NET, but you can easily use it in your C# applications (and vice versa).

Simplify development
The use of class libraries allows you to better organize code to foster code reuse and ease the maintenance task. In addition, any future code changes are easier to implement when the code is centrally located.

Tony Patton began his professional career as an application developer earning Java, VB, Lotus, and XML certifications to bolster his knowledge.