Narsimha.Puranik

SQL SERVER – List All the Tables for All Databases Using System Tables

2012-02-13T10:08:00.000-08:00

sp_msforeachdb 'select "?" AS db, * from [?].sys.tables'

Table-Valued Parameters in Sql Server

2012-02-02T10:37:00.002-08:00

This is a new feature intorduced in Sql Server 2008. Table-Valued Parameters provides option for the Client Applications to pass multiple rows of Data to Stored Procedure.

Prior to this, if we were needed to pass multiple rows of Data from client application to Sql Server, then we use to model the input data as xml and pass it to the stored procedure and in Stored Procedure convert this xml to a table variable/temporary table.

In this article we will not only go over this Table-Valued Parameter we will also understand how to call the Stored Procedure with Table-Valued Parameter from Sql Server and C# .Net Code.

Table-Valued User Defined Data Type
First we need to Create a User Defined Table Type which can be reused in multiple stored procedures as input table parameter data type.

CREATE TYPE dbo.CustomerTableType AS TABLE
(
[CustomerID] INT,
[Name] VARCHAR(50)
)
GOStored Procedure with Table-Valued input Parameter
Now let us create a simple stored procedure which takes CustomerType User Definde Table Type which we have created previously

CREATE PROCEDURE dbo.GetCustomerDetails
(
@Customers AS dbo.CustomerTableType READONLY
)
AS
BEGIN
SET NOCOUNT ON

SELECT *
FROM @Customers
ENDUsing Stored Procedure With Table Valued Parameter in Sql Server

Declare @CustomerDetails As dbo.CustomerTableType
Insert Into @CustomerDetails Values(1,'Narsimha'),
(2,'Mithun'),
(3,'Sachin')

Exec dbo.GetCustomerDetails @CustomerDetails
GO
Result:
CustomerID Name
----------- ------------
1 Narsimha
2 Mithun
3 Sachin

Calling Stored Procedure with Table Valued Parameter from C# Code
Below is a sample C# Code example which calls the GetCustomerDetails Stored Procedure with Table-Valued Parameter which is created in the previous section.

using System;
using System.Data;
using System.Data.SqlClient;
namespace TableValuedParameter
{
class Program
{
static void Main(string[] args)
{
//Create and open a connection object
SqlConnection conn = new SqlConnection(
"ENTER A VALID CONNECTION STRING");
conn.Open();

//Create a command object specify the stored procedure
SqlCommand cmd = new SqlCommand("dbo.GetCustomerDetails", conn);
cmd.CommandType = CommandType.StoredProcedure;
//PrePare the rows of Data to be Passed to the Stored Procedure
DataTable dataTable = new DataTable("Customer");
dataTable.Columns.Add("Id", typeof(Int32));
dataTable.Columns.Add("Name", typeof(string));
dataTable.Rows.Add(1, "Narsimha");
dataTable.Rows.Add(2, "Mithun");
dataTable.Rows.Add(3, "Sachin");

//Add the Table-Valued Parameter value to the Command Object
SqlParameter param = new SqlParameter("@Customers", dataTable);
param.SqlDbType = SqlDbType.Structured;
cmd.Parameters.Add(param);
// Execute the command
SqlDataReader rdr = cmd.ExecuteReader();
// iterate through results, printing each record to the console
while (rdr.Read())
{
Console.WriteLine("Employee ID: {0} Name: {1}"
,rdr["CustomerID"],rdr["Name"]);
}
conn.Close();
rdr.Close();
Console.ReadKey();
}
}
}

Result Seen on the console:
Employee ID: 1 Name: Narsimha
Employee ID: 2 Name: Mithun
Employee ID: 3 Name: Sachin

EXECUTE Permission ON Table Type User Defined Type: Eventhough we have Execute permission on the Stored Procedure, we still need to give Execute permission on the Table Type User Defined Type. Below is the syntax for granting execute persmission on the Table Type User Defined Type

GRANT EXECUTE ON TYPE::dbo.CustomerTableType TO UserName

New Features in Sql Server 2008

2012-02-02T10:32:00.001-08:00

Following are the some of the new features of the Sql Server 2008 which are very helpful to the Sql Developers

1) Table-Valued Parameters in Sql Server: provides option for the Client Applications to pass multiple rows of Data to Sql Server.

Prior to this, if we were needed to pass multiple rows of Data from client application to Sql Server, then we use to model the input data as xml /comma separated values and pass it to the stored procedure and in Stored Procedure convert this xml/comma separated values to a table variable/temporary table.

You can find detailed information on the Table-Valued Parameters and also on calling Stored Procedure with Table-Valued Parameter from Sql Server and C# .Net Code @ http://beginsql.wordpress.com/2011/09/09/table-valued-parameters-in-sql-server/

2) Variable declaration allows initialization:

Prior to Sql Server 2008 to initialize a variable, we needed to first declare the variable and then we can initialize it by using SET/SELECT statement as shown below:

DECLARE @COUNT INT
SET @COUNT =100Now in Sql Server 2008 Variable declaration allows initialization similar to the one we do in C#. Now instead of writing two statements, we can write a single statement as below:

DECLARE @COUNT INT =1003) Insert multiple rows using single INSERT Statement

To understand this feature first create an Employee Table by using the below script:

CREATE TABLE DBO.Employee ( Id INT, Name VARCHAR(50) )Prior to Sql Server 2008, to insert multiple records we use to write statements like below:

INSERT INTO dbo.Employee VALUES(1,'Narsimha')
INSERT INTO dbo.Employee VALUES(2,'Mithun')
INSERT INTO dbo.Employee VALUES(3,'Sachin')Now in Sql Server 2008 we can accomplish the same by writing script like below:

INSERT INTO dbo.Employee VALUES(1,'Narsimha') ,(2,'Mithun') ,(3,'Sachin')

4) Arithematic Assignment Operators
Now Sql Server 2008 also supports the Arithematic Assignment Operators like the below ones:

Operator Usage Description
+= SET @x+=@y Same as: SET @x = @x + @y
-= SET @x-=@y Same as: SET @x = @x - @y
*= SET @x*=@y Same as: SET @x = @x * @y
/= SET @x/=@y Same as: SET @x = @x / @y
%= SET @x%=@y Same as: SET @x = @x % @yExample:

DEClARE @x INT =2 ,@y INT = 2
SET @x+=@y
SELECT @x as x,@y as y
Result:
x y
----------- -----------
4 25)

MERGE Statement

Merge statement is one of the interesting T-Sql enhancements of Sql Server 2008. With Merge statement we can very efficiently perform multiple DML operations like INSERT, UPDATE and DELETE on the target table data based on Source table data and the join condition specified between them.

You can find detailed information on MERGE Statement @ http://beginsql.wordpress.com/2011/09/24/merge-statemen…ql-server-2008/

6) Sparse Column

Sparse Column is one more new feature introduced in SQL SERVER 2008. Storing a null value in a sparse column doesn’t take any space, but storing a non-null value in sparse column takes 4 bytes extra space than the non-sparse columns of the same data type.

Difference between DateTime and DateTime2 DataType

2012-02-02T10:31:00.003-08:00

DateTime2 is the new Data Type introduced in Sql Server 2008 for storing Date and Time value. As per MSDN, Microsoft Suggests to use this new Data Type for new work instead of DateTime. Following table summarizes some of the major difference between this new DateTime2 and the old DateTime Data Type.

DateTime DateTime2[(n)]
Min Value 1753-01-01 00:00:00 0001-01-01 00:00:00
Max Value 9999-12-31 23:59:59.997 9999-12-31 23:59:59.9999999
Storage Size 8 Bytes 6 to 8 bytes
Note: Parameter n is optional and if it is not specified then fractional seconds precision is 7 digit and it can be from 0 to 7 digit.
For fractional seconds precision <3, takes 6 bytesFor fractional seconds precision 3 or 4 it will take 7 bytesFor fractional seconds precision >4 it will take 8 bytes
Usage Declare @now datetime Declare @now datetime2(7)
Compliance Is not an ANSI/ISO compliant Is an ANSI/ISO compliant
Current Date and Time function GetDate() – It returns DB Current Date and Time of DateTime Data Type
Example: SELECT GETDATE()
Result: 2011-09-16 13:23:18.767 SYSDATETIME()- It returns DB Current Date and Time of DateTime2 Data Type
Example: SELECT SYSDATETIME()
Result: 2011-09-16 13:23:18.7676720
+/- days WORKS
Example: DECLARE @nowDateTime DATETIME = GETDATE()
SELECT @nowDateTime + 1
Result: 2011-09-17 13:44:31.247 FAILS – Need to use only DateAdd function
Example: DECLARE @nowDateTime2 DATETIME2= SYSDATETIME()
SELECT @nowDateTime2+1
Result: Msg 206, Level 16, State 2, Line 2
Operand type clash: datetime2 is incompatible with int

DateTime2 with fractional seconds precision of 3 is same as datetime data type. And DateTime(3) uses 7 bytes of storage instead of 8 byte which old datetime datatype uses and it also provides higer date range (i.e. 0001-01-01 to 9999-12-31 ) compared to DateTime data type. Now let us see this with an example:

DECLARE @nowDateTime DATETIME = GETDATE(),
@nowDateTime2 DATETIME2(3)= SYSDATETIME()

SELECT DATALENGTH(@nowDateTime) 'DateTime Storage Size' ,
DATALENGTH(@nowDateTime2) 'DateTime2(3) Storage Size'

Result:
DateTime Storage Size DateTime2 Storage Size
--------------------- ----------------------
8 7

Merge Statement in Sql Server 2008

2012-02-02T10:31:00.001-08:00

Merge statement is one of the interesting T-Sql enhancements of Sql Server 2008. With Merge statement we can very efficiently perform multiple DML operations like INSERT, UPDATE and DELETE on the target table data based on Source table data and the join condition specified between them.

This feature is very useful in a scenario where we want to synchronize the data in the target table with source table data. In earlier versions of sql server to achieve this synchronization we would have scanned the source and target tables multiple times(i.e. ones for inserting the new records , second time for updating the matching records and third time for deleting the records in the destination table which are not present in the source table), but with Merge statement we can achieve all this with single statement and with only one time looking-up of the source and target tables.

Let us understand the Merge statement with a simple example.

First create a Source Table with Sample Data:

CREATE TABLE dbo.EmployeeSource(Id INT, Name VARCHAR(50))
GO
INSERT INTO dbo.EmployeeSource
VALUES(1,'Basavaraj Biradar') ,
(3,'Monty')
GO
SELECT * FROM dbo.EmployeeSource WITH(NOLOCK)
GO
--Source Table Data
Id Name
1 Basavaraj Biradar
3 MontyNow create a Target Table with Sample Data:

CREATE TABLE dbo.EmployeeTarget(Id INT, Name VARCHAR(50))
GO
INSERT INTO dbo.EmployeeTarget
VALUES(1,'Basavaraj') ,
(2,'Shashank')
GO
SELECT * FROM dbo.EmployeeTarget WITH(NOLOCK)
GO
--Target Table Data
Id Name
1 Basavaraj
2 ShashankNow Syncronize the target table with source table data using the below Merge statement:

MERGE dbo.EmployeeTarget AS T
USING dbo.EmployeeSource AS S
ON T.Id = S.Id
WHEN MATCHED THEN -- Matching Employee record
UPDATE SET T.NAME = S.NAME
WHEN NOT MATCHED BY TARGET THEN
-- Employee record presnet in Source but not in target
INSERT (Id, Name)
VALUES (S.Id, S.Name)
WHEN NOT MATCHED BY SOURCE THEN
-- Employee record present in destination but not in source
DELETE;Target table data after executing the above Merge statement:

SELECT * FROM dbo.EmployeeTarget WITH(NOLOCK)
GO
--Target Table Data
Id Name
1 Basavaraj Biradar
3 Monty

FileUpload Save Images in Database in ASP.NET C# VB.NET

2011-11-06T21:36:00.000-08:00

In this example i am Uploading Images using FileUpload Control and saving or storing them in SQL Server database in ASP.NET with C# and VB.NET.

Database is having a table named Images with three columns.
1. ID Numeric Primary key with Identity Increment.
2. ImageName Varchar to store Name of Image.
3. Image Image to store image in binary format.

Using C#.Net

protected void btnUpload_Click(object sender, EventArgs e)
{
string strImageName = txtName.Text.ToString();
if (FileUpload1.PostedFile != null &&
FileUpload1.PostedFile.FileName != "")
{
byte[] imageSize = new byte
[FileUpload1.PostedFile.ContentLength];
HttpPostedFile uploadedImage = FileUpload1.PostedFile;
uploadedImage.InputStream.Read
(imageSize, 0, (int)FileUpload1.PostedFile.ContentLength);

// Create SQL Connection
SqlConnection con = new SqlConnection();
con.ConnectionString = ConfigurationManager.ConnectionStrings
["ConnectionString"].ConnectionString;

// Create SQL Command

SqlCommand cmd = new SqlCommand();
cmd.CommandText = "INSERT INTO Images(ImageName,Image)" +
" VALUES (@ImageName,@Image)";
cmd.CommandType = CommandType.Text;
cmd.Connection = con;

SqlParameter ImageName = new SqlParameter
("@ImageName", SqlDbType.VarChar, 50);
ImageName.Value = strImageName.ToString();
cmd.Parameters.Add(ImageName);

SqlParameter UploadedImage = new SqlParameter
("@Image", SqlDbType.Image, imageSize.Length);
UploadedImage.Value = imageSize;
cmd.Parameters.Add(UploadedImage);
con.Open();
int result = cmd.ExecuteNonQuery();
con.Close();
if (result > 0)
lblMessage.Text = "File Uploaded";
GridView1.DataBind();
}
}

Using VB.Net

Protected Sub btnUpload_Click
(ByVal sender As Object, ByVal e As EventArgs)

Dim strImageName As String = txtName.Text.ToString()
If FileUpload1.PostedFile IsNot Nothing AndAlso
FileUpload1.PostedFile.FileName <> "" Then

Dim imageSize As Byte() = New Byte
(FileUpload1.PostedFile.ContentLength - 1) {}

Dim uploadedImage__1 As HttpPostedFile =
FileUpload1.PostedFile

uploadedImage__1.InputStream.Read(imageSize, 0,
CInt(FileUpload1.PostedFile.ContentLength))

' Create SQL Connection
Dim con As New SqlConnection()
con.ConnectionString =
ConfigurationManager.ConnectionStrings
("ConnectionString").ConnectionString

' Create SQL Command

Dim cmd As New SqlCommand()
cmd.CommandText = "INSERT INTO Images
(ImageName,Image) VALUES (@ImageName,@Image)"
cmd.CommandType = CommandType.Text
cmd.Connection = con

Dim ImageName As New SqlParameter
("@ImageName", SqlDbType.VarChar, 50)
ImageName.Value = strImageName.ToString()
cmd.Parameters.Add(ImageName)

Dim UploadedImage__2 As New SqlParameter
("@Image", SqlDbType.Image, imageSize.Length)
UploadedImage__2.Value = imageSize
cmd.Parameters.Add(UploadedImage__2)
con.Open()
Dim result As Integer = cmd.ExecuteNonQuery()
con.Close()
If result > 0 Then
lblMessage.Text = "File Uploaded"
End If
GridView1.DataBind()
End If
End Sub

Programattically render pdf from ReportViewer

2011-11-06T21:23:00.000-08:00

Dim warnings As Warning() = Nothing
Dim streamids As String() = Nothing
Dim mimeType As String = Nothing
Dim encoding As String = Nothing
Dim extension As String = Nothing
Dim bytes As Byte()

'First delete existing file
Dim filepath As String = FolderLocation & "PCSummary.PDF"
File.Delete(filepath)
'Then create new pdf file
bytes = ReportViewer1.LocalReport.Render("PDF", Nothing, mimeType, _
encoding, extension, streamids, warnings)
Dim fs As New FileStream(FolderLocation & "PCSummary.PDF", FileMode.Create)
fs.Write(bytes, 0, bytes.Length)
fs.Close()

Upload & Download Files with FTP

2011-10-27T12:38:00.000-07:00

Download Files with FTP

using System;
using System.IO;
using System.Net;
using System.Text;

namespace Examples.System.Net
{
public class WebRequestGetExample
{
public static void Main ()
{
// Get the object used to communicate with the server.
FtpWebRequest request = (FtpWebRequest)WebRequest.Create("ftp://www.contoso.com/test.htm");
request.Method = WebRequestMethods.Ftp.DownloadFile;

// This example assumes the FTP site uses anonymous logon.
request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");

FtpWebResponse response = (FtpWebResponse)request.GetResponse();

Stream responseStream = response.GetResponseStream();
StreamReader reader = new StreamReader(responseStream);
Console.WriteLine(reader.ReadToEnd());

Console.WriteLine("Download Complete, status {0}", response.StatusDescription);

reader.Close();
response.Close();
}
}
}

Upload :

namespace Examples.System.Net
{
public class WebRequestGetExample
{
public static void Main ()
{
// Get the object used to communicate with the server.
FtpWebRequest request = (FtpWebRequest)WebRequest.Create("ftp://www.contoso.com/test.htm");
request.Method = WebRequestMethods.Ftp.UploadFile;

// This example assumes the FTP site uses anonymous logon.
request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");

// Copy the contents of the file to the request stream.
StreamReader sourceStream = new StreamReader("testfile.txt");
byte [] fileContents = Encoding.UTF8.GetBytes(sourceStream.ReadToEnd());
sourceStream.Close();
request.ContentLength = fileContents.Length;

Stream requestStream = request.GetRequestStream();
requestStream.Write(fileContents, 0, fileContents.Length);
requestStream.Close();

FtpWebResponse response = (FtpWebResponse)request.GetResponse();

Console.WriteLine("Upload File Complete, status {0}", response.StatusDescription);

response.Close();
}
}
}
}

List Directory Contents with FTP

namespace Examples.System.Net
{
public class WebRequestGetExample
{
public static void Main ()
{
// Get the object used to communicate with the server.
FtpWebRequest request = (FtpWebRequest)WebRequest.Create("ftp://www.contoso.com/");
request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;

// This example assumes the FTP site uses anonymous logon.
request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");

FtpWebResponse response = (FtpWebResponse)request.GetResponse();

Stream responseStream = response.GetResponseStream();
StreamReader reader = new StreamReader(responseStream);
Console.WriteLine(reader.ReadToEnd());

Console.WriteLine("Directory List Complete, status {0}", response.StatusDescription);

reader.Close();
response.Close();
}
}
}

Dynamically Add checkBox to GridView

2011-10-21T12:50:00.000-07:00

'Code to Create checkbox dynamically...
Private Sub ADDCheckBox_Column(ByVal gridName As DataGridView)
Dim AddColumn As New DataGridViewCheckBoxColumn
With AddColumn
' .HeaderText = "CheckAll"
.Name = "Check"
.Width = 10
End With
gridName.Columns.Insert(0, AddColumn)
End Sub

'Code for checkAll event...
Private Sub chkCheckAll_CheckedChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles chkCheckAll.CheckedChanged

If chkCheckAll.Checked = True Then
For i As Integer = 0 To dgvFacility.Rows.Count - 1
dgvFacility(0, i).Value = True
Next
Else
For i As Integer = 0 To dgvFacility.Rows.Count - 1
dgvFacility(0, i).Value = False
Next
End If
End Sub

'Code to get ids when user select checkBox from gridview
For i As Integer = 0 To dgManagement.Rows.Count - 1
If TypeOf Me.dgManagement.Rows(i).Cells(0) Is DataGridViewCheckBoxCell Then
row = dgManagement.Rows(i)
If CBool((row.Cells(0)).FormattedValue) = True Then
lst.Add(dgManagement.Rows(i).Cells(1).Value)
lstrptName.Add(dgManagement.Rows(i).Cells(2).Value)
End If
End If
Next

How To Create an ASP.NET HTTP Handler by Using Visual C# .NET

2011-08-01T06:43:00.001-07:00

Implement the Handler
1. Open Microsoft Visual Studio .NET. In Visual C# .NET, create a new Class Library project named MyHandler.
2. Set a reference to the System.Web.dll assembly.
3. Add the following directive to the class:
4. using System.Web;

5. Rename the class SyncHandler.cs, and then change the class definition to reflect this.
6. Implement the IHttpHandler interface. Your class definition should appear as follows:
7. public class SyncHandler : IHttpHandler

8. Implement the IsReusable property and the ProcessRequest method of the IHttpHandler interface. Because this is a synchronous handler, return False for the IsReusable property so that the handler is not pooled.
9. public bool IsReusable
10. {
11. get {return false;}
12. }
13.
14. public void ProcessRequest(HttpContext context)
15. {
16. context.Response.Write("Hello from custom handler.");
17. }

18. Compile the project.
Deploy the Handler
1. Create a new directory named Handler under the C:\Inetpub\Wwwroot directory.
2. Create a subdirectory named Bin in the newly created Handler directory. The resultant path is C:\Inetpub\Wwwroot\Handler\Bin.
3. Copy MyHandler.dll from your project's Bin\Debug directory to the C:\Inetpub\Wwwroot\Handler\Bin directory.
4. Follow these steps to mark the new Handler directory as a Web application:
a. Open Internet Services Manager.
b. Right-click the Handler directory and then click Properties.
c. On the Directory tab, click Create.
5. Follow these steps to create an application mapping for the handler. For this handler, create a mapping to the Aspnet_isapi.dll file for the *.sync extension. Whenever a .sync file is requested, the request is routed to ASP.NET, and ASP.NET executes the code in the handler.
. Right-click on the Handler Web application, and then click Properties.
a. On the Directory tab, click Configuration.
b. Click Add to add a new mapping.
c. In the Executable text box, type the following path: Microsoft Windows 2000:
C:\WINNT\Microsoft.NET\Framework\\Aspnet_isapi.dll
Microsoft Windows XP:
C:\WINDOWS\Microsoft.NET\Framework\\Aspnet_isapi.dll
d. In the Extension text box, type .sync.
e. Make sure that the Check that file exists check box is cleared, and then click OK to close the Add/Edit Application Extension Mapping dialog box.
f. Click OK to close the Application Configuration and the Handler Properties dialog boxes.
6. Close Internet Services Manager.
Configure the System
1. In the C:\Inetpub\Wwwroot\Handler directory, create a new file named Web.config.
2. Add the following code to Web.config:
3. <configuration>
4. <system.web>
5. <httphandlers>
6. <add verb="*" path="*.sync" type="MyHandler.SyncHandler, MyHandler" />
7. </httpHandlers>
8. </system.web>
9. </configuration>

In the verb="*" attribute, we instruct the handler to process a request that uses any verb (for
example, POST, HEAD, GET, and so on). If you want this handler to process only the POST request, change this to verb="POST".

In the path="*.sync" attribute, we instruct the handler to process any incoming requests for files with the .sync extension.

In the type="MyHandler.SyncHandler, MyHandler" attribute, we instruct the handler that processes the request to implement in the MyHandler.SyncHandler namespace, and this class resides in the MyHandler assembly.

Test the Module
To test a handler, a page does not need to exist in the file system. For example, request the Default.sync file in the Handler Web application (http:///Handler/Default.sync). You should receive the following results:
Hello from custom handler.

Public Key Encryption (RSA Method) for Encryption and Decryption...

2011-07-26T01:33:00.000-07:00

The RSA Public Key Encryption is useful method for Encryption and Decryption .

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.IO;

public class Tester
{
public static void Main()
{
RSACryptoServiceProvider myRSAProvide = new RSACryptoServiceProvider();
string strCrypt = null;
byte[] bteCrypt = null;
byte[] bteResult = null;
try
{
strCrypt = "12345678";
bteCrypt = Encoding.ASCII.GetBytes(strCrypt);
bteResult = myRSAProvide.Encrypt(bteCrypt, false);
Console.WriteLine(Encoding.ASCII.GetString(bteResult));
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
string strResault = null;
byte[] bteDecrypt = null;
try
{
bteDecrypt = myRSAProvide.Decrypt(bteResult, false);
strResault = Encoding.ASCII.GetString(bteDecrypt);
Console.WriteLine(strResault);
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadLine();
}
}

How to implement impersonation in an ASP.NET application

2011-07-19T05:06:00.000-07:00

Impersonate the IIS Authenticated Account or User:

To impersonate the Microsoft Internet Information Services (IIS) authenticating user on every request for every page in an ASP.NET application, you must include an tag in the Web.config file of this application and set the impersonate attribute to true. For example:

< identity impersonate="true" / >

Impersonate a Specific User for All the Requests of an ASP.NET Application:

To impersonate a specific user for all the requests on all pages of an ASP.NET application, you can specify the userName and password attributes in the tag of the Web.config file for that application. For example:

< identity impersonate="true" userName="accountname" password="password" / >

Use the 'Globalization' section in web.config

2011-07-19T04:54:00.001-07:00

If you're from Denmark (like me!) chances are you would like all dates, numbers etc. formatted "the danish way" on your website. Instead of writing custom code on every page, you should instead tell ASP.NET which CultureInfo, Encoding etc. to use.

< configuration >
< system.web >
< globalization
fileEncoding="utf-8"
requestEncoding="utf-8"
responseEncoding="utf-8"
culture="da-DK"
uiCulture="da-DK" / >
< /system.web >
< /configuration >

Values are valid if they are accepted by the related classes Encoding and CultureInfo. You can find more information about the Encoding and CultureInfo classes in the .NET Framework SDK.

A call to the method "ToShortDateString()" on a DateTime instance will now result in dd-mm-yyyy or e.g. 26-11-2006, which is nice.

Introducing Linq

2011-07-04T21:17:00.000-07:00

Linq is short for Language Integrated Query.

Imagine we have a list of orders. For this example, we will imagine they are stored in memory, but they could be in a file on disk too. We want to get a list of the costs of all orders that were placed by the customer identified by the number 84. If we set about implementing this in C# before version 3 and a range of other popular languages, we would probably write something like (assuming C# syntax for familiarity):
List Found = new List();
foreach (Order o in Orders)
if (o.CustomerID == 84)
Found.Add(o.Cost);Here we are describing how to achieve the result we want by breaking the task into a series of instructions. This approach, which is very familiar to us, is called imperative programming. It relies on us to pick a good algorithm and not make any mistakes in the implementation of it; for more complex tasks, the algorithm is more complex and our chances of implementing it correctly decrease.

If we had the orders stored in a table in a database and we used SQL to query it, we would write something like:
SELECT Cost FROM Orders WHERE CustomerID = 84Here we have not specified an algorithm, or how to get the data. We have just declared what we want and left the computer to work out how to do it. This is known as declarative or logic programming.

Linq brings declarative programming features into imperative languages. It is not language specific, and has been implemented in the Orcas version of VB.Net amongst other languages. In this series we are focusing on C# 3.0, but the principles will carry over to other languages.

Understanding A Simple Linq Query
Let's jump straight into a code example. First, we'll create an Order class, then make a few instances of it in a List as our test data. With that done, we'll use Linq to get the costs of all orders for customer 84.
class Order
{
private int _OrderID;
private int _CustomerID;
private double _Cost;
public int OrderID
{
get { return _OrderID; }
set { _OrderID = value; }
}
public int CustomerID
{
get { return _CustomerID; }
set { _CustomerID = value; }
}
public double Cost
{
get { return _Cost; }
set { _Cost = value; }
}
}
class Program
{
static void Main(string[] args)
{
// Set up some test orders.
var Orders = new List {
new Order {
OrderID = 1,
CustomerID = 84,
Cost = 159.12
},
new Order {
OrderID = 2,
CustomerID = 7,
Cost = 18.50
},
new Order {
OrderID = 3,
CustomerID = 84,
Cost = 2.89
}
};
// Linq query.
var Found = from o in Orders
where o.CustomerID == 84
select o.Cost;

// Display results.
foreach (var Result in Found)
Console.WriteLine("Cost: " + Result.ToString());
}
}The output of running this program is:
Cost: 159.12
Cost: 2.89Let's walk through the Main method. First, we use collection and object initializers to create a list of Order objects that we can run our query over. Next comes the query - the new bit. We declare the variable Found and request that its type be inferred for us by using the "var" keyword.

We then run across a new C# 3.0 keyword: "from".
from o in OrdersThis is the keyword that always starts a query. You can read it a little bit like a "foreach": it takes a collection of some kind after the "in" keyword and makes what is to the left of the "in" keyword refer to a single element of the collection. Unlike "foreach", we do not have to write a type.

Following this is another new keyword: "where".
where o.CustomerID == 84This introduces a filter, allowing us to pick only some of the objects from the Orders collection. The "from" made the identifier "o" refer to a single item from the collection, and we write the condition in terms of this. If you type this query into the IDE yourself, you will notice that it has worked out that "o" is an Order and intellisense works as expected.

The final new keyword is "select".
select o.CostThis comes at the end of the query and is a little like a "return" statement: it states what we want to appear in the collection holding the results of the query. As well as primitive types (such as int), you can instantiate any object you like here. In this case, we will end up with Found being a List, though.

You may be thinking at this point, "hey, this looks like SQL but kind of backwards and twisted about a bit". That is a pretty good summary. I suspect many who have written a lot of SQL will find the "select comes last" a little grating at first; the other important thing to remember is that all of the conditions are to be expressed in C# syntax, not SQL syntax. That means "==" for equality testing, rather than "=" in SQL. Thankfully, in most cases that mistake will lead to a compile time error anyway.

A Few More Simple Queries
We may wish our query to return not only the Cost, but also the OrderID for each result that it finds. To do this we take advantage of anonymous types.
var Found = from o in Orders
where o.CustomerID == 84
select new { OrderID = o.OrderID, Cost = o.Cost };Here we have defined an anonymous type that holds an OrderID and a Cost. This is where we start to see the power and flexibility that they offer; without them we would need to write custom classes for every possible set of results we wanted. Remembering the projection syntax, we can shorten this to:
var Found = from o in Orders
where o.CustomerID == 84
select new { o.OrderID, o.Cost };And obtain the same result. Note that you can perform whatever computation you wish inside the anonymous type initializer. For example, we may wish to return the Cost of the order with an additional sales tax of 10% added on to it.
var Found = from o in Orders
where o.CustomerID == 84
select new {
o.OrderID,
o.Cost,
CostWithTax = o.Cost * 1.1
};Conditions can be more complex too, and are built up in the usual C# way, just as you would do in an "if" statement. Here we apply an extra condition that we only want to see orders valued over a hundred pounds.
var Found = from o in Orders
where o.CustomerID == 84 && o.Cost > 100
select new {
o.OrderID,
o.Cost,
CostWithTax = o.Cost * 1.1
};

Ordering
It is possible to sort the results based upon a field or the result of a computation involving one or more fields. This is achieved by using the new "orderby" keyword.
var Found = from o in Orders
where o.CustomerID == 84
orderby o.Cost ascending
select new { o.OrderID, o.Cost };After the "orderby" keyword, we write the expression that the objects will be sorted on. In this case, it is a single field. Notice this is different from SQL, where there are two words: "ORDER BY". I have added the keyword "ascending" at the end, though this is actually the default. The result is that we now get the orders in order of increasing cost, cheapest to most expensive. To get most expensive first, we would have used the "descending" keyword.

While I said earlier that the ordering condition is based on fields in the objects involved in the query, it actually doesn't have to be. Here's a way to get the results in a random order.
Random R = new Random();
var Found = from o in Orders
where o.CustomerID == 84
orderby R.Next()
select new { OrderID = o.OrderID, Cost = o.Cost };

Joins
So far we have just had one type of objects to run our query over. However, real life is usually more complex than this. For this example, let's introduce another class named Customer.
class Customer
{
private int _CustomerID;
private string _Name;
private string _Email;
public int CustomerID
{
get { return _CustomerID; }
set { _CustomerID = value; }
}
public string Name
{
get { return _Name; }
set { _Name = value; }
}
public string Email
{
get { return _Email; }
set { _Email = value; }
}
}In the Main method, we will also instantiate a handful of Customer objects and place them in a list.
var Customers = new List {
new Customer {
CustomerID = 7,
Name = "Emma",
Email = "emz0r@worreva.com"
},
new Customer {
CustomerID = 84,
Name = "Pedro",
Email = "pedro@cerveza.es"
},
new Customer {
CustomerID = 102,
Name = "Vladimir",
Email = "vladimir@pivo.ru"
}
};We would like to produce a list featuring all orders, stating the ID and cost of the order along with the name of the customer. To do this we need to involve both the List of orders and the List of customers in our query. This is achieved using the "join" keyword. Let's replace our query and output code with the following.
// Query.
var Found = from o in Orders
join c in Customers on o.CustomerID equals c.CustomerID
select new { c.Name, o.OrderID, o.Cost };
// Display results.
foreach (var Result in Found)
Console.WriteLine(Result.Name + " spent " +
Result.Cost.ToString() + " in order " +
Result.OrderID.ToString());The output of running this program is:
Pedro spent 159.12 in order 1
Emma spent 18.5 in order 2
Pedro spent 2.89 in order 3We use the "join" keyword to indicate that we want to refer to another collection in our query. We then once again use the "in" keyword to declare an identifier that will refer to a single item in the collection; in this case it has been named "c". Finally, we need to specify how the two collections are related. This is achieved using the "on ... equals ..." syntax, where we name a field from each of the collections. In this case, we have stated that the CustomerID of an Order maps to the CustomerID of a Customer.

When the query is evaluated, an object in the Customers collection is located to match each object in the Orders collection. Note that if there were many customers with the same ID, there may be more than one matching Customer object per Order object. In this case, we get extra results. For example, change Vladimir to also have an OrderID of 84. The output of the program would then be:
Pedro spent 159.12 in order 1
Vladimir spent 159.12 in order 1
Emma spent 18.5 in order 2
Pedro spent 2.89 in order 3
Vladimir spent 2.89 in order 3Notice that Vladimir never featured in the results before, since he had not ordered anything.

Getting All Permutations With Multiple "from"s
It is possible to write a query that gets every combination of the objects from two collections. This is achieved by using the "from" keyword multiple times.
var Found = from o in Orders
from c in Customers
select new { c.Name, o.OrderID, o.Cost };Earlier I suggested that you could think of "from" as being a little bit like a "foreach". You can also think of multiple uses of "from" a bit like nested "foreach" loops; we are going to get every possible combination of the objects from the two collections. Therefore, the output will be:
Emma spent 159.12 in order 1
Pedro spent 159.12 in order 1
Vladimir spent 159.12 in order 1
Emma spent 18.5 in order 2
Pedro spent 18.5 in order 2
Vladimir spent 18.5 in order 2
Emma spent 2.89 in order 3
Pedro spent 2.89 in order 3
Vladimir spent 2.89 in order 3Which is not especially useful. You may have spotted that you could have used "where" in conjunction with the two "from"s to get the same result as the join:
var Found = from o in Orders
from c in Customers
where o.CustomerID == c.CustomerID
select new { c.Name, o.OrderID, o.Cost };However, don't do this, since it computes all of the possible combinations before the "where" clause, which goes on to throw most of them away. This is a waste of memory and computation. A join, on the other hand, never produces them in the first place.

Grouping
Another operations that you may wish to perform is categorizing objects that have the same value in a given field. For example, we might want to categorize orders by CustomerID. The result we expect back is a list of groups, where each group has a key (in this case, the CustomerID) and a list of matching objects. Here's the code to do the query and output the results.
// Group orders by customer.
var OrdersByCustomer = from o in Orders
group o by o.CustomerID;
// Iterate over the groups.
foreach (var Cust in OrdersByCustomer)
{
// About the customer...
Console.WriteLine("Customer with ID " + Cust.Key.ToString() +
" ordered " + Cust.Count().ToString() + " items.");
// And what they ordered.
foreach (var Item in Cust)
Console.WriteLine(" ID: " + Item.OrderID.ToString() +
" Cost: " + Item.Cost.ToString());
}The output that it produces is as follows:
Customer with ID 84 ordered 2 items.
ID: 1 Cost: 159.12
ID: 3 Cost: 2.89
Customer with ID 7 ordered 1 items.
ID: 2 Cost: 18.5This query looks somewhat different to the others that we have seen so far in that it does not end with a "select". The first line is the same as we're used to. The second introduces the new "group" and "by" keywords. After the "by" we name the field that we are going to group the objects by. Before the "by" we put what we would like to see in the resulting per-group collections. In this case, we write "o" so as to get the entire object. If we had only been interested in the Cost field, however, we could have written:
// Group orders by customer.
var OrdersByCustomer = from o in Orders
group o.Cost by o.CustomerID;
// Iterate over the groups.
foreach (var Cust in OrdersByCustomer)
{
// About the customer...
Console.WriteLine("Customer with ID " + Cust.Key.ToString() +
" ordered " + Cust.Count().ToString() + " items.");
// And the costs of what they ordered.
foreach (var Cost in Cust)
Console.WriteLine(" Cost: " + Cost.ToString());
}Which produces the output:
Customer with ID 84 ordered 2 items.
Cost: 159.12
Cost: 2.89
Customer with ID 7 ordered 1 items.
Cost: 18.5You are not restricted to just a single field or the object itself; you could, for example, instantiate an anonymous type there instead.

Query Continuations
At this point you might be wondering if you can follow a "group ... by ..." with a "select". The answer is yes, but not directly. Both "group ... by ..." and "select" are special in so far as they produce a result. You must terminate a Linq query with one or the other. If you try to do something like:
var CheapOrders = from o in Orders
where o.Cost < 10;Then it will lead to a compilation error. Since both "select" and "group ... by ..." terminate a query, you need a way of taking the results and using them as the input to another query. This is called a query continuation, and the keyword for this is "into".

In the following example we take the result of grouping orders by customer and then use a select to return an anonymous type containing the CustomerID and the number of orders that the customer has placed.
var OrderCounts = from o in Orders
group o by o.CustomerID into g
select new {
CustomerID = g.Key,
TotalOrders = g.Count()
};Notice the identifier "g", which we introduce after the keyword "into". This identifier represents an item in the collection containing the results of the previous query. We use in the select statement. Remember that each element of the collection we are querying in this second query is actually a collection itself, since this is what "group ... by ..." produces. Therefore, we can call Count() on it to get the number of elements, which is the number of orders per customer. We grouped by the CustomerID field, so that is our Key.

Query continuations can be used to chain together as many selection and grouping queries as you need in whatever order you need.

SQL Server Performance Check List

2011-07-04T21:12:00.001-07:00

SQl Server Performance :

CheckList:

1. Schema

Define all primary keys and foreign key relationships.
Define all unique constraints and check constraints.
Choose the most appropriate data type.
Partition tables vertically and horizontally.

2. Queries:

Write correctly formed queries.
Return only the rows and columns needed.
Avoid expensive operators such as NOT LIKE.
Avoid explicit or implicit functions in WHERE clauses.
Use stored procedures or parameterized queries.
Minimize cursor use.
Limit query and index hint use

3. Indexes:

Create indexes based on use.
Keep clustered index keys as small as possible.
Create an index on all foreign keys.

4. Stored Procedures

Use Set NOCOUNT ON in stored procedures.
Do not use the sp_prefix for custom stored procedures.

Zoom Images Using JavaScript

2011-07-03T08:46:00.000-07:00

Here on MouseOver it will increases the Height & Width for the image, ViceVersa for ImageDecreasing.

--
< script language='javascript' ;>

function zoomIncrease()
{
document.getElementById('i1').style.height=300;
document.getElementById('i1').style.width=550;
}

function zoomDecrease()
{
document.getElementById('i1').style.height=100;
document.getElementById('i1').style.width=150;
}

< /script ;>

--Body

< img src="D:\Sample.jpg" name="i1" height="100" width="150" onmouseout='zoomDecrease()' onmouseover='zoomIncrease();' ;> </img ;>

Hash Algorithm Example

2011-06-25T05:06:00.000-07:00

This topics just describes how to convert the data in into Hash Format & How we can compare two Hash Values together,

In the following exaple i have taken two TextBoxes & Two button
From First TextBox i will accept the value to be hashed & then i will it to hash format and finally display into second text field.

Declaring Variables:

string txt;
byte [] hashValue;
byte [] messageKey;
UnicodeEncoding uniCode;

Code for ComputeHash Button:

txt = textBox1.Text;
uniCode = new UnicodeEncoding();
messageKey = uniCode.GetBytes(txt);
SHA1Managed sha1 = new SHA1Managed();
hashValue = sha1.ComputeHash(messageKey);

foreach (byte b in hashValue)
{
textBox2.Text=textBox2.Text + string.Format("{0:X2}",b);
}

Code for Comparing Two Hash Value

string f, f1;
f = txtf.Text;
f1 = txts.Text;

if (string.Equals(f, f1))
{
MessageBox.Show("both are equal");
}
else
{
MessageBox.Show("both are Unequal");
}

String Format for Int [C#]

2011-06-25T04:54:00.000-07:00

Integer numbers can be formatted in .NET in many ways. You can use static method String.Format or instance method int.ToString. Following examples shows how to align numbers (with spaces or zeroes), how to format negative numbers or how to do custom formatting like phone numbers.

Add zeroes before number

To add zeroes before a number, use colon separator „:“ and write as many zeroes as you want.

String.Format("{0:00000}", 15); // "00015"
String.Format("{0:00000}", -15); // "-00015"

Align number to the right or left

To align number to the right, use comma „,“ followed by a number of characters. This alignment option must be before the colon separator.

String.Format("{0,5}", 15); // " 15"
String.Format("{0,-5}", 15); // "15 "
String.Format("{0,5:000}", 15); // " 015"
String.Format("{0,-5:000}", 15); // "015 "

Different formatting for negative numbers and zero

You can have special format for negative numbers and zero. Use semicolon separator „;“ to separate formatting to two or three sections. The second section is format for negative numbers, the third section is for zero.

String.Format("{0:#;minus #}", 15); // "15"
String.Format("{0:#;minus #}", -15); // "minus 15"
String.Format("{0:#;minus #;zero}", 0); // "zero"

Custom number formatting (e.g. phone number)

Numbers can be formatted also to any custom format, e.g. like phone numbers or serial numbers.

String.Format("{0:+### ### ### ###}", 447900123456); // "+447 900 123 456"
String.Format("{0:##-####-####}", 8958712551); // "89-5871-2551"

Dropdown list bind with database inside gridview

2011-06-20T10:51:00.000-07:00

protected void grid_RowCreated(object sender, GridViewRowEventArgs e)
{
DropDownList drdList;
drdList = (DropDownList)e.Row.FindControl("drp");
if (drdList != null)
{
drdList.DataSource = ds.Tables[0];
drdList.DataMember = "ename";
drdList.DataValueField = "ename";
//drdList.DataTextField = "ename";
drdList.DataBind();

}
}

Differences between varchar and nvarchar in SQL Server

2011-06-19T07:54:00.000-07:00

VARCHAR is an abbreviation for variable-length character string. It's a string of text characters that can be as large as the page size for the database table holding the column in question. The size for a table page is 8,196 bytes, and no one row in a table can be more than 8,060 characters. This in turn limits the maximum size of a VARCHAR to 8,000 bytes.

The "N" in NVARCHAR means uNicode. Essentially, NVARCHAR is nothing more than a VARCHAR that supports two-byte characters. The most common use for this sort of thing is to store character data that is a mixture of English and non-English symbols.

String Format for DateTime [C#]

2010-10-31T23:33:00.000-07:00

This example shows how to format DateTime using String.Format method. All formatting can be done also using DateTime.ToString method.

Custom DateTime Formatting
There are following custom format specifiers y (year), M (month), d (day), h (hour 12), H (hour 24), m (minute), s (second), f (second fraction), F (second fraction, trailing zeroes are trimmed), t (P.M or A.M) and z (time zone).

Following examples demonstrate how are the format specifiers rewritten to the output.

[C#]
// create date time 2008-03-09 16:05:07.123
DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);

String.Format("{0:y yy yyy yyyy}", dt); // "8 08 008 2008" year
String.Format("{0:M MM MMM MMMM}", dt); // "3 03 Mar March" month
String.Format("{0:d dd ddd dddd}", dt); // "9 09 Sun Sunday" day
String.Format("{0:h hh H HH}", dt); // "4 04 16 16" hour 12/24
String.Format("{0:m mm}", dt); // "5 05" minute
String.Format("{0:s ss}", dt); // "7 07" second
String.Format("{0:f ff fff ffff}", dt); // "1 12 123 1230" sec.fraction
String.Format("{0:F FF FFF FFFF}", dt); // "1 12 123 123" without zeroes
String.Format("{0:t tt}", dt); // "P PM" A.M. or P.M.
String.Format("{0:z zz zzz}", dt); // "-6 -06 -06:00" time zone

You can use also date separator / (slash) and time sepatator : (colon). These characters will be rewritten to characters defined in the current DateTimeForma tInfo.DateSepa rator and DateTimeForma tInfo.TimeSepa rator.

[C#]
// date separator in german culture is "." (so "/" changes to ".")
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9/3/2008 16:05:07" - english (en-US)
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9.3.2008 16:05:07" - german (de-DE)

Here are some examples of custom date and time formatting:

[C#]
// month/day numbers without/with leading zeroes
String.Format("{0:M/d/yyyy}", dt); // "3/9/2008"
String.Format("{0:MM/dd/yyyy}", dt); // "03/09/2008"

// day/month names
String.Format("{0:ddd, MMM d, yyyy}", dt); // "Sun, Mar 9, 2008"
String.Format("{0:dddd, MMMM d, yyyy}", dt); // "Sunday, March 9, 2008"

// two/four digit year
String.Format("{0:MM/dd/yy}", dt); // "03/09/08"
String.Format("{0:MM/dd/yyyy}", dt); // "03/09/2008"

Standard DateTime Formatting
In DateTimeForma tInfo there are defined standard patterns for the current culture. For example property ShortTimePattern is string that contains value h:mm tt for en-US culture and value HH:mm for de-DE culture.

Following table shows patterns defined in DateTimeForma tInfo and their values for en-US culture. First column contains format specifiers for the String.Format method.

Specifier DateTimeFormatInfo property Pattern value (for en-US culture)
t ShortTimePattern h:mm tt
d ShortDatePattern M/d/yyyy
T LongTimePattern h:mm:ss tt
D LongDatePattern dddd, MMMM dd, yyyy
f (combination of D and t) dddd, MMMM dd, yyyy h:mm tt
F FullDateTimePattern dddd, MMMM dd, yyyy h:mm:ss tt
g (combination of d and t) M/d/yyyy h:mm tt
G (combination of d and T) M/d/yyyy h:mm:ss tt
m, M MonthDayPattern MMMM dd
y, Y YearMonthPattern MMMM, yyyy
r, R RFC1123Pattern ddd, dd MMM yyyy HH':'mm':'ss 'GMT' (*)
s SortableDateTi mePattern yyyy'-'MM'-'dd'T'HH':'mm':'ss (*)
u UniversalSorta bleDateTimePat tern yyyy'-'MM'-'dd HH':'mm':'ss'Z' (*)
(*) = culture independent
Following examples show usage of standard format specifiers in String.Format method and the resulting output.

[C#]
String.Format("{0:t}", dt); // "4:05 PM" ShortTime
String.Format("{0:d}", dt); // "3/9/2008" ShortDate
String.Format("{0:T}", dt); // "4:05:07 PM" LongTime
String.Format("{0:D}", dt); // "Sunday, March 09, 2008" LongDate
String.Format("{0:f}", dt); // "Sunday, March 09, 2008 4:05 PM" LongDate+ShortTime
String.Format("{0:F}", dt); // "Sunday, March 09, 2008 4:05:07 PM" FullDateTime
String.Format("{0:g}", dt); // "3/9/2008 4:05 PM" ShortDate+ShortTime
String.Format("{0:G}", dt); // "3/9/2008 4:05:07 PM" ShortDate+LongTime
String.Format("{0:m}", dt); // "March 09" MonthDay
String.Format("{0:y}", dt); // "March, 2008" YearMonth
String.Format("{0:r}", dt); // "Sun, 09 Mar 2008 16:05:07 GMT" RFC1123
String.Format("{0:s}", dt); // "2008-03-09T16:05:07" SortableDateTime
String.Format("{0:u}", dt); // "2008-03-09 16:05:07Z" UniversalSortableDateTime

Gateway Provider Implementations

2010-10-16T00:10:00.000-07:00

Authorize.NET:

Authorize.NET has become the most popular Gateway provider and having written implementation code for various gateways I can see why. Authorize.NET is easy to work with and doesn't require any external configuration. Even if you were to start from scratch building an interface you could probably do it in very short order. Authorize.NET uses plain HTTP POST operations against its gateway server.

The ccAuthorizeNet class provides Credit Card processing against the Authorize.Net Gateway. It uses plain POST operations against the Web Server so other than providing URL and login information there are no further setup requirements.

What you need:

Authorize.NET Gateway URL
Authorize.NET Merchant Login ID and Password
Referring URL
No further installation required - uses plain POST interface to server gateway
Here is the ccAuthorizeNet implementation:

///

/// This class provides Credit Card processing against
/// the Authorize.Net Gateway.
///

public class ccAuthorizeNet : ccProcessing
{

public ccAuthorizeNet()
{
this.HttpLink = "https://secure.authorize.net/gateway/transact.dll";
}

///

/// Validates the actual card against Authorize.Net Gateway using the HTTP
/// interface.
/// Class ccAuthorizeNet
///

/// /// Boolean
public override bool ValidateCard()
{
if (!base.ValidateCard() )
return false;

if (this.Http == null)
{
this.Http = new wwHttp();
this.Http.Timeout = this.Timeout;
}

string CardNo = Regex.Replace(this.CreditCardNumber,@"[ -/._#]","");

this.Http.AddPostKey("x_version","3.1");
this.Http.AddPostKey("x_method","CC");
this.Http.AddPostKey("x_delim_data","True");
this.Http.AddPostKey("x_password",this.MerchantPassword);
this.Http.AddPostKey("x_login",this.MerchantId);

if (this.UseTestTransaction)
this.Http.AddPostKey("x_test_request","True");

if (this.OrderAmount >= 0)
{
if (this.ProcessType == ccProcessTypes.Sale)
this.Http.AddPostKey("x_type","AUTH_CAPTURE");
else if (this.ProcessType == ccProcessTypes.PreAuth)
this.Http.AddPostKey("x_type","AUTH_ONLY");
else if (this.ProcessType == ccProcessTypes.Credit )
this.Http.AddPostKey("x_type","CREDIT");

this.Http.AddPostKey("x_amount",this.OrderAmount.ToString(
CultureInfo.InvariantCulture.NumberFormat));
}
else
{
this.Http.AddPostKey("x_type","CREDIT");
this.Http.AddPostKey("x_amount",((int) (-1 * this.OrderAmount)).ToString(CultureInfo.InvariantCulture.NumberFormat));
}

if (this.TaxAmount > 0.00M)
this.Http.AddPostKey("x_tax",
this.TaxAmount.ToString(CultureInfo.InvariantCulture.NumberFormat));

this.Http.AddPostKey("x_card_num",CardNo);
this.Http.AddPostKey("x_exp_date",this.CreditCardExpirationMonth.ToString() + "-" +
this.CreditCardExpirationYear.ToString() );

if (this.SecurityCode.Trim() != "")
this.Http.AddPostKey("x_card_code",this.SecurityCode.Trim());

this.Http.AddPostKey("x_first_name",this.Firstname);
this.Http.AddPostKey("x_last_name",this.Lastname);
this.Http.AddPostKey("x_company",this.Company);
this.Http.AddPostKey("x_address",this.Address);
this.Http.AddPostKey("x_city",this.City);
this.Http.AddPostKey("x_state",this.State);
this.Http.AddPostKey("x_zip",this.Zip);
this.Http.AddPostKey("x_country",this.Country);

if (this.Phone.Trim() != "")
this.Http.AddPostKey("x_phone",this.Phone);

this.Http.AddPostKey("x_email",this.Email);

this.Http.AddPostKey("x_invoice_num",this.OrderId);
this.Http.AddPostKey("x_description",this.Comment);

this.Http.CreateWebRequestObject(this.HttpLink);
this.Http.WebRequest.Referer=this.ReferringUrl;

this.RawProcessorResult = this.Http.GetUrl(this.HttpLink);

if (this.Http.Error)
{
this.ValidatedResult = "FAILED";
this.ValidatedMessage = this.Http.ErrorMessage;
this.SetError(this.Http.ErrorMessage);
this.LogTransaction();
return false;
}

string[] Result = this.RawProcessorResult.Split(new char[1] {','} );
if (Result == null)
{
this.ValidatedResult = "FAILED";
this.ValidatedMessage = "Invalid response received from Merchant Server";
this.SetError(this.ValidatedMessage);
this.LogTransaction();
return false;
}

// *** REMEMBER: Result Codes are in 0 based array!
this.TransactionId = Result[6];
this.AvsResultCode = Result[5];

if (Result[0] == "3" ) // Error - Processor communications usually
{
// *** Consider an invalid Card a DECLINE
// *** so we can send back to the customer for display
if (Result[3].IndexOf("credit card number is invalid") > -1)
this.ValidatedResult = "DECLINED";
else
this.ValidatedResult = "FAILED";

this.ValidatedMessage = Result[3];
this.SetError(this.ValidatedMessage);
}
if (Result[0] == "2" || Result[0] == "4") // Declined
{
this.ValidatedResult = "DECLINED";
this.ValidatedMessage = Result[3];
if (this.ValidatedMessage == "")
this.ValidatedMessage = this.RawProcessorResult;
this.SetError(this.ValidatedMessage);
}
else
{
this.ValidatedResult = "APPROVED";

// *** Make the RawProcessorResult more readable for client application
this.ValidatedMessage = Result[3];
this.AuthorizationCode = Result[4];
this.SetError(null);
}

this.LogTransaction();

return !this.Error;
}

}

Note, Authorize.NET's gateway API has become so popular that various smaller providers now offer Authorize.NET compatible gateways. For example, MerchantPlus offers its NaviGate gateway that uses the same Authorize.NET POST interface. Other smaller gateway providers are starting to do the same.

The class above uses a custom wwHTTP class that's a thin wrapper around the .NET WebRequest class. It's provided as part of the sample downloads for this article.
Verisign PayFlow Pro
Verisign uses a custom API that is based that is available in COM and .NET versions. The .NET version is merely a COM interop wrapper around the COM API, so it's a bit bulky to install as you have to register both the COM object and the interop assembly. In fact I found it easier to bypass the .NET API altogether and directly call the COM API to avoid the Interop assembly which really didn't provide any special features.

The ccPayFlow class processes credit cards against Verisign PayFlowPro gateway service. This service is set up to work with the PayFlow Pro COM object which must be installed and configured properly on the machine to process credit cards. To avoid use of the Interop assembly, the class uses Late Binding with Reflection to invoke the COM API which is merely a single method call.

To configure PayFlow Pro follow these steps: Download the PayFlow Pro SDK Version 3.0 from the Verisign Web Site. You can download a free trial from here:

http://www.verisign.com/products/payflow/trial.html

To install the SDK unzip the file into a directory. The following instructions are basic instructions for installing the PayFlow SDK itself - if you run into problems with this please check the SDK documentation.
The implementation used with the Web Store uses the COM implementation of PayFlow so you will need to register the COM component. To do so:
Find the Win32\Libs directory in the SDK
Copy the pfPro.dll file into the Windows\System32 directory
Find the Win32\COM in the SDK
Run PFProCOMSetup.exe in the COM\ dir to install and register the Payflow Pro COM client
Find and make a note of the Win32\Certs directory
Create an Environment Variable called PFPRO_CERT_PATH and point it at this path
To do this open Control Panel | System
Go to the Advanced Tab
Click on Environment Variables
Select System Variables
Create a new variable PFPRO_CERT_PATH
Set the value to the path of the Cert directory

For ASP.Net operation the PFPRO_CERT_PATH environment variable is not available to the NETWORK SERVICE/ASPNET account by default and you have to manually copy the CERTS directory into the operating directory of the Web Server (or rather the IIS worker process). This directory is typically:
/System32/inetsrv

Copy the SDK's entire Cert directory into this path so you have:

/System32/inetsrv/cert/

with the content of the certificate file.

If you've performed all these steps the PayFlow SDK should be up and running.

In addition to the steps above you'll also need PayFlow UserId and Password which should be assigned to MerchantId and MerchantPassword respectively.

Here's the implementation of the PayFlowPro class:

public class ccPayFlowPro : ccProcessing
{
public int HostPort
{
get { return _HostPort; }
set { _HostPort = value; }
}
private int _HostPort = 443;

public string ProxyAddress
{
get { return _ProxyAddress; }
set { _ProxyAddress = value; }
}
private string _ProxyAddress = "";

public int ProxyPort
{
get { return _ProxyPort; }
set { _ProxyPort = value; }
}
private int _ProxyPort = 0;

public string ProxyUsername
{
get { return _ProxyUsername; }
set { _ProxyUsername = value; }
}
private string _ProxyUsername = "";

public string ProxyPassword
{
get { return _ProxyPassword; }
set { _ProxyPassword = value; }
}
private string _ProxyPassword = "";

///

/// Sign up partner ID. Required only if you signed up through
/// a third party.
///

public string SignupPartner
{
get { return _SignupPartner; }
set { _SignupPartner = value; }
}
private string _SignupPartner = "Verisign";

///

/// Overridden consistency with API names.
/// maps to MerchantId
///

public string UserId
{
get { return _UserId; }
set { _UserId = value; }
}
private string _UserId = "";

///

/// Internal string value used to hold the values sent to the server
///

string Parameters = "";

///

/// Validates the credit card. Supported transactions include only Sale or Credit.
/// Credits should have a negative sales amount.
///

///
public override bool ValidateCard()
{
if (!base.ValidateCard())
return false;

this.Error = false;
this.ErrorMessage = "";

// *** Counter that holds our parameter string to send
this.Parameters = "";

// *** Sale and Credit Supported
decimal TOrderAmount = this.OrderAmount;
if (this.OrderAmount < 0.00M) { this.Parameters = "TRXTYPE=C"; TOrderAmount = this.OrderAmount * -1.0M; } else this.Parameters = "TRXTYPE=S"; string CardNo = Regex.Replace(this.CreditCardNumber,@"[ -/._#]",""); string TUserId = this.UserId; if (TUserId == "") TUserId = this.MerchantId; string ExpDate = string.Format("{0:##}",this.CreditCardExpirationMonth) ; ExpDate += this.CreditCardExpirationYear; this.Parameters += "&TENDER=C" + "&ACCT=" + CardNo + "&VENDOR=" + this.MerchantId + "&USER=" + TUserId + "&PWD=" + this.MerchantPassword + "&PARTNER=" + this.SignupPartner + "&AMT=" + TOrderAmount.ToString(CultureInfo.InvariantCulture.NumberFormat) + "&EXPDATE=" + ExpDate + "&STREET=" + this.Address + "&CITY=" + this.City + "&STATE=" + this.State + "&ZIP=" + this.Zip + "&EMAIL=" + this.Email + "&COMMENT1=" + this.Comment; if (this.TaxAmount > 0.00M)
this.Parameters += "&TAXAMT=" + this.TaxAmount.ToString(CultureInfo.InvariantCulture.NumberFormat);

if (this.SecurityCode != "")
this.Parameters += "&CVV2=" + this.SecurityCode;

// *** Save our raw input string for debugging
this.RawProcessorRequest = this.Parameters;

// *** connects to Verisign COM object to handle transaction
System.Type typPayFlow = System.Type.GetTypeFromProgID( "PFProCOMControl.PFProCOMControl.1" );
object PayFlow = Activator.CreateInstance( typPayFlow );

this.RawProcessorResult = "";

try
{
// *** Use Reflection and Late binding to call COM object
// *** to avoid creating Interop assembly
int context = (int) wwUtils.CallMethod(PayFlow,"CreateContext",this.HttpLink,this.HostPort,this.Timeout,
this.ProxyAddress,this.ProxyPort,this.ProxyUsername, this.ProxyPassword);

this.RawProcessorResult = (string) wwUtils.CallMethod(PayFlow,"SubmitTransaction",context,Parameters,Parameters.Length);

wwUtils.CallMethod(PayFlow, "DestroyContext",context);
}
catch(Exception ex)
{
this.ValidatedResult = "FAILED";
this.ValidatedMessage = ex.Message;
this.LogTransaction();
return false;
}

string ResultValue = wwHttpUtils.GetUrlEncodedKey(this.RawProcessorResult,"RESULT");

this.TransactionId = wwHttpUtils.GetUrlEncodedKey(this.RawProcessorResult, "PNREF");

// *** 0 means success
if (ResultValue == "0")
{
this.ValidatedResult = "APPROVED";
this.AuthorizationCode = wwHttpUtils.GetUrlEncodedKey(this.RawProcessorResult, "AUTHCODE");
this.LogTransaction();
return true;
}
// *** Empty response means we have an unknown failure
else if (ResultValue == "")
{
this.ValidatedMessage = "Unknown Error";
this.ValidatedResult = "FAILED";
}
// *** Negative number means communication failure
else if (ResultValue.StartsWith("-") )
{
this.ValidatedResult = "FAILED";
this.ValidatedMessage = wwHttpUtils.GetUrlEncodedKey(this.RawProcessorResult,"RESPMSG");

}
// *** POSITIVE number means we have a DECLINE
else
{
this.ValidatedResult = "DECLINED";
this.ValidatedMessage = wwHttpUtils.GetUrlEncodedKey(this.RawProcessorResult,"RESPMSG");
}

this.Error = true;
this.LogTransaction();
return false;
}

}
Note that this class implements a few additional provider specific properties such as the proxy settings and VerisignPartner.

It's kind of ironic that this API uses COM to call out to the Verisign servers, but it requires a UrlEncoded input and output mechanism to get the actual result values.

Create and Read Excel file from C#.Net

2010-10-13T12:00:00.000-07:00

using Excel = Microsoft.Office.Interop.Excel;

private void releaseObject(object obj)
{
try
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(obj);
obj = null;
}
catch (Exception ex)
{
obj = null;
MessageBox.Show("Exception Occured while releasing object " + ex.ToString());
}
finally
{
GC.Collect();
}
}

Button Click Event:

Excel.Application xlApp;
Excel.Workbook xlWorkBook;
Excel.Worksheet xlWorkSheet;
object misValue = System.Reflection.Missing.Value;

xlApp = new Excel.ApplicationClass();
xlWorkBook = xlApp.Workbooks.Add(misValue);

xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);
//xlWorkSheet.Cells[1, 1] = "http://csharp.net-informations.com";
xlWorkSheet.Cells[1, 1] = "Employee ID";
xlWorkSheet.Cells[1, 2] = "Employee Name";
xlWorkSheet.Cells[1, 3] = " Email";
xlWorkSheet.Cells[2, 1] = "100";
xlWorkSheet.Cells[2, 2] = "Vikas";
xlWorkSheet.Cells[2, 3] = "vikas@gmail.com";

xlWorkBook.SaveAs("csharp-Excel.xls", Excel.XlFileFormat.xlWorkbookNormal, misValue, misValue, misValue, misValue, Excel.XlSaveAsAccessMode.xlExclusive, misValue, misValue, misValue, misValue, misValue);
xlWorkBook.Close(true, misValue, misValue);
xlApp.Quit();

releaseObject(xlWorkSheet);
releaseObject(xlWorkBook);
releaseObject(xlApp);

MessageBox.Show("Excel file created , you can find the file c:\\csharp-Excel.xls");

//Read Excell File

private void ReadExcell()
{
Excel.Application xlApp;
Excel.Workbook xlWorkBook;
Excel.Worksheet xlWorkSheet;
Excel.Range range;

string str;
int rCnt = 0;
int cCnt = 0;

xlApp = new Excel.ApplicationClass();
xlWorkBook = xlApp.Workbooks.Open("csharp-Excel.xls", 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);

range = xlWorkSheet.UsedRange;
ArrayList lst = new ArrayList();

for (rCnt = 1; rCnt <= range.Rows.Count; rCnt++)
{
for (cCnt = 1; cCnt <= range.Columns.Count; cCnt++)
{
str = Convert.ToString((range.Cells[rCnt, cCnt] as Excel.Range).Value2);
lst.Add(str);
}
}

textBox1.Text = lst[0].ToString();
textBox2.Text = lst[1].ToString();
textBox3.Text = lst[2].ToString();

xlWorkBook.Close(true, null, null);
xlApp.Quit();

releaseObject(xlWorkSheet);
releaseObject(xlWorkBook);
releaseObject(xlApp);

}

Transfer data from One Form to another Form in C#.Net

2010-10-06T10:09:00.000-07:00

The Constructor Approach

This could be the easiest method of all. A method is invoked whenever you instantiate an object. This method is called a constructor. Code a constructor for form2 class with one string parameter. In the constructor assign the text to the label's text property. Instantiate form2 class in form1's button click event handler using the constructor with one string parameter and pass the textbox's text to the constructor.

Follow the below steps.

Step 1: Code a constructor for form2 class as below

public Form2(string strTextBox)
{

InitializeComponent();

label1.Text=strTextBox;

}

Step 2: Instantiate form2 class in form1's button click event handler as below

private void button1_Click(object sender, System.EventArgs e)

{

Form2 frm=new Form2(textBox1.Text);

frm.Show();

}

Agile Software Development

2010-10-01T12:43:00.000-07:00

What is Agile Software Development?

In the late 1990’s several methodologies began to get increasing public attention. Each had a different combination of old ideas, new ideas, and transmuted old ideas. But they all emphasized close collaboration between the programmer team and business experts; face-to-face communication (as more efficient than written documentation); frequent delivery of new deployable business value; tight, self-organizing teams; and ways to craft the code and the team such that the inevitable requirements churn was not a crisis

The Agile Manifesto

The Agile Manifesto was written in February of 2001, at a summit of seventeen independent-minded practitioners of several programming methodologies. The participants didn't agree about much, but they found consensus around four main values.

The Manifesto for Agile Software Development
We are uncovering better ways of developing software by doing it and helping others do it.
Through this work we have come to value:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

The Twelve Principles of Agile Software

We follow these principles:

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.

Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.

Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.

Business people and developers must work together daily throughout the project.
Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.

The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.

Working software is the primary measure of progress.

Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.

Continuous attention to technical excellence and good design enhances agility.

Simplicity--the art of maximizing the amount of work not done--is essential.

The best architectures, requirements, and designs emerge from self-organizing teams.

At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

Waterfall Model

2010-10-01T12:36:00.000-07:00

There are various software development approaches defined and designed which are used/employed during development process of software, these approaches are also referred as "Software Development Process Models". Each process model follows a particular life cycle in order to ensure success in process of software development.

One such approach/process used in Software Development is "The Waterfall Model". Waterfall approach was first Process Model to be introduced and followed widely in Software Engineering to ensure success of the project. In "The Waterfall" approach, the whole process of software development is divided into separate process phases. The phases in Waterfall model are: Requirement Specifications phase, Software Design, Implementation and Testing & Maintenance. All these phases are cascaded to each other so that second phase is started as and when defined set of goals are achieved for first phase and it is signed off, so the name "Waterfall Model". All the methods and processes undertaken in Waterfall Model are more visible.

The stages of "The Waterfall Model" are:

Requirement Analysis & Definition:

All possible requirements of the system to be developed are captured in this phase. Requirements are set of functionalities and constraints that the end-user (who will be using the system) expects from the system. The requirements are gathered from the end-user by consultation, these requirements are analyzed for their validity and the possibility of incorporating the requirements in the system to be development is also studied. Finally, a Requirement Specification document is created which serves the purpose of guideline for the next phase of the model.

System & Software Design:

Before a starting for actual coding, it is highly important to understand what we are going to create and what it should look like? The requirement specifications from first phase are studied in this phase and system design is prepared. System Design helps in specifying hardware and system requirements and also helps in defining overall system architecture. The system design specifications serve as input for the next phase of the model.

Implementation & Unit Testing:

On receiving system design documents, the work is divided in modules/units and actual coding is started. The system is first developed in small programs called units, which are integrated in the next phase. Each unit is developed and tested for its functionality; this is referred to as Unit Testing. Unit testing mainly verifies if the modules/units meet their specifications.

Integration & System Testing: As specified above, the system is first divided in units which are developed and tested for their functionalities. These units are integrated into a complete system during Integration phase and tested to check if all modules/units coordinate between each other and the system as a whole behaves as per the specifications. After successfully testing the software, it is delivered to the customer.

Operations & Maintenance:

This phase of "The Waterfall Model" is virtually never ending phase (Very long). Generally, problems with the system developed (which are not found during the development life cycle) come up after its practical use starts, so the issues related to the system are solved after deployment of the system. Not all the problems come in picture directly but they arise time to time and needs to be solved; hence this process is referred as Maintenance.

There are some disadvantages of the Waterfall Model.

1) As it is very important to gather all possible requirements during the Requirement Gathering and Analysis phase in order to properly design the system, not all requirements are received at once, the requirements from customer goes on getting added to the list even after the end of "Requirement Gathering and Analysis" phase, this affects the system development process and its success in negative aspects.

2) The problems with one phase are never solved completely during that phase and in fact many problems regarding a particular phase arise after the phase is signed off, this results in badly structured system as not all the problems (related to a phase) are solved during the same phase.

3) The project is not partitioned in phases in flexible way.

4) As the requirements of the customer goes on getting added to the list, not all the requirements are fulfilled, this results in development of almost unusable system. These requirements are then met in newer version of the system; this increases the cost of system development.

Sending Email in .Net2.0

2010-10-01T12:26:00.000-07:00

MailMessage msg = new MailMessage();

msg.To.Add(textBox1.Text);

msg.From = new MailAddress(textBox2.Text);

msg.CC.Add(textBox3.Text);

msg.Bcc.Add(textBox4.Text);

msg.Subject = textBox5.Text;

msg.Body = textBox6.Text;

msg.Attachments.Add(new Attachment(textBox7.Text));

SmtpClient smtp = new SmtpClient();

smtp.Credentials = new System.Net.NetworkCredential(textBox2.Text, "Password");

smtp.Host = "smtp.gmail.com";

smtp.EnableSsl = true;

smtp.Port = 587;

//smtp.UseDefaultCredentials=true;

smtp.Send(msg);

Working with FileInfo and DirectoryInfo classes

2010-09-07T11:51:00.000-07:00

This article will explain about the Files and directory information and its operations. I have attached the sample web applications for FileInfo and DirectoryInfo classes. Let us see about these two classes.

Basics

The System.IO is one of the significant names which are used to work with the files in .Net framework. The FileInfo class which gives all the information about a file and DirectoryInfo class which gives all the information about a directory.

FileInfo class will be used to get the information about a file path, extension, create time, last access time, last write time and length,etc..,It has few methods like delete and exists.

FileInfo

The FileInfo class resides in the System.IO namespace. This is used to get the information about a file stored on the server.

The properties of the FileInfo class which inherits from the FileSystemInfo class.

S.No Property Description
1 CreationTime This property returns the creation of the file date and time.
2 CreationTimeUtc It returns the creation of the file in Universal time
3 Directory It returns the parent directory name
4 DirectoryInfo It returns the full directory path
5 Exists It returns whether the file exists or not as Boolean result.
6 Extension It returns the type of the file in the extension name
7 FullName It returns the full name of the file from the root directory.
8 IsReadOnly It returns the file is read only or not in the Boolean result.
9 Name It returns the name of the file
10 LastAccessTime It returns the date and time of the last access time
11 LastAccessTimeUtc It returns the last accessing date and time in universal format.
12 LastWriteTime It returns the last file saving date and time
13 LastWriteTimeUtc It returns the last write in the universal format
14 Length It returns the size of the file content in the bytes format.

The methods of the FileInfo class.

The FileInfo class helps to work with the files like reading the existing file content, creating a new file which as specified in the FileInfo path, add the content to the existing file, copy the file into another new file, delete the exiting created file, move the file one place into another place.

CreateText:

This method is used to create a new file. The content can be written into the newly created file.

FileInfo oFileInfo = new FileInfo(@"e:\SampleFile.txt");
StreamWriter oStreamWriter = oFileInfo.CreateText();
oStreamWriter.WriteLine("-----------------------------------");
oStreamWriter.WriteLine("Sample file creation");
oStreamWriter.WriteLine("Senthilkumar");
oStreamWriter.WriteLine("-----------------------------------");
oStreamWriter.Close();

In the above code example, I have created a new file and added some content to that file.

OpenText:

The OpenText method is used to read the content from the existing file.

FileInfo oFileInfo = new FileInfo(@"e:\SampleFile.txt");
StreamReader oStreamReader = oFileInfo.OpenText();
Console.WriteLine(oStreamReader.ReadToEnd());
oStreamReader.Close();

In the above example, whatever the content available in the SampleFile.txt will be printed.

Create:

This method is used to create the new file.

FileInfo oFileInfo = new FileInfo(@"c:\NewFile.dat");
FileStream oFileStream = oFileInfo.Create();
oFileStream.Close();

The above sample code will be created a new file name called NewFile in the c root directory.

Delete:

This method is used to delete the existing file.

FileInfo oFileInfo = new FileInfo(@"c:\NewFile.dat");
If (oFileInfo.Exists)
{
oFileInfo.Delete ();
}

CopyTo and MoveTo

The CopyTo method is used to copy the existing file into new file.

The MoveTo method is used to move the file one place to another valid location.

DirectoryInfo

The DirectoryInfo class is used to get the information about a directory and some operations like delete, create new directory and sub directories.

There are methods to get the available files and directories.

Let us see the properties of the DirectoryInfo class

S.No Property Description
1 CreationTime This property returns the creation of the directory date and time.
2 CreationTimeUtc It returns the creation of the file in Universal time
3 Exists It returns whether the directory exists or not as Boolean result.
4 Extension It returns the type of the file in the extension name
5 FullName It returns the full name of the file from the root directory.
6 Name It returns the name of the directory
7 LastAccessTime It returns the date and time of the last access time
8 LastAccessTimeUtc It returns the last accessing date and time in universal format.
9 LastWriteTime It returns the last file saving date and time
10 LastWriteTimeUtc It returns the last write in the universal format
11 Root It returns the Root directory.
12 Parent It returns the Parent directory of the current directory
13 LastWriteTimeUtc It returns the last write in the universal format
14 Length It returns the size of the file content in the bytes format.

Let us see the some of the methods in the DirectoryInfo class.

Create:

This method is used to create a new directory.

DirectoryInfo oDirInfo = new DirectoryInfo (@"c:\SampleDir");
If(oDirInfo.Exists)
{
Console.WriteLine("Directory already exists!");
Return;
}
oDirInfo.Create();
Console.WriteLine("Directory created!!");

The above code will create the new directory.

Delete:

The Delete method is used to delete the directory.

DirectoryInfo oDirInfo = new DirectoryInfo (@"c:\SampleDir");
if (oDirInfo.Exists)
{
oDirInfo.Delete();
Console.WriteLine("Directory Deleted!");
}
Else
{
Console.WriteLine("Directory doesnot exists!");
}

GetFiles:

The GetFiles method is used to get the files in the specified folder.

DirectoryInfo oDirInfo = new DirectoryInfo(@"c:\Windows");
if (oDirInfo.Exists)
{
FileInfo[] Files = oDirInfo.GetFiles();
foreach (object FileName in Files)
{
Console.WriteLine(FileName.ToString());
}
}

GetDirectories:

This method is used to get the sub directories in the given directory path.

DirectoryInfo oDirInfo = new DirectoryInfo(@"c:\windows");
if (oDirInfo.Exists)
{
DirectoryInfo[] Dirs = oDirInfo.GetDirectories();
foreach (object DirNames in Dirs)
{
Console.WriteLine(DirNames.ToString());
}
}
Else
{
Console.WriteLine("The given directory doesnot exists");
}

Example of DataGrid in ASP.NET

2010-09-07T11:44:00.000-07:00

From Here we can design our web form. We use a DataGrid on webForm. Here we set all the property as we have to perform the operation with in DataGrid.

This is .cs code in DataGrid:

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;
using System.Data.SqlClient;

public partial class sapnamalik_DataGrid : System.Web.UI.Page
{
SqlDataAdapter da;
DataSet ds = new DataSet();
SqlCommand cmd = new SqlCommand();
SqlConnection con;
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
BindData();
}
}
public void BindData()
{
con = new SqlConnection(ConfigurationManager.AppSettings["connect"]);
cmd.CommandText = "Select * from Employee";
cmd.Connection = con;
da = new SqlDataAdapter(cmd);
da.Fill(ds);
con.Open();
cmd.ExecuteNonQuery();
Grid.DataSource = ds;
Grid.DataBind();
con.Close();
}
protected void Grid_PageIndexChanged(object source, DataGridPageChangedEventArgs e)
{
Grid.CurrentPageIndex = e.NewPageIndex;
BindData();
}
protected void Grid_EditCommand(object source, DataGridCommandEventArgs e)
{
Grid.EditItemIndex = e.Item.ItemIndex;
BindData();
}
protected void Grid_CancelCommand(object source, DataGridCommandEventArgs e)
{
Grid.EditItemIndex = -1;
BindData();
}
protected void Grid_DeleteCommand(object source, DataGridCommandEventArgs e)
{
con = new SqlConnection(ConfigurationManager.AppSettings["connect"]);
cmd.Connection = con;
int EmpId = (int)Grid.DataKeys[(int)e.Item.ItemIndex];
cmd.CommandText = "Delete from Employee where EmpId=" + EmpId;
cmd.Connection.Open();
cmd.ExecuteNonQuery();
cmd.Connection.Close();
Grid.EditItemIndex = -1;
BindData();
}
protected void Grid_UpdateCommand(object source, DataGridCommandEventArgs e)
{
con = new SqlConnection(ConfigurationManager.AppSettings["connect"]);
cmd.Parameters.Add("@EmpId", SqlDbType.Int).Value = ((TextBox)e.Item.Cells[0].Controls[0]).Text;
cmd.Parameters.Add("@F_Name", SqlDbType.Char).Value = ((TextBox)e.Item.Cells[1].Controls[0]).Text;
cmd.Parameters.Add("@L_Name", SqlDbType.Char).Value = ((TextBox)e.Item.Cells[2].Controls[0]).Text;
cmd.Parameters.Add("@City", SqlDbType.Char).Value = ((TextBox)e.Item.Cells[3].Controls[0]).Text;
cmd.Parameters.Add("@EmailId", SqlDbType.Char).Value = ((TextBox)e.Item.Cells[4].Controls[0]).Text;
cmd.Parameters.Add("@EmpJoining", SqlDbType.DateTime).Value = DateTime.Now.ToString();
cmd.CommandText = "Update Employee set F_Name=@F_Name,L_Name=@L_Name,City=@City,EmailId=@EmailId,EmpJoining=@EmpJoining where EmpId=@EmpId";
cmd.Connection = con;
cmd.Connection.Open();
cmd.ExecuteNonQuery();
cmd.Connection.Close();
Grid.EditItemIndex = -1;
BindData();
}
protected void btnsubmit_Click(object sender, EventArgs e)
{
SqlConnection con;
con = new SqlConnection(ConfigurationManager.AppSettings["connect"]);
con.Open();
SqlCommand cmd;
cmd = new SqlCommand("Insert into Employee (EmpId,F_Name,L_Name,City,EmailId,EmpJoining) values('" + TextBox1.Text + "','" + TextBox2.Text + "','" + TextBox3.Text + "','" + TextBox4.Text + "','" + TextBox5.Text + "','" + TextBox6.Text + "')", con);
cmd.ExecuteNonQuery();
con.Close();
}
protected void btnReset_Click(object sender, EventArgs e)
{
TextBox1.Text = "";
TextBox2.Text = "";
TextBox3.Text = "";
TextBox4.Text = "";
TextBox5.Text = "";
TextBox6.Text = "";
}
protected void btnOk_Click(object sender, EventArgs e)
{
BindData1();
}
public void BindData1()
{
con = new SqlConnection(ConfigurationManager.AppSettings["connect"]);
cmd.CommandText = "Select * from Employee";
cmd.Connection = con;
da = new SqlDataAdapter(cmd);
da.Fill(ds);
con.Open();
cmd.ExecuteNonQuery();
Grid1.DataSource = ds;
Grid1.DataBind();
con.Close();
}
}

How to prevent multiple instances of child form in MDI windows form application in .NET

2010-09-07T11:31:00.000-07:00

For preventing multiple instances of child form we can use ShowDialog() method. But it will be problematic to user because if user wants to work with many windows at a time he can not because he need to close opened window if he opened it with ShowDialog() method.

So lets implement some code that will open new window, if there is no child window opened before. And if its opened previously then application will just focus that window and will not create any new child windows.

private void button1_Click(object sender, EventArgs e)
{
bool IsOpen = false;
foreach (Form f in Application.OpenForms)
{
if (f.Text == "Form2")
{
IsOpen = true;
f.Focus();
break;
}
}
if (IsOpen == false)
{
Form2 f2 = new Form2();
f2.MdiParent = this;
f2.Show();
}
}
Understanding the code

Here we have declared one variable that is used as flag for the child window is already opened or not? This flag will store the status of child form :)

Now we iterate through each opened form in our application and check if any form with Form2 is already opened or not. If it is found, then we set flag to true and focus() that already opened form and break the loop.

Now we are checking status of flag. If application sees that flag is still false after iterating then it will create a new instance of that child window :)

That's it you are done !

TRY...CATCH in SQL Server 2005

2010-06-14T23:57:00.000-07:00

SQL Server 2005 offers a number of new features over its predecessor, including many features aimed at making working with databases more like writing .NET application code. For example, in SQL Server 2005, stored procedures, triggers, UDFs, and so on can be written using any .NET Framework programming language (such as Visual Basic or C#). Another feature, and the focus of this article, is SQL Server 2005's support for TRY...CATCH blocks. TRY...CATCH blocks are the standard approach to exception handling in modern programming languages, and involve:

A TRY Block - the TRY block contains the instructions that might cause an exception
A CATCH Block - if an exception occurs from one of the statements in the TRY block, control is branched to the CATCH block, where the exception can be handled, logged, and so on.

Checking @@ERROR - the Old Way of Handling Errors in T-SQL
SQL Server provides an @@ERROR variable that indicates the status of the last completed SQL statement in a given batch. If a SQL statement is completed successfully, @@ERROR is assigned 0. If, however, an error occurs, @@ERROR is set to the number of the error message.

To see how the @@ERROR variable can be used, imagine that we have a data-driven web application that maintains employee information. Let's assume that our database has Employees and EmployeePhoneNumbers tables, among others. These two tables share a one-to-many relationship; that is, each Employees record can have an arbitrary number of related records in the EmployeePhoneNumbers table. There might be one for their office phone, one for their pager, one for their cell phone, and so on. Imagine that our database includes a stored procedure, DeleteEmployee, which is comprised of two DELETE statements - one to delete the employee's related phone numbers from the system and one to delete the actual employee record:

CREATE PROCEDURE DeleteEmployee ( @EmployeeID int )
AS

-- Delete the Employee's phone numbers
DELETE FROM EmployeePhoneNumbers
WHERE EmployeeID = @EmployeeID

-- Delete the Employee record
DELETE FROM Employees
WHERE EmployeeID = @EmployeeID

Since we want these two delete statements to be atomic and either both fail or both succeed, we need to wrap up these two statements into a transaction. By using a transaction, we can rollback the transaction in the face of an error and undo any changes made since the start of the exception. To accomplish this we might initially try to use the following syntax:

CREATE PROCEDURE DeleteEmployee ( @EmployeeID int )
AS

BEGIN TRANSACTION -- Start the transaction

-- Delete the Employee's phone numbers
DELETE FROM EmployeePhoneNumbers
WHERE EmployeeID = @EmployeeID

-- Delete the Employee record
DELETE FROM Employees
WHERE EmployeeID = @EmployeeID

-- See if there is an error
IF @@ERROR <> 0
-- There's an error b/c @ERROR is not 0, rollback
ROLLBACK
ELSE
COMMIT -- Success! Commit the transaction

This stored procedure (it appears) starts a transaction, runs the two DELETE statements, and then checks to see if there was an error. If there was one, it rolls the transaction back, else it commits the transaction. I say "it appears" because this syntax, while legal, is semantically incorrect because the @@ERROR variable is set after every SQL statement. Therefore, if the first DELETE statement has an error the @@ERROR variable will be set to its error number. Then, the second DELETE will execute. If this second DELETE succeeds, @@ERROR will be set back to 0, in which case the transaction will be committed even though there was a problem with the first statement! Whoops!

Instead, a check must be made after every SQL statement to see if there has been an error. If so, the transaction must be rolled back and the stored procedure exited. This can lead to bulky scripts as a stored procedure with, say, five statements will have five checks against the @@ERROR variable. And if you forget to cut and paste a check in for a particular statement you're opening yourself up to a potential problem.

For more information on transactions and the @@ERROR syntax used for checking for errors and rolling back as needed, see Managing Transactions in SQL Server Stored Procedures.

Handling Errors With SQL Server 2005's TRY...CATCH Blocks
While SQL Server 2005 still supports the @@ERROR approach, a better alternative exists with its new TRY...CATCH blocks. As with programming languages like Visual Basic, C#, and Java, the SQL Server 2005 TRY...CATCH block executes a number of statements in the TRY block. If there are no errors in any of the statements, control proceeds to after the CATCH block. If, however, one of the statements causes an error, control branches immediately to the start of the CATCH block. Furthermore, like programming languages, nested TRY...CATCH blocks are allowed, meaning that you can have an entire TRY...CATCH block in the TRY or CATCH portions of an "outter" TRY...CATCH block.

BEGIN TRY
Try Statement 1
Try Statement 2
...
Try Statement M
END TRY
BEGIN CATCH
Catch Statement 1
Catch Statement 2
...
Catch Statement N
END CATCH

BEGIN TRY
-- This will generate an error, as ProductID is an IDENTITY column
-- Ergo, we can't specify a value for this column...
INSERT INTO Products(ProductID, ProductName)
VALUES(1, 'Test')
END TRY
BEGIN CATCH
SELECT 'There was an error! ' + ERROR_MESSAGE()
END CATCH

Integrating Electronic Payment Processing into ASP.NET Web Applications

2010-05-26T01:43:00.000-07:00

http://www.west-wind.com/presentations/aspnetecommerce/aspnetecommerce.asp

Storing User Profiles

2010-05-26T00:47:00.000-07:00

User Profiles - The profile feature in ASP.NET 2.0 allows you to define and store per-user settings to be used throughout your application. Settings can also be stored in an anonymous profile while users are not logged in, and then migrated to a logged-in user profile at a later time.

Web sites frequently need a convenient method to store user-specific data that is applicable site-wide. The Profile feature delivers an easy-to-use approach for defining user-specific data as well storing and retrieving this user data.

A user's profile is a collection of properties that define information you want to store for your web site's users. The user's profile is defined using a simple XML syntax in a configuration file (machine.config and/or web.config). Within your page, you reference a user's profile information with the Profile property. ASP.NET reads the schema defined in configuration, and automatically generates a class that is accessible from the Profile property on a page. You access properties on the Profile just as you would access properties on any other class.

Although the most common use of the Profile feature is storing data for authenticated users, the Profile feature also supports storing information for anonymous users. Storing profile information for anonymous users depends on the Anonymous Identification feature. The Profile and Anonymous Identification features work together to enable the use of the Profile property for anonymous users. The samples included in the QuickStart demonstrate using the Profile feature with both authenticated and unauthenticated users.

Prior to the start of the page lifecycle, ASP.NET ensures that the Profile is available for use by the page. Similarly, at the end of the ASP.NET page lifecycle, ASP.NET automatically saves the Profile to the underlying data store(s). As with other features such as Membership and Role Manager, the Profile feature has been designed with a provider-based model. Providers abstract the physical data storage for a feature from the classes and business logic exposed by a feature. The Profile feature ships with a provider for Microsoft™ SQL Server. You can create your own custom providers and configure them to work either the Profile feature. Pages that use the Profile feature will continue to work unchanged with your custom providers.
In addition to the Profile property, the Profile feature provides support for administration of profiles (both for authenticated users and anonymous users) with the ProfileManager. Common tasks that you perform with the ProfileManager include:

Searching for statistical information about all profiles, profiles for authenticated users, and profiles for anonymous users
Determine the number of profiles that have not been modified in a given period of time
Deleting individual profiles as well as deleting multiple profiles based on a profile's last modification date
Defining the Profile Schema

The configuration file in the following sample defines a Profile using properties, as well as a property group. Properties are defined using elements within a element. A property group is a convenient way of logically grouping multiple properties. You define a property group with a element. In the sample schema, a property group called "AutomobilePreferences" groups together two additional properties. Note that elements cannot be nested (that is: there is only one level of group nesting supported beneath the element).

The sample schema demonstrates the flexibility you have in terms of defining data types for your profile properties. By default, properties are assumed to be of type System.String. However, you can define a profile property using any type that is resolvable by the ASP.NET application at runtime. The sample schema includes definitions for System.Collections.ArrayList as well as System.Drawing.Color.

Note that the element supports a variety of optional attributes beyond those shown in this sample. Normally, the Profile feature serializes properties using either type conversion to a string, or Xml serialization. However, not all types are serializable as strings or as Xml fragments. This is why the "PreferredBackgroundColor" property has a serializeAs attribute that explicitly indicates binary serialization. The "PricePoint" property has a defaultValue attribute that defines the default value for this property if one has not already been set.

The "PreferredBackgroundColor" property also has an allowAnonymous attribute that is set to true. By default, profile properties are restricted to authenticated users. When the allowAnonymous attribute is set to true this indicates that the property can also be used to load and store information for anonymous users.

Anonymous Profiles

The profile schema shown in the last sample allows both authenticated and anonymous users to store their preferred background color. On the sample page an anonymous user can choose from a selection of colors. When the page refreshes it will render using the selected color. Notice that if you shut down the browser, and then re-run the sample, the color selection is remembered. The reason for this is that the Anonymous Identification feature is enabled for all of the samples (by default, Anonymous Identification is disabled). The Anonymous Identification feature automatically generates a random identifier for an anonymous user and stores it in a cookie. On subsequent visits to a site, the identifier in the cookie is used as a surrogate "id" when retrieving profile information for an anonymous user.

In the sample page, you get and set the background color using the syntax Profile.PreferredBackgroundColor. The coding style for using a Profile property is the same as accessing properties on any other class. In this sample, the page uses some common conversions available on the System.Drawing.Color structure to get and set Profile.PreferredBackgroundColor.

Authenticated Profiles

In this sample, you log in as an authenticated user and set values for all of the profile properties. When you first run the sample you will be on a home page that is accessible to both anonymous and authenticated users. Note that the background color is set to the value you selected as an anonymous user in the previous sample. Click on the link that allows you to create a new user (this link is at the bottom of the login control). Enter a username and a password and then click the button to create a new user. After the new user is created, click on the button to continue to the page that displays the profile properties for the logged in user.

When you first view the page with all of your profile properties, you will notice that the background color is set to the selection you made earlier as an anonymous user. The reason for this is covered in more detail in the next sample. For now, notice that you can set values for all of the profile properties. Also, notice that initially the automobile price point is set to the default value defined in the profile schema.

After entering new values in the HTML form, press the "Update Preferences" button. When the page refreshes the property changes take immediate effect. Click on the logout link to remove the Forms Authentication cookie from your machine. Then close the browser. Now, if you re-run the sample you will be prompted to log in again. After entering your credentials and logging in, notice that the profile properties page correctly displays the information you entered earlier. If you click on the link that takes you back to the home page, you will see that the home page uses both the name and the background color that you selected for the logged in user. This demonstrates how profile properties can be used across secured and non-secure pages on a site. On the home page the background color and name are displayed using either the anonymous user's Profile (if you are not logged in yet), or the logged in user's Profile (once you choose to log in).

As with the anonymous example, this sample demonstrates how the Profile syntax follows the property accessor syntax for VB.NET and C#. Notice that the syntax for accessing a property within a property group uses two levels of property accessors: Profile.AutomobilePreferences.PricePoint. The property group simply acts as an intermediate property. The code for manipulating Profile.AutomobilePreferences.CarModels demonstrates using an System.Collections.Arraylist as a Profile property. The string that is typed into the HTML form should be a comma-delimited set of names. The page code parses this into an System.Array of strings prior to adding the array values to the Profile.AutomobilePreferences.CarModels property. When retrieving the car models, Profile.AutomobilePreferences.CarModels is enumerated using standard for-each syntax.

Migrating Anonymous Profiles to Authenticated Profiles

In earlier samples it was demonstrated that the background color for an anonymous user was carried over to the authenticated user. You can verify this by running the sample below. If you are already logged in, click the logout link at the bottom of the page. On the home page, select a different color from the dropdown in the upper left corner of the page. The home page will refresh itself and display using the selected background color. Also, the page will have text stating "Hello Anonymous User" because the name property on the Profile is only supported for authenticated users. Log in to the site using the login control on the home page. Notice that once you log in, the background color on the profile properties page reflects the selection that was made earlier as an anonymous user.

On the profile properties page, click the link that takes you back to the home page. Notice that on the home page the name that is displayed is based on the value set for the Profile.Name property. Now that you are back on the home page as an authenticated user, select a different color from the dropdown and click the update button. The page refreshes and uses the updated background color. If you then click on the link that leads back to the profile properties page, you will see that the background color is retained.

Once you are back on the profile properties page, click on the logout link. This will redirect you back to the home page. Notice that when you are redirected to the home page, your previous selections for background color are no longer in effect. The reason for this is twofold. First, once you are logged out, the site considers you to be an anonymous user - as a result any background color that was set on the authenticated user's Profile is not available. Secondly, any color selection that was previously made when you were an anonymous user is no longer available. The reason for this is that once an anonymous users logs in, the cookie containing the autogenerated anonymous identifier was removed from the browser. As a result, when you log in, and then log out, the site considers you to be a completely new anonymous user. This interaction between anonymous users and logged in users leads to the need for migrating data from anonymous profiles to authenticated profiles.

The Profile feature exposes an event called the MigrateAnonymous event. You can subscribe to this event by placing an event handler in global.asax called Profile_MigrateAnonymous. This event fires whenever an anonymous identifier is available (either as a cookie or in the URL as a cookieless ticket), and the current user is authenticated. Within the event handler, you can load the Profile for the anonymous user by calling Profile.GetProfile and passing in the anonymous ID (the anonymous ID is one of the properties available off of the event arguments). Once you have a reference to the anonymous Profile, you can transfer property settings from the anonymous Profile to the authenticated Profile. The sample global.asax file demonstrates transferring the background color from the anonymous Profile to the authenticated Profile. The code also deletes the anonymous Profile data from the database. Lastly, the code calls a method in Anonymous Identification to clear the cookie that contains the anonymous identifier. Note that developers must explicitly choose to clear the anonymous identifier from the request - otherwise ASP.NET will not automatically clear the identifier. By the time the MigrateAnonymous event completes, ASP.NET will have issued an Http header to clear the anonymous identifier from the browser, and on subsequent page requests the event will no longer fire.

Reference:http://quickstarts.asp.net/QuickStartv20/aspnet/doc/profile/default.aspx

Themes in Asp.net

2010-05-26T00:36:00.000-07:00

Asp.net 2.0 came with a new feature called a theme. A theme is a collection of property settings that allow you to define the look of pages and controls, and then apply the look consistently across pages in a Web application, across an entire Web application, or across all Web applications on a server.

Themes are made up of a set of elements: skins, cascading style sheets (CSS), images, and other resources. Skins provide the ability to apply server-side styling to a control on the server side. By providing a SkinID for the skin, this skin can be applied to a control that matches the skin type and SkinID; otherwise, if the SkinID is left null, then the skin will be applied globally. For instance, take a look at the example below:

asp:Button SkinID="One" runat="server" BackColor="Blue"

This skin is applied to any button that has a SkinID of "One". However, the following skin is applied to every button:

asp:Button runat="server" BackColor="Yellow"

A button with a SkinID set will use that skin over the skin that's globally applied. At a minimum, a theme will contain skins, but it's common to include CSS files. Themes are defined in special directories in your Web site or on your Web server. You can apply Themes dynamically also, but the theme should be applied only in the page_Preinit event by assigning a value to the Page.Theme property.

You can also can theme third-party controls by adding them into a .skin and adding (if required) their reference.

Best practices

When to use themes/skins

foreground images cannot be controlled by CSS
CSSClasses have to be applied by hand for a control to change it's look and feel.
For advenced controls and collections
Switch image files based on the current theme

What belongs in a theme

CSS file specific to ASP.NET controls
Images used for the advanced controls or other foreground images

What does not belong in a theme

Shared CSS files/styles
Print CSS files/styles
Global images
Any content that has nothing to do with the content affected by the theme/skin

ASP.NET 2.0 Site Navigation Features

2010-05-26T00:30:00.001-07:00

http://weblogs.asp.net/scottgu/archive/2005/11/20/431019.aspx

http://quickstarts.asp.net/QuickStartv20/aspnet/doc/navigation/default.aspx

Expand or collapse all TreeNodes with JavaScript

2010-05-26T00:03:00.000-07:00

We can expand and collapse all TreeNodes on the server side, but it needs a post back. To avoid this, we can use JavaScript.

In the sample code below, the function “TreeviewExpandCollapseAll” is used to demonstrate how to expand or collapse a TreeView. The function takes two parameters, the first parameter “treeViewId” is the TreeView control’s ID, and the second parameter “expandAll” is used to determine whether or not to expand the TreeView control.

--Head section starts

function TreeviewExpandCollapseAll(treeViewId, expandAll) {
var displayState = (expandAll == true ? "none" : "block");
var treeView = document.getElementById(treeViewId);
if (treeView) {
var treeLinks = treeView.getElementsByTagName("a");
var nodeCount = treeLinks.length;

for (i = 0; i < nodeCount; i++) { if (treeLinks[i].firstChild.tagName) { if (treeLinks[i].firstChild.tagName.toLowerCase() == "img") { var currentToggleLink = treeLinks[i]; var childContainer = GetParentByTagName("table", currentToggleLink).nextSibling; if (childContainer.style.display == displayState) { eval(currentToggleLink.href); } } } } } } function GetParentByTagName(parentTagName, childElementObj) { var parent = childElementObj.parentNode; while (parent.tagName.toLowerCase() != parentTagName.toLowerCase()) { parent = parent.parentNode; } return parent; } a href="javascript:TreeviewExpandCollapseAll('<%=TreeViewDemo.ClientID%>',true)">Expand All

a href="javascript:TreeviewExpandCollapseAll('<%=TreeViewDemo.ClientID%>', false)">
Collapse All

- Form Section ends here
-Body section Ends here

Application and User Settings in C#.Net

2010-04-29T03:48:00.000-07:00

Settings have four properties:

Name: The Name property of settings is the name that is used to access the value of the setting at run time.

Type: The Type of the setting is the .NET Framework type that the setting represents. A setting can be of any type. For example, a setting that holds a user preference of color would be a System.Color type.

Scope: The Scope property represents how a setting can be accessed at run time. There are two possible values for the Scope property: Application and User. These will be discussed more in this section.

Value: The Value property represents the value returned when the setting is accessed. The value will be of the type represented by the Type property.

Reading Settings at Run Time:

string strCon = Properties.Settings.Default.con;

Saving User Settings at Run Time:

Application-scope settings are read only, and can only be changed at design time or by altering the .exe.config file in between application sessions. User-scope settings, however, can be written at run time, just as you would change any property value. The new value persists for the duration of the application session. You can persist changes to user settings between application sessions by calling the Settings.Save method. These settings are saved in the User.config file.

To Write and Persist User Settings at Run Time

Access the user setting and assign it a new value, as shown in the following example:

Properties.Settings.Default.myColor = Color.AliceBlue;

If you want to persist changes to user settings between application sessions, call the Save method, as shown in the following code:

Properties.Settings.Default.Save();

Regular Expressions and C#, .NET

2010-04-23T03:38:00.000-07:00

What are regular expressions?

Regular expressions are Patterns that can be used to match strings. You can call it a formula for matching strings that follow some pattern. Regular expression(s) can be considered as a Language, which is designed to manipulate text. You can then ask questions such as

“Does the given string match the pattern?”, or
“Does the given string contain characters that match a pattern?”.
Regular Expressions may be used to find one or more occurrences of a pattern of characters within a string. You may choose to replace it with some other characters or perform some other tasks based on the results obtained. These patterns of characters can be simple or very complex. Regular Expressions generally comprises of two types of characters –

1) Literal or Normal Characters such as “abcd123”
2) Special Characters that have a special meaning such as “.” Or “$” or “^”

Due to the special characters Regular Expressions form a very powerful means of manipulating strings and text.

.NET support for Regular Expressions:
.Net provides an extensive set of Regular expressions which you could use to create, modify or compare strings. They can be classified as follows –

a) Character Escapes
b) Substitutions
c) Character Classes
d) Regular Expression Options
e) Atomic Zero-Width Assertions
f) Quantifiers
g) Grouping Constructs
h) Backreference Constructs
i) Alternation Constructs
j) Miscellaneous Constructs

.
Matches any single character. An example of this is the regular expression s.t would match the strings sat, sit, but not sight.

$
Matches the end of a line. For instance, the regular expression reason$ would match the end of the string "He has a reason" but not the string "He has his reasons"

^
Matches the beginning of a line. For instance, the regular expression ^Where would match the beginning of the string "Where is my cap" but would not match "Do you know Where it is " .

*
Matches zero or more occurrences of the character immediately preceding. For example, the regular expression .* means match any number of any characters.

This is a escape or quoting character. The character after this is treated as an ordinary character. For example, ^ is used to match the caret sign character (^) rather than the beginning of a line. Similarly, the expression . is used to match the “.” character .

[ ]
[c1-c2]
[^c1-c2]
Matches any one of the characters between the brackets.
For example, the regular expression s[ia]t matches sat, sit, but not set.

Ranges of characters can specified by using a hyphen.
For example, the regular expression [0-9] means match any digit. Multiple ranges can be specified as well. The regular expression [A-Za-z] means match any upper or lower case letter.

To match any character except those in the range, the complement range, use the caret as the first character after the opening bracket.
For example, the expression [^123a-z] will match any characters except 1,2, 3, and lower case letters.

< >

Matches the beginning ( < ) or end ( >) or a word. For example, < THE< _fckxhtmljob="2" span > matches on "the" in the string "for the older" but does not match "the" in "rather"

( )

Treat the expression between ( and ) as a group. Also, saves the characters matched by the expression into temporary holding areas. Up to nine pattern matches can be saved in a single regular expression. They can be referenced as 1 through 9.
|

Or two conditions together. For example (him|her) matches the line "it belongs to him" and matches the line "it belongs to her" but does not match the line "it belongs to them."

+

Matches one or more occurrences of the character or regular expression immediately preceding. For example, the regular expression 9+ matches 9, 99, 999.

?

Matches 0 or 1 occurrence of the character or regular expression immediately preceding.

{i}
{i,j}

Match a specific number of instances or instances within a range of the preceding character.
For example, the expression A[0-9]{3} will match "A" followed by exactly 3 digits. That is, it will match A123 but not A1234.

The expression [0-9]{4,6} any sequence of 4, 5, or 6 digits

Character Escapes :

The escape character (a single backslash) signals to the regular expression parser that the character following the backslash is not an operator

b
Matches a backspace
t
Matches a tab
r
Matches a carriage return
v
Matches a vertical tab
f
Matches a form feed
n
Matches a new line
e
Matches an escape
40
Matches an ASCII character as octal (up to three digits);
x20
Matches an ASCII character using hexadecimal representation (exactly two digits).
cC
Matches an ASCII control character; for example, cC is control-C.
u0020
Matches a Unicode character using hexadecimal representation (exactly four digits).

Explanation of Regular Expressions:

Regular expressions are used to search specified in the source string.

Examples:

Pattern#1
Regex objNotNaturalPattern=new Regex("[^0-9]");

Pattern#2
Regex objNaturalPattern=new Regex("0*[1-9][0-9]*");

Pattern#1 will match for strings other than 0 to 9.^ symbol is used for Specifying not condition.[] brackets if we are to give range values such as 0 - 9 or a-z or A-Z

eg. abc will return true

123 will return false.

Pattern#2 will match for string which are Natural Numbers.Natural numbers Are numbers which are always greater than 0.The pattern 0* tells that a natural Number can be prefixed with any number of zero's or no zero's.the next [1-9] tells that it should contain atleast one number from 1 to 9 followed by any numbers of

0-9's

Eg. 0007 returns true whereas 00 will return false.

Basic things to be understood in RegEx:

"*" matches 0 or more patterns
"?" matches single character
"^" for ignoring matches.
"[]" for searching range patterns.

More RegEx patterns in Next Article.

Source Code:

// Source Code starts
using System.Text.RegularExpressions;
using System;
/*

csc /r:System.Text.RegularExpressions.dll,System.dll Validation.cs

*/
class Validation
{
public static void Main()
{
String strToTest;
Validation objValidate=new Validation();
Console.Write("Enter a String to Test for Alphabets:");
strToTest=Console.ReadLine();
if(objValidate.IsAlpha(strToTest))
{
Console.WriteLine("{0} is Valid Alpha String",strToTest);
}
else
{
Console.WriteLine("{0} is not a Valid Alpha String",strToTest);
}
}

// Function to test for Positive Integers.
public bool IsNaturalNumber(String strNumber)
{
Regex objNotNaturalPattern=new Regex("[^0-9]");
Regex objNaturalPattern=new Regex("0*[1-9][0-9]*");
return !objNotNaturalPattern.IsMatch(strNumber) &&
objNaturalPattern.IsMatch(strNumber);
}

// Function to test for Positive Integers with zero inclusive
public bool IsWholeNumber(String strNumber)
{
Regex objNotWholePattern=new Regex("[^0-9]");
return !objNotWholePattern.IsMatch(strNumber);
}

// Function to Test for Integers both Positive & Negative
public bool IsInteger(String strNumber)
{
Regex objNotIntPattern=new Regex("[^0-9-]");
Regex objIntPattern=new Regex("^-[0-9]+$|^[0-9]+$");
return !objNotIntPattern.IsMatch(strNumber) && objIntPattern.IsMatch(strNumber);
}

// Function to Test for Positive Number both Integer & Real
public bool IsPositiveNumber(String strNumber)
{
Regex objNotPositivePattern=new Regex("[^0-9.]");
Regex objPositivePattern=new Regex("^[.][0-9]+$|[0-9]*[.]*[0-9]+$");
Regex objTwoDotPattern=new Regex("[0-9]*[.][0-9]*[.][0-9]*");
return !objNotPositivePattern.IsMatch(strNumber) &&
objPositivePattern.IsMatch(strNumber) &&
!objTwoDotPattern.IsMatch(strNumber);
}

// Function to test whether the string is valid number or not
public bool IsNumber(String strNumber)
{
Regex objNotNumberPattern=new Regex("[^0-9.-]");
Regex objTwoDotPattern=new Regex("[0-9]*[.][0-9]*[.][0-9]*");
Regex objTwoMinusPattern=new Regex("[0-9]*[-][0-9]*[-][0-9]*");
String strValidRealPattern="^([-]|[.]|[-.]|[0-9])[0-9]*[.]*[0-9]+$";
String strValidIntegerPattern="^([-]|[0-9])[0-9]*$";
Regex objNumberPattern =new Regex("(" + strValidRealPattern +")|(" + strValidIntegerPattern + ")");
return !objNotNumberPattern.IsMatch(strNumber) &&
!objTwoDotPattern.IsMatch(strNumber) &&
!objTwoMinusPattern.IsMatch(strNumber) &&
objNumberPattern.IsMatch(strNumber);
}
// Function To test for Alphabets.
public bool IsAlpha(String strToCheck)
{
Regex objAlphaPattern=new Regex("[^a-zA-Z]");
return !objAlphaPattern.IsMatch(strToCheck);
}
// Function to Check for AlphaNumeric.
public bool IsAlphaNumeric(String strToCheck)
{
Regex objAlphaNumericPattern=new Regex("[^a-zA-Z0-9]");
return !objAlphaNumericPattern.IsMatch(strToCheck);
}
}

Textbox Validation in C#.Net

2010-04-23T01:26:00.000-07:00

For Numbers:

Ex 1:

if((e.KeyChar > 47 && e.KeyChar < 58)||(e.KeyChar==46)||(e.KeyChar==8)){e.Handled = false;}else{e.Handled = true;MessageBox.Show("Please enter valid integer.");}Ex 2:string val = "0123456789";if (val.IndexOf(e.KeyChar)<0&&e.KeyChar!= 8 && e.KeyChar!=32){e.Handled = true;txtSid.Focus();}Ex 3: if (!Char.IsDigit(e.KeyChar))e.Handled=true;}For Letter:Ex 1.string val="abcdefghijklmnopqrstuvwxyz";if (val.IndexOf(e.KeyChar)< 0 && e.KeyChar!= 8 && e.KeyChar!= 32){e.Handled = true;txtName.Focus();}For Email Id:string pattern=@"^[a-z][a-z|0-9|]*([_][a-z|0-9]+)*([.][a-z|" + @"0-9]+([_][a-z|0-9]+)*)?@[a-z][a-z|0-9|]*\.([a-z]" + @"[a-z|0-9]*(\.[a-z][a-z|0-9]*)?)$";System.Text.RegularExpressions.Match match = Regex.Match(txtEmail.Text.Trim(), pattern, RegexOptions.IgnoreCase);if(match.Success)MessageBox.Show("Success");elseMessageBox.Show("Fail");Using Javascript:if (document.getElementById("<%=txtName.ClientID%>").value=="")
{
alert("Name Feild can not be blank");
document.getElementById("<%=txtName.ClientID%>").focus();
return false;
}

C#.Net Coding Standards...

2010-04-22T02:51:00.000-07:00

Pascal Casing - First character of all words are Upper Case and other characters are lower case.

Example: BackColor

Camel Casing - First character of all words, except the first word are Upper Case and other characters are

lower case.
Example: backColor

1.Use Pascal casing for Class names

public class HelloWorld
{
...
}

2.Use Pascal casing for Method names

void SayHello(string name)
{
...
}

3.Use Camel casing for variables and method parameters

int totalCount = 0;
void SayHello(string name)
{
string fullMessage = "Hello " + name;
...
}

4.Use the prefix “I” with Camel Casing for interfaces ( Example: IEntity )

5.Do not use Hungarian notation to name variables.

In earlier days most of the programmers liked it - having the data type as a prefix for the variable name and using m_ as prefix for member variables. Eg:

string m_sName;
int nAge;

However, in .NET coding standards, this is not recommended. Usage of data type and m_ to represent member variables should not be used. All variables should use camel casing.

Some programmers still prefer to use the prefix m_ to represent member variables, since there is no other easy way to identify a member variable.

6.Use Meaningful, descriptive words to name variables. Do not use abbreviations.

Good:

string address
int salary

Not Good:

string nam
string addr
int sal

7.Do not use single character variable names like i, n, s etc. Use names like index, temp

One exception in this case would be variables used for iterations in loops:

for ( int i = 0; i < count; i++ ){ ...}If the variable is used only as a counter for iteration and is not used anywhere else in the loop, many people still like to use a single char variable (i) instead of inventing a different suitable name. 8.Do not use underscores (_) for local variable names. 9.All member variables must be prefixed with underscore (_) so that they can be identified from other local variables.10.Do not use variable names that resemble keywords.11.Prefix boolean variables, properties and methods with “is” or similar prefixes.Ex: private bool _isFinished12.Namespace names should follow the standard pattern ...

13.File name should match with class name.

Introduction to Web Services

2010-03-19T01:22:00.000-07:00

Its an application logic that can be exposed to internet and can be accessed by
different web applications.

web services represent a model in which discrete tasks within e-business processes are distributed widely throughout a value net.

Web Services are platform-independent and language-independent, since they use standard XML languages. This means that my client program can be programmed in C++ and running under Windows, while the Web Service is programmed in Java and running under Linux.

Most Web Services use HTTP for transmitting messages (such as the service request and response). This is a major advantage if you want to build an Internet-scale application, since most of the Internet's proxies and firewalls won't mess with HTTP traffic (unlike CORBA, which usually has trouble with firewalls).

web services can be accessed programmatically. Unlike web sites and desktop applications, web services are not designed for direct human interaction, and they do not have a graphical user interface. Rather, web services operate at the code level; they are called by and exchange data with other software

Core Layers of the Web Services Stack:

Simple Object Access Protocol (SOAP):

SOAP is a protocol for messaging and RPC-style communication between applications. It is based on XML and uses common Internet transport protocols like HTTP to carry its data. SOAP has been submitted to the World Wide Web Consortium (W3C) standards body and will emerge later this year as "XML Protocol (XP)".

Extensible Markup Language (XML):

XML is a widely accepted format for exchanging data and its corresponding semantics. It is a fundamental building block for nearly every other layer in the web services stack.

Web Services Description Language (WSDL):

WSDL is an XML-based description of how to connect to a particular web service. A WSDL description abstracts a particular service's various connection and messaging protocols into a high-level bundle and forms a key element of the UDDI directory.

Universal Description, Discovery, and Integration (UDDI):

UDDI represents a set of protocols and a public directory for the registration and realtime lookup of web services and other business processes.

ASP.NET Master Pages Overview

2010-03-08T23:43:00.000-08:00

ASP.NET master pages allow you to create a consistent layout for the pages in your application. A single master page defines the look and feel and standard behavior that you want for all of the pages (or a group of pages) in your application. You can then create individual content pages that contain the content you want to display. When users request the content pages, they merge with the master page to produce output that combines the layout of the master page with the content from the content page.

How Master Pages Work

Master pages actually consist of two pieces, the master page itself and one or more content pages.

Master Pages

A master page is an ASP.NET file with the extension .master (for example, MySite.master) with a predefined layout that can include static text, HTML elements, and server controls. The master page is identified by a special @ Master directive that replaces the @ Page directive that is used for ordinary .aspx pages. The directive looks like the following.

<%@ Master Language="VB" %>

The @ Master directive can contain most of the same directives that a @ Control directive can contain. For example, the following master-page directive includes the name of a code-behind file, and assigns a class name to the master page.

<%@ Master Language="VB" CodeFile="MasterPage.master.vb" Inherits="MasterPage" %>

In addition to the @ Master directive, the master page also contains all of the top-level HTML elements for a page, such as html, head, and form. For example, on a master page you might use an HTML table for the layout, an img element for your company logo, static text for the copyright notice, and server controls to create standard navigation for your site. You can use any HTML and any ASP.NET elements as part of your master page.

Content Pages

You define the content for the master page's placeholder controls by creating individual content pages, which are ASP.NET pages (.aspx files and, optionally, code-behind files) that are bound to a specific master page. The binding is established in the content page's @ Page directive by including a MasterPageFile attribute that points to the master page to be used. For example, a content page might have the following @ Page directive, which binds it to the Master1.master page.

<%@ Page Language="VB" MasterPageFile="~/MasterPages/Master1.master" Title="Content Page" %>

Advantages of Master Pages :

Master pages provide functionality that developers have traditionally created by copying existing code, text, and control elements repeatedly; using framesets; using include files for common elements; using ASP.NET user controls; and so on. Advantages of master pages include the following:

* They allow you to centralize the common functionality of your pages so that you can make updates in just one place.
* They make it easy to create one set of controls and code and apply the results to a set of pages. For example, you can use controls on the master page to create a menu that applies to all pages.
* They give you fine-grained control over the layout of the final page by allowing you to control how the placeholder controls are rendered.
* They provide an object model that allows you to customize the master page from individual content pages.

Validation in ASP.NET 2.0

2010-03-08T23:39:00.000-08:00

Validation server controls are set of controls that enable you to work with the information your end users inputs into application. Application should always ensure that valid data is recorded. To ensure valid data is collected, we apply set of validations to data we collect. Validation is a set of rules that you apply to the data you collect. In this way, we can bring certain degree of discipline in end user.

We can understand validation under two categories: Client side validation and Server side validation. Client side validation involves validating user input before the page is posted to server. Server side validation involves performing checks on server instead of client. This is most secure form but comes at cost of performance.

ASP.NET introduced smart validation server controls to implement page level validations. They are capable of performing both server side and client side validations. So, Validation server controls offer the combined power of both approaches such that the security of application is never compromised.

ASP.NET 2.0 Validation server controls:

* RequiredFieldValidator
* CompareValidator
* RangeValidator
* RegularExpressionValidator
* CustomValidator
* ValidationSummary

RequiredFieldValidator:

The RequiredFieldValidator control is simple validation control which checks to see if the data is entered for the attached control. You can have a RequiredFieldValidator control for each form element on which you wish to enforce Mandatory Field rule.

CompareValidator Server Control:

The CompareValidator control allows you to make comparisons between two form elements as well as to compare values contained with in form element to constants that you specify. For instance, you can specify that a form's element value must be an integer and greater than a specified number.

RangeValidator Server Control:

The RangeValidator Server Control makes sure that the end user value or selection provided is between a specified ranges.

RegularExpressionValidator Server Control:

Using RegularExpressionValidator server control, you can check a user's input based on a pattern that you define using a regular expression. This means that you can define a structure that a user's input will be applied against to see if its structure matches the one that you define.

CustomValidator Server Control:

Sometimes, predefined Validation controls cannot address some of our critical requirements. You have to go beyond what they offer. This is where the CustomValidator control comes into play. The CustomValidator control allows you to build your own client-side or server-side validations that can then be easily applied to your web forms.

ValidationSummary Server Control:

The ValidationSummary control is reporting control, which is used by the other validation controls on a page. You can use this validation control to consolidate errors reporting for all the validation errors that occur on a page instead of leaving this up to each and every individual validation control.

Using WebParts in ASP.Net 2.0

2010-03-08T23:30:00.000-08:00

It would not be wrong to say that Webparts are going to be the future of web based management systems. WebParts give us the option of dragging and dropping of objects on a page as well as, changing titles and border style properties of objects at runtime. Before the introduction of WebParts it was used to be a hectic task because we had to write a lot of JavaScript and had to save the state of objects in a database.

There are two basic things in WebParts:

* WebPart manager
* WebPart zones

WebPartManager

The WebPartManager is the manager for all webparts. If you use webparts in your web projects you are required to use the WebPartManager. Usually you just drag and drop this into your webform and are ready to go.
WebPart Zones

There are four kinds of zones in webpart zones:

* WebPart Zone
* Editor Zone
* Catalog Zone
* Connection Zone

WebPart Zone

The webpart Zone is the basic unit for webparts. By placing different contents in a webpart zone we can allow a user to drag and drop contents on a page.

To use different zones add a dropdownlist to your webform and add the following items to it.

* Browse
* Display
* Edit
* Catalog
* Connect

Paste the following code in the SelectedIndexChanged event of the dropdownlist (this assumes the dropdownlist’s id is cmbOptions and the webpart Manager’s id is WebPartManager1).

if (cmbOptions.SelectedValue == "Design")
{
WebPartManager1.DisplayMode = WebPartManager.DesignDisplayMode;
}
else if (cmbOptions.SelectedValue == "Browse")
{
WebPartManager1.DisplayMode = WebPartManager.BrowseDisplayMode;
}
else if (cmbOptions.SelectedValue == "Catalog")
{
WebPartManager1.DisplayMode = WebPartManager.CatalogDisplayMode;
}
else if (cmbOptions.SelectedValue == "Edit")
{
WebPartManager1.DisplayMode = WebPartManager.EditDisplayMode;
}
else if (cmbOptions.SelectedValue == "Connect")
{
WebPartManager1.DisplayMode = WebPartManager.ConnectDisplayMode;
}

Browse mode

The Browse mode is the default mode of webparts. In Browse mode we can not drag and drop the webparts but we can see two options, minimize and close. Minimizing a webpart will still display it in minimized state.If you choose close then it can only be restored while being in catalog mode.

Design mode

In design mode we can drag drop objects between webparts. There are two webparts named as Links and Search. The following screenshot shows the Links webpart being dragged over the Search one.

Edit Mode

The edit mode is used to edit webparts at runtime. Editing a webpart is further divided into four types: Appearance, Behavior, Property and Layout. We will first see how to use the Appearance and LayoutEditorPart.
AppearanceEditorPart and LayoutEditorPart

First, place an editor zone into the web form. Then place an AppearanceEditorPart and LayoutEditorPart inside the editor zone. Run the application and select the edit mode from the dropdownlist. Click edit from the menu available for webparts.

PropertyGridEditorPart

By using the property editor we can change the properties of the objects in our webparts. In our example we are going to change the CSSClass property of the object. To use this we will follow the same method as explained in the AppearanceEditorPart and LayoutEditorPart section.

Place an editor zone into the web form. Then place a PropertyGridEditorPart inside the editor zone. To use the editor zone add a new user control into your project. Place a textbox in the user control and place this user control inside the webpart of the web form. In the code behind of user control paste the following code.

string _cssClass = "FrmTxtBox";
[WebBrowsable(), Personalizable(true)]
public string CssClass
{
get { return _cssClass; }
set { TextBox1.CssClass= value; }
}

protected void Page_Load(Object sender, EventArgs e)
{
TextBox1.CssClass = CssClass;
}

The above code changes the CssClass of the TextBox. This property will now be available in the webparts edit mode and we will be able to change this at run-time as well. Besides setting the CssClass we have also used two additional attributes in the class declaration:

* WebBrowsable - It allows a webpart to display a user defined property in edit mode.
* Personalizable - It allows a property to be editable.

Catalog mode

The Catalog mode gives us the option to add/remove webparts at runtime. For example if we have few modules like weather, news, shopping, horoscope etc. and want to give the user an option to show or hide these modules at runtime, we can accomplish this task using the catalog mode.

CatalogZone

The CatalogZone is divided into three subtypes: PageCatalogPart, DeclarativeCatalogPart and ImportCatalogPart. On the webform add a CatalogZone and add the previous mentioned three types into it. We can show webparts with the help of the Pagecatalog which are closed by using the close option of the webpart.

Building an ASP.NET Shopping Cart Using DataTables

2010-03-08T23:21:00.000-08:00

Most dynamic Web applications are created for the sole purpose of making money on the Web.

Let's face it: why would you go through all the work of creating a dynamic Web application if you don't plan to make money through it? Sure, companies employ dynamic intranet sites and there are still some -- although very few -- free Web applications you can use.

In the real world, however, dynamic Web applications are created in an attempt to make money by allowing site owners to sell merchandise on the Web. Providing users with the capability to add items to a virtual shopping cart as they browse through your Website is still very much a business that commands good money. Companies such as VeriSign, Paypal, WebAssist, and LinkPoint charge to provide developers with the capability to add shopping cart functionality to their own Websites. But why pay $300-$400 for a solution that someone else already built, when you can build one just as easily yourself utilizing new technology in ASP.NET, for free?

This article will allow you to develop and implement your own shopping cart utilizing a Session, a DataGrid, and the DataTable class of the DataSet object. Through this article, you'll learn to:

* Build a user interface using ASP.NET Web Server Controls
* Dynamically construct a DataTable depending on user interaction
* Bind the dynamically constructed DataTable to a DataGrid
* Allow the user to remove items from the cart freely
* Keep a running cost total of items within the cart

At the end of this article, you'll have a fully functioning shopping cart, and you'll have gained a thorough understanding of DataTables, DataGrids, and Session Variables

This project is separated into five parts:

1. Building the user interface

2. Building the DataTable structure

3. Adding items to the cart

4. Keeping a running total

5. Removing items from the cart

Step 1: Building the Shopping Cart User Interface

The user interface or UI for the application is quite simple. In fact, most of the interaction will occur within the DataGrid, but the UI does include some key components that the user will be interacting with:

* A DropDownList Web control that will display the products that we'll offer. The cost of each item will be associated with the value of the DropDownList Web control for simplicity's sake.
* A TextBox Web control that offers the user the ability to adjust quantities
* A Button Web control to add to the cart
* A DataGrid that will contain the cart's contents
* A Label control that will display to the user a running total in terms of price

Now that you have an idea of what the UI will display, let's add these components to the body of an HTML page. Using Dreamweaver MX, we'll create a new page and add this code into the tag of the page:

Product:

Socks
Pants
Shirt
Hat

Quantity:
"

Total:

"
The code is actually quite simple and needs very little explanation. Basically, a hard-coded DropDownList control (ddlProducts) is added, with four products. The cost of those products is maintained by associating a decimal value for each specific product.

Second, a TextBox control (txtQuantity) is added so that the user can modify quantities. Next, a Button control (btnAdd) is added with the text "Add to Cart". The onClick event associated with the Button control will call the AddToCart() subroutine, which will be created in the next section.

Next, a DataGrid (dg) is added which will be used to bind to the dynamically constructed DataTable. Remember, the DataTable will be constructed in code, and bound to the DataGrid for presentation to the user. We'll add a button column to allow the user to remove a specific item if he or she wishes a little later. Finally, we'll add a Label control (lblTotal), which will be used to display to the user a running total of the items within the cart.
Step 2: Building the DataTable Structure

If you're familiar with DataSets, then you know that DataTables provide you with a way to dynamically create a purely memory-resident representation of a database table. Typically, you'd fill a DataTable from an existing database, but you could also create one programmatically, as will be the case here.

In a DataTable, columns are represented by the columns property, and rows are represented by the rows property. Thus, DataTables will be the perfect choice for the creation of our shopping cart. We can build the columns just as we would within a database, using the columns property of the DataTable, and add rows to the DataTable with the Rows property. With the DataTable built, we can then bind the DataTable to a DataGrid to display the results in an intuitive manner.

Because DataTables contain rows and columns, you will be able to effectively mock the structure of a conventional database table. The rows will be added to the DataTable as the user adds items to the cart. For now, we'll need to construct the columns that will serve as the categories for the row items. In order for the cart to function correctly, we'll need to add the following columns with a corresponding data type:

You're probably wondering how data types, auto increment, and uniqueness will be set programmatically. Remember, DataTables contain column and row properties. Some of those properties include the ability to set the above mentioned items, just as you would a traditional database table. You'll also notice that the DataTable contains a column for ID. Technically, this column has nothing to do with the shopping cart, but it will have a lot to do with keeping the items in the cart unique, and will allow us to establish a primary key if we ever want to create a relationship with another DataTable.

For now we just want the structure of the DataTable built when the page loads for the first time. We don't want to actually start to define rows until the user selects an item to add to the cart.

To begin building the cart's structure, add this code into the head of your page:

Dim objDT As System.Data.DataTable
Dim objDR As System.Data.DataRow

Private Sub Page_Load(s As Object, e As EventArgs)
If Not IsPostBack Then
makeCart()
End If
End Sub

Function makeCart()
objDT = New System.Data.DataTable("Cart")
objDT.Columns.Add("ID", GetType(Integer))
objDT.Columns("ID").AutoIncrement = True
objDT.Columns("ID").AutoIncrementSeed = 1

objDT.Columns.Add("Quantity", GetType(Integer))
objDT.Columns.Add("Product", GetType(String))
objDT.Columns.Add("Cost", GetType(Decimal))

Session("Cart") = objDT
End Function

Looking at the code, you can see, that the makeCart() function is called only when the page is loaded for the first time. This is the reason for the IsPostBack check.

Within the makeCart() function, we'll add the code that defines the actual structure for the DataTable and its columns. First, we add a column to the DataTable named ID, assigning it the data type for integer. We assign the property for AutoIncrement to True, and begin the seed at 1.

Next, add three more columns to the DataTable for Quantity, Product, and Cost, assigning them the data types for integer, string, and decimal respectively. Finally, the DataTable is added into a Session conveniently named "Cart", for storage.

That's it! If you think about the structure of a database table and then consider the structure and code for the DataTable, they begin to resemble each other conceptually. The next step involves adding items to the cart, which is no harder than defining new rows for the DataTable.

Step 3: Building the Add to Cart Functionality

Now that the structure of the DataTable has been completely built, we'll want to begin to add to the cart the specific items that the user selects from the drop down menu. Again, to do this, we simply construct new rows and add them to the appropriate position within the DataTable cart. To construct the Add to Cart functionality, add the code below:

Sub AddToCart(s As Object, e As EventArgs)

objDT = Session("Cart")
Dim Product = ddlProducts.SelectedItem.Text

objDR = objDT.NewRow
objDR("Quantity") = txtQuantity.Text
objDR("Product") = ddlProducts.SelectedItem.Text
objDR("Cost") = Decimal.Parse(ddlProducts.SelectedItem.Value)
objDT.Rows.Add(objDR)
Session("Cart") = objDT

dg.DataSource = objDT
dg.DataBind()

End Sub

You'll remember that the Button control had the onClick event that called the AddToCart() subroutine. This subroutine contains all the code that's necessary to retrieve an existing cart from the Session object if it exists, add new items to the cart, place the cart back into the session, and finally, bind to the DataGrid.

As I mentioned, the first two lines of code retrieve the cart from the session if it exists, and retrieve the product selected from the drop down menu. As you have already created a new instance of the DataRow class, you can create the new rows for the specific columns within the DataTable.

You'll notice that we set the Quantity column equal to the value of the quantity text box control, and set the Product column equal to the text value of the drop down menu selection. We then convert the value of the drop down menu, which is cost, into a decimal value for the cost column. Finally, we add the new row to the DataTable, add the DataTable to the Session, or overwrite it if it already exists, and bind the DataTable to the DataGrid.

Test what you have so far in the browser. It should work fine, except for one problem. You'll see that if you select an item, add it to the cart, and then select the same item again, rather than adding the sum of the old quantity with the new quantity, it just creates a new row. You can fix this problem by modifying the AddToCart() subroutine. Just below the code where you retrieve the item from the drop down menu, add the following loop to check within the DataTable for an existing product:

Dim blnMatch As Boolean = False

For Each objDR In objDT.Rows
If objDR("Product") = Product Then
objDR("Quantity") += txtQuantity.Text
blnMatch = True
Exit For
End If
Next

Now wrap the new code that adds a new row within a conditional statement.

If Not blnMatch Then
objDR = objDT.NewRow
objDR("Quantity") = Int32.Parse(txtQuantity.Text)
objDR("Product") = ddlProducts.SelectedItem.Text
objDR("Cost") = Decimal.Parse(ddlProducts.SelectedItem.Value)
objDT.Rows.Add(objDR)
End If

Basically, a new row will only be created if the product is not found within the cart. If it is found, however, it will simply adjust the quantity by whatever the user places into the quantity textbox control.
Step 4: Keeping the Order Total

The next step will be to build the function that keeps a running total of the cost of the items within the cart. This will be used to present the user with a working total as they add and remove items in the cart. You can add this functionality using the code below:

Function GetItemTotal() As Decimal

Dim intCounter As Integer
Dim decRunningTotal As Decimal

For intCounter = 0 To objDT.Rows.Count -- 1
objDR = objDT.Rows(intCounter)
decRunningTotal += (objDR("Cost") * objDR("Quantity"))
Next

Return decRunningTotal

End Function

You can see that this function simply loops through the rows in the DataTable, multiplies the quantity column by the cost column, and returns the result. The first step involves defining the functon. As you want to return a decimal value, make sure you define the function as a decimal. Next, we'll create two new variables: one as an integer and one as a decimal. Next, you loop through the rows within the DataTable and multiply the cost column for a specific row by the quantity for that row, and store it within the decRunningTotal variable. Finally, we'll return the value.

The last step will be to write the value of the function into the label control. Add the following line to the end of the btnAddToCart subroutine -- this effectively writes the cost into the label control:

lblTotal.Text = "$" & GetItemTotal()

Save your work and run it in a browser. This time, as you add items to the cart, a total is presented within the label control. Fantastic! Now, the last part we'll discuss involves removing items from the cart.
Step 5: Removing Items from the Cart

Now that a working model of the shopping cart has been constructed, we'll want to add the next bit of functionality: removing items from the cart. Obviously you can see the importance of this: you want users to be able to add and remove any and all items to or from the shopping cart as required. Add the functionality for removing items from the cart using the following subroutine:

Sub Delete_Item(s As Object, e As DataGridCommandEventArgs)

objDT = Session("Cart")
objDT.Rows(e.Item.ItemIndex).Delete()
Session("Cart") = objDT

dg.DataSource = objDT
dg.DataBind()

lblTotal.Text = "$" & GetItemTotal()

End Sub

This subroutine, which we'll associate with the DataGrid in a minute, simply dumps the contents of the session into a new DataTable object, deletes the specific row that a user clicked, and then places the revised DataTable back into the Session variable for storage. Finally we re-bind to the DataGrid and update the total by calling the GetItemTotal() function.

You'll want to note that one of the parameters being passed into the subroutine is that of the DataGridCommandEventArgs. Without this parameter, we wouldn't be able to determine which item within the DataGrid the user selected.

The last step will be to modify the DataGrid. You will need to add a new button column, as well as a new event, to call the Delete_Item subroutine. The new DataGrid should resemble the following code:

ASP.NET Web.config File

2010-03-08T23:12:00.001-08:00

Applications of XML have been integrated into .NET to such an extent that XML is hardly a buzzword anymore. Microsoft, as you probably know, has taken XML into the core of its .NET framework. Not only is XML a generally accepted format for the exchange of data, it's also used to store configuration settings.

Configuration settings for any of your ASP.NET Web applications can be stored in a simple text file. Presented in an easily understandable XML format, this file, called Web.config, can contain application-wide data such as database connection strings, custom error messages, and culture settings.

Because the Web.config is an XML file, it can consist of any valid XML tags, but the root element should always be . Nested within this tag you can include various other tags to describe your settings. Since a Web.config file comes as a standard when you start to build a new Web application, let's look at the default XML file generated by Visual Studio .NET:

Experienced ASP.NET programmers will have noticed that I've left out the comment tags that are generated automatically with the file. I've done that to provide a clear view of the XML that's used here. Also, I'll elaborate on each configuration tag later in this article, and this discussion will make the comment tags rather obsolete.

If you look at the example XML, you'll notice that the tag has only one child tag, which we call section group, the tag. A section group typically contains the setting sections, such as: compilation, customErrors, authentication, authorization, etc. The way this works is pretty straightforward: you simply include your settings in the appropriate setting sections. If, for example, you wanted to use a different authentication mode for your Web application, you'd change that setting in the authentication section.

Apart from the standard system.web settings, you can define your own specific application settings, such as a database connection string, using the tag. Consequently, your most common Web.config outline would be:

Let's discuss the details of both section groups now.
The system.web Section Group

In this section group, you'll typically include configuration settings that, in the pre-.NET era, you'd have set up somewhere in the IIS administration console. At Microsoft's MSDN Library, you can find an overview of all the tags that the system.web section group understands, but, depending on the complexity of your site, you may not ever use even half of those options.

Let's have a look at the most valuable tweaks you can make within the system.web section group, in alphabetical order.

The authentication section controls the type of authentication used within your Web application, as contained in the attribute mode. You'll enter the value "None" if anyone may access your application. If authentication is required, you'll use "Windows", "Forms" or "Passport" to define the type of authentication. For example:

To allow or deny access to your web application to certain users or roles, use or child tags.

It's important to understand that ASP.NET's authorization module iterates through the sections, applying the first rule that corresponds to the current user. In this example, users carrying the role Administrators or Users will be allowed access, while all others (indicated by the * wildcard) will encounter the second rule and will subsequently be denied access.

Here, you can configure the compiler settings for ASP.NET. You can use loads of attributes here, of which the most common are debug and defaultLanguage. Set debug to "true" only if you want the browser to display debugging information. Since turning on this option reduces performance, you'd normally want to set it to "false". The defaultLanguage attribute tells ASP.NET which language compiler to use, since you could use either Visual Basic .NET or C# for instance. It has value vb by default.

To provide your end users with custom, user-friendly error messages, you can set the mode attribute of this section to On. If you set it to RemoteOnly, custom errors will be shown only to remote clients, while local host users will see the ugly but useful ASP.NET errors -- clearly, this is helpful when debugging. Setting the mode attribute to Off will show ASP.NET errors to all users.

If you supply a relative (for instance, /error404.html) or absolute address (http://yourdomain.com/error404.html) in the defaultRedirect attribute, the application will be automatically redirected to this address in case of an error. Note that the relative address is relative to the location of the Web.config file, not the page in which the error takes place. In addition you can use tags to provide a statusCode and a redirect attribute:

The globalization section is useful when you want to change the encoding or the culture of your application. Globalization is such an extensive subject that an entire article could be dedicated to the matter. In short, this section allows you to define which character set the server should use to send data to the client (for instance UTF-8, which is the default), and which settings the server should use to interpret and displaying culturally specific strings, such as numbers and dates.

Encoding is done through the attributes requestEncoding and responseEncoding. The values should be equal in all one-server environments. In this example, the application culture is set to Dutch. If you don't supply a culture, the application will use the server's regional settings.

You can use the httpRuntime section to configure a number of general runtime settings, two of which are particularly convenient.

The first attribute specifies the number of requests the server may queue in memory at heavy-traffic times. In the example, if there are already 100 requests waiting to be processed, the next request will result in a 503 error ("Server too busy").

The executionTimeout attribute indicates the number of seconds for which ASP.NET may process a request before it's timed out.

In this section of the Web.config file, we tell ASP.NET where to store the session state. The default is in the process self:

Session variables are very powerful, but they have a few downsides. Information is lost when the ASP.NET process crashes, and sessions are generally useless in the case of a Web farm (multiple Web servers). In that instance, a shared session server can solve your issues. It's beyond the scope of this article to expand on this topic, but it's worth a mention. More information on sessionState can be found in the MSDN Library online.

Your application's trace log is located in the application root folder, under the name trace.axd. You can change the display of tracing information in the trace section.

The attributes you will look for initially are enabled: localOnly, and pageOutput.

Set localOnly to "false" to access the trace log from any client. If you set the value of pageOutput to "true", tracing information will be added to the bottom of each Web page.
The appSettings Section Group

Apart from the Website configuration settings I've been talking about in the preceding paragraphs, you'll know that a programmer frequently likes to use custom application-wide constants to store information over multiple pages. The most appealing example of such a custom constant is a database connection string, but you can probably think of dozens more from your own experience.

The common denominator of these constants is that you want to retrieve their values programmatically from your code. The Web.config file provides the possibility to do so, but as a security measure, these constants have to be included in the section group. Just like , is a direct child tag of the Web.config's configuration root.

A typical custom section group would look something like this:

The example shows that keys and values can be included in the custom application settings via an tag. The way to access such a value in any of your Web pages is illustrated below:

ConfigurationSettings.AppSettings("sqlConn")

Yes, it's as easy as that! Note that the value of these settings is always a String format.
A Few Other Issues

I won't go into them here, but the Web.config file can contain several other section groups besides the aforementioned system.web and appSettings, such as the configSettings group.

* A Web application can contain more than one Web.config file. The settings in a file apply to the directory in which it's located, and all child directories. Web.config files in child directories take precedence over the settings that are specified in parent directories.
* Web.config files are protected by IIS, so clients cannot get to them. If you try to retrieve an existing http://mydomain.com/Web.config file, you'll be presented with an "Access denied" error message.
* IIS monitors the Web.config files for changes and caches the contents for performance reasons. There's no need to restart the Web server after you modify a Web.config file.

Introduction to ADO.Net

2010-03-08T23:08:00.000-08:00

In any .NET data access page, before you connect to a database, you first have to import all the necessary namespaces that will allow you to work with the objects required. As we're going to work with SQL Server, we'll first import the namespaces we need. Namespaces in .NET are simply a neat and orderly way of organizing objects, so that nothing becomes ambiguous.

<%@ Import Namespace="System" %>
<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.Data.SqlClient" %>

Note: If we were using a database other than SQL, for instance, MS Access, we would then replace the SQLClient with OleDb. If we use Oracle, .NET v 1.1 provides the System.Data.OracleClient namespace, and for any ODBC data source it provides the System.Data.Odbc namespace. You'll find detailed information on all the available methods and objects we'll discuss in the .NET SDK Framework documentation.

Connection:

After we import all the necessary namespaces, we're ready to connect to our database. Now, whether you implement the DataReader or Dataset, your initial database connection will still be as follows:

SqlConnection objConnect = new SqlConnection (Your Connection String);

objConnect.Open();

Methods:

.Open - Opens the connection to our database
.Close - Closes the database connection
.Dispose - Releases the resources on the connection object. Used to force garbage collecting, ensuring no resources are being held after our connection is used.

DataReader:

Used to read the data from the database table.The four Execute methods all pertain to an action performed by the Command object, wile the remaining methods are used to enhance the Command object's own functionality.

. ExecuteReader - Simply executes the SQL query against the database, using the Read() method to traverse through data, as illustrated below
. ExecuteNonQuery - Used whenever you work with SQL stored procedures with parameters, as illustrated in the Stored Procedures section below
. ExecuteScalar - Returns a lightning fast single value as an object from your database Ex. object val = Command.ExecuteScalar(); Then check if != null.
. ExecuteXmlReader - Executes the SQL query against SQL Server only, while returning an XmlReader object. See .NET documentation for more information.

Example:

SqlCommand objCommand = new SqlCommand(Sql String, objConnect);
SqlDataReader objDataReader = objCommand.ExecuteReader();
while (objDataReader.Read() == true)
{
Response.Write (objDataReader[0].ToString() + "
");
}

DataReader Methods:

. Read - Moves the record pointer to the first row, which allows the data to be read by column name or index position. Can check for data existence with conditional, if (DataReader.Read() = true)
. HasRows - New only with .NET v1.1. HasRows checks if any data exists, and is used instead of the Read method. Ex. if (DataReader.HasRows).
. IsClosed - A method that can determine if the DataReader is closed. Ex. if (DataReader.IsClosed == false)

Stored Procedures:

The Datareader itself, as with the DataSet, is more than capable of dealing with Stored Procedures; they offer plenty of performance advantages and the ability to consolidate many operations in one location. However, the Dataset's approach to Stored Procedures tends to become a little drawn-out, as it follows closely with the data manipulation model that the Dataset offers. When it comes to quick and straightforward Stored Procedure handling, the DataReader's Command Object methods are more than sufficient, as we'll see now.

We begin by creating a trivial stored procedure that accepts one parameter - @txt, which is passed into my query

CREATE PROCEDURE ShowSuppliers (
@txt varchar(50)
)
AS
Select CompanyName, City, Country from Suppliers Where
Country like "%" + @txt + "%"

If you wanted to simply execute a Stored Procedure, pass it a value, and then read through that, how would you do it? Easy! Prior to calling the ExecuteReader method, replace the SQL String in the SqlCommand constructor with the name of the Stored Procedure, then specify to the Command Object's CommandType Property that you're working with a Stored Procedure. After you've done this, implement the Parameters collection (via the Param SqlParameter variable) to set up the value you wish to pass to your stored procedure, like so:

SqlCommand objCommand = new SqlCommand("ShowSuppliers",
objConnect);
objCommand.CommandType = CommandType.StoredProcedure;

SqlDataReader objDataReader = objCommand.ExecuteReader
(CommandBehavior.CloseConnection);

SqlParameter Param = objCommand.Parameters.Add("@txt",
SqlDbType.VarChar, 50);
Param.Value = "US";

// ... Get Data

Stored Procedures - and Alternative Method

An alternative method of working with Stored Procedures within this context is the Command.ExecuteNonQuery() method. This is useful when working with more multifaceted Stored Procedures that have input, output and return values. Using them is not that much more complicated; simply implement the Parameters collection shown below, i.e. Param.Direction = ParameterDirection.Input or .OutPut or .ReturnValue; and apply the .Value =, whatever the value type:

CREATE PROCEDURE ShowSuppliers (
@txt varchar(50),
@Name varchar (50) output,
@Company varchar (50) output,
@Country varchar (50) output
)
AS
Select @Name = ContactName, @Company = CompanyName,
@Country = Country from Suppliers Where Country like "%" + @txt + "%"
GO

Here we've created a slightly more elaborate Stored Procedure to illustrate the ExecuteQuery method. As you can see, this not only contains our initial search word variable - @txt, but we could now obtain several output values.

// ... Database Connection / Command here like above

SqlParameter Param = objCommand.Parameters.Add("@txt",
SqlDbType.VarChar, 50);
Param.Direction = ParameterDirection.Input;
Param.Value = "US";

Param = objCommand.Parameters.Add("@Name", SqlDbType.VarChar,50);
Param.Direction = ParameterDirection.Output;

Param = objCommand.Parameters.Add("@Company", SqlDbType.VarChar,50);
Param.Direction = ParameterDirection.Output;

Param = objCommand.Parameters.Add("@Country", SqlDbType.VarChar,50);
Param.Direction = ParameterDirection.Output;

objCommand.ExecuteNonQuery();

Response.Write (objCommand.Parameters["@Name"]
.Value.ToString() + "
");
Response.Write (objCommand.Parameters["@Company"]
.Value.ToString() + "
");
Response.Write (objCommand.Parameters["@Country"]
.Value.ToString() + "
");

The only thing here that's dissimilar from our last Sproc example is the fact that we've just added a new Parameter Direction to reflect the values we wish to retrieve. In turn, we Response.Write them in the way shown here.

DataSet:

The DataSet can be thought of as an in-memory storage container for all your data. It allows us far more capability and power over the manipulation and presentation of our data, even extending to XML. Here, the DataAdapter acts as the intermediary object responsible for joining our database with our DataSet, as the Command Object is with the DataReader.

When working with Datasets, we would use the DataAdapter to do the querying, and the Fill() method to populate our DataSet with results:

SqlDataAdapter objDataAdapter = new SqlDataAdapter ("Select
CompanyName, ContactName, City, Country, Region from
Suppliers", objConnect);

DataSet objDS = new DataSet();

objDataAdapter.Fill (objDS);

Dataview:

By using a DataView we can create different views on our Dataset's DataTable, which enables us to filter or sort the data. To do this, you'd assign your DataGrid's Datasource property to the DataView, then bind it.

DataView objView = objDS.Tables[0].DefaultView;

objView.RowFilter = "Country like '%US%'";

or

objView.Sort = "Country asc";

MyDataGrid.DataSource = objView;

MyDataGrid.DataBind();

Application Life Cycle in General

2010-02-16T10:02:00.000-08:00

1. User requests an application resource from the Web server:

The life cycle of an ASP.NET application starts with a request sent by a browser to the Web server (for ASP.NET applications, typically IIS). ASP.NET is an ISAPI extension under the Web server. When a Web server receives a request, it examines the file-name extension of the requested file, determines which ISAPI extension should handle the request, and then passes the request to the appropriate ISAPI extension. ASP.NET handles file name extensions that have been mapped to it, such as .aspx, .ascx, .ashx, and .asmx.

2. ASP.NET receives the first request for the application:

When ASP.NET receives the first request for any resource in an application, a class named ApplicationManager creates an application domain. Application domains provide isolation between applications for global variables and allow each application to be unloaded separately. Within an application domain, an instance of the class named HostingEnvironment is created, which provides access to information about the application such as the name of the folder where the application is stored.

3. ASP.NET core objects are created for each request:

After the application domain has been created and the HostingEnvironment object instantiated, ASP.NET creates and initializes core objects such as HttpContext, HttpRequest, and HttpResponse. The HttpContext class contains objects that are specific to the current application request, such as the HttpRequest and HttpResponse objects. The HttpRequest object contains information about the current request, including cookies and browser information. The HttpResponse object contains the response that is sent to the client, including all rendered output and cookies.

4. An HttpApplication object is assigned to the request:

After all core application objects have been initialized, the application is started by creating an instance of the HttpApplication class. If the application has a Global.asax file, ASP.NET instead creates an instance of the Global.asax class that is derived from the HttpApplication class and uses the derived class to represent the application.

Asp.Net2.0 Page Life Cycle

2010-02-16T09:23:00.001-08:00

When an ASP.NET page runs, the page goes through a life cycle in which it performs a series of processing steps. These include initialization, instantiating controls, restoring and maintaining state, running event handler code, and rendering.

Page Events:

PreInit :

Use this event for the following:

·Check the IsPostBack property to determine whether this is the first time the page is being processed.
·Create or re-create dynamic controls.· Set a master page dynamically.
·Set the Theme property dynamically.
·Read or set profile property values.

Init :

Raised after all controls have been initialized and any skin settings have been applied. Use this event to read or initialize control properties.

Load :

The Page calls the OnLoad event method on the Page, then recursively does the same for each child control, which does the same for each of its child controls until the page and all controls are loaded.Use the OnLoad event method to set properties in controls and establish database connections.

PreRender :

The PreRender event occurs for each control on the page. Use the event to make final changes to the contents of the page or its controls.

Unload :

This event occurs for each control and then for the page. In controls, use this event to do final cleanup for specific controls, such as closing control-specific database connections.

Asp.Net Security

2009-11-22T04:28:00.000-08:00

The .Net provides two security mechanism for asp.net application

1. Windows Authentication
2. Form Authentication

Before going to have look on above security types, we will look into some basic
terms that we used during this topic,

1. Authentication
2. Authorisation

Authentication : Validating User Credentials [User name & Password]
Authorization : Determines whether authenticated user has the permission to access the requested resource.

Windows Authentication :

When asp.net application configured with 'Windows Authentication', Then it relies on IIS to authenticate its Clients using authentication types supported by the IIS.

After Successfully authenticating user, IIS passes 'Windows Token' represents the authenticated user to the Asp.Net worker process.

IIS Authentication Modes:

1. Anonymous authentication
2. Basic authentication
3. Integrated Windows authentication

Anonymous authentication :

If you do not need to authenticate your clients then you can configure IIS to allow anonymous access. In this event, IIS creates a Windows token to represent all anonymous users with the same anonymous (or guest) account. The default anonymous account is IUSR_MACHINENAME.

Basic authentication :

Basic authentication requires the user to supply credentials in the form of a user name and password to prove their identity.

Integrated Windows :

Integrated Windows authentication (formerly called NTLM, and also known as Windows NT Challenge/Response authentication) uses either Kerberos v5 authentication or NTLM authentication, depending upon the client and server configuration.

IF Your ASP.NET Web application is running under the NetworkService account or a custom domain account. If your application runs under a local account, such as the ASP.NET account on Windows 2000 Server, then NTLM authentication will be used.

Windows Authentication :

The WindowsAuthenticationModule class is activated when the following element is in the Web.config file

The WindowsAuthenticationModule class is responsible for creating WindowsPrincipal and WindowsIdentity objects to represent the authenticated user, and for attaching these objects to the current Web request.

Tracking code to my website

2008-12-17T04:57:00.000-08:00

Please refer the following URL:

http://www.google.com/support/googleanalytics/bin/answer.py?answer=55488&topic=11126

Send SMS from a trigger

2008-12-17T04:45:00.000-08:00

-- given a sample table:
CREATE TABLE [dbo].[TestTriggerSMS]
(
[test_field] [varchar] (50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL
) ON [PRIMARY]

go

-- **************************************************
create trigger tr_Update_TestTriggerSMS on [dbo].[TestTriggerSMS]
for update
as
set nocount on

declare @rows int
select @rows = count(*) from inserted

-- send notification if TestTriggerSMS table is being updated

if @rows=1 -- notification only if update 1 row
begin
if update(test_field) -- notification only if update [test_field] field
begin
print ' [test_field] field updated'
declare @old_value varchar(50)
, @new_value varchar(50)

declare @tab char(1)
set @tab = char(9)

declare @message varchar(555)

set @old_value = (select test_field from deleted)
set @new_value = (select test_field from inserted)

set @message = 'TestTriggerSMS updated:' + char(13) +
'Old Value ' + @tab + @tab + '[' + @old_value + ']'+ char(13) +
'New Value ' + @tab + @tab + '[' + @new_value + ']'

exec master.dbo.xp_sendmail @recipients = 'siccolo_mobile_management@yahoo.com'
, @message = @message
, @subject = 'TestTriggerSMS updated!'

-- send SMS to cell phone --
/*
Teleflip.com now provides SMS service.
To use teleflip just email the SMS message to the following email address:
<10 digit cell number>@teleflip.com
-- or --
T-Mobile: phonenumber@tmomail.net
Virgin Mobile: phonenumber@vmobl.com
Cingular: phonenumber@cingularme.com
Sprint: phonenumber@messaging.sprintpcs.com
Verizon: phonenumber@vtext.com
Nextel: phonenumber@messaging.nextel.com

where phonenumber = your 10 digit phone number
*/
exec master.dbo.xp_sendmail @recipients = '4108441212@cingularme.com'
, @message = @message
, @subject = 'TestTriggerSMS updated!'
end
end

set nocount off
go

JavaScript Events

2008-12-11T23:05:00.000-08:00

Form Events

blur - The input focus was lost.
change - An element lost the focus since it was changed.
focus - The input focus was obtained.
reset - The user reset the object, usually a form.
select - Some text is selected
submit - The user submitted an object, usually a form

Image Events

abort - A user action caused an abort.
error - An error occurred.
load - The object was loaded.

Image Map Events

mouseOut - The mouse is moved from on top a link.
mouseOver - The mouse is moved over a link.

Link Events

click - An object was clicked.
mouseOut - The mouse is moved from on top a link.
mouseOver - The mouse is moved over a link.

Window Events

blur - The input focus was lost.
error - An error occurred.
focus - The input focus was obtained.
load - The object was loaded.
unload - The object was exited.

Asynchronous Calls in asp.net2.0

2008-12-11T22:50:00.000-08:00

.Net Framework 2.0 makes life so easy with asynchronous calls from pages. I remember in asp.net1.x we had to do so much to achieve the same behaviour, but we are lucky that in asp.net2.0 its very easy.
Again there are more than one ways to implement asynchronous calls in asp.net2.0 and you may be asking which pattern to use.
The first way is to use the AddOnPreRenderCompleteAsync
AddOnPreRenderCompleteAsync (
new BeginEventHandler(BeginAsyncMethod),
new EndEventHandler (EndAsyncMethod)
);

The second way is to use the PageAsyncTask and RegisterAsyncTask
PageAsyncTask task = new PageAsyncTask(
new BeginEventHandler(BeginAsyncMethod),
new EndEventHandler(EndAsyncMethod),
new EndEventHandler(TimeoutAsyncMethod), null
);

RegisterAsyncTask(task);

The second way is preferrably better as it has the following advantages over the first way.
• RegisterAsyncTask also take an additional parameter for timeout.
• More than one RegisterAsyncTask can be called in one Request.
• The fourth parameter of RegisterAsyncTask can take state of the Begin Method.
• To the End the Timeout Method RegisterAsynTask gives you handy objects (ie HttpContext.Current, impersonation and culture).

Remember to put Async="true" attribute in the @ Page directive for any of the preferred methods mentioned above.
Also for Webservices we can use this following pattern:
theproxy.MyMethodCompleted += new MyMethodCompletedEventHandler (OnMyMethodCompleted);
theproxy.MyMethodAsync (...);

void OnMyMethodCompleted (Object source, MyMethodCompletedEventArgs e)
{
// This is called when MyMethod completes
}

Tips to improve Performance of Web Application

2008-12-11T22:31:00.000-08:00

In Web.config

1. Turn off Tracing unless until required.

2. Turn off session state in web.config file or at least for a page if there is no sessions.

3. set debug=false

4. Increase the Pool "Packet size" for transferring large blob or image fields

5. Disable View State of a Page or Datagrid if possible.

6. Use Response.Redirect (".aspx",false) instead of response.redirect(".aspx"). It

Reduces CLR Exceptions count.

7. String Builder in place of string when ever needed

8. Avoid Throwing Exceptions. It is very expensive.

9. Avoid Recursive Functions / Nested Loops

10. Enable Option Strict and Option Explicit for your pages.

11. Avoid unnecessary round trips to the server

12. Precompiling pages and disabling AutoEventWireup

13. Use "For each" Instead of For.

14. Explicitly Close Connections