Database

nAML: A New Revolutionary Way to Model Your .NET Applications!

Mohammad Ashraful Alam — Fri, 12 Sep 2008 15:35:10 GMT

Understanding the architecture and code in software application plays as major factors while building good software products. Having an easy to understand visual notation, not only helps architects to model the system efficiently, but also helps developers to quickly implement that, as well as it helps the re-engineering process to easily adopt the architectural model with respect to new requirement.

A new visual modeling technique, termed as “nAML” (.NET Application Modeling Language) is being introduced which overcomes the limitation of typical modeling languages by providing revolutionary way within a single space to describe an application system with its structural and behavioral, as well as physical and logical components. It illustrates real world samples, from user interface experience, .NET specific language (such as C#) classes to database level SQL commands, to let software architects and developers to have a clean model for the future system. One of it’s the most powerful objectives of this new visual language is the besides an easy way to model the system, the target model will require near to zero knowledge on notation semantics from reader aspect.

Primary Objectives

The primary objectives of nAML can be considered as follows:

Provides a single space to visually describe one or more application systems with structural and behavioral components.
Provides a single space to visually describe one or more application systems with logical and physical components.
Provides a single space to visually describe one or more application systems from top to low level.
Provides a single space to visually describe a part or whole of one or more application systems.
Extremely simple and easy understand and learn from readers and designers perspective.
Concentrates on .NET applications, with its related logical and physical entities (user interface, application logic, business logic, database etc).

Links and Downloads

Here is the nAML project site: http://code.msdn.microsoft.com/nAML
Download the latest specification, examples and Visio 2003 Stencil for nAML tutorial from here.
Download Visio 2003 Stencil for nAML from here.

Technorati Tags: architecture,modeling,.net,asp.net,development

Using .NET 2.0 Generics for Custom Entity Collection

Mohammad Ashraful Alam — Mon, 18 Feb 2008 11:12:59 GMT

Generics is a new feature in .NET 2.0 which allows us to create a data structure without committing to a specific data type. In the early age of .net 2.0 (i.e. .net 1.x), while using custom entity model in our application data architecture, we had to create a separate class regarding the collection for each of custom entity.

The custom entity

public class SystemUser
{
    public string _Name, _Password;

    public SystemUser(string name, string password)
    {
        _Name = name;
        _Password = password;
    }

    public string Password
    {
        get { return _Password; }
        set { _Password = value; }
    }

    public string Name
    {
        get { return _Name; }
        set { _Name = value; }
    }

The old age custom entity collection class

For a custom entity "SystemUser" we had to create a separate collection class as below:

public class SystemUserCollection: CollectionBase
{
    public SystemUser this[ int index ]
    {
        get{return ( (SystemUser) List[index]);}
        set{List[index]=value;}
    }
    
    public int Add(SystemUser value)
    {
        return (List.Add(value));
    }
    
    public int IndexOf(SystemUser value)
    {
        return (List.IndexOf(value));
    }
    
    public void Insert(int index, SystemUser value)
    {
        List.Insert(index, value);
    }
    
    public void Remove(SystemUser value)
    {
        List.Remove(value);    
    }
    
    public bool Contains(SystemUser value)
    {
        return (List.Contains(value));    
    }
  
}

Custom entity collection using .net 2.0 generics

The generics in .net 2.0 made developers life extremely easy, we can create a common collection class for all custom business entity with respect to common collection based functionality.

/// <summary>
/// This is the helper collection class, that holds

generic type data.
/// This type will be used to manipulate generic class.
/// </summary>
/// <typeparam name="GenericType"></typeparam>
public class CustomCollection<GenericType> : CollectionBase
{
        /// <summary>
        /// Adds an object to the collection.
        /// </summary>
        /// <param name="GenericObject"></param>
        public void Add(GenericType item)
        {
            InnerList.Add(item);
        }

        /// <summary>
        /// Removes an object from the collection.
        /// </summary>
        /// <param name="index"></param>
        public void Remove(int index)
        {
            InnerList.RemoveAt(index);
        }

        /// <summary>
        /// Gets and sets the appropriate object

in the specified index.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public GenericType this[int index]
        {
            get { return ((GenericType)List[index]); }
            set { List[index] = value; }
        }

}//end of GenericCollection<GenericType>

Using generic collection

Generic collection classes can be used in the following way:

public static CustomCollection<SystemUser>

GetSampleGenericCollection()
{
    SystemUser user1 = new SystemUser("ashraf", "12345");
    SystemUser user2 = new SystemUser("ehsan", "12345");
    SystemUser user3 = new SystemUser("tuhin", "12345");
    SystemUser user4 = new SystemUser("rabbi", "12345");

    CustomCollection<SystemUser> mySystemUserCollection

= new CustomCollection<SystemUser>();

    mySystemUserCollection.Add(user1);
    mySystemUserCollection.Add(user2);
    mySystemUserCollection.Add(user3);
    mySystemUserCollection.Add(user4);

    return mySystemUserCollection;

}

Download code:

Technorati Tags: .net,coding,programming,C#,sample

ASP.NET Role Based Security: The Basics

Mohammad Ashraful Alam — Mon, 18 Feb 2008 10:31:40 GMT

Authentication and authorization is the two basic part of the user-end security in asp.net web applications. After to successful authentication of a user, authorization takes the place according to which the authenticated user are allowed to access to the corresponding resources in the web application.

Role based security is very basic requirements in the current trend of web applications. Mostly there are two roles involved, which are registered user and the admin users. However in a web application a user can have multiple roles which can be authorized on page and page control level. Today we'll check a basic sample which includes page based authorizations for specific roles.

To implement the basic role based security, there are three points to be considered. In this example we are considering two different roles "member" and "admin". There are two separate folders named "member", which can be accessed by any logged in user, including admin users and "admin", where only the user who contains the "admin" role can access the child resources (page, images etc).

1. Defining the authorization regions in web.config

The following xml tags are required to be added under the "configuration" node of the web.config.

Defining security authorization for "member" users

  <location path="member">
    <system.web>
      <authorization>
        <deny users="?"/>
      </authorization>
    </system.web>
  </location>

Defining security authorization for "admin" users

  <location path="admin">
    <system.web>
      <authorization>
        <allow roles="admin"/>
        <deny users="*"/>
      </authorization>
    </system.web>
  </location>

2. Authenticating the user

After the successful authentication, the following codes are required to establish the form based authentication for the corresponding user.

//Authenticating the user Identity.

System.Web.Security.FormsAuthentication.RedirectFromLoginPage

("member1", this.CheckBox1.Checked);

3. Implementing the role based security

The "Application_AuthenticateRequest" event which was defined in the "Global.asax" file, will include the appropriate codes regarding the role info of the logged in user, which will be accesses each time for any web request in this web application. This can be done in either "cache" or "cookie" mechanism.

Cache based mechanism

protected void Application_AuthenticateRequest(Object sender, EventArgs e)

{

if (HttpContext.Current.User != null)

{

if (HttpContext.Current.User.Identity.IsAuthenticated)

{

if (HttpContext.Current.User.Identity.AuthenticationType != "Forms")

throw new Exception("Only forms authentication is supported, not " +

HttpContext.Current.User.Identity.AuthenticationType);

System.Security.Principal.IIdentity userId = HttpContext.Current.User.Identity;

//if role info is already NOT loaded into cache, put the role info in cache

if (System.Web.HttpContext.Current.Cache[userId.Name] == null)

{

string[] roles;

if (userId.Name == "admin1")

roles = new string[1] { "admin" };//this info will be generally collected from database

else if (userId.Name == "member1")

roles = new string[1] { "member" };//this info will be generally collected from database

else

roles = new string[1] { "public" };//this info will be generally collected from database

//1 hour sliding expiring time. Adding the roles in chache. This will be used in Application_AuthenticateRequest event located in Global.ascx.cs file to attach user Principal object.

System.Web.HttpContext.Current.Cache.Add(userId.Name, roles, null, DateTime.MaxValue, TimeSpan.FromHours(1), System.Web.Caching.CacheItemPriority.BelowNormal, null);

}

//now assign the user role in the current security context

HttpContext.Current.User = new System.Security.Principal.GenericPrincipal(userId, (string[])System.Web.HttpContext.Current.Cache[userId.Name]);

}

Cookie based mechanism

protected void Application_AuthenticateRequest(Object sender, EventArgs e)

{

if (HttpContext.Current.User != null)

{

if (Request.IsAuthenticated == true)

{

if (HttpContext.Current.User.Identity.AuthenticationType != "Forms")

throw new Exception("Only forms authentication is supported, not " +

HttpContext.Current.User.Identity.AuthenticationType);

//Create/Retrieve cookie and initizalyze the role info in the current security context

string userInformation = String.Empty;//where the cookie info will be placed

string[] roles;//where the user role will be placed

// Create the roles cookie if it doesn't exist yet for this session.

if ((Request.Cookies["cnstUserRole"] == null) || (Request.Cookies["cnstUserRole"].Value == ""))

{

if (HttpContext.Current.User.Identity.Name == "admin1")

roles = new string[1] { "admin" };//this info will be generally collected from database

else if (HttpContext.Current.User.Identity.Name == "member1")

roles = new string[1] { "member" };//this info will be generally collected from database

else

roles = new string[1] { "public" };//this info will be generally collected from database

// Create a string to persist the role and user id

userInformation = roles[0] + ";" + Context.User.Identity.Name;

// Create a cookie authentication ticket.

FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(

1, // version

User.Identity.Name, // user name

DateTime.Now, // issue time

DateTime.Now.AddHours(1), // expires every hour

false, // don't persist cookie

userInformation

);

// Encrypt the ticket

String cookieStr = FormsAuthentication.Encrypt(ticket);

// Send the cookie to the client

Response.Cookies["cnstUserRole"].Value = cookieStr;

Response.Cookies["cnstUserRole"].Path = "/";

Response.Cookies["cnstUserRole"].Expires = DateTime.Now.AddMinutes(1);

}//if role cookie not found in local pc

else//we are getting the role info from cookie

{

// Get roles from roles cookie

FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(Context.Request.Cookies["cnstUserRole"].Value);

userInformation = ticket.UserData;

//info[0] contains the single role and info[1] contains the user name

string[] cookieInfo = userInformation.Split(new char[] { ';' });

roles = new string[1] { cookieInfo[0] };

}

//now assign the user role in the current security context

Context.User = new System.Security.Principal.GenericPrincipal(Context.User.Identity, roles);

}//if (Request.IsAuthenticated == true)

}

Download source code:

Technorati Tags: asp.net,security,programming,coding,C#,.net

Performing Long Running Operation with Asynchronous Page in ASP.NET 2.0

Mohammad Ashraful Alam — Thu, 22 Nov 2007 07:29:04 GMT

Technorati Tags: asp.net,async,web service,performance,database

There are few cases in current web applications, where it involves long running operations. For instance, a system admin uploads 1 gig of data in the system, which will be processed by the system for 30-40 minutes to be splitted and putted properly in the database system, as well as notifying other system user regarding the availability if data.

In the traditional approach of web application, the user has to wait for the whole time until the whole process needs to be completed. The modern age of web application includes a technique where the user doesn't required to be wait to complete the whole process with the current page, where as they can move on other page (or even can close the browser) or if they resides on that page the system will show a simple progress bar , which stops when the data processing (or the long running operation) completes. The corresponding technique that implies this usability feature is using an asynchronous model.

Before the asp.net 2.0 ages, creating an asynchronous model was very complex and time consuming along with several over-heads. ASP.NET 2.0 comes with a new nice feature, where we can declare and use a page easily in asynchronous style. Besides the easy implementation model, ASP.NET asynchronous page utilizes ASP.NET threads efficiently. While calling a long running database query or web service, at the moment the request reaches at the asynchronous point, the corresponding asynchronous operation starts without keeping the current ASP.NET allocated, and thus lets the thread to be returned back to the thread pool. As soon as the asynchronous process completes, another ASP.NET thread get allocated and continues accordingly. This model really improves the utilization of ASP.NET thread pool and thus improves the scalability of the corresponding web applications. More can be found here.

To make a web page asynchronous, we just have to put a property in the page directive as follows:

<%@ Page Async="true" ...

There are two different implementation model for ASP.NET 2.0 asynchronous pages, with respect to database and web-service call.

Implementation model for database

The implementation model for database query requires a "PageAsyncTask" class to be set with few event handler methods such as "Begin Event Handler", "End Event Handler", "Timeout Event Handler" etc. This task should be registered as an Asynchronous tasks to continue and complete the asynchronous scenario properly.

public partial class AsyncPageTask : System.Web.UI.Page
{
    private SqlConnection _connection;
    private SqlCommand _command;
    private SqlDataReader _reader;
 
    IAsyncResult BeginAsyncOperation(object sender, EventArgs e, AsyncCallback cb, object state)
    {
        Response.Write("Starts at: " + DateTime.Now.ToString());
 
        _command = DAL.GetCommandForInsertRecord();
        _connection = _command.Connection;
        return _command.BeginExecuteReader(cb, state);
    }
 
    void EndAsyncOperation(IAsyncResult ar)
    {
        _reader = _command.EndExecuteReader(ar);
        Response.Write(" Ends at: " + DateTime.Now.ToString());
    }
 
    void TimeoutAsyncOperation(IAsyncResult ar)
    {
 
    }
 
    public override void Dispose()
    {
        if (_connection != null)
            _connection.Close();
        base.Dispose();
    }
 
    protected void btnClick_Click(object sender, EventArgs e)
    {
        Response.Write("Hello ");
        PageAsyncTask task = new PageAsyncTask(
            new BeginEventHandler(BeginAsyncOperation),
            new EndEventHandler(EndAsyncOperation),
            new EndEventHandler(TimeoutAsyncOperation),
            null
        );
        RegisterAsyncTask(task);
    }
 
}

Implementation model for web service

The implementation model for web service call is much more simpler than the database query. Ii just includes creating an web service instance, followed by calling the MethodName"Async" (for instance, if the web method name is "HelloWorld" then its asynchronous method name is "HelloWorldAsync". Besides the calling the asynchronous method for a web service method, we can register it's complete event handler to perform some post completion tasks.

protected void btnClick_Click(object sender, EventArgs e)
    {
        Response.Write("Starts at: " + DateTime.Now.ToString());
        MyWebService.WebService MyWS = new MyWebService.WebService();
        MyWS.HelloWorldCompleted += new MyWebService.HelloWorldCompletedEventHandler(MyWS_HelloWorldCompleted);
        MyWS.HelloWorldAsync();
    }
 
    void MyWS_HelloWorldCompleted(object sender, MyWebService.HelloWorldCompletedEventArgs e)
    {
        Response.Write(" Ends at: " + DateTime.Now.ToString());
    }
 
Download Source code: 

Performance Benchmark on Database Column and Row Expansion

Mohammad Ashraful Alam — Mon, 19 Nov 2007 10:50:59 GMT

What performs better – Expanding DB column or expanding db row? My benchmark test shows expanding DB column performs better, on the following machine configuration:

Processor: Intel® Pentium® 4; 2.66 GHz;

Memory: 960 RAM.

Operating System: Windows XP, Version 2002, Service Pack 2.

Expanding Columns

A table having 4 columns with nchar(10) data type with 20,112 rows, query executes:

SQL Server Execution Times: CPU time = 47 ms, elapsed time = 125 ms.

Scan count 1, logical reads 232, physical reads 0, read-ahead reads 0.

Expanding Rows

A table having 1 column with nchar(10) data type with 80,017 rows, query executes:

SQL Server Execution Times: CPU time = 63 ms, elapsed time = 253 ms.

Scan count 1, logical reads 301, physical reads 0, read-ahead reads 0.

Efficient Batch Operation From ASP.NET 2.0 Using SQL Server 2005 XML Data Type

Mohammad Ashraful Alam — Mon, 19 Nov 2007 09:52:50 GMT

One of the good practice while developing high performance web application is to reduce the database roundtrip as much as possible. In the current trend of web applications, its a very common to enable users to delete multiple items in a list user interface at a time.

To perform this type of batch delete operation, one common mistake that happens by beginner developers are to calling the data access method repetitively for each item with in a loop as below:

For Each row As GridViewRow In gvEmployees.Rows
            ' Access the CheckBox 
            Dim cb As CheckBox = CType(row.FindControl("chkEmployeeSelector"), CheckBox)
            If cb IsNot Nothing AndAlso cb.Checked Then
                ' First, get the EmployeeID for the selected row 
                Dim employeeId As SqlInt32 = CType(gvEmployees.DataKeys(row.RowIndex).Value, SqlInt32)
 
                ' Deleting a employee... 
                DAL.Employee.Delete.(employeeId) 
 
            End If
Next

A good approach regarding this issue is to send all of the employee id's at a time to the database stored procedure, so that all the deletion operation can be handled at a time, and thus reducing the cost with respect to database roundtrip! BUT one basic problem with this approach is SQL Server doesn't support array, and thus we can't pass the list of ID's as an array! Then?

Oh yes! We have XML data type available is SQL Server 2005, well we can utilize that concept easily. How? Easy! Just to create the list as an xml and then pass to the corresponding stored procedure. The stored procedure will extract the xml accordingly and perform required operation individually on each item.

Application End:

The method below converts a .net generic list to a xml representation of list of Id's which is passed to stored procedure to perform required batch operation:

public static string FormatXMLForIdArray(System.Collections.Generic.List<SqlInt32> idsToList)
    {
        //converting the list to xml first 
        StringBuilder xmlString = new StringBuilder();
        for (int i = 0; i < idsToList.Count; i++)
        {
            xmlString.AppendFormat("<Id>{0}</Id>", idsToList[i]);
        }
 
        return xmlString.ToString();
    } 

Stored Procedure End:

ALTER PROCEDURE spr_Employee_DeleteEmployeeList 
@EmployeeSystemUserIdList xml 
AS 
 
 
DELETE App_Employee 
WHERE EmployeeSystemUserId in 
( 
    SELECT ParamValues.EmployeeSystemUserId.value('.','Int') as Id 
    FROM @EmployeeSystemUserIdList.nodes('/EmployeeSystemUserId') as ParamValues(EmployeeSystemUserId) 
) 
 

Some Basic Differences Between ASP.NET 2.0 ObjectDataSource and SqlDataSource

Mohammad Ashraful Alam [MVP] — Wed, 15 Nov 2006 16:59:00 GMT

* Type Name
For ObjectDataSource, the property TypeName includes the class name, that will responsible to manage data, this may NOT be the data object collection. The select, insert etc methods will use the mentioned methods to access or retrieve data. For SqlDataSource, a built-in data collection is used, which can be bound to data data controls.

* Connection String
For ObjectDataSource, there is NO connection string needed, as it is used middle tier. For SqlDataSource, connection string is needed.

* CRUD Method
For ObjectDataSource, there is NO method (select, insert etc) type, as the methods are being used from a class of middle tier. For SqlDataSource, there are two types of methods StoredProcedure and Text. note, in SqlDataSource, for parameters, in the execution time the system automatically includes a '@' before the name as specified in the name property.

Concentration on Smarter Database Documentation

Mohammad Ashraful Alam — Wed, 18 Oct 2006 15:13:00 GMT

I have been working in SQL Server 2000 for previous several years. Of course it's a nice tool, where I can compile the top level requirements to physical implementation layer in much professional way. Well, as a developer, I have been faced a common problem in multiple projects, where I got confused while seeing the database diagram of an existing system, after a long time while I designed the database. Using database diagram, I can easily see the data fields, analyze the relations etc. But the problem is, since the attributes and relations are designed and shown in a technical manner, sometimes it becomes a bit tricky to match the top level requirements with the physical data model.

For that reason, I needed a support in the server tools set for another level of documentation, which lies between the top level requirements documents and physical data model.

[Top level requirement doc] -> [Readable documentation of physical db objects] -> [Physical data model]

In this level each physical entities, attributes and relations will be explained in much human readable way, in short a support for description for database objects, which can easily be integrated, reused in technical way (i.e. support for navigation while clicking/pointing the object in the documentation, specific data logic (for instance how particular query will be achieved using attributes) etc.

Well, right now, I am using MS Word, to describe entities, relations in very simple, but meaningful text and trying to discover a better and smarter structure of database documentation in the mentioned layer.

LINQ – We can use intellisense on queries !!!

Mohammad Ashraful Alam — Thu, 20 Jul 2006 06:13:00 GMT

As a developer always we want to have the opportunity to write the codes properly, along with programming language specific words and keyword to be highlighted in to different colors. Also VS.NET developers enjoys an IDE features named “Intellisense”, where while wring codes, a list of probable class or object name appears in a list and can be inserted to the code segment, just by selecting the appropriate item from the list. This becomes EXTREMELY useful, when we have to use long class names (for code readability, which is very much necessary).

While we invoke SQL statements from the “coding” layer, for instance using any .net ( ex. C# 3.0, VB.NET etc) language, we invoke a SQL statement, by using ADO.NET object model of .net framework, we really face a great problem now a days, since we have to write the SQL statements is string, where we can’t get the keyword colors or can use the intellisense features.

While invoking SQL statements into codes, personally I desired a language feature several times, where I can use the queries as language specific style. Yes, in the next version of C# programming language, there will be a new feature, named LINQ (Language Integrated Query), where we can invoke, debug and use the returned result of a database related query much more efficiently or effectively.

The code snippet below illustrates a very simple example of LINQ used in a C# programming language environment…

[Title("Where - Simple 1")]

[Description("This sample illustrate a sample method that uses LINQ")]

public void Linq1() {

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

var lowNums =

from n in numbers

where n < 5

select n;

Console.WriteLine("Numbers < 5:");

foreach (var x in lowNums) {

Console.WriteLine(x);

}

“Instance Saver” Custom Entity Model- Basic Architecture

Mohammad Ashraful Alam — Mon, 10 Jul 2006 02:09:00 GMT

Business Entity:

For each custom business entity, there is a collection class. However, if our tech platform is .net 2.0, we can use the generic list class for collections.

Business Layer:

1. Contains a “Save” instance method in business layer for insert and update operations.
2. For delete and get operations, it uses static methods in the business layer.

Data Access Layer:

Data access layer contains all CRUD operations in one class.