Sunday, February 22, 2009

How to create ASPX Page Dynamically - A Step Ahead Series?

Introduction


In a simple creating an aspx page dynamically is a very tedious job. Whenever we think for dynamically creation scenarios stuck in mind about the overload to server etc. But with the help of this article one can attain the same as easily as creating another simple aspx page.

Need and Requirement


Now next words came to mind that what is the need to create an aspx page dynamically? Let me explain it:


  1. You need to create a page, based on selected requirement at the moment.

  2. Need to create a page from static html contents.

  3. Having huge data, need to represent in an individual page and its tough to store in database.



Article Scenario


As stated above, I choose a scenario where you are running a technical community and need to the template where member of your site will able to write some static html contents.

Explanation


For the same we need following pages:
1. PageHeader.ascx
This contains the header information of your page like LOGO etc.


<%@ Control Language="C#" AutoEventWireup="true" CodeFile="PageHeader.ascx.cs" Inherits="myTemplates_PageHeader" %>
<link href="../style.css" rel="stylesheet" type="text/css" />
<div>
<asp:PlaceHolder ID ="plhImage" runat="server" />
<ul class="menu">
<li><a href="./default.aspx">HOME</a></li>
<li><a href="./default.aspx">About US</a></li>
<li><a href="./default.aspx">Recent Posts</a></li>
<li><a href="./default.aspx">Site Map</a></li>
<li><a href="./default.aspx">Contact US</a></li>
<li><a href="./default.aspx">Tags</a></li>
<li><a href="./default.aspx">Meta</a></li>
<li><a href="./default.aspx">Most Emailed</a></li>
</ul>
</div>



2. PageFooter.ascx
Obvious it contains the Footer information.


<%@ Control Language="C#" AutoEventWireup="true" CodeFile="PageFooter.ascx.cs" Inherits="myTemplates_PageFooter" %>
<link href="../style.css" rel="stylesheet" type="text/css" />
<div id="footer">
<div>
<a href="http://www.webdesign.org">Web Design</a> by <a href="http://www.freetemplatesonline.com">Free Templates</a> Online<br />
<a href="#">Terms of Use</a> / <a href="#">Privacy Policy</a>
</div>
<div class="centeral-block">
<strong>New-York, USA</strong>
11 Some Street Second Floor<br /> New York WA 02020
</div>
<div>
Tel/Fax : 1(800)123-4567<br />
              1(800)123-1234<br />
E-mail : <a href="#" id="mail">info@yourcompany.com</a>
</div>
</div>

Click to check Snapshot

3. createPage.ascx
Definitely this is the main page, it just create a skeleton as per the above requirement and then segregate the contents and make the title.


<%@ Control Language="C#" AutoEventWireup="true" CodeFile="createPage.ascx.cs" Inherits="myTemplates_createPage" %>
<div>
<table>
<tr>
<td style="width: 100px">
Page Title
</td>
<td style="width: 100px">
<asp:TextBox ID="txtTitle" runat="server"></asp:TextBox>
</td>
</tr>
<tr>
<td style="width: 100px">
Tags
</td>
<td style="width: 100px">
<asp:TextBox ID="txtTags" runat="server"></asp:TextBox>
</td>
</tr>
<tr>
<td style="width: 100px">
Description
</td>
<td style="width: 100px">
<asp:TextBox ID="txtContent" runat="server" Height="292px" TextMode="MultiLine" Width="510px"></asp:TextBox>
</td>
</tr>
<tr>
<td style="width: 100px">
</td>
<td style="width: 100%">
<ul>
<li><font color="red">You may use basic html tags like <H1> <H2> <B>
<I> <FONT> etc. </font></li>
<li><font color="red">Tags like <BODY> <HEAD> <TABLE> are NOT allowed.</font></li>
<li><font color="red">Please check spelling before posting articles.</font></li>
</ul>
</td>
</tr>
<tr>
<td style="width: 100px">
</td>
<td style="width: 100px">
<asp:Label ID="lblMessage" runat="server"></asp:Label>
</td>
</tr>
<tr>
<td style="width: 100px">
</td>
<td style="width: 100%">
<asp:LinkButton ID="lnkNewPage" OnClick="lnkNewPage_Click" runat="server"></asp:LinkButton>
</td>
</tr>
<tr>
<td style="width: 100px">
</td>
<td style="width: 100px">
<asp:Button ID="btnGenerate" runat="server" OnClick="btnGenerate_Click" Text="Generate" />
</td>
</tr>
</table>
</div>


Click to check Snapshot

4. Default.aspx
This is the page or container which contains above all 3-controls.


<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" ValidateRequest="false" %>

<%@ Register TagPrefix="myPage" TagName="aspxPage" Src="~/myTemplates/createPage.ascx" %>
<%@ Register TagPrefix="myPageHeader" TagName="PgHeader" Src="~/myTemplates/PageHeader.ascx" %>
<%@ Register TagPrefix="myPageFooter" TagName="PgFooter" Src="~/myTemplates/PageFooter.ascx" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<link href="style.css" rel="stylesheet" type="text/css" />
</head>
<body>
<form id="form1" runat="server">
<div>
<table width="100%">
<tr>
<td colspan="2">
<myPageHeader:PgHeader ID="PgHeader1" runat="server" />
</td>
</tr>
<tr>
<td>
<h2>
Create Dynamic Page(S)</h2>
</td>
</tr>
<tr>
<td colspan="2">
<myPage:aspxPage ID="asxPage1" runat="server" />
</td>
</tr>
<tr>
<td colspan="2">
<myPageFooter:PgFooter ID="PgFooter1" runat="server" />
</td>
</tr>
</table>
</div>
</form>
</body>
</html>


5. myPageTemplate.tmp
This is the template page for all pages

<%@ Page Language="C#" CodeFileBaseClass="PageBase" AutoEventWireup="true" CodeFile ="myPageCode.cs"
Inherits= "myPageCode" PageID="[ID]" MetaTitle="[MetaTitle]" MetaKeywords="[MetaKeywords]" %>
<%@ Register TagPrefix="myPageHeader" TagName="PgHeader" Src="~/myTemplates/PageHeader.ascx" %>
<%@ Register TagPrefix="myPageFooter" TagName="PgFooter" Src="~/myTemplates/PageFooter.ascx" %>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<link href="style.css" rel="stylesheet" type="text/css" />
</head>
<body>
<form id="form1" runat="server">
<div>
<table width="100%">
<tr>
<td colspan="2">
<myPageHeader:PgHeader ID="PgHeader1" runat="server" />
</td>
</tr>
<tr>
<td>
<h2>
<%=MetaTitle%></h2>
</td>
</tr>
<tr class=content>
<td colspan="2">
[PageContent]
</td>
</tr>
<tr>
<td colspan="2">
<myPageFooter:PgFooter ID="PgFooter1" runat="server" />
</td>
</tr>
</table>
</div>
</form>
</body>
</html>



6. myPageCode.cs
A common code-behind page for all dynamic pages


using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

public partial class myPageCode : PageBase
{
public String newPageID
{
get
{
if (ViewState["newPageID"] != null)
return Convert.ToString(ViewState["newPageID"]);
else
return "0";
}
set
{
ViewState["newPageID"] = value;
}
}
protected void Page_Load(object sender, EventArgs e)
{
base.PageID = this.newPageID;
}

}

7. PageBase.cs
A pagebase which inherits System.Web.UI.Page.

using System;
using System.Collections.Generic;
using System.Web;
using System.Data;
using System.Configuration;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

///
/// Summary description for PageBase
///
public class PageBase : System.Web.UI.Page
{
public PageBase()
{
//
// TODO: Add constructor logic here
//
}
#region Properties
public String PageID
{
get
{
if (ViewState["PageID"] != null)
return Convert.ToString(ViewState["PageID"]);
else
return "0";
}
set
{
ViewState["PageID"] = value;
}
}
public String MetaTitle
{
get
{
if (ViewState["MetaTitle"] != null)
return Convert.ToString(ViewState["MetaTitle"]);
else
return "No Title";
}
set
{
ViewState["MetaTitle"] = value;
}
}
public String MetaKeywords
{
get
{
if (ViewState["MetaKeywords"] != null)
return Convert.ToString(ViewState["MetaKeywords"]);
else
return "No Keywords";
}
set
{
ViewState["MetaKeywords"] = value;
}
}
#endregion

protected override void OnLoad(EventArgs e)
{
if (!String.IsNullOrEmpty(MetaTitle))
{
HtmlMeta Title = new HtmlMeta();
Title.Name = "Title";
Title.Content = this.MetaTitle;
this.Header.Controls.Add(Title);
}

if (!String.IsNullOrEmpty(MetaKeywords))
{
HtmlMeta Keyword = new HtmlMeta();
Keyword.Name = "Keywords";
Keyword.Content = this.MetaKeywords;
this.Header.Controls.Add(Keyword);
}

//overide base
base.OnLoad(e);
}

void Page_Error(object sender, EventArgs e)
{
//Write Some logic here
}
}


Important


  1. Please note that I don’t check for any validation

  2. Instead of the use of Custom Control you can use Master Pages too.

  3. The same will create a good facility while you need to create dynamic pages.



How to run attached code:

1. Download the zip file
2. Open your Visual Studio2008
3. Open WebProject select the specific folder
4. Press F5 and enjoy

Your suggestions are invited to improve this.
Posted by Gaurav at 2/22/2009 05:34:00 AM 0 comments
Labels: ,

Saturday, February 14, 2009

What are constructors in C# - A Step Ahead Series?

Introduction


In a simple words Constructor is nothing but a method, a special kind of method of a class, which gets executed when its (class) object is created.

Now, let’s take above in broader sense, A constructor is a class method automatically executed whenever class’s object is created or whenever class is initialized. Consider following bit of code:


public class MsDotNetHeaven
{
public MsDotNetHeaven()
{
//A default Constructor
}

//Class members

}


In above snippet, try to change the name of constructor from MsDotNetHeaven to MsDotNetMentor and see whats happen, you have to put same name as you gave it to class.

Behind the scenes:

What happened behind the scenes : whenever you try to create an object of class or initialize a class, then the default constructor is invoked.


//Initializes the Class
MsDotNetHeaven objMsDnH = new MsDotNetHeaven();


Types of Constructor


This is a n issue of debate but I always like to segregated Constructors in following types:


  1. Default Constructor

    2. A constructor that takes no parameters is called a default constructor. Default constructors are invoked whenever an object is instantiated by using the new operator and no arguments are provided to new.

  2. Parameterized Constructor

    3. Besides a default constructor when its need to pass some argument on the initialization of a class a parameterized constructor is come to picture. It follows the same rules as default constructor with a difference that it has some parameters which also differentiate it from default constructor. Go through following snippet:


    public class MsDotNetHeaven
    {
    public MsDotNetHeaven()
    {
    //A default Constructor
    }

    public MsDotNetHeaven(String strName)
    {
    //A parameterized Constructor having one parameter
    }

    public MsDotNetHeaven(String strFirstName, String strLastName)
    {
    //A parameterized Constructor having two parameters
    }


    //Class members

    }


    Note:
    1. A default constructor should be explicitly declared while declaring parameterized constructor.

    2. Some writer also take Private constructor and Static Constructor as types of constructor but in my view these are constructor with different modifiers so behave differ; I will cover these in next section.


Access Modifiers and Prefix with Constructors


By default Constructors are public but we can also use other modifiers and prefix like private and static. With the use of these modifiers constructors behave differently:

Using Access Modifier private with Constructor

When put private as access modifier to constructor then that constructor is known as private Constructor

A private constructor is a special instance constructor. It is commonly used in classes that contain static members only. If a class has one or more private constructors and no public constructors, then other classes (except nested classes) are not allowed to create instances of this class.

Some time there is a need where we have not allow outer world to get instantiate our class then we need to use private modifier with constructor. Consider following piece of code:


public class MsDotNetHeaven
{
private MsDotNetHeaven()
{
//A default Constructor as private
}

//Class members

}


Now, whenever you try to invoke following piece of code:


//Initializes the Class
MsDotNetHeaven objMsDnH = new MsDotNetHeaven();


it throws an error: Constructors. MsDotNetHeaven. MsDotNetHeaven ()' is inaccessible due to its protection level

Now, question comes to mind if the above contains error then what the use is of private constructor, we can make above class to be initialized by declaring another public constructor, modify above code-snippet with bellow one:


public class MsDotNetHeaven
{
private MsDotNetHeaven()
{
//A default Constructor as private
}
public MsDotNetHeaven(String strName): this()
{
//A parameterized Constructor having one parameter
System.Console.WriteLine(“My name is : “ + strName);
}

//Class members
}


Now, you can initialize class as follow:


//Initializes the Class
MsDotNetHeaven objMsDnH = new MsDotNetHeaven(“Gaurav Arora”);


Using prefix static with Constructor

With the use of static with constructor gives a name as static constructor

For C++ developers it’s a new concept introduced in C#.

A static constructor is used to initialize any static data, or to perform a particular action that needs performed once only. It is called automatically before the first instance is created or any static members are referenced.
Consider the following:


public class MsDotNetHeaven
{
static MsDotNetHeaven()
{
//A static Constructor
// Can only access static members here.

System.Console.WriteLine("I am a static constructor.");
}

//Class members

}


Now whenever you create an instance of the class MsDotNetHeaven the line I am a static constructor get printed.

Consider following piece of code:


public class MsDotNetHeaven
{
static MsDotNetHeaven()
{
//A static Constructor
// Can only access static members here.

System.Console.WriteLine("I am a static constructor.");
}

public MsDotNetHeaven()
{
//A default Constructor
}

//Class members

}


Above code is perfectly alright and will perform same result as earlier code.

Calling Parent Class Constructors in child class during inheritance


Now, suppose a scenario when you are inheriting a class and want to use Parent class constructor then how to attain that.

Simple the same has been achieved by using base()
Consider following code-snippet


public class MsDotNetHeaven
{
public MsDotNetHeaven()
{
//A default Constructor
}

public MsDotNetHeaven(String strName)
{
//A parameterized Constructor having one parameter
}

//Class members

}

public class MsDotNetMentor : MsDotNetHeaven
{
public MsDotNetMentor ()
{
//A default Constructor
}

public MsDotNetMentor (String strName) : base(strName)
{
//A parameterized Constructor having one parameter
}

//Class members

static void Main()
{
MsDotNetMentor objMsDnM = new MsDotNetMentor(); //(A)
MsDotNetMentor objNameMsDnM = new MsDotNetMentor(“Gaurav Arora”); //(B)
}


}


(A) From above : the sequence of invoking a constructor is first public MsDotNetHeaven() and then public MsDotNetMentor()
(B) From above : the sequence of invoking a constructor is public MsDotNetHeaven(String strName)and then public MsDotNetMentor(String strName)

Note:

  1. A static constructor should not be declared with any access modifier.

  2. A static constructor does not accept parameters

  3. A static constructor is called automatically.

  4. There is no way to call a static constructor directly.

  5. Can’t stop the execution of Static constructor



Due to the scope of this article it might be possible that something I forgot please remind me if any :

Important :

  1. Constructor is nothing but a special method, which initializes the class or its task to initialize the object of it class.

  2. Its name must be same as the name of class

  3. This is a special method as constructors do not have return types, not even void

  4. Constructor cannot return any value because they didn’t have any return type.

  5. Constructor can’t be get inherited, although a derived class can class the base class constructor.

  6. A class has atleast one constructor also known as default constructor [a constructor without parameter]

  7. You have to explicitly write a default constructor while Overloading constructors.

  8. Concept declaring multiple constructors of a class with different sets of parameters known as Constructor overloading.

  9. A constructor can be called another constructor using this()

Posted by Gaurav at 2/14/2009 05:43:00 PM 0 comments
Labels: , ,

Tuesday, February 10, 2009

LINQ Querry : A Step Ahead Series

LINQ Querry : A Step Ahead Series
History:
The article is related to previous posts :

1. Anonymous Types in LINQ: A Step Ahead Series

2. How to Test Anonymous Type Equality - LINQ: A Step Ahead Series

Introduction:

LINQ - Language Integreted Query is repeadily used in these days. The presented article is elaborate the idea "How to describe a LINQ Query".

Simply, a query is an expression that retrieves data from a data source.

Scope:
The scope of the presented article is upto its title and projected scenarios.
  • Basics

  • LINQ Actions

  • Some basic example

  • Creating a LINQ project using Visual Studio



Description:

Now lets elaborate the topic in following points:

1. Operation of LINQ Query:

LINQ query consists three distinct actions as defined bellow:

(a) In this step LINQ gather the DataSource it may be any source of data.
(b) In next step have to create the Query
(c) Finally, execute the Query.

Lest, go through the following code-lines and try to understand the above operations:


class LINQQuery
{
static void Main()
{

// This is the Data source - Operation - I
int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };

// Query Creation - Operation - II
var numQuery =
from num in numbers
where (num % 2) == 0
select num;

// Query Execution - Operation - III
foreach (int num in numQuery)
{
Console.Write("{0,1} ", num);
}
}
}


Three actions of LINQ Query [adapted from MSDN - bb397906]
LINQ Query Actions

2. Skip and Take:

Skip, SkipWhile, Take, and TakeWhile are used to partition collectionsinto two parts and then return one of the parts. These partition features are only implemented as extension methods.

skip jumps to the indicated argument position in the sequence and returns everything after that.

SkipWhile accepts a predicate and instead of using a position, it skips until the predicate evaluates to false.

Take grabs all of the elements up to the specified position in the index.

TakeWhile grabs all of the items in a sequence as long as the predicate evaluates to true.

3. Create a LINQ Project:

As per MSDN :

To use LINQ to XML or LINQ to DataSet in either C# or VB.Net language, you must manually add namespaces and references as described in the following :

If you are upgrading a project that you created by using an earlier version of Visual Studio, you may have to supply these or other LINQ -related references manually and also manually set the project to target .NET Framework version 3.5.

To target the .NET Framework version 3.5


  1. In Visual Studio, open a Visual Basic or C# project that was created in Visual Studio 2005 and follow the prompts to

    convert it to a Visual Studio 2008 project.

  2. For a C# project, click the Project menu, and then click Properties.

  3. In the Application property page, select .NET Framework 3.5 in the Target Framework drop-down list.

  4. For a Visual Basic project, click the Project menu, and then click Properties.

  5. In the Compile property page, click Advanced Compile Options and then select .NET Framework 3.5 in the Target Framework

    (all configurations) drop-down list.



Important Points:

  1. LINQ queries start with the keyword from.

  2. In a LINQ query, you are always working with objects.

  3. You an apply the basic operations to LINQ Query as follow:



    • Filtering is the common operation tyhrough which you can filter the data, consider following code:


      //filter all employees on last name as 'Arora'
      var lnqueryNames = from empname in employee
      where empname.lastname == "Arora"
      select empname;



      • Ordering sets the ordering for the output, lets take a loon in the following:


      //display all Arora in ascending order with departments
      var lnqueryNames = from empname in employee
      where empname.lastname == "Arora"
      orderby empname.dept ascending
      select empname;



    • Ordering give the output in a group, consider following example:



      var lnqueryNames = from empname in employee
      group empname by empname.department;

      foreach (var empbydept in lnqueryNames)
      {
      Console.WriteLine(empbydept.Key);
      foreach (Employee emp in empbydept)
      {
      Console.WriteLine(" {0}", emp.lastName);
      }
      }

Posted by Gaurav at 2/10/2009 07:37:00 PM 0 comments
Labels: ,

Monday, February 9, 2009

How to Test Anonymous Type Equality - LINQ: A Step Ahead Series

How to Test Anonymous Type Equality - LINQ: A Step Ahead Series

First of all Anonymous Type Equality : If two or more anonymous types have same order, number and member declaratory type amd name then the same anonymous type is defined. So, its permissible to use the referencial equality operator on these types.

Now lets see the other face of the coin means of any of order, number and member declarator type and name is different then different anonymous type is defined for each. Then it throw compiler error while testing referential integrity.

Note:

  • Here you can use reflection to get the type information of anonymous types.

  • Use the Equals method (defined by all objects) to test equality of members.



Lets go through following lines :

var paternalMember = new {Father = "R k Arora", City = "Nangal Dam"};
var maternalMember = new {Mother = "Santosh Arora", City = "New Delhi"};

var fatherHome = new {Father = "R k Arora", City = "Nangal Dam"};
var motherHome = new {City = "New Delhi", Mother = "Santosh Arora"};

//Compare member equality:
paternalMember.Equals(fatherHome); //returns true
paternalMember.Equals(fatherHome); //error


If you want to know more about Anonymous Type-LINQ please refer to Anonymous Types in LINQ : A Step Ahead Series
Posted by Gaurav at 2/09/2009 05:52:00 PM 0 comments
Labels: , ,

Friday, February 6, 2009

Anonymous Types in LINQ : A Step Ahead Series

Introduction:

Programers of Visual Basic the keyword 'var' is confusing here as the type variants was used in Visual Basic.

Here, the keyword var tells to compiler emit a strong type based on t5e value of the operation on the right side.

Important:
Anonymous types can be used to initialize simple types like integers and strings.

Rules : Following are the some basic rules to use LINQ Anonymous Types.


  • Anonymous types can't be null.

  • Must always have an initial assignment.

  • Can be used with Simple or complex types, but composite anonymous types require member declaration

    example:
    var mylist = new {Topic="Anonymous-Types" [, declaratory = value, ...]}.

    in above Topic is the member declaratory.

  • Supports intelliSense.

  • Cannot be used for class field.

  • Can be used with arrays.

  • Anonymous types are all derived from the Object type.



Now, lets explore some category or types of anonymous types:

Simple Anonymous Type

With the keyword var and giving the value of the variable in the right side of the assignment operator (=), anyone can declare the Simple anonymous type.

var list = "Anonymous Types in LINQ : A Step Ahead Series";


The anonymous type is assigned to the name on the left side of the assignment operator, and the type emitted by the compiler to Microsoft Intermediate Language (MSIL) is determined by the right side of the operator.

The above line is identical in the MSIL if defined as following:

var list = "Anonymous Types in LINQ : A Step Ahead Series";


Array Initializer Syntax

Anyone can use the Anonymous Type to initialize the array too but with a rigid rule that is : new keyword must have to use.

example:

var myArrayWithAntype = new int[]{ 1, 2, 12, 53, 58, 8, 2113, 2221 };


In above the array is Anonymous as it is defined with Annonymous Type initialize rule.

Composite Anonymous Types : Lets define

Now, lets take a look how to define Composite Anonymous Type. Its called just as class without the "typed" class definition.

var fullname = new {FirstName=”Gaurav”, LastName=”Arora”};


in above 'fullname' contains both first and last name. Go through following:


//throws an error
Console.WriteLine(fullname.FirstName);

//Displays fullname
Console.WriteLine(fullname);


Note :
1. Anonymous types are immutable.
2. Within the scope of article we have supplied a little tricks, there can be generic anonymous methods, you can apply methods, can return anonymous values etc.
Posted by Gaurav at 2/06/2009 08:34:00 PM 0 comments
Labels: ,
Subscribe to: Posts (Atom)