Application Architecture Using Generics C#.Net 2.0

Transcription

1 Application Architecture Using Generics C#.Net 2.0

2 2 Table of Contents Application Architecture Using Generics C#.Net... 3 Preface... 3 Audience Level... 3 Introduction... 3 About Generics & Its advantages... 3 Syntax of Generics... 4 Application Architecture Component... 5 Explanation... 6 Layers Explained... 6 Business Layer in details... 6 BusinessInfo Layer in details... 9 Conclusion... 10

3 3 Application Architecture Using Generics C#.Net Preface We have been introduced to several design patterns for.net programming languages. It is a fact that the design needs to be engineered as per the requirements. I found the architectures using the array list, collection base structures in.net Framework 1.1 to be very useful for rapid application development. The advantages that we found were that we could incorporate change requests with zero or lesser implications, faster maintainability, performance boost. In all these cases, we are in need of a type conversion in the existing routine. So I found it necessary to upgrade the existing architecture to leverage the potentials of concept of Generics available in.net Framework 2.0. Audience Level This component is aimed to be read by an Intermediate\Expert level. Familiarity to design patterns, n-tier architecture and IList, IEnumerator, IComparer interfaces of.net framework 2.0 would help in using this architecture. Introduction The need for reusable architectures for software projects has been immense. Always there would be constant quest for good patterns and practices. I would like to share a good practice component with you in this article. About Generics & Its advantages Any collection of any type of data is known as Generics. The advantages of CLR Generics are compile-time type safety, binary code reuse, performance, and clarity. We will go through these advantages one by one. As an example let's take two hypothetical collection classes: SortedList, a collection of Object references, and GenericSortedList<T>, a collection of any type. Type safety: When a user adds a String to a collection of type SortedList, there is an implicit cast to Object. Similarly, if a String object is retrieved from the list, it must be cast at run time from an Object reference to a String reference. This lack of type safety at compile time is both tedious for the developer and prone to error. On the other hand, a use of GenericSortedList<String> where T is typed to String causes all add and lookup methods to work with String references. This allows for specifying and checking the type of the elements at compile time rather than at run time. Binary code reuse:

4 4 For maintenance purposes, a developer may elect to achieve compile-time type safety using SortedList by deriving a SortedListOfStrings from it. The problem with this approach is that new code has to be written for every type for which you want a type-safe list, which can quickly become laborious. With GenericSortedList<T>, all you need to do is instantiate the type with the desired element type as T. As an added value, generics code is generated at run time, so two expansions over unrelated element types such as GenericSortedList<String> and GenericSortedList<FileStream> are able to reuse most of the same just-in-time (JIT)-compiled code. The CLR takes care of this. Performance: The bottom line is this: if type checking is done at compile time rather than at run time, performance improves. In managed code, casts between references and values incur several both boxings and unboxings, and avoiding such casts can have an equally negative impact on performance. As per the current analysis of a quick-sort of an array of one million integers shows the generic method is three times faster than the non-generic equivalent. This is because boxing of the values is avoided completely. The same sort over an array of string references resulted in a 20 percent improvement in performance with the generic method due to the absence of a need to perform type checking at run time. Clarity: Clarity with generics comes in a number of forms. Constraints are a feature in generics that have the effect of making incompatible expansions of generic code impossible. In the GenericSortedList<T> example, the collection class would have a constraint that makes it only work with types for T that can be compared and therefore sorted. Also, generic methods can often be called without employing any special syntax by using a feature called type inference. And, type safety at compile time increases clarity in application code. Syntax of Generics Defining Code class Node<T> T m_data; Node<T> m_next; struct Pair<T,U> T m_element1; U m_element2; interface IComparable<T> Int32 CompareTo(T other); Referencing Code class Node8Bit : Node<Byte> Pair<Byte,String> pair; pair.m_element1 = 255; pair.m_element2 = "Hi"; class MyType : IComparable<MyType> public Int32 CompareTo(MyType other)...

5 5 Defining Code void Swap<T>(ref T item1, ref T item2) T temp = item1; item1 = item2; item2 = temp; delegate void EnumerateItem<T>(T item); Referencing Code Decimal d1 = 0, d2 = 2; Swap<Decimal>(ref d1, ref d2); EnumerateItem<Int32> callback = new EnumerateItem<Int32>(CallMe); void CallMe(Int32 num)... Application Architecture Component The application architecture is an n-tiered one. It has Business, BusinessInfo, DataAccess, Common, View, ServiceAccess, Utilities layers. The application architecture can be depicted as follows: The layer dependencies are depicted in the architecture diagram using connecting lines between the layers. After creating the project framework the solution explorer of visual studio will be displaying projects as follows:

6 6 Explanation Layers Explained Business: Holds the business logic BusinessInfo: Holds the entities DataAccess: Holds the data access logic for the project Common: Holds the shared functions and constants View: Holds the user interface for the application ServiceAccess: Holds the external service subscription interfaces and logic Utilities: Holds all utility classes like , Image Handler etc Business Layer in details Business Layer contains all entities with their behaviors (functionalities). The entities in this class contain the generics based BusinessInfo entities which holds the state of the business entities.

7 7 In our example, we have a User class defined in the Business Layer. using System; using System.Collections.Generic; using System.Data.SqlClient; using BusinessInfo; namespace Business /// Class to represent User entity public sealed class User : List<UserInfo> /// The default constructor public User() /// Assigns data to a User Info object /// <param name="userinfo"></param> /// <param name="dr"></param> private void AssignData(UserInfo userinfo, SqlDataReader dr) /// Loads all Users /// <returns>number of users </returns> public int Load() UserInfo userinfo = null; try userinfo = new UserInfo(); // TO DO : Perform the data access operations Add(userInfo); catch (Exception ex) throw new BusinessException(ex, "Error occured while loading users"); return this.count; /// Inserts a user's details to the data store

8 8 /// <param name="userinfo">user's details</param> /// <returns>true if operation successful</returns> public bool Insert(UserInfo userinfo) bool result = false; try // TO DO : Perform the data insertion operations result = true; catch (Exception ex) throw new BusinessException(ex, "Error occured while inserting user details"); return result; /// Deletes a user's details from the data store /// <returns>true if operation successful</returns> public bool Delete(int UserId) bool result = false; try // TO DO : Perform the data insertion operations result = true; catch (Exception ex) throw new BusinessException(ex, "Error occured while deleting user details"); return result; /// Updates the data store with a user's details /// <param name="userinfo">user's details</param> /// <returns>true if operation successful</returns> public bool Update(UserInfo userinfo) bool result = false; try // TO DO : Perform the data insertion operations result = true; catch (Exception ex) throw new BusinessException(ex, "Error occured while updating user details");

9 9 return result; BusinessInfo Layer in details The classes in this layer acts as the business object which holds the state for the entities defined in Business Layer. Corresponding to an entity defined in Business Layer, a BusinessInfo object is defined in this layer. In our example, we have a User class defined in the Business Layer. So a UserInfo object will be defined in BusinessInfo Layer. using System; using System.Collections.Generic; namespace BusinessInfo /// Class to hold the users's state public class UserInfo /// Holds the user's name private string m_name = string.empty; /// The default constructor public UserInfo() /// Gets/Sets the name of the user public string Name get return m_name; set m_name = value;

10 10 The business layer classes acts as generics lists of their corresponding state holder type. So the business entity can store and supply the state object, as per the requirement of the presentation layer. In the presentation layer, you can create an instance of User entity and can access all the business objects in the generics by indices. // Declare the user instance Business.User user = null; try // Create the user instance user = new Business.User(); // Load all users from data store user.load(); if (user.count > 0) // Write a welcome message to the first Response.Write("First User's Name : " + user[0].name); catch (Exception ex) // TO DO : Log the exception details finally // De reference the user instance if (user!= null) user = null; Here, in the presentation layer, we can see that we are avoiding a type conversion by directly referencing user[0].name. The same architecture, using collection based list, would have achieved the purpose by using a type conversion to a UserInfo instance at the presentation layer explicitly. The Generics list is enriched with additional functionalities for sorting, searching etc. This give a noticeable domination for generics over the collection based lists. Conclusion CLR generics are a powerful application and library development feature. Whether you choose to apply generics by using the collection classes or by architecting your application generically throughout, generics can make your code more type-safe, maintainable, and efficient.