MAVRA - Digital Technology

How to Format Date/Time - SQL Server

2014-05-03T16:34:00.002+03:00

Sometimes I can't find a better way to present something then through a series of code/exmaples, so, without much addoo:

- Microsoft SQL Server T-SQL date and datetime formats

- Date time formats - mssql datetime 

- MSSQL getdate returns current system date and time in standard internal format

SELECT convert(varchar, getdate(), 100) - mon dd yyyy hh:mmAM (or PM)

                                        - Oct  2 2008 11:01AM          

SELECT convert(varchar, getdate(), 101) - mm/dd/yyyy - 10/02/2008                  

SELECT convert(varchar, getdate(), 102) - yyyy.mm.dd - 2008.10.02           

SELECT convert(varchar, getdate(), 103) - dd/mm/yyyy

SELECT convert(varchar, getdate(), 104) - dd.mm.yyyy

SELECT convert(varchar, getdate(), 105) - dd-mm-yyyy

SELECT convert(varchar, getdate(), 106) - dd mon yyyy

SELECT convert(varchar, getdate(), 107) - mon dd, yyyy

SELECT convert(varchar, getdate(), 108) - hh:mm:ss

SELECT convert(varchar, getdate(), 109) - mon dd yyyy hh:mm:ss:mmmAM (or PM)

                                        - Oct  2 2008 11:02:44:013AM   

SELECT convert(varchar, getdate(), 110) - mm-dd-yyyy

SELECT convert(varchar, getdate(), 111) - yyyy/mm/dd

SELECT convert(varchar, getdate(), 112) - yyyymmdd

SELECT convert(varchar, getdate(), 113) - dd mon yyyy hh:mm:ss:mmm

                                        - 02 Oct 2008 11:02:07:577     

SELECT convert(varchar, getdate(), 114) - hh:mm:ss:mmm(24h)

SELECT convert(varchar, getdate(), 120) - yyyy-mm-dd hh:mm:ss(24h)

SELECT convert(varchar, getdate(), 121) - yyyy-mm-dd hh:mm:ss.mmm

SELECT convert(varchar, getdate(), 126) - yyyy-mm-ddThh:mm:ss.mmm

                                        - 2008-10-02T10:52:47.513

- SQL create different date styles with t-sql string functions

SELECT replace(convert(varchar, getdate(), 111), -/-, - -) - yyyy mm dd

SELECT convert(varchar(7), getdate(), 126)                 - yyyy-mm

SELECT right(convert(varchar, getdate(), 106), 8)          - mon yyyy

----

- SQL Server date formatting function - convert datetime to string

----

- SQL datetime functions

- SQL Server date formats

- T-SQL convert dates

- Formatting dates sql server

CREATE FUNCTION dbo.fnFormatDate (@Datetime DATETIME, @FormatMask VARCHAR(32))

RETURNS VARCHAR(32)

AS

BEGIN

    DECLARE @StringDate VARCHAR(32)

    SET @StringDate = @FormatMask

    IF (CHARINDEX (-YYYY-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -YYYY-,

                         DATENAME(YY, @Datetime))

    IF (CHARINDEX (-YY-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -YY-,

                         RIGHT(DATENAME(YY, @Datetime),2))

    IF (CHARINDEX (-Month-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -Month-,

                         DATENAME(MM, @Datetime))

    IF (CHARINDEX (-MON-,@StringDate COLLATE SQL_Latin1_General_CP1_CS_AS)>0)

       SET @StringDate = REPLACE(@StringDate, -MON-,

                         LEFT(UPPER(DATENAME(MM, @Datetime)),3))

    IF (CHARINDEX (-Mon-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -Mon-,

                                     LEFT(DATENAME(MM, @Datetime),3))

    IF (CHARINDEX (-MM-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -MM-,

                  RIGHT(-0-+CONVERT(VARCHAR,DATEPART(MM, @Datetime)),2))

    IF (CHARINDEX (-M-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -M-,

                         CONVERT(VARCHAR,DATEPART(MM, @Datetime)))

    IF (CHARINDEX (-DD-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -DD-,

                         RIGHT(-0-+DATENAME(DD, @Datetime),2))

    IF (CHARINDEX (-D-,@StringDate) > 0)

       SET @StringDate = REPLACE(@StringDate, -D-,

                                     DATENAME(DD, @Datetime))   

RETURN @StringDate

END

GO

- Microsoft SQL Server date format function test

- MSSQL formatting dates

SELECT dbo.fnFormatDate (getdate(), -MM/DD/YYYY-)           - 01/03/2012

SELECT dbo.fnFormatDate (getdate(), -DD/MM/YYYY-)           - 03/01/2012

SELECT dbo.fnFormatDate (getdate(), -M/DD/YYYY-)            - 1/03/2012

SELECT dbo.fnFormatDate (getdate(), -M/D/YYYY-)             - 1/3/2012

SELECT dbo.fnFormatDate (getdate(), -M/D/YY-)               - 1/3/12

SELECT dbo.fnFormatDate (getdate(), -MM/DD/YY-)             - 01/03/12

SELECT dbo.fnFormatDate (getdate(), -MON DD, YYYY-)         - JAN 03, 2012

SELECT dbo.fnFormatDate (getdate(), -Mon DD, YYYY-)         - Jan 03, 2012

SELECT dbo.fnFormatDate (getdate(), -Month DD, YYYY-)       - January 03, 2012

SELECT dbo.fnFormatDate (getdate(), -YYYY/MM/DD-)           - 2012/01/03

SELECT dbo.fnFormatDate (getdate(), -YYYYMMDD-)             - 20120103

SELECT dbo.fnFormatDate (getdate(), -YYYY-MM-DD-)           - 2012-01-03

- CURRENT_TIMESTAMP returns current system date and time in standard internal format

SELECT dbo.fnFormatDate (CURRENT_TIMESTAMP,-YY.MM.DD-)      - 12.01.03

GO

----

/***** SELECTED SQL DATE/DATETIME FORMATS WITH NAMES *****/

- SQL format datetime

- Default format: Oct 23 2006 10:40AM

SELECT [Default]=CONVERT(varchar,GETDATE(),100)

- US-Style format: 10/23/2006

SELECT [US-Style]=CONVERT(char,GETDATE(),101)

- ANSI format: 2006.10.23

SELECT [ANSI]=CONVERT(char,CURRENT_TIMESTAMP,102)

- UK-Style format: 23/10/2006

SELECT [UK-Style]=CONVERT(char,GETDATE(),103)

- German format: 23.10.2006

SELECT [German]=CONVERT(varchar,GETDATE(),104)

- ISO format: 20061023

SELECT ISO=CONVERT(varchar,GETDATE(),112)

- ISO8601 format: 2008-10-23T19:20:16.003

SELECT [ISO8601]=CONVERT(varchar,GETDATE(),126)

----

- SQL Server datetime formats

- Century date format MM/DD/YYYY usage in a query

- Format dates SQL Server 2005

SELECT TOP (1)

      SalesOrderID,

      OrderDate = CONVERT(char(10), OrderDate, 101),

      OrderDateTime = OrderDate

FROM AdventureWorks.Sales.SalesOrderHeader

/* Result

SalesOrderID      OrderDate               OrderDateTime

43697             07/01/2001          2001-07-01 00:00:00.000

*/

- SQL update datetime column

- SQL datetime DATEADD

UPDATE Production.Product

SET ModifiedDate=DATEADD(dd,1, ModifiedDate)

WHERE ProductID = 1001

- MM/DD/YY date format

- Datetime format sql

SELECT TOP (1)

      SalesOrderID,

      OrderDate = CONVERT(varchar(8), OrderDate, 1),

      OrderDateTime = OrderDate

FROM AdventureWorks.Sales.SalesOrderHeader

ORDER BY SalesOrderID desc

/* Result

SalesOrderID      OrderDate         OrderDateTime

75123             07/31/04          2004-07-31 00:00:00.000

*/

- Combining different style formats for date & time

- Datetime formats

- Datetime formats sql

DECLARE @Date DATETIME

SET @Date = -2015-12-22 03:51 PM-

SELECT CONVERT(CHAR(10),@Date,110) + SUBSTRING(CONVERT(varchar,@Date,0),12,8)

- Result: 12-22-2015  3:51PM

- Microsoft SQL Server cast datetime to string

SELECT stringDateTime=CAST (getdate() as varchar)

- Result: Dec 29 2012  3:47AM

----

- SQL Server date and time functions overview

----

- SQL Server CURRENT_TIMESTAMP function

- SQL Server datetime functions

- local NYC - EST - Eastern Standard Time zone

- SQL DATEADD function - SQL DATEDIFF function

SELECT CURRENT_TIMESTAMP                        - 2012-01-05 07:02:10.577

- SQL Server DATEADD function

SELECT DATEADD(month,2,-2012-12-09-)            - 2013-02-09 00:00:00.000

- SQL Server DATEDIFF function

SELECT DATEDIFF(day,-2012-12-09-,-2013-02-09-)  - 62

- SQL Server DATENAME function

SELECT DATENAME(month,   -2012-12-09-)          - December

SELECT DATENAME(weekday, -2012-12-09-)          - Sunday

- SQL Server DATEPART function

SELECT DATEPART(month, -2012-12-09-)            - 12

- SQL Server DAY function

SELECT DAY(-2012-12-09-)                        - 9

- SQL Server GETDATE function

- local NYC - EST - Eastern Standard Time zone

SELECT GETDATE()                                - 2012-01-05 07:02:10.577

- SQL Server GETUTCDATE function

- London - Greenwich Mean Time

SELECT GETUTCDATE()                             - 2012-01-05 12:02:10.577

- SQL Server MONTH function

SELECT MONTH(-2012-12-09-)                      - 12

- SQL Server YEAR function

SELECT YEAR(-2012-12-09-)                       - 2012

----

- T-SQL Date and time function application

- CURRENT_TIMESTAMP and getdate() are the same in T-SQL

----

- SQL first day of the month

- SQL first date of the month

- SQL first day of current month - 2012-01-01 00:00:00.000

SELECT DATEADD(dd,0,DATEADD(mm, DATEDIFF(mm,0,CURRENT_TIMESTAMP),0))

- SQL last day of the month

- SQL last date of the month

- SQL last day of current month - 2012-01-31 00:00:00.000

SELECT DATEADD(dd,-1,DATEADD(mm, DATEDIFF(mm,0,CURRENT_TIMESTAMP)+1,0))

- SQL first day of last month

- SQL first day of previous month - 2011-12-01 00:00:00.000

SELECT DATEADD(mm,-1,DATEADD(mm, DATEDIFF(mm,0,CURRENT_TIMESTAMP),0))

- SQL last day of last month

- SQL last day of previous month - 2011-12-31 00:00:00.000

SELECT DATEADD(dd,-1,DATEADD(mm, DATEDIFF(mm,0,DATEADD(MM,-1,GETDATE()))+1,0))

- SQL first day of next month - 2012-02-01 00:00:00.000

SELECT DATEADD(mm,1,DATEADD(mm, DATEDIFF(mm,0,CURRENT_TIMESTAMP),0))

- SQL last day of next month - 2012-02-28 00:00:00.000

SELECT DATEADD(dd,-1,DATEADD(mm, DATEDIFF(mm,0,DATEADD(MM,1,GETDATE()))+1,0))

GO

- SQL first day of a month - 2012-10-01 00:00:00.000

DECLARE @Date datetime; SET @Date = -2012-10-23-

SELECT DATEADD(dd,0,DATEADD(mm, DATEDIFF(mm,0,@Date),0))

GO

- SQL last day of a month - 2012-03-31 00:00:00.000

DECLARE @Date datetime; SET @Date = -2012-03-15-

SELECT DATEADD(dd,-1,DATEADD(mm, DATEDIFF(mm,0,@Date)+1,0))

GO

- SQL first day of year 

- SQL first day of the year  -  2012-01-01 00:00:00.000

SELECT DATEADD(yy, DATEDIFF(yy,0,CURRENT_TIMESTAMP), 0)

- SQL last day of year  

- SQL last day of the year   - 2012-12-31 00:00:00.000

SELECT DATEADD(yy,1, DATEADD(dd, -1, DATEADD(yy,

                     DATEDIFF(yy,0,CURRENT_TIMESTAMP), 0)))

- SQL last day of last year

- SQL last day of previous year   - 2011-12-31 00:00:00.000

SELECT DATEADD(dd,-1,DATEADD(yy,DATEDIFF(yy,0,CURRENT_TIMESTAMP), 0))

GO

- SQL calculate age in years, months, days

- SQL table-valued function

- SQL user-defined function - UDF

- SQL Server age calculation - date difference

- Format dates SQL Server 2008

USE AdventureWorks2008;

GO

CREATE FUNCTION fnAge  (@BirthDate DATETIME)

RETURNS @Age TABLE(Years  INT,

                   Months INT,

                   Days   INT)

AS

  BEGIN

    DECLARE  @EndDate     DATETIME, @Anniversary DATETIME

    SET @EndDate = Getdate()

    SET @Anniversary = Dateadd(yy,Datediff(yy,@BirthDate,@EndDate),@BirthDate)

    INSERT @Age

    SELECT Datediff(yy,@BirthDate,@EndDate) - (CASE

                                                 WHEN @Anniversary > @EndDate THEN 1

                                                 ELSE 0

END), 0, 0

     UPDATE @Age     SET    Months = Month(@EndDate - @Anniversary) - 1

    UPDATE @Age     SET    Days = Day(@EndDate - @Anniversary) - 1

    RETURN

END

GO

- Test table-valued UDF

SELECT * FROM   fnAge(-1956-10-23-)

SELECT * FROM   dbo.fnAge(-1956-10-23-)

/* Results

Years       Months      Days

52          4           1

*/

----

- SQL date range between

----

- SQL between dates

USE AdventureWorks;

- SQL between

SELECT POs=COUNT(*) FROM Purchasing.PurchaseOrderHeader

WHERE OrderDate BETWEEN -20040301- AND -20040315-

- Result: 108

- BETWEEN operator is equivalent to >=-AND-.<=

SELECT POs=COUNT(*) FROM Purchasing.PurchaseOrderHeader

WHERE OrderDate

BETWEEN -2004-03-01 00:00:00.000- AND -2004-03-15  00:00:00.000-

/*

Orders with OrderDates

-2004-03-15  00:00:01.000-  - 1 second after midnight (12:00AM)

-2004-03-15  00:01:00.000-  - 1 minute after midnight

-2004-03-15  01:00:00.000-  - 1 hour after midnight

are not included in the two queries above.

*/

- To include the entire day of 2004-03-15 use the following two solutions

SELECT POs=COUNT(*) FROM Purchasing.PurchaseOrderHeader

WHERE OrderDate >= -20040301- AND OrderDate < -20040316-

- SQL between with DATE type (SQL Server 2008)

SELECT POs=COUNT(*) FROM Purchasing.PurchaseOrderHeader

WHERE CONVERT(DATE, OrderDate) BETWEEN -20040301- AND -20040315-

----

- Non-standard format conversion: 2011 December 14

- SQL datetime to string

SELECT [YYYY Month DD] =

CAST(YEAR(GETDATE()) AS VARCHAR(4))+ - -+

DATENAME(MM, GETDATE()) + - - +

CAST(DAY(GETDATE()) AS VARCHAR(2))

- Converting datetime to YYYYMMDDHHMMSS format: 20121214172638

SELECT replace(convert(varchar, getdate(),111),-/-,-) +

replace(convert(varchar, getdate(),108),-:-,-)

- Datetime custom format conversion to YYYY_MM_DD

select CurrentDate=rtrim(year(getdate())) + -_- +

right(-0- + rtrim(month(getdate())),2) + -_- +

right(-0- + rtrim(day(getdate())),2)

- Converting seconds to HH:MM:SS format

declare @Seconds int

set @Seconds = 10000

select TimeSpan=right(-0- +rtrim(@Seconds / 3600),2) + -:- +

right(-0- + rtrim((@Seconds % 3600) / 60),2) + -:- +

right(-0- + rtrim(@Seconds % 60),2)

- Result: 02:46:40

- Test result

select 2*3600 + 46*60 + 40

- Result: 10000

- Set the time portion of a datetime value to 00:00:00.000

- SQL strip time from date

- SQL strip time from datetime

SELECT CURRENT_TIMESTAMP ,DATEADD(dd, DATEDIFF(dd, 0, CURRENT_TIMESTAMP), 0)

- Results: 2014-01-23 05:35:52.793 2014-01-23 00:00:00.000

/*******

VALID DATE RANGES FOR DATE/DATETIME DATA TYPES

SMALLDATETIME date range:

January 1, 1900 through June 6, 2079

DATETIME date range:

January 1, 1753 through December 31, 9999

DATETIME2 date range (SQL Server 2008):

January 1,1 AD through December 31, 9999 AD

DATE date range (SQL Server 2008):

January 1, 1 AD through December 31, 9999 AD

*******/

- Selecting with CONVERT into different styles

- Note: Only Japan & ISO styles can be used in ORDER BY

SELECT TOP(1)

     Italy  = CONVERT(varchar, OrderDate, 105)

   , USA    = CONVERT(varchar, OrderDate, 110)

   , Japan  = CONVERT(varchar, OrderDate, 111)

   , ISO    = CONVERT(varchar, OrderDate, 112)

FROM AdventureWorks.Purchasing.PurchaseOrderHeader

ORDER BY PurchaseOrderID DESC

/* Results

Italy       USA         Japan       ISO

25-07-2004  07-25-2004  2004/07/25  20040725

*/

- SQL Server convert date to integer

DECLARE @Datetime datetime

SET @Datetime = -2012-10-23 10:21:05.345-

SELECT DateAsInteger = CAST (CONVERT(varchar,@Datetime,112) as INT)

- Result: 20121023

- SQL Server convert integer to datetime

DECLARE @intDate int

SET @intDate = 20120315

SELECT IntegerToDatetime = CAST(CAST(@intDate as varchar) as datetime)

- Result: 2012-03-15 00:00:00.000

----

- SQL Server CONVERT script applying table INSERT/UPDATE

----

- SQL Server convert date

- Datetime column is converted into date only string column

USE tempdb;

GO

CREATE TABLE sqlConvertDateTime   (

            DatetimeCol datetime,

            DateCol char(8));

INSERT sqlConvertDateTime (DatetimeCol) SELECT GETDATE()

UPDATE sqlConvertDateTime

SET DateCol = CONVERT(char(10), DatetimeCol, 112)

SELECT * FROM sqlConvertDateTime

- SQL Server convert datetime

- The string date column is converted into datetime column

UPDATE sqlConvertDateTime

SET DatetimeCol = CONVERT(Datetime, DateCol, 112)

SELECT * FROM sqlConvertDateTime

- Adding a day to the converted datetime column with DATEADD

UPDATE sqlConvertDateTime

SET DatetimeCol = DATEADD(day, 1, CONVERT(Datetime, DateCol, 112))

SELECT * FROM sqlConvertDateTime

- Equivalent formulation

- SQL Server cast datetime

UPDATE sqlConvertDateTime

SET DatetimeCol = DATEADD(dd, 1, CAST(DateCol AS datetime))

SELECT * FROM sqlConvertDateTime

GO

DROP TABLE sqlConvertDateTime

GO

/* First results

DatetimeCol                   DateCol

2014-12-25 16:04:15.373       20141225 */

/* Second results:

DatetimeCol                   DateCol

2014-12-25 00:00:00.000       20141225  */

/* Third results:

DatetimeCol                   DateCol

2014-12-26 00:00:00.000       20141225  */

----

- SQL month sequence - SQL date sequence generation with table variable

- SQL Server cast string to datetime - SQL Server cast datetime to string

- SQL Server insert default values method

DECLARE @Sequence table (Sequence int identity(1,1))

DECLARE @i int; SET @i = 0

DECLARE @StartDate datetime;

SET @StartDate = CAST(CONVERT(varchar, year(getdate()))+

                 RIGHT(-0-+convert(varchar,month(getdate())),2) + -01- AS DATETIME)

WHILE ( @i < 120)

BEGIN

      INSERT @Sequence DEFAULT VALUES

      SET @i = @i + 1

END

SELECT MonthSequence = CAST(DATEADD(month, Sequence,@StartDate) AS varchar)

FROM @Sequence

GO

/* Partial results:

MonthSequence

Jan  1 2012 12:00AM

Feb  1 2012 12:00AM

Mar  1 2012 12:00AM

Apr  1 2012 12:00AM

*/

----

----

- SQL Server Server datetime internal storage

- SQL Server datetime formats

----

- SQL Server datetime to hex

SELECT Now=CURRENT_TIMESTAMP, HexNow=CAST(CURRENT_TIMESTAMP AS BINARY(8))

/* Results

Now                     HexNow

2009-01-02 17:35:59.297 0x00009B850122092D

*/

- SQL Server date part - left 4 bytes - Days since 1900-01-01

SELECT Now=DATEADD(DAY, CONVERT(INT, 0x00009B85), -19000101-)

GO

- Result: 2009-01-02 00:00:00.000

- SQL time part - right 4 bytes - milliseconds since midnight

- 1000/300 is an adjustment factor

- SQL dateadd to Midnight

SELECT Now=DATEADD(MS, (1000.0/300)* CONVERT(BIGINT, 0x0122092D), -2009-01-02-)

GO

- Result: 2009-01-02 17:35:59.290

----

----

- String date and datetime date&time columns usage

- SQL Server datetime formats in tables

----

USE tempdb;

SET NOCOUNT ON;

- SQL Server select into table create

SELECT TOP (5)

      FullName=convert(nvarchar(50),FirstName+- -+LastName),

      BirthDate = CONVERT(char(8), BirthDate,112),

      ModifiedDate = getdate()

INTO Employee

FROM AdventureWorks.HumanResources.Employee e

INNER JOIN AdventureWorks.Person.Contact c

ON c.ContactID = e.ContactID

ORDER BY EmployeeID

GO

- SQL Server alter table

ALTER TABLE Employee ALTER COLUMN FullName nvarchar(50) NOT NULL

GO

ALTER TABLE Employee

ADD CONSTRAINT [PK_Employee] PRIMARY KEY (FullName )

GO

/* Results

Table definition for the Employee table

Note: BirthDate is string date (only)

CREATE TABLE dbo.Employee(

      FullName nvarchar(50) NOT NULL PRIMARY KEY,

      BirthDate char(8) NULL,

      ModifiedDate datetime NOT NULL

)

*/

SELECT * FROM Employee ORDER BY FullName

GO

/* Results

FullName                BirthDate   ModifiedDate

Guy Gilbert             19720515    2009-01-03 10:10:19.217

Kevin Brown             19770603    2009-01-03 10:10:19.217

Rob Walters             19650123    2009-01-03 10:10:19.217

Roberto Tamburello      19641213    2009-01-03 10:10:19.217

Thierry D-Hers          19490829    2009-01-03 10:10:19.217

*/

- SQL Server age

SELECT FullName, Age = DATEDIFF(YEAR, BirthDate, GETDATE()),

       RowMaintenanceDate = CAST (ModifiedDate AS varchar)

FROM Employee ORDER BY FullName

GO

/* Results

FullName                Age   RowMaintenanceDate

Guy Gilbert             37    Jan  3 2009 10:10AM

Kevin Brown             32    Jan  3 2009 10:10AM

Rob Walters             44    Jan  3 2009 10:10AM

Roberto Tamburello      45    Jan  3 2009 10:10AM

Thierry D-Hers          60    Jan  3 2009 10:10AM

*/

- SQL Server age of Rob Walters on specific dates

- SQL Server string to datetime implicit conversion with DATEADD

SELECT AGE50DATE = DATEADD(YY, 50, -19650123-)

GO

- Result: 2015-01-23 00:00:00.000

- SQL Server datetime to string, Italian format for ModifiedDate

- SQL Server string to datetime implicit conversion with DATEDIFF

SELECT FullName,

         AgeDEC31 = DATEDIFF(YEAR, BirthDate, -20141231-),

         AgeJAN01 = DATEDIFF(YEAR, BirthDate, -20150101-),

         AgeJAN23 = DATEDIFF(YEAR, BirthDate, -20150123-),

         AgeJAN24 = DATEDIFF(YEAR, BirthDate, -20150124-),

       ModDate = CONVERT(varchar, ModifiedDate, 105)

FROM Employee

WHERE FullName = -Rob Walters-

ORDER BY FullName

GO

/* Results

Important Note: age increments on Jan 1 (not as commonly calculated)

FullName    AgeDEC31    AgeJAN01    AgeJAN23    AgeJAN24    ModDate

Rob Walters 49          50          50          50          03-01-2009

*/

----

- SQL combine integer date & time into datetime

----

- Datetime format sql

- SQL stuff

DECLARE @DateTimeAsINT TABLE ( ID int identity(1,1) primary key, 

   DateAsINT int, 

   TimeAsINT int 

)

- NOTE: leading zeroes in time is for readability only!  

INSERT @DateTimeAsINT (DateAsINT, TimeAsINT) VALUES (20121023, 235959)  

INSERT @DateTimeAsINT (DateAsINT, TimeAsINT) VALUES (20121023, 010204)  

INSERT @DateTimeAsINT (DateAsINT, TimeAsINT) VALUES (20121023, 002350)

INSERT @DateTimeAsINT (DateAsINT, TimeAsINT) VALUES (20121023, 000244)  

INSERT @DateTimeAsINT (DateAsINT, TimeAsINT) VALUES (20121023, 000050)  

INSERT @DateTimeAsINT (DateAsINT, TimeAsINT) VALUES (20121023, 000006)  

SELECT DateAsINT, TimeAsINT,

  CONVERT(datetime, CONVERT(varchar(8), DateAsINT) + - -+

  STUFF(STUFF ( RIGHT(REPLICATE(-0-, 6) + CONVERT(varchar(6), TimeAsINT), 6),

                  3, 0, -:-), 6, 0, -:-))  AS DateTimeValue

FROM   @DateTimeAsINT 

ORDER BY ID

GO

/* Results

DateAsINT   TimeAsINT   DateTimeValue

20121023    235959      2012-10-23 23:59:59.000

20121023    10204       2012-10-23 01:02:04.000

20121023    2350        2012-10-23 00:23:50.000

20121023    244         2012-10-23 00:02:44.000

20121023    50          2012-10-23 00:00:50.000

20121023    6           2012-10-23 00:00:06.000

*/

----

- SQL Server string to datetime, implicit conversion with assignment

UPDATE Employee SET ModifiedDate = -20150123-

WHERE FullName = -Rob Walters-

GO

SELECT ModifiedDate FROM Employee WHERE FullName = -Rob Walters-

GO

- Result: 2015-01-23 00:00:00.000

/* SQL string date, assemble string date from datetime parts  */

- SQL Server cast string to datetime - sql convert string date

- SQL Server number to varchar conversion

- SQL Server leading zeroes for month and day

- SQL Server right string function

UPDATE Employee SET BirthDate =

      CONVERT(char(4),YEAR(CAST(-1965-01-23- as DATETIME)))+

      RIGHT(-0-+CONVERT(varchar,MONTH(CAST(-1965-01-23- as DATETIME))),2)+

      RIGHT(-0-+CONVERT(varchar,DAY(CAST(-1965-01-23- as DATETIME))),2)

      WHERE FullName = -Rob Walters-

GO

SELECT BirthDate FROM Employee WHERE FullName = -Rob Walters-

GO

- Result: 19650123

- Perform cleanup action

DROP TABLE Employee

- SQL nocount

SET NOCOUNT OFF;

GO

----

----

- sql isdate function

----

USE tempdb;

- sql newid - random sort

SELECT top(3) SalesOrderID,

stringOrderDate = CAST (OrderDate AS varchar)

INTO DateValidation

FROM AdventureWorks.Sales.SalesOrderHeader

ORDER BY NEWID()

GO

SELECT * FROM DateValidation

/* Results

SalesOrderID      stringOrderDate

56720             Oct 26 2003 12:00AM

73737             Jun 25 2004 12:00AM

70573             May 14 2004 12:00AM

*/

- SQL update with top

UPDATE TOP(1) DateValidation

SET stringOrderDate = -Apb 29 2004 12:00AM-

GO

- SQL string to datetime fails without validation

SELECT SalesOrderID, OrderDate = CAST (stringOrderDate as datetime)

FROM DateValidation

GO

/* Msg 242, Level 16, State 3, Line 1

The conversion of a varchar data type to a datetime data type resulted in an

out-of-range value.

*/

- sql isdate - filter for valid dates

SELECT SalesOrderID, OrderDate = CAST (stringOrderDate as datetime)

FROM DateValidation

WHERE ISDATE(stringOrderDate) = 1

GO

/* Results

SalesOrderID      OrderDate

73737             2004-06-25 00:00:00.000

70573             2004-05-14 00:00:00.000

*/

- SQL drop table

DROP TABLE DateValidation

Go

----

- SELECT between two specified dates - assumption TIME part is 00:00:00.000

----

- SQL datetime between

- SQL select between two dates

SELECT EmployeeID, RateChangeDate

FROM AdventureWorks.HumanResources.EmployeePayHistory

WHERE RateChangeDate >= -1997-11-01- AND 

      RateChangeDate < DATEADD(dd,1,-1998-01-05-)

GO

/* Results

EmployeeID  RateChangeDate

3           1997-12-12 00:00:00.000

4           1998-01-05 00:00:00.000

*/

/* Equivalent to

- SQL datetime range

SELECT EmployeeID, RateChangeDate

FROM AdventureWorks.HumanResources.EmployeePayHistory

WHERE RateChangeDate >= -1997-11-01 00:00:00- AND 

      RateChangeDate <  -1998-01-06 00:00:00-

GO

*/

----

- SQL datetime language setting

- SQL Nondeterministic function usage - result varies with language settings

SET LANGUAGE  -us_english-;  -- Jan 12 2015 12:00AM 

SELECT US = convert(VARCHAR,convert(DATETIME,-01/12/2015-));

SET LANGUAGE  -British-;     -- Dec  1 2015 12:00AM 

SELECT UK = convert(VARCHAR,convert(DATETIME,-01/12/2015-));

SET LANGUAGE  -German-;      -- Dez  1 2015 12:00AM 

SET LANGUAGE  -Deutsch-;     -- Dez  1 2015 12:00AM 

SELECT Germany = convert(VARCHAR,convert(DATETIME,-01/12/2015-));

SET LANGUAGE  -French-;      -- d�c  1 2015 12:00AM 

SELECT France = convert(VARCHAR,convert(DATETIME,-01/12/2015-));

SET LANGUAGE  -Spanish-;     -- Dic  1 2015 12:00AM 

SELECT Spain = convert(VARCHAR,convert(DATETIME,-01/12/2015-));

SET LANGUAGE  -Hungarian-;   -- jan 12 2015 12:00AM 

SELECT Hungary = convert(VARCHAR,convert(DATETIME,-01/12/2015-));

SET LANGUAGE  -us_english-;

GO

----

----

- Function for Monday dates calculation

----

USE AdventureWorks2008;

GO

- SQL user-defined function

- SQL scalar function - UDF

CREATE FUNCTION fnMondayDate

               (@Year          INT,

                @Month         INT,

                @MondayOrdinal INT)

RETURNS DATETIME

AS

  BEGIN

    DECLARE  @FirstDayOfMonth CHAR(10),

             @SeedDate        CHAR(10)

    SET @FirstDayOfMonth = convert(VARCHAR,@Year) + --- + convert(VARCHAR,@Month) + --01-

    SET @SeedDate = -1900-01-01-

    RETURN DATEADD(DD,DATEDIFF(DD,@SeedDate,DATEADD(DD,(@MondayOrdinal * 7) - 1,

                  @FirstDayOfMonth)) / 7 * 7,  @SeedDate)

END

GO

- Test Datetime UDF

- Third Monday in Feb, 2015

SELECT dbo.fnMondayDate(2016,2,3)

- 2015-02-16 00:00:00.000

- First Monday of current month

SELECT dbo.fnMondayDate(Year(getdate()),Month(getdate()),1)

- 2009-02-02 00:00:00.000  

----

How To: Fixing DNS problems

2014-04-15T09:22:00.001+03:00

By TG Publishing TeamJanuary 13, 2003 10:00 AM

The inability to open a website by name usually indicates a DNS (Domain Name System) problem. DNS is the service that converts the website URL, i.e. www.yahoo.com into the IP address that is needed for actual communication.

A quick way to test this is to try to access the problem website via its IP address instead of its name. You can find a website’s IP address by opening a Windows MS-DOS or Command prompt and typing ping, followed by the website domain you are trying to reach (don’t type the www, though). Here’s an example using google.com :

C :\Windows>ping google.com

Pinging google.com [216.239.51.100] with 32 Bytes of data :

Reply from 216.239.51.100 : Bytes=32 time=267ms TTL=242
Reply from 216.239.51.100 : Bytes=32 time=261ms TTL=242
Reply from 216.239.51.100 : Bytes=32 time=256ms TTL=242
Reply from 216.239.51.100 : Bytes=32 time=252ms TTL=242

Ping statistics for 216.239.51.100 :
Packets : Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds :
Minimum = 252ms, Maximum = 267ms, Average = 259ms

You can see that 216.239.51.100 is google.com’s IP address, so now enter http://216.239.51.100/ into your web browser’s address or location box. If the website comes up, you’ve got a DNS problem.

Fixing DNS

The most common cause of the behavior described above is incorrect DNS settings in your computer’s TCP/IP properties. This typically happens after installing a hardwarerouter or Internet Sharing software like Windows’ Internet Connection Sharing feature. If your computer had its TCP/IP properties set manually (statically), you’re likely to have DNS-related problems.

The reason for the problem is that sharing devices (and programs) usually like to handle DNS duties as part of their sharing functions, and need to have computers that are connected to them set up to get their DNS services from the router (or sharing program) instead of your ISP. Even though most people follow the router setup instructions and change their network adapter TCP/IP settings to "Obtain an IP address automatically", they commonly may neglect to clear out the DNS settings, which in Win98 are located on the DNS Configuration tab of the Network Properties window. WinXP makes it harder to forget to clear any manual DNS settings that you may have, since it puts IP address, default gateway, and DNS settings in the same window.

Fixing the problem is easy. Here’s how for Win95 and 98 :

1) Right click on the Network Neighborhood icon on your desktop and choose Properties. A window similar to Figure 1 will open.

Figure 1 : Win98SE TCP/IP properties

2) Scroll down the window in the Configuration tab until you find the copy of TCP/IP that is bound (indicated by ->) to the network adapter that you are using to connect to your network. You should be able to recognize the correct adapter, since it will usually have some sort of manufacturer’s name in it. Click on the adapter to select, then click the Properties button. Another window similar to Figure 2 will appear.

3) The IP Address tab will probably have the Obtain an IP address automatically radio button selected. Click on the DNS Configuration tab.

Figure 2 : Win98SE DNS properties

4) Figure 2 shows that the old DNS settings (your will probably be different from the screenshot) are still in charge. Fix this by deleting all entries in the DNS Server Search Order box. Then click the Disable DNS button. While you’re at it, click on the Gateway tab, and make sure there are no entries there. Click the OK button to close the TCP/IP properties window, then click the OK button to close the Networkproperties window. Restart your system when prompted.

5) After the system restarts, it’s possible that your computer may still have old IP address information that can result in the same behavior as before. To force the system to get new IP address information click Start > Run and type winipcfg. Click the More Info button. Select your network adapter, click the Release button, wait until the information in the window is cleared, then click the Renew button. After a short delay you should see new information in the window. (This is called a DHCP Release / Renew.)

6) Now open your web browser and try your problem sites. The problem should be fixed. If it isn’t, see the What Else can be wrong ? section below.

Here’s the fix for WinXP :

1) Open the Network Connections Control Panel. Double click on the Local Area Connection icon in the LAN or High-Speed Internet section of the Network Connections window that opens. Click on the Properties button of the Local Area Connection Status window that opens. You should see another window similar to Figure 3 open.

Figure 3 : WinXP Local Area Connection properties

2) Click on the Internet Protocol (TCP/IP) item to select it and click the Properties button. A new window similar to Figure 4 should open.

Figure 4 : WinXP TCP/IP properties

3) All you need to do is click the Obtain DNS server address automatically button (the static DNS server information will automatically be cleared). Click OK in each of the TCP/IP and Local Area Connection properties windows to close them.

4) Once again, we want to be sure that we now have new IP address information. You should still have the Local Area Connection Status window open. Click the Support tab, then click the Repair button. After a short delay, you should get a repair completed popup and IP address information should reappear in the window. You’ll need to click the Details... button to see the DNS server information.

5) Now open your web browser and try your problem sites. The problem should be fixed. If it isn’t, see the What Else can be wrong ? section below.

What Else can be wrong ?

If only all problems were so straightforward ! But, unfortunately, bogus DNS settings in your computers aren’t always the problem. Here are some other possible causes and actions to take if you’re having problems accessing certain websites :

ISP DNS problems
If things were working correctly with your exact same network setup, and then mysteriously stopped working, it’s possible that your ISP’s DNS servers are having problems. Contact your ISP’s tech support to report the problem and ask them to fix it !

Proxy problems

This also tends to fall into the ISP problem category. Some ISPs (AOL for example) make all their subscribers run through a proxy server. Proxies sit between you and the actual Internet and are used both to locally store (cache) content that doesn’t change very often and, in some cases, prevent access to certain websites and web services. Most of the time proxies operate without your knowing they’re even there, but sometimes they get confused and cause problems.

You can see if you’re using a proxy by checking the Internet Options Control Panel, selecting the Connections tab, and clicking the LAN Settings... button. If any of the checkboxes are checked on the window that opens, you’re probably using a proxy. You can try clearing the checkboxes (write down the settings first or grab a screenshot), then quitting and restarting your browser and see if that helps. But if your ISP requires use of a proxy and doesn’t allow you to bypass it, this won’t help. Again, your option will be to contact your ISP’s support and tell them your problem.

Content filtering
Although more popular in work-settings, content or website filtering is also available on a simpler basis for consumer router and Internet sharing applications. This function allows particular domains or website pages to be blocked to some, or all users. In many cases you won’t get an indication that the web page you’re trying to reach is being blocked and the router will just hang.

Again, if you don’t control your Internet access, there’s not much you can do about this one. A web-browsing proxy service may get you past any filters set up by Mom or Dad, but savvy network admins will probably have those websites blocked too.

A COMPARISON OF MICROSOFT'S C# PROGRAMMING LANGUAGE TO SUN MICROSYSTEMS' JAVA PROGRAMMING LANGUAGE

2014-04-12T15:30:00.003+03:00

By: Dare Obasanjo

Introduction

The C# language is an object-oriented language that is aimed at enabling programmers to quickly build a wide range of applications for the Microsoft .NET platform. The goal of C# and the .NET platform is to shorten development time by freeing the developer from worrying about several low level plumbing issues such as memory management, type safety issues, building low level libraries, array boundschecking , etc. thus allowing developers to actually spend their time and energy working on their application and business logic instead. As a Java developer the previous sentence could be described as "a short description of the Java language and platform" if the words C# and the .NET platform were replaced with words Java and the Java platform.
What follows is an overview of similarities and differences between the language features and libraries of the C# and Java programming languages based on my experience using both languages. All code snippets below were tested on Microsoft's .NET Framework version 2.0 for C# snippets and Java™ Platform, Standard Edition version 6 for the Java snippets.
Quick Index

The More Things Change The More They Stay The Same
This section describes concepts and language features that are almost exactly the same in C# and Java.
The Same But Different
This section describes concepts and language features that differ either only in syntax or in some similarly minor manner between C# and Java.
An Ever So Slight Feeling of D¨¨j¨¤ Vu
This section describes concepts and language features that exist in C# that are similar to those that exist in Java but with a significant difference.
Now For Something Completely Different
This section describes language features and concepts that exist in C# and have no Java counterpart.
Wish You Were Here
This section describes language features and concepts that exist in Java and have no C# counterpart.
Conclusion(2001)
Conclusion (2007)
Resources
Acknowledgements

The More Things Change The More They Stay The Same

We Are All Objects
Just like Java, C# has a single rooted class hierarchy where all classes in C# are subclasses of System.Object the same way all Java classes are subclasses of java.lang.Object. The methods of the two languages' Object classes share some similarities (e.g. System.Object's ToString() to java.lang.Object's toString()) and differences (System.Object does not have analogs to wait(), notify() or notifyAll() in java.lang.Object).

NOTE: In C#, the object class can either be written as object or Object. The lower case "object" is a C# keyword which is replaced with the class name "System.Object" during compilation.

Keyword Jumble

There are a large number of syntactic similarities between Java and C#, similarly almost every Java keyword has a C# equivalent except for a few like transient, throws and strictfp. Below is a table of Java and C# keywords with the Java keywords in red while the equivalent C# keywords are in blue.

C# keyword	Java keyword	C# keyword	Java keyword	C# keyword	Java keyword	C# keyword	Java keyword
abstract	abstract	extern	native	operator	N/A	throw	throw
as	N/A	false	false	out	N/A	true	true
base	super	finally	finally	override	N/A	try	try
bool	boolean	fixed	N/A	params	...	typeof	N/A
break	break	float	float	partial	N/A	uint	N/A
byte	N/A	for	for	private	private	ulong	N/A
case	case	foreach	for	protected	N/A	unchecked	N/A
catch	catch	get	N/A	public	public	unsafe	N/A
char	char	goto	goto¹	readonly	N/A	ushort	N/A
checked	N/A	if	if	ref	N/A	using	import
class	class	implicit	N/A	return	return	value	N/A
const	const¹	in	N/A	sbyte	byte	virtual	N/A
continue	continue	int	int	sealed	final	void	void
decimal	N/A	interface	interface	set	N/A	volatile	volatile
default	default	internal	protected	short	short	where	extends
delegate	N/A	is	instanceof	sizeof	N/A	while	while
do	do	lock	synchronized	stackalloc	N/A	yield	N/A
double	double	long	long	static	static	:	extends
else	else	namespace	package	string	N/A	:	implements
enum	N/A	new	new	struct	N/A	N/A	strictfp
event	N/A	null	null	switch	switch	N/A	throws
explicit	N/A	object	N/A	this	this	N/A	transient²

NOTE: Although goto and const are Java language keywords they are unused in the Java language.
NOTE: The [NonSerialized] attribute in C# is equivalent to the transient keyword in Java.

Of Virtual Machines and Language Runtimes
Just like Java is typically compiled to Java byte code which then runs in managed execution environment (the Java Virtual Machine or JVM) so also is C# code compiled to an Intermediate Language (IL) which then runs in the Common Language Runtime (CLR). Both platforms support native compilation via Just In Time compilers.

NOTE: While the Java platform supports interpretation of byte code or byte code being JITed then run natively, the .NET platform only supports native execution of C# code because the IL code is always natively compiled before running.
Heap Based Classes and Garbage Collection
In Java objects are created on the heap using the new keyword. Most classes in C# are created on the heap by using the new keyword. Also just as the JVM manages the destruction of objects so also does the CLR via a Mark and Compact garbage collection algorithm

NOTE: C# also supports stack-based classes, called value types, which are discussed further below.
Arrays Can Be Jagged
In languages like C and C++, each subarray of a multidimensional array must have the same dimensions. In Java and C# arrays do not have to be uniform because jagged arrays can be created as one-dimensional arrays of arrays. In a jagged array the contents of the array are arrays which may hold instances of a type or references to other arrays. For this reason the rows and columns in a jagged array need not have uniform length as can be seen from the following code snippet:
```
 int [][]myArray = new int[2][]; 
  myArray[0] = new int[3]; 
  myArray[1] = new int[9];
```
The above code snippet is valid for both C# and Java.
No Global Methods
Just like Java and unlike C++, methods in C# have to be part of a class either as member or static methods.
Interfaces, Yes. Multiple Inheritance, No
C#, like Java, supports the concept of an interface which is akin to a pure abstract class. Similarly C# and Java both allow only single inheritance of classes but multiple inheritance (or implementation) of interfaces.
Strings Are Immutable
C# has a System.String class which is analogous to the java.lang.String class. Both classes are immutable meaning that the values of the strings cannot be changed once the strings have been created. In both instances methods that appear to modify the actual content of a string actually create a new string to return, leaving the original string unchanged. Thus the following C# and Java code does not modify the string in either case
```
C# Code
   String csString = "Apple Jack"; 
   csString.ToLower(); /* Does not modify string, instead returns lower case copy of string */ 

Java Code
   String jString = "Grapes"; 
   jString.toLowerCase(); /* Does not modify string, instead returns lower case copy of string */ 
```
To create a string-like object that allows modification in C# it is advisable to use the System.Text.StringBuilder class whereas in Java one would use the java.lang.StringBuffer class.

NOTE: In C#, the string class can either be written as string or String.
Unextendable Classes
Both Java and C# provide mechanisms to specify that a class should be the last one in an inheritance hierarchy and cannot be used as a base class. In Java this is done by preceding the class declaration with the final keyword while in C# this is done by preceding the class declaration with the sealed keyword. Below are examples of classes that cannot be extended in either language
```
C# Code
 sealed class Student {
   string fname;
   string lname;
   int uid;
   void attendClass() {}
} 

Java Code
 final class Student {
   String fname;
   String lname;
   int uid;
   void attendClass() {}
} 
```

Throwing and Catching Exceptions

Exceptions in C# and Java share a lot of similarities. Both languages support the use of the try block for indicating guarded regions, the catch block for handling thrown exceptions and the finally block for releasing resources before leaving the method. Both languages have an inheritance hierarchy where all exceptions are derived from a single Exception class. Exceptions can be caught and rethrown after some error handling occurs in both languages. Finally, both languages provide a mechanism for wrapping exceptions in one another for cases where a different exception is rethrown from the one that was caught. An example of using the exception wrapping capability is a three tier application where a SQLException is thrown during database access but is caught, examined, then an application specific exception is thrown. In this scenario the application specific exception can be initialized with the original SQLException so handlers of the application specific exception can access the original exception thrown if needed. Below are two equivalent code samples that show the similarities between exceptions in both languages.

NOTE: Although exceptions in both languages support methods for getting a stack trace, only Java exceptions have methods that allow one to alter the stack trace.

C# Code
using System;
using System.IO; 

class MyException: Exception{

  public MyException(string message): base(message){ }

  public MyException(string message, Exception innerException): 
    base(message, innerException){ }


}

public class ExceptionTest {
    
    
    static void DoStuff(){  
    throw new FileNotFoundException();  
    }
    
    
    public static void Main(string[] args){

    try{            

        try{        
        
        DoStuff(); 
        return;  //won't get to execute 

        }catch(IOException ioe){ /* parent of FileNotFoundException */ 
        
        throw new MyException("MyException occured", ioe); /* rethrow new exception with inner exception specified */
        }
        
    }finally{
        
        Console.WriteLine("***Finally block executes even though MyException not caught***");
    
    }
    
}//Main(string[])

} // ExceptionTest

Java Code

class MyException extends Exception{

    public MyException(String message){ super(message); }
    
    public MyException(String message, Exception innerException){ super(message, innerException); }


}

public class ExceptionTest {
    
    
    static void doStuff(){  
    throw new ArithmeticException();    
    }
    
    
    public static void main(String[] args) throws Exception{
    
    try{            
        
        try{        
        
        doStuff(); 
        return;  //won't get to execute 
        
        }catch(RuntimeException re){ /* parent of ArithmeticException */ 
        
        throw new MyException("MyException occured", re); /* rethrow new exception with cause specified */
        }
        
    }finally{
        
        System.out.println("***Finally block executes even though MyException not caught***");
    
    }
    
}//main(string[])

} // ExceptionTest

Member Initialization at Definition and Static Constructors

Instance and static variables can be initialized at their point of definition in both C# and Java. If the member variable is an instance variable, then initialization occurs just before the constructor is called. Static members are initialized sometime before the first usage of the member and before the first creation of an instance of the class. It is also possible to specify a block of code that should run before the class is used either via creation of an instance variable or invocation of a static method. These code blocks are called are called static constructors in C# and static initialization blocks in Java. Static constructors are invoked before the first invocation of a static method in the class and before the first time an instance of the class is created.

C# Code
using System; 

class StaticInitTest{


    string instMember = InitInstance(); 

    string staMember = InitStatic(); 
    

    StaticInitTest(){
    Console.WriteLine("In instance constructor");
    }

    static StaticInitTest(){
    Console.WriteLine("In static constructor");
    }


    static String InitInstance(){
    Console.WriteLine("Initializing instance variable");
    return "instance";
    }

     static String InitStatic(){
    Console.WriteLine("Initializing static variable");
    return "static";
    }


    static void DoStuff(){
    Console.WriteLine("Invoking static DoStuff() method");
    }

    
    public static void Main(string[] args){

    Console.WriteLine("Beginning main()");

    StaticInitTest.DoStuff(); 
    
    StaticInitTest sti = new StaticInitTest(); 

    Console.WriteLine("Completed main()");

    }

}

Java Code
class StaticInitTest{


    String instMember = initInstance(); 

    String staMember = initStatic(); 
    

    StaticInitTest(){
    System.out.println("In instance constructor");
    }

    static{
    System.out.println("In static constructor");
    }


    static String initInstance(){
    System.out.println("Initializing instance variable");
    return "instance";
    }

     static String initStatic(){
    System.out.println("Initializing static variable");
    return "static";
    }


    static void doStuff(){
    System.out.println("Invoking static DoStuff() method");
    }

    
    public static void main(String[] args){

    System.out.println("Beginning main()");

    StaticInitTest.doStuff(); 
    
    StaticInitTest sti = new StaticInitTest(); 

    System.out.println("Completed main()");

    }

}


OUTPUT FROM BOTH EXAMPLES: 
In static constructor
Beginning main()
Invoking static DoStuff() method
Initializing instance variable
Initializing static variable
In instance constructor
Completed main()

Boxing

In situations where value types need to be treated as objects, the .NET and Java runtimes automatically converts value types to objects by wrapping them within a heap-allocated reference type in a process called boxing. The process of automatically convert an object to its corresponding value type such as converting an instance of java.lang.Integer to an int is known as unboxing. Below are examples of various situations where boxing occurs in both runtimes.



C# Code
using System; 
using System.Collections;

//stack allocated structs also need to be boxed to be treated as objects
struct Point{

  //member fields 
    private int x; 
    private int y; 

    public Point (int x, int y){
  
    this.x = x;
    this.y = y; 

    } 
    
    public override string ToString(){

    return String.Format("({0}, {1})", x, y); 

    }


}//Point

class Test{


     public static void PrintString(object o){

     Console.WriteLine(o);

     }

     public static void Main(string[] args){

       Point p = new Point(10, 15); 
       ArrayList list = new ArrayList(); 
       int z = 100;

       PrintString(p); //p boxed to object when passed to PrintString
       PrintString(z); //z boxed to object when passed to PrintString

       // integers and float boxed when stored in collection 
       // therefore no need for Java-like wrapper classes 
       list.Add(1); 
       list.Add(13.12); 
       list.Add(z); 
       
       for(int i =0; i < list.Count; i++)
       PrintString(list[i]);    
       
     }

}

Java Code
import java.util.*;

class Test{

public static void PrintString(Object o){

 System.out.println(o);

}

public static void PrintInt(int i){

 System.out.println(i); 
  
}

public static void main(String[] args){

 Vector list = new Vector(); 
 int z = 100;
 Integer x = new Integer(300);
 PrintString(z); //z boxed to object when passed to PrintString
 PrintInt(x); //x unboxed to int when passed to PrintInt

 // integers and float boxed when stored in collection 
 // therefore no need for Java wrapper classes 
 list.add(1); 
 list.add(13.12); 
 list.add(z); 
       
 for(int i =0; i < list.size(); i++)
   PrintString(list.elementAt(i));    
       
}

}

The Same But Different

Main Method
The entry point of both C# and Java programs is a main method. There is a superficial difference in that the Main method in C# begins with an uppercase "M" (as do all .NET Framework method names, by convention) while the main method in Java begins with a lowercase "m" (as do all Java method names, by convention). The declaration for the main method is otherwise the same in both cases except for the fact that parameter to the Main() method in C# can have a void parameter.
```
C# Code
 using System; 

 class A{
   
   public static void Main(String[] args){
   
     Console.WriteLine("Hello World"); 
   
   }
} 

Java Code
 class B{
   
   public static void main(String[] args){
   
     System.out.println("Hello World"); 
   
   }
} 
```
It is typically recommended that one creates a main method for each class in an application to test the functionality of that class besides whatever main method actually drives the application. For instance it is possible to have two classes, A and B, which both contain main methods. In Java, since a class is the unit of compilation then all one has to do is invoke the specific class one wants run via the command line to run its main method. In C# one can get the same effect by compiling the application with the /main switch to specify which main should be used as the starting point of the application when the executable is created. Using test mains in combination with conditional compilation via preprocessor directives is a powerful testing technique.
```
Java Example
C:\CodeSample> javac A.java B.java 

C:\CodeSample> java A
 Hello World from class A

C:\CodeSample> java B
 Hello World from class B

C# Example
C:\CodeSample> csc /main:A /out:example.exe A.cs B.cs 

C:\CodeSample> example.exe
 Hello World from class A

C:\CodeSample> csc /main:B /out:example.exe A.cs B.cs 

C:\CodeSample> example.exe
 Hello World from class B
```
So in Java's favor, one doesn't have to recompile to change which main is used by the application while a recompile is needed in a C# application. However, On the other hand, Java doesn't support conditional compilation, so the main method will be part of even your released classes.
Inheritance Syntax
C# uses C++ syntax for inheritance, both for class inheritance and interface implementation as opposed to the extends and implements keywords.
```
C# Code
 using System;

 class B:A, IComparable{
   
  int CompareTo(){}

   public static void Main(String[] args){
   
     Console.WriteLine("Hello World"); 
   
   }
} 

Java Code
 class B extends A implements Comparable{
   
   int compareTo(){}

   public static void main(String[] args){
   
     System.out.println("Hello World"); 
   
   }
} 
```
Since C# is aimed at transitioning C++ developers the above syntax is understandable although Java developers may pine for the Java syntax especially since it is clear from looking at the class declaration in the Java version whether the class is subclassing a class or simply implementing an interface while it isn't in the C# version without intimate knowledge of all the classes involved. Although it should be noted that in .NET naming conventions, interface names have an upper-case "I" prepended to their names (as in IClonable), so this isn't an issue for programs that conform to standard naming conventions.
Run Time Type Identification (is operator)
The C# is operator is completely analogous to Java's instanceof operator. The two code snippets below are equivalent.
```
C# Code

  if(x is MyClass)
   MyClass mc = (MyClass) x;

Java Code

  if(x instanceof MyClass)
   MyClass mc = (MyClass) x;
```

Namespaces

A C# namespace is a way to group a collection of classes and is used in a manner similar to Java's package construct. Users of C++ will notice the similarities between the C# namespace syntax and that in C++. In Java, the package names dictate the directory structure of source files in an application whereas in C# namespaces do not dictate the physical layout of source files in directories only their logical structure. Examples below:

C# Code

  namespace com.carnage4life{

   public class MyClass {
 
   int x; 

   void doStuff(){}

   }

 }

Java Code
  package com.carnage4life;

  public class MyClass {
 
  int x; 

  void doStuff(){}

 }

C# namespace syntax also allows one to nest namespaces in the following way

C# Code
  using System;

  namespace Company{
    
    public class MyClass { /* Company.MyClass */ 
 
        int x; 

        void doStuff(){}

        } 

    namespace Carnage4life{
    
       public class MyOtherClass {  /* Company.Carnage4life.MyOtherClass */ 
 
        int y; 

        void doOtherStuff(){}
    
       public static void Main(string[] args){
    
        Console.WriteLine("Hey, I can nest namespaces"); 
       }

      }// class MyOtherClass
       }// namespace Carnage4life
   }// namespace Company

Constructors, Destructors and Finalizers
The syntax and semantics for constructors in C# is identical to that in Java. C# also has the concept of destructors which use syntax similar to C++ destructor syntax but have the mostly the same semantics as Java finalizers. Although finalizers exist doing work within them is not encouraged for a number of reasons including the fact that there is no way to control the order of finalization which can lead to interesting problems if objects that hold references to each other are finalized out of order. Finalization also causes more overhead because objects with finalizers aren't removed after the garbage collection thread runs but instead are eliminated after the finalization thread runs which means they have to be maintained in the system longer than objects without finalizers. Below are equivalent examples in C# and Java.
NOTE: In C#, destructors(finalizers) automatically call the base class finalizer after executing which is not the case in Java.
```
C# Code
using System; 

 public class MyClass {
 
 static int num_created = 0; 
 int i = 0; 

 MyClass(){ 
 i = ++num_created; 
 Console.WriteLine("Created object #" + i); 
 }

 ~MyClass(){
 Console.WriteLine("Object #" + i + " is being finalized"); 
 }

 public static void Main(string[] args){

 for(int i=0; i < 10000; i++)
 new MyClass(); 
 
 }

 }

Java Code
 public class MyClass {
 
 static int num_created = 0; 
 int i = 0; 

 MyClass(){ 
 i = ++num_created; 
 System.out.println("Created object #" + i); 
 }

 public void finalize(){
 System.out.println("Object #" + i + " is being finalized"); 
 }

 public static void main(String[] args){

 for(int i=0; i < 10000; i++)
 new MyClass(); 
 
 }

 }
```
Synchronizing Methods and Code Blocks
In Java it is possible to specify synchronized blocks of code that ensure that only one thread can access a particular object at a time and then create a critical section of code. C# provides the lock statement which is semantically identical to the synchronized statement in Java.
```
C# Code

 public void WithdrawAmount(int num){ 

 lock(this){ 

 if(num < this.amount)
 this.amount -= num; 

 }

 }

Java Code

 public void withdrawAmount(int num){ 

 synchronized(this){ 

 if(num < this.amount)
 this.amount -= num; 

 }

 }
```
Both C# and Java support the concept of synchronized methods. Whenever a synchronized method is called, the thread that called the method locks the object that contains the method. Thus other threads cannot call a synchronized method on the same object until the object is unlocked by the first thread when it finishes executing the synchronized method. Synchronized methods are marked in Java by using the synchronized keyword while in C# it is done by annotating the method with the [MethodImpl(MethodImplOptions.Synchronized)] attribute. Examples of synchronized methods are shown below
```
C# Code
using System;
using System.Runtime.CompilerServices;

public class BankAccount{

 [MethodImpl(MethodImplOptions.Synchronized)]
 public void WithdrawAmount(int num){ 

 if(num < this.amount)
 this.amount - num; 

 }

}//BankAccount

Java Code

public class BankAccount{

 public synchronized void withdrawAmount(int num){ 

 if(num < this.amount)
 this.amount - num; 

 }

}//BankAccount
```
Access Modifiers
Below is a table mapping C# access modifiers to Java's. C++ fans who were disappointed when Sun changed the semantics of the protected keyword in Java 2 will be happy to note that the C# protected keyword has the same semantics as the C++ version. This means that a protected member can only be accessed by member methods in that class or member methods in derived classes but is inaccessible to any other classes. The internal modifier means that the member can be accessed from other classes in the same assembly as the class. The internal protected modifier means that a member can be accessed from classes that are in the same assembly or from derived classes.

C# access modifier Java access modifier

private private

public public

internal protected

protected N/A

internal protected N/A

NOTE: The default accessibility of a C# field or method when no access modifier is specified is private while in Java it is protected (except that derived classes from outside the package cannot inherit the field).

Reflection

The ability to discover the methods and fields in a class as well as invoke methods in a class at runtime, typically called reflection, is a feature of both Java and C#. The primary difference between reflection in Java versus reflection in C# is that reflection in C# is done at the assembly level while reflection in Java is done at the class level. Since assemblies are typically stored in DLLs, one needs the DLL containing the targeted class to be available in C# while in Java one needs to be able to load the class file for the targeted class. The examples below which enumerate the methods in a specified class should show the difference between reflection in C# and Java.

C# Code

using System; 
using System.Xml; 
using System.Reflection;
using System.IO; 

class ReflectionSample {

   
    public static void Main( string[] args){


    Assembly assembly=null;
    Type type=null;
    XmlDocument doc=null; 

    try{
        // Load the requested assembly and get the requested type
        assembly = Assembly.LoadFrom("C:\\WINNT\\Microsoft.NET\\Framework\\v1.0.2914\\System.XML.dll");
        type = assembly.GetType("System.Xml.XmlDocument", true);

        //Unfortunately one cannot dynamically instantiate types via the Type object in C#. 
        doc  =  Activator.CreateInstance("System.Xml","System.Xml.XmlDocument").Unwrap() as XmlDocument;

          if(doc != null)
                 Console.WriteLine(doc.GetType() + " was created at runtime");
              else
                 Console.WriteLine("Could not dynamically create object at runtime");

    }catch(FileNotFoundException){
        Console.WriteLine("Could not load Assembly: system.xml.dll");
         return;
    }catch(TypeLoadException){
        Console.WriteLine("Could not load Type: System.Xml.XmlDocument from assembly: system.xml.dll");
        
        return;
    }catch(MissingMethodException){
       Console.WriteLine("Cannot find default constructor of " + type);
       }catch(MemberAccessException){
       Console.WriteLine("Could not create new XmlDocument instance");
       }
    
    // Get the methods from the type
    MethodInfo[] methods = type.GetMethods();
        
    //print the method signatures and parameters
    for(int i=0; i < methods.Length; i++){
    
        Console.WriteLine ("{0}", methods[i]);
        
        ParameterInfo[] parameters = methods[i].GetParameters(); 
        
        for(int j=0; j < parameters.Length; j++){   
        Console.WriteLine (" Parameter: {0} {1}", parameters[j].ParameterType, parameters[j].Name);
        }
        
    }//for (int i...) 
    
    }

}
Java Code

import java.lang.reflect.*;
import org.w3c.dom.*;
import javax.xml.parsers.*; 

class ReflectionTest {

   public static void main(String[] args) {
     
       Class c=null; 
       Document d;

       try{

       c =  DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument().getClass();
       d =  (Document) c.newInstance();
       
       System.out.println(d + " was created at runtime from its Class object");

       }catch(ParserConfigurationException pce){
       System.out.println("No document builder exists that can satisfy the requested configuration");
       }catch(InstantiationException ie){
       System.out.println("Could not create new Document instance");
       }catch(IllegalAccessException iae){
       System.out.println("Cannot access default constructor of " + c);
       }

       // Get the methods from the class
      Method[] methods = c.getMethods();

        //print the method signatures and parameters
      for (int i = 0; i < methods.length; i++) {

         System.out.println( methods[i]);
        
         Class[] parameters = methods[i].getParameterTypes();
        
         for (int j = 0; j < parameters.length; j++) {         
            System.out.println("Parameters: " +  parameters[j].getName());
         }
      
      }
   }
}

One might notice from the above code samples that there is slightly more granularity in the C# Reflection API than the Java Reflection API as can be seen by the fact that C# has a ParameterInfo class which contains metadata about the parameters of a Method while Java uses Class objects for that which lose some information such as the name of the parameter.
Sometimes there is a need to obtain the metadata of a specific class encapsulated as an object. This object is the java.lang.Class object in Java and the System.Type object in C#. To retrieve this metadata class from an instance of the target class, the getClass() method is used in Java while the GetType() method is used in C#. If the name of the class is known at compile time then one can avoid creating an instance of the class just to obtain the metadata class by doing the following

C# Code
  
   Type t = typeof(ArrayList);

Java Code

   Class c = java.util.Arraylist.class; /* Must append ".class" to fullname of class */

Declaring Constants
To declare constants in Java the final keyword is used. Final variables can be set either at compile time or run time. In Java, when the final is used on a primitive it makes the value of the primitive immutable while when used on object references it makes the reference constant meaning that the reference can only point to only one object during its lifetime. Final members can be left uninitialized when declared but then must be defined in the constructor.
To declare constants in C# the const keyword is used for compile time constants while the readonly keyword is used for runtime constants. The semantics of constant primitives and object references in C# is the same as in Java.
Unlike C++, it is not possible to specify an immutable class via language constructs in either C# or Java. Neither is it possible to create a reference through which it's impossible to modify a mutable object.
```
C# Code

using System; 

public class ConstantTest{
    
    /* Compile time constants */ 
    const int i1 = 10;   //implicitly a static variable 
    
    // code below won't compile because of 'static' keyword
    // public static const int i2 = 20; 

    /* run time constants */
    public static readonly uint l1 =  (uint) DateTime.Now.Ticks;
  
    /* object reference as constant */ 
    readonly Object o = new Object();
 
    /* uninitialized readonly variable */ 
    readonly float f; 

  
    ConstantTest() {
    // unitialized readonly variable must be initialized in constructor 
    f = 17.21f; 
    }
  
}

Java Code

import java.util.*; 

public class ConstantTest{
    
    /* Compile time constants */ 
    final int i1 = 10;   //instance variable 
    static final int i2 = 20; //class variable 

    /* run time constants */
    public static final long l1 = new Date().getTime();
  
    /* object reference as constant */ 
    final Vector v = new Vector();
 
    /* uninitialized final */ 
    final float f; 

  
    ConstantTest() {
    // unitialized final variable must be initialized in constructor 
    f = 17.21f; 
    }
  
}
```
NOTE: The Java language also supports having final parameters to a method. This functionality is non-existent in C#.

The primary use of final parameters is to allow arguments to a method to be accessible from within inner classes declared in the method body.
Primitive Types
For every Java primitive type there is a corresponding C# type which has the same name (except for byte). The byte type in Java is signed and is thus analagous to the sbyte type in C# and not the byte type.C# also has unsigned versions of some primitives such as ulong, uint, ushort and byte . The only significantly different primitive in C# is the decimal type, a type which stores decimal numbers without rounding errors (at the cost of more space and less speed).

Below are different ways to declare real valued numbers in C#.
```
C# Code

  decimal dec = 100.44m; //m is the suffix used to specify decimal numbers
  double  dbl = 1.44e2d; //e is used to specify exponential notation while d is the suffix used for doubles
```

Array Declarations

Java has two ways in which one can declare an array, one which is backwards compatible with the notation used in C & C++ and another which is generally accepted as being clearer to read, C# uses only the latter array declaration syntax.

C# Code

  int[] iArray = new int[100]; //valid, iArray is an object of type int[] 
  float fArray[] = new float[100]; //ERROR: Won't compile  

Java Code

  int[] iArray = new int[100]; //valid, iArray is an object of type int[] 
  float fArray[] = new float[100]; //valid, but isn't clear that fArray is an object of type float[]

Calling Base Class Constructors and Constructor Chaining

C# and Java automatically call base class constructors, and both provide a way to call the constructor of the base class with specific parameters. Similarly both languages enforce that the call to the base class constructor occurs before any initializations in the derived constructor which prevents the derived constructor from using members that are yet to be initialized. The C# syntax for calling the base class constructor is reminiscent of the C++ initializer list syntax.
Both languages also provide a way to call a constructor from another which allows one to reduce the amount of code duplication that can occur in constructors. This practice is typically called constructor chaining.

C# Code

using System; 

class MyException: Exception
{

  private int Id; 

  public MyException(string message): this(message, null, 100){ }

  public MyException(string message, Exception innerException): 
    this(message, innerException, 100){ }

  public MyException(string message, Exception innerException, int id):
    base(message, innerException){
    
    this.Id = id;   
  }

}
  
Java Code


class MyException extends Exception{

    private int Id; 
    

    public MyException(String message){
    
    this(message, null, 100); 
    }

    public MyException(String message, Exception innerException){
    
    this(message, innerException, 100); 
    
    }

  public MyException( String message,Exception innerException, int id){
      
      super(message, innerException); 
      this.Id = id;     

  }
}

Variable Length Parameter Lists

In C and C++ it is possible to specify that a function takes a variable number of arguments. This functionality is used extensively in the printf and scanf family of functions. Both C# and Java allow one to define a parameter that indicates that a variable number of arguments are accepted by a method. In C#, the mechanism for specifying that a method accepts a variable number of arguments is by using the params keyword as a qualifier to the last argument to the method which should be an array. In Java, the same effect is achieved by appending the string "..." to the typename of the last argument to the method.

C# Code
using System;

class ParamsTest{

    public static void PrintInts(string title, params int[] args){

    Console.WriteLine(title + ":");

    foreach(int num in args)
        Console.WriteLine(num); 

    }


    public static void Main(string[] args){

    PrintInts("First Ten Numbers in Fibonacci Sequence", 0, 1, 1, 2, 3, 5, 8, 13, 21, 34);
    }

}
Java Code
class Test{

    public static void PrintInts(String title, Integer... args){

    System.out.println(title + ":");

    for(int num : args)
        System.out.println(num); 

    }

    public static void main(String[] args){

    PrintInts("First Ten Numbers in Fibonacci Sequence", 0, 1, 1, 2, 3, 5, 8, 13, 21, 34);
    }

}

Generics

Both C# and Java provide a mechanism for creating strongly typed data structures without knowing the specific types at compile time. Prior to the existence of the Generics feature set, this capability was achieved by specifying the type of the objects within the data structure as Object then casting to specific types at runtime. This technique had several drawbacks including lack of type safety, poor performance and code bloat.
The following code sample shows how one would calculate the sum of all the integers in a collection using generics and using a collection of Objects so that both approaches can be compared.


C# Code
using System;
using System.Collections;
using System.Collections.Generic; 

class Test{

    public static Stack GetStackB4Generics(){
	Stack s = new Stack(); 
	s.Push(2);
	s.Push(4); 
	s.Push(5);

	return s;
    }

    public static Stack GetStackAfterGenerics(){
	Stack s = new Stack(); 
	s.Push(12);
	s.Push(14); 
	s.Push(50);

	return s;
    }

    public static void Main(String[] args){

	Stack s1 = GetStackB4Generics(); 
	int sum1 = 0; 
	
	while(s1.Count != 0){
	    sum1 += (int) s1.Pop(); //cast 
	}
	
	Console.WriteLine("Sum of stack 1 is " + sum1); 

	Stack s2 = GetStackAfterGenerics(); 
	int sum2 = 0; 
	
	while(s2.Count != 0){
	    sum2 += s2.Pop(); //no cast
	}
	
	Console.WriteLine("Sum of stack 2 is " + sum2); 
    }

}
Java Code
import java.util.*; 

class Test{

    public static Stack GetStackB4Generics(){
	Stack s = new Stack(); 
	s.push(2);
	s.push(4); 
	s.push(5);

	return s;
    }

    public static Stack GetStackAfterGenerics(){
	Stack s = new Stack(); 
	s.push(12);
	s.push(14); 
	s.push(50);

	return s;
    }

    public static void main(String[] args){

	Stack s1 = GetStackB4Generics(); 
	int sum1 = 0; 
	
	while(!s1.empty()){
	    sum1 += (Integer) s1.pop(); //cast 
	}
	
	System.out.println("Sum of stack 1 is " + sum1); 

	Stack s2 = GetStackAfterGenerics(); 
	int sum2 = 0; 
	
	while(!s2.empty()){
	    sum2 += s2.pop(); //no cast
	}
	
	System.out.println("Sum of stack 2 is " + sum2); 
    }

}

Although similar in concept to templates in C++, the Generics feature in C# and Java is not implemented similarly. In Java, the generic functionality is implemented using type erasure. Specifically the generic type information is present only at compile time, after which it is erased by the compiler and all the type declarations are replaced with Object. The compiler then automatically inserts casts in the right places. The reason for this approach is that it provides total interoperability between generic code and legacy code that doesn't support generics. The main problem with type erasure is that the generic type information is not available at run time via reflection or run time type identification. Another consequence of this approach is that generic data structures types must always be declared using objects and not primitive types. Thus one must create Stack instead of Stack when working integers.
In C#, there is explicit support for generics in the .NET runtime's instruction language (IL). When the generic type is compiled, the generated IL contains place holders for specific types. At runtime, when an initial reference is made to a generic type (e.g. List) the system looks to see if anyone already asked for the type or not. If the type has been previously requested, then the previously generated specific type is returned. If not, the JIT compiler instantiates a new type by replacing the generic type parameters in the IL with the specific type (e.g. replacing List with List). It should be noted that if the requested type is a reference type as opposed to a value type then the generic type parameter is replaced with Object. However there is no casting done internally by the .NET runtime when accessing the type.
In certain cases, one may need create a method that can operate on data structures containing any type as opposed to those that contain a specific type (e.g. a method to print all the objects in a data structure) while still taking advantage of the benefits of strong typing in generics. The mechanism for specifying this in C# is via a feature called generic type inferencing while in Java this is done using wildcard types. The following code samples show how both approaches lead to the same result.

C# Code
using System;
using System.Collections;
using System.Collections.Generic; 

class Test{

    //Prints the contents of any generic Stack by 
    //using generic type inference 
    public static void PrintStackContents(Stack s){
	while(s.Count != 0){
	    Console.WriteLine(s.Pop()); 
	}	
    }

    public static void Main(String[] args){

	Stack s2 = new Stack(); 
	s2.Push(4); 
	s2.Push(5); 
	s2.Push(6); 

	PrintStackContents(s2); 	
	
	Stack s1 = new Stack(); 
	s1.Push("One"); 
	s1.Push("Two"); 
	s1.Push("Three"); 

	PrintStackContents(s1); 
    }

}
Java Code
import java.util.*; 

class Test{

    //Prints the contents of any generic Stack by 
    //specifying wildcard type 
    public static void PrintStackContents(Stack s){
	while(!s.empty()){
	    System.out.println(s.pop()); 
	}	
    }

    public static void main(String[] args){

	Stack  s2 = new Stack (); 
	s2.push(4); 
	s2.push(5); 
	s2.push(6); 

	PrintStackContents(s2); 	
	
	Stack s1 = new Stack(); 
	s1.push("One"); 
	s1.push("Two"); 
	s1.push("Three"); 

	PrintStackContents(s1); 
    }

}

Both C# and Java provide mechanisms for specifying constraints on generic types. In C# there are three types of constraints that can be applied to generic types

A derivation constraint indicates to the compiler that the generic type parameter derives from a base type such an interface or a particular base class
A default constructor constraint indicates to the compiler that the generic type parameter exposes a public default constructor
A reference/value type constraint constrains the generic type parameter to be a reference or a value type.

In Java, only the derivation constraint is supported. The following code sample shows how constraints are used in practice.

C# Code
using System;
using System.Collections;
using System.Collections.Generic; 

public class Mammal {
    public Mammal(){;}

    public virtual void Speak(){;} 
}

public class Cat : Mammal{
    public Cat(){;}

    public override void Speak(){
	Console.WriteLine("Meow");
    }
}

public class Dog : Mammal{
    public Dog(){;}

    public override void Speak(){
	Console.WriteLine("Woof");
    } 
}


public class MammalHelper where T: Mammal /* derivation constraint */,
                                   new() /* default constructor constraint */{ 

    public static T CreatePet(){
	return new T(); 
    }

    
    public static void AnnoyNeighbors(Stack pets){
	while(pets.Count != 0){
	    Mammal m = pets.Pop(); 
	    m.Speak();  
	}	
    }  
}

public class Test{

 public static void Main(String[] args){

	Stack s2 = new Stack(); 
	s2.Push(MammalHelper.CreatePet()); 
	s2.Push(MammalHelper.CreatePet()); 

	MammalHelper.AnnoyNeighbors(s2); 		
    }
}

Java Code
import java.util.*; 

abstract class Mammal {
    public abstract void speak(); 
}

class Cat extends Mammal{
    public void speak(){
	System.out.println("Meow");
    }
}

class Dog extends Mammal{
    public void speak(){
	System.out.println("Woof");
    } 
}

public class Test{
    
    //derivation constraint applied to pets parameter
    public static void AnnoyNeighbors(Stack pets){
	while(!pets.empty()){
	    Mammal m = pets.pop(); 
	    m.speak();  
	}	
    }

    public static void main(String[] args){

	Stack s2 = new Stack(); 
	s2.push(new Dog()); 
	s2.push(new Cat()); 

	AnnoyNeighbors(s2); 		
    }
}

C# also includes the default operator which returns the default value for a type. The default value for reference types is null, and the default value for value types (such as integers, enum, and structures) is a zero whitewash (filling the structure with zeros). This operator is very useful when combined with generics. The following code sample excercises the functionality of this operator.

C# Code
using System;

public class Test{

    public static T GetDefaultForType(){
	return default(T); //return default value of type T
    }

    public static void Main(String[] args){
	
	Console.WriteLine(GetDefaultForType());
	Console.WriteLine(GetDefaultForType());	
	Console.WriteLine(GetDefaultForType());

    }
}

for-each Loop
The for-each loop is an iteration construct that is popular in a number of scripting languages (e.g. Perl, PHP, Tcl/Tk), build tools (GNU Make) and function libraries (e.g. for_each in in C++). The for-each loop is a less verbose way to iterate through arrays or classes that implement the the System.Collections.IEnumerable interface in C# or the java.lang.Iterable interface in Java.
In C#, the keywords foreach and in are used when creating the for-each loop while in Java the keyword for and the operator : are used.
```
C# Code
string[] greek_alphabet = {"alpha", "beta", "gamma", "delta", "epsilon"};

foreach(string str in greek_alphabet)
  Console.WriteLine(str + " is a letter of the greek alphabet");

Java Code
String[] greek_alphabet = {"alpha", "beta", "gamma", "delta", "epsilon"};

for(String str : greek_alphabet)
  System.out.println(str + " is a letter of the greek alphabet");
```
Metadata Annotations
Metadata annotations provide a powerful way to extend the capabilities of a programming language and the language runtime. These annotations can be directives that request the runtime to perform certain additional tasks, provide extra information about an item or extend the abilities of a type. Metadata annotations are common in a number of programming environments including Microsoft's COM and the Linux kernel.
C# attributes provide a way to add annotations (i.e. metadata) to a module, type, method, parameter or member variable. Below are descriptions of a few attributes that are intrinsic to .NET and how they are used to extend the capabilities of the C#.
1. [MethodImpl(MethodImplOptions.Synchronized)]: is used to specify that a access to a method by multiple threads is protected by a lock to prevent concurrent access to the method and is similar to the synchronized in Java.
2. [Serializable]: is used to mark a class as serializable and is similar to a Java class implementing the Serializable interface.
3. [FlagsAttribute]: is used to specify that an enum should support bitwise operations. This is particularly important for enumerations where the target can have multiple values.
```
C# Code
   //declaration of bit field enumeration 
   [Flags]
   enum ProgrammingLanguages{ 
   C     = 1, 
   Lisp  = 2, 
   Basic = 4, 
   All  = C | Lisp | Basic
   }

  aProgrammer.KnownLanguages  =  ProgrammingLanguages.Lisp; //set known languages  ="Lisp"
  aProgrammer.KnownLanguages |=  ProgrammingLanguages.C; //set known languages  ="Lisp C"
  aProgrammer.KnownLanguages &= ~ProgrammingLanguages.Lisp; //set known languages  ="C"

  if((aProgrammer.KnownLanguages & ProgrammingLanguages.C) > 0){ //if programmer knows C
    //.. do something 
  }
```
4. [WebMethod]: is used in combination with ASP.NET to specify that a method should be available over the web as a web service automatically. Doing the same in Java involves configuring JAXP, UDDI, and J2EE as well as have to create an Enterprise Java Bean which involves at least two interfaces and one implementation class plus setting up the deployment descriptor. For more information on webservices in C#, examine the Your First C# Web Service page on CodeProject.
It is possible to access the attributes of a module, class, method or field via reflection. This is particularly useful for seeing if a class supports certain behavior at runtime or for extracting metadata about a class for usage by others. Developers can create their own custom attributes by subclassing the System.Attribute class. What follows is an example of using an attribute to provide information about the author of a class then using reflection to access that information.
```
C# Code
using System; 
using System.Reflection;
[AttributeUsage(AttributeTargets.Class)]
public class AuthorInfoAttribute: System.Attribute{

    string author; 
    string email; 
    string version;


    public AuthorInfoAttribute(string author, string email){

    this.author = author; 
    this.email  = email;
    
    }


    public string Version{


    get{
        return version;
    }

    set{
        version = value; 
    }

    }


    public string Email{


    get{
        return email;
    }

    }

     public string Author{


    get{
        return author;
    }

    }

}



[AuthorInfo("Dare Obasanjo", "kpako@yahoo.com", Version="1.0")]
class HelloWorld{

}



class AttributeTest{

    public static void Main(string[] args){

    /* Get Type object of HelloWorld class */      
    Type t = typeof(HelloWorld); 

    Console.WriteLine("Author Information for " + t);
    Console.WriteLine("=================================");

    foreach(AuthorInfoAttribute att in t.GetCustomAttributes(typeof(AuthorInfoAttribute), false)){

        Console.WriteLine("Author: " + att.Author);
        Console.WriteLine("Email: " + att.Email);
        Console.WriteLine("Version: " + att.Version);   

    }//foreach

    }//Main

}
```
Java annotations provide a way to add annotations (i.e. metadata) to an package, type, method, parameter, member or local variable. There are only three built-in annotations provided in the Java language which are listed below.
1. @Override: is used to specify that a method is intended to override a method in a base class. If the annotated method does not override a method in the base class then an error is issued during compilation.
2. @Deprecated: is used to indicate that a particular method has been deprecated. If the annotated method is used then a warning is issued during compilation.
3. @SuppressWarnings: is used to prevent particular warnings from being issued by the compiler. This annotation optionally takes the name of the specific warning to suppress as an argument.
As in C# it is possible to access the annotations on a module, class, method or field via reflection. However a key difference between C# attributes and Java annotations is that one can create meta-annotations (i.e. annotations on annotations) in Java but can not do the same in C#. Developers can create their own custom annotations by creating an annotation type which is similar to an interface except that the keyword @interface is used to define it. What follows is an example of using an attribute to provide information about the author of a class then using reflection to access that information.
```
Java Code
import java.lang.annotation.*;
import java.lang.reflect.*;

@Documented //we want the annotation to show up in the Javadocs 
@Retention(RetentionPolicy.RUNTIME) //we want annotation metadata to be exposed at runtime
@interface AuthorInfo{
    String author(); 
    String email(); 
    String version() default "1.0";
}

@AuthorInfo(author="Dare Obasanjo", email="kpako@yahoo.com")
class HelloWorld{

}

public class Test{

    public static void main(String[] args) throws Exception{

    /* Get Class object of HelloWorld class */      
    Class c = Class.forName("HelloWorld");
    AuthorInfo a = (AuthorInfo) c.getAnnotation(AuthorInfo.class); 
    
    System.out.println("Author Information for " + c);
    System.out.println("=======================================");
    System.out.println("Author: " + a.author());
    System.out.println("Email: " + a.email());
    System.out.println("Version: " + a.version());      

    }
}
```

Enumerations

Enums are used to create and group together a list of user defined named constants. Although on the surface the enumerated types in C# and Java seem quite similar there are some significant differences in the implementation of enumerated types in both languages. In Java, enumerated types are a full fledged class which means they are typesafe and can be extended by adding methods, fields or even implementing interfaces. Whereas in C#, an enumerated type is simply syntactic sugar around an integral type (typically an int) meaning they cannot be extended and are not typesafe.
The following code sample highlights the differences between enums in both languages.

C# Code
using System;

public enum DaysOfWeek{
    SUNDAY, 
    MONDAY, 
    TUESDAY, 
    WEDNESDAY,
    THURSDAY, 
    FRIDAY,
    SATURDAY
}

public class Test{

    public static bool isWeekDay(DaysOfWeek day){
	return !isWeekEnd(day);   
    }

    public static bool isWeekEnd(DaysOfWeek day){
	return (day == DaysOfWeek.SUNDAY || day == DaysOfWeek.SATURDAY); 
    }

    public static void Main(String[] args){

	DaysOfWeek sun = DaysOfWeek.SUNDAY; 
	Console.WriteLine("Is " + sun + " a weekend? " + isWeekEnd(sun));
	Console.WriteLine("Is " + sun + " a week day? " + isWeekDay(sun));

	/* Example of how C# enums are not type safe */
	sun = (DaysOfWeek) 1999;
	Console.WriteLine(sun);
	
    }
}

Java Code
enum DaysOfWeek{
    SUNDAY, 
    MONDAY, 
    TUESDAY, 
    WEDNESDAY,
    THURSDAY, 
    FRIDAY,
    SATURDAY;

    public boolean isWeekDay(){
	return !isWeekEnd();   
    }

    public boolean isWeekEnd(){
	return (this == SUNDAY || this == SATURDAY); 
    }

}

public class Test{

    public static void main(String[] args) throws Exception{

	DaysOfWeek sun = DaysOfWeek.SUNDAY; 
	System.out.println("Is " + sun + " a weekend? " + sun.isWeekEnd());
	System.out.println("Is " + sun + " a week day? " + sun.isWeekDay());
    }
}

An Ever So Slight Feeling of D¨¨j¨¤ Vu

Nested classes
In Java and C# it is possible to nest class declarations within each other. In Java there are two kinds of nested classes; non-static nested classes also known as inner classes and static nested classes. A Java inner class can be considered as a one-to-one relationship between the inner class and its enclosing class where for each instance of the enclosing class there exists a corresponding instance of the inner class that has access to the enclosing class's instance variables and contains no static methods. On the other hand a Java static nested class is a similar to nesting a class decaration within another where the nested class has access to the static members and methods of the enclosing class.
C# has the equivalent of Java's static nested classes but has nothing analogous to Java's inner classes. The following nested class declarations below are equivalent
```
C# Code
public class Car{

  private Engine engine;

  private class Engine{

    string make; 

  }

}

Java Code
public class Car{

  private Engine engine;

  private static class Engine{

    String make; 

  }

}
```
NOTE: In Java a nested class can be declared in any block of code including methods, this is not the case in C#. The ability to create nested classes in methods in Java may seem unnecessary but combined with anonymous inner classes can provide a means of creating powerful design patterns.

Threads and Volatile Members A thread is a sequential flow of control within a program. A program or process can have multiple threads running concurrently all of which may share data or run independently while performing tasks. Threads are powerful in that they allow a developer to perform multiple tasks at once in a single program or process. Advantages of threads include exploiting parallelism in multiprocessor architectures, reducing execution time by being able to perform tasks while waiting on a blocking system calls (such as printing or other I/O), and avoiding freezing in GUI applications.
Java threads are created by subclassing the java.lang.Thread class and overriding its run() method or by implementing the java.lang.Runnable interface and implementing the run() method. Whereas in C#, one creates a thread by creating a new System.Threading.Thread object and passing it a System.Threading.ThreadStart delegate which is initialized with the method that is to be run as a thread. Thus, in Java a method that shall run in a multithreaded context is designed up front specifically with that in mind. On the other hand, in C# any method can be passed to a ThreadStart object and run in a multithreaded scenario.
In Java, every class inherits the wait(), notify() and notifyAll() from java.lang.Object which are used for thread operations. The equivalent methods in C# are the Wait(), Pulse() and PulseAll() methods in the System.Threading.Monitor class.
The example below shows a scenario where worker threads are dispatched in a specific order and must be processed in the same order upon return. Due to the non-deterministic nature of threads, on some runs the threads finish working in the order they were dispatched in and in other runs they appear out of order and thus each thread must wait until its turn comes up.

C# Code

using System; 
using System.Threading; 
using System.Collections; 

public class WorkerThread{
       
    private int idNumber;
    private static int num_threads_made = 1; 
    private ThreadSample owner; 

    public WorkerThread(ThreadSample owner){
        
        idNumber = num_threads_made;    
    num_threads_made++;        
    this.owner = owner;
    
    }/* WorkerThread() */
    
    //sleeps for a random amount of time to simulate working on a task
    
    public void PerformTask(){

    Random r = new Random((int) DateTime.Now.Ticks); 
    int timeout = (int) r.Next() % 1000; 

    if(timeout < 0)
        timeout *= -1; 

    //Console.WriteLine(idNumber + ":A");
       
    try{        
        Thread.Sleep(timeout);      
        } catch (ThreadInterruptedException e){
            Console.WriteLine("Thread #" + idNumber + " interrupted");
        }
    
    //Console.WriteLine(idNumber + ":B");

    owner.workCompleted(this); 

    }/* performTask() */
    
           
    public int getIDNumber() {return idNumber;}
         
    
} // WorkerThread



public class ThreadSample {

    private static Mutex m = new Mutex(); 
    private ArrayList threadOrderList = new ArrayList(); 
    
    private int NextInLine(){

    return (int) threadOrderList[0]; 
    }

    private void RemoveNextInLine(){

    threadOrderList.RemoveAt(0);

    //all threads have shown up 
    if(threadOrderList.Count == 0)
        Environment.Exit(0);
    }

    
    public void workCompleted(WorkerThread worker){
        
    try{
        
        lock(this){
        
        
        while(worker.getIDNumber() != NextInLine()){
            
            try {
            //wait for some other thread to finish working
            Console.WriteLine ("Thread #" + worker.getIDNumber() + " is waiting for Thread #" + 
                       NextInLine() + " to show up.");
            
            Monitor.Wait(this, Timeout.Infinite);
            
            } catch (ThreadInterruptedException e) {}
            
        }//while
            
        
        Console.WriteLine("Thread #" + worker.getIDNumber() + " is home free");
        
        //remove this ID number from the list of threads yet to be seen
        RemoveNextInLine(); 
        
        //tell the other threads to resume
        Monitor.PulseAll(this); 
        
        }
        
    }catch(SynchronizationLockException){Console.WriteLine("SynchronizationLockException occurred");}
                
    }

    public static void Main(String[] args){
    

    ThreadSample ts = new ThreadSample(); 

    /* Launch 25 threads */ 
    for(int i=1; i <= 25; i++){
        WorkerThread wt = new WorkerThread(ts); 
        ts.threadOrderList.Add(i); 
        Thread t = new Thread(new ThreadStart(wt.PerformTask));
        t.Start();    
    }

    Thread.Sleep(3600000); //wait for it all to end
    
    }/* main(String[]) */ 


}//ThreadSample

Java Code
import java.util.*; 


class WorkerThread extends Thread{
       
    private Integer idNumber;
    private static int num_threads_made = 1; 
    private ThreadSample owner; 

    public WorkerThread(ThreadSample owner){
        
        super("Thread #" + num_threads_made);   
    
        idNumber = new Integer(num_threads_made);   
    num_threads_made++;        
    this.owner = owner;
    
    start(); //calls run and starts the thread.
    }/* WorkerThread() */
    
    //sleeps for a random amount of time to simulate working on a task
    public void run(){

    Random r = new Random(System.currentTimeMillis()); 
    int timeout = r.nextInt()  % 1000; 

    if(timeout < 0)
        timeout *= -1 ;

    try{        
        Thread.sleep(timeout);      
        } catch (InterruptedException e){
            System.out.println("Thread #" + idNumber + " interrupted");
        }
    
    owner.workCompleted(this); 

    }/* run() */
    
           
    public Integer getIDNumber() {return idNumber;}
         
    
} // WorkerThread



public class ThreadSample{

    private Vector threadOrderList = new Vector(); 
    
    private Integer nextInLine(){

    return (Integer) threadOrderList.firstElement(); 
    }

    private void removeNextInLine(){

    threadOrderList.removeElementAt(0);

    //all threads have shown up 
    if(threadOrderList.isEmpty())
        System.exit(0); 
    }

    public synchronized void workCompleted(WorkerThread worker){

    
    while(worker.getIDNumber().equals(nextInLine())==false){
    
        try {
        //wait for some other thread to finish working
        System.out.println (Thread.currentThread().getName() + " is waiting for Thread #" + 
                    nextInLine() + " to show up.");
        wait();
        } catch (InterruptedException e) {}
           
    }//while
    
    System.out.println("Thread #" + worker.getIDNumber() + " is home free");

    //remove this ID number from the list of threads yet to be seen
    removeNextInLine(); 

    //tell the other threads to resume
    notifyAll(); 
    }

    public static void main(String[] args) throws InterruptedException{
    

    ThreadSample ts = new ThreadSample(); 

    /* Launch 25 threads */ 
    for(int i=1; i <= 25; i++){
        new WorkerThread(ts); 
        ts.threadOrderList.add(new Integer(i)); 
    }

    Thread.sleep(3600000); //wait for it all to end
    
    }/* main(String[]) */ 


}//ThreadSample

In many situations one cannot guarantee that the order of execution of a program will be the same as that in the source code. Reasons for the unexpected ordering of program execution include compiler optimizations that reorder statements or mulitiprocessor systems that fail to store variables in global memory amongst others. To work around this, both C# and Java have the concept of the volatile keyword which is used to tell the language runtime that reordering instructions related to accessing such fields is prohibited. There are major differences in the semantics of volatile in Java and C# which are illustrated in the example below taken from The "Double-Checked Locking is Broken" Declaration

C# Code

/* Used to lazily instantiate a singleton class */ 
/*             WORKS AS EXPECTED                */
  class Foo {
        private volatile Helper helper = null;
        public Helper getHelper() {
            if (helper == null) {
                lock(this) {
                    if (helper == null)
                        helper = new Helper();
                }
            }
            return helper;
        }
    }


Java Code

/* Used to lazily instantiate a singleton class */ 
/* BROKEN UNDER CURRENT SEMANTICS FOR VOLATILE */ 

  class Foo {
        private volatile Helper helper = null;
        public Helper getHelper() {
            if (helper == null) {
                synchronized(this) {
                    if (helper == null)
                        helper = new Helper();
                }
            }
            return helper;
        }
    }

Although the above code snippets seem identical save for the substitution of the synchronized keyword with the lock keyword, the Java version is not guaranteed to work on all JVMs. Currently the Java Memory Model does not prevent reordering of writes to volatile variables with writes to other variables so it is possible that the new object is constructed before the helper reference is made to point at the newly created object meaning that two objects are created. Also it is possible that the helper reference is made to point at a block of memory while the object is still being created meaning that a reference to an incomplete object will be returned. In C#, the semantics of volatile prevent such problems from occurring because reads and writes cannot be moved backward or forward across a volatile write. Also in C#, being marked as volatile also prevents the Just In Time compiler from placing the variable in a register and also ensures that the variable is stored in global memory on multiprocessor systems.
For more information on the problems with the Java Memory Model and Double-Checked Locking, see the Double-checked locking: Clever, but broken article on Javaworld.

Operator Overloading
Operator overloading allows standard operators in a language to be given new semantics when applied in the context of a particular class or type. Operator overloading can be used to simplify the syntax of certain operations especially when they are performed very often, such as string concatenation in Java or interactions with iterators and collections in the C++ Standard Template Library.
Operator overloading is a point of contention for many developers due to the fact that it provides a lot of flexibility and power which makes it prone to abuse. There is a tendency for developers to use it poorly by doings like overloading operators in an unintuitive manner (e.g. overloading ++ and -- to connect and disconnect from the network) , overloading operators in a manner inconsistent with their typical use (e.g. overloading [ ] to return a copy of an object at a particular index in a collection instead of a reference to the actual object) or overloading some operators and not others (e.g. overloading < but not >).
Overloading operators tends to be most useful when the class lends itself intuitively to using that operator. Examples of situations that intuitively suggest that operator overloading would be beneficial are overloading [ ] for use with collections, overloading + and * for use with matrices, overloading mathematical operators for use with complex numbers, and overloading the == and != operators for classes that have some means to measure equality. Below is an example that shows how operator overloading works in C#.
NOTE: Unlike C++, C# does not allow the overloading of the following operators; new, ( ), ||, &&, =, or any variations of compound assignments such as +=, -=, etc. However, compound assignment operators will call overloaded operators, for instance, += would call overloaded +.
```
C# Code
using System;

class OverloadedNumber{

 private int value; 

 public OverloadedNumber(int value){

 this.value = value; 

 }

 public override string ToString(){
 return value.ToString(); 
 }


 public static OverloadedNumber operator -(OverloadedNumber number){
 return new OverloadedNumber(-number.value); 
 }

 public static OverloadedNumber operator +(OverloadedNumber number1, OverloadedNumber number2){
 return new OverloadedNumber(number1.value + number2.value); 
 }

 public static OverloadedNumber operator ++(OverloadedNumber number){
 return new OverloadedNumber(number.value + 1); 
 }

}

public class OperatorOverloadingTest {

 
 public static void Main(string[] args){

 OverloadedNumber number1 = new OverloadedNumber(12); 
 OverloadedNumber number2 = new OverloadedNumber(125); 

 Console.WriteLine("Increment: {0}", ++number1);
 Console.WriteLine("Addition: {0}", number1 + number2);
 
 }
} // OperatorOverloadingTest
```

switch Statment

There are two major differences between the switch statement in C# versus that in Java. In C#, switch statements support the use of string literals and do not allow fall-through unless the label contains no statements. Fall-throughs are explicitly disallowed because they are a leading cause of hard-to-find bugs in software.

C# Code

switch(foo){    
    
    case "A": 
        Console.WriteLine("A seen");
        break;
    case "B": 
    case "C": 
        Console.WriteLine("B or C seen");
        break; 

        /* ERROR: Won't compile due to fall-through at case "D" */
    case "D": 
        Console.WriteLine("D seen");
    case "E":
        Console.WriteLine("E seen");
        break; 
    }

Assemblies
C# assemblies share a lot in common with Java JAR files. An assembly is the fundamental unit of code packaging in the .NET environment. Assemblies are self contained and typically contain the intermediate code from compiling classes, metadata about the classes, and any other files needed by the packaged code to perform its task.
Since assemblies are the fundamental unit of code packaging, several actions related to interacting with types must be done at the assembly level. For instance, granting of security permissions, code deployment, and versioning are done at the assembly level. Java JAR files perform a similar task in Java with most differences being in the implementation. Assemblies are usually stored as EXEs or DLLs while JAR files are stored in the ZIP file format.
Collections
A number of popular programming languages contain a collections framework which typically consists of a number of data structures for holding multiple objects as well as algorithms for manipulating the objects within the aforementioned data structures. The primary advantage of a collections framework is that it frees developers from having to write data structures and sort algorithms every time one is needed and instead frees them up to work on the actual application logic. A secondary benefit is that collections frameworks lead to consistency across projects which means the learning curve for new developers using applications that use a collections framework is less steep when compared to a situation where one was not used.
The C# collections framework consists of the classes in the System.Collections and the System.Collections.Generic namespaces. The Systems.Collections namespace contains interfaces and abstract classes that represent abstract data types such as IList, IEnumerable, IDictionary, ICollection, and CollectionBase which enable developers to manipulate data structures independently of how they are actually implemented as long as the data structures inherit from the abstract data types. The System.Collections namespace also contains some concrete implementations of data structures such as ArrayList, Stack, Queue, HashTable and SortedList. All four of the concrete data structure implementations enable one to obtain synchronized wrappers to the collection which allows for access in a thread-safe manner. The System.Collections.Generic namespace has generic implementations of the key data structures in the System.Collections namespace including generic List, Stack,Queue, Dictionary and SortedDictionary classes .
The Java collections framework consists of a large number of the classes and interfaces in the java.util package. Instead of having a separate namespace for generic collections, the collections in the java.util package have been retrofitted to support generics. The Java collection framework is similar to that in C# except for the fact that it can be considered a superset of the C# collection framework since it contains a number of extra features. The Java collection framework contains data structures that are missing from those in C# such as sets and linked lists. Also the Java collections framework not only has methods that enable one to access unsafe collections in a thread safe manner but contains thread-safe versions of most of the data structures as well. Finally, the Java collections framework has a number of algorithms for manipulating the elements within the data structures including algorithms that can do the following; find the largest element based on some Comparator, find the smallest element, find sublists within a list, reverse the contents of a list, shuffle the contents of a list, creates immutable versions of a colection, performs sorts, and binary searches.
At the current time, the Java collections framework is more sophisticated than that available in .NET via C#.

goto (no longer considered harmful)

Unlike Java, C# contains the goto statement which can be used to jump directly from a point in the code to a label. Although much derided, gotos can be used in certain situations to reduce code duplication while enhancing readability. A secondary usage of the goto statement is the ability to mimic resumeable exceptions like those in Smalltalk, as long as the exception thrown does not cross method boundaries.
NOTE: In C#, one cannot jump into a statement block using the goto statement;

C# Code
using System; 
using System.Net.Sockets; 

class GotoSample{


    public static void Main(string[] args){
    
    int num_tries = 0;
    
       retry: 

    try{             

        num_tries++;    
        Console.WriteLine("Attempting to connect to network. Number of tries =" + num_tries);

        //Attempt to connect to a network times out 
        //or some some other network connection error that 
        //can be recovered from
       
        throw new SocketException(); 

    }catch(SocketException){

        if(num_tries < 5)
        goto retry;                 
    }       
   
   }/* Main(string[]) */ 

}//GotoSample

Virtual Methods (and final ones too)
One of the tenets of object oriented programming is polymorphism. Polymorphism enables one to interact with members of a type hierarchy as generic types instead of dealing with specific types. The means of implementing polymorphism typically involves having methods in a base class that may be overidden by derived classes. These methods can be invoked even though the client has a reference to a base class type which points to an object of the derived class. Such methods are bound at runtime instead of being bound during compilation and are typically called virtual methods.
In Java all methods are virtual methods while in C#, as in C++, one must explicitly state which methods one wants to be virtual since by default they are not. To mark a method as virtual in C#, one uses the virtual keyword. Also, implementers of a child class can decide to either explicitly override the virtual method by using the override keyword or explicitly choose not to by using the new keyword instead. By default, in C#, the behavior of methods in a derived class that have the same signature as those in the base class is as if they were declared with the new keyword.
It is possible to mark methods as final in Java which means that the method cannot be overridden by derived classes. In C# this can be done by not marking the method as virtual. The major difference is that in C#, the class can still define the method but the base class version is the one that will be called if the object is used via a base class reference. Java disallows the derived class from containing a method that has the same signature as the final base class method.
Below are examples that show the differences in virtual methods in both languages.
```
C# Code
using System; 

public class Parent{

    public void DoStuff(string str){
    Console.WriteLine("In Parent.DoStuff: " + str); 
    }

}

public class Child: Parent{

     public void DoStuff(int n){
    Console.WriteLine("In Child.DoStuff: " + n);    
    }

     public void DoStuff(string str){
    Console.WriteLine("In Child.DoStuff: " + str);  
    }
}


public class VirtualTest{

    public static void Main(string[] args){

    Child ch = new Child(); 

    ch.DoStuff(100); 
    ch.DoStuff("Test"); 

    ((Parent) ch).DoStuff("Second Test"); 
    }

}//VirtualTest

OUTPUT:
In Child.DoStuff: 100
In Child.DoStuff: Test
In Parent.DoStuff: Second Test

Java Code
class Parent{

    public void DoStuff(String str){
    System.out.println("In Parent.DoStuff: " + str);    
    }

}

class Child extends Parent{

     public void DoStuff(int n){
    System.out.println("In Child.DoStuff: " + n);   
    }

     public void DoStuff(String str){
    System.out.println("In Child.DoStuff: " + str); 
    }
}


public class VirtualTest{

    public static void main(String[] args){

    Child ch = new Child(); 

    ch.DoStuff(100); 
    ch.DoStuff("Test"); 

    ((Parent) ch).DoStuff("Second Test"); 
    }

}//VirtualTest

OUTPUT:
In Child.DoStuff: 100
In Child.DoStuff: Test
In Child.DoStuff: Second Test
```
The C# example can be made to produce the same output as the Java example by marking the DoStuff(string) method in the Parent class as virtual and marking the DoStuff(string) method in the Child class with the override keyword.
```
C# Code

using System; 

public class Parent{

    public virtual void DoStuff(string str){
    Console.WriteLine("In Parent.DoStuff: " + str); 
    }

}

public class Child: Parent{

     public void DoStuff(int n){
    Console.WriteLine("In Child.DoStuff: " + n);    
    }

     public override void DoStuff(string str){
    Console.WriteLine("In Child.DoStuff: " + str);  
    }
}


public class VirtualTest{

    public static void Main(string[] args){

    Child ch = new Child(); 

    ch.DoStuff(100); 
    ch.DoStuff("Test"); 

    ((Parent) ch).DoStuff("Second Test"); 
    }

}//VirtualTest

OUTPUT:
In Child.DoStuff: 100
In Child.DoStuff: Test
In Child.DoStuff: Second Test
```
The above example can be made to produce the original results by altering the signature of the DoStuff(string) method in the Child class to

public new void DoStuff(string str)
which states that although the DoStuff method is virtual in the base class, the child class would like to treat it as a non-virtual method.

File I/O

Both languages support performing I/O via Stream classes. The examples below copy the contents of a file named "input.txt" to another called "output.txt".

C# Code
using System;
using System.IO; 


public class FileIOTest {

    public static void Main(string[] args){

    FileStream inputFile  = new FileStream("input.txt", FileMode.Open);
    FileStream outputFile = new FileStream("output.txt", FileMode.Open);

        StreamReader sr     = new StreamReader(inputFile);
        StreamWriter sw     = new StreamWriter(outputFile);


    String str;

    while((str = sr.ReadLine())!= null)
        sw.Write(str);

        sr.Close();
        sw.Close();
    }

}//FileIOTest

Java Code
import java.io.*;

public class FileIO{

    public static void main(String[] args) throws IOException {

    File inputFile  = new File("input.txt");
    File outputFile = new File("output.txt");

        FileReader in     = new FileReader(inputFile);
    BufferedReader br = new BufferedReader(in);

        FileWriter out    = new FileWriter(outputFile);
    BufferedWriter bw = new BufferedWriter(out);

    String str;

    while((str = br.readLine())!= null)
        bw.write(str);

        br.close();
        bw.close();
    }

}//FileIOTest

Object Serialization

Object Persistence also known as Serialization is the ability to read and write objects via a stream such as a file or network socket. Object Persistence is useful in situations where the state of an object must be retained across invocations of a program. Usually in such cases simply storing data in a flat file is insufficient yet using a Database Management System (DBMS) is overkill. Serialization is also useful as a means of transferring the representation of a class in an automatic and fairly seamless manner.
Serializable objects in C# are annotated with the [Serializable] attribute. The [NonSerialized] attribute is used to annote members of a C# class that should not be serialized by the runtime. Such fields are usually calculated or temporary values that have no meaning when saved. C# provides two formats for serializing classes; either as XML or in a binary format, the former is more readable by humans and applications while the latter is more efficient. One can also define custom ways an object is serialized if the standard ways are insufficient by implementing the ISerializable interface.
In Java, serializable objects are those that implement the Serializable interface while the transient keyword is used to mark members of a Java class as ones not to be serialized. By default Java supports serializing objects to a binary format but does provide a way of overriding the standard serialization process. Objects that plan to override default serializations can implement methods with the following signatures

   private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException;

   private void writeObject(java.io.ObjectOutputStream stream) throws IOException

Since the above methods are private there is no interface that can be implemented to indicate that a Java class supports custom serialization using readObject and writeObject. For classes that need publicly accessible methods for custom serialization there exists the java.io.Externalizable interface which specifies the readExternal() and writeExternal() for use in customizing how an object is read and written to a stream.

C# Code

using System;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;


[Serializable]
class SerializeTest{

    [NonSerialized]
    private int x; 

    private int y; 

    public SerializeTest(int a, int b){

    x = a; 
    y = b; 

    }

    public override String ToString(){

    return "{x=" + x + ", y=" + y + "}"; 

    }

    public static void Main(String[] args){

    SerializeTest st = new SerializeTest(66, 61); 
    Console.WriteLine("Before Binary Write := " + st);

    Console.WriteLine("\n Writing SerializeTest object to disk");
    Stream output  = File.Create("serialized.bin");
    BinaryFormatter bwrite = new BinaryFormatter(); 
    bwrite.Serialize(output, st); 
    output.Close(); 

    Console.WriteLine("\n Reading SerializeTest object from disk\n");
    Stream input  = File.OpenRead("serialized.bin");
    BinaryFormatter bread = new BinaryFormatter(); 
    SerializeTest fromdisk = (SerializeTest)bread.Deserialize(input); 
    input.Close(); 


    /* x will be 0 because it won't be read from disk since non-serialized */ 
    Console.WriteLine("After Binary Read := " + fromdisk);

    
    st = new SerializeTest(19, 99);  
    Console.WriteLine("\n\nBefore SOAP(XML) Serialization := " + st);

    Console.WriteLine("\n Writing SerializeTest object to disk");
    output  = File.Create("serialized.xml");
    SoapFormatter swrite = new SoapFormatter(); 
    swrite.Serialize(output, st); 
    output.Close(); 

    Console.WriteLine("\n Reading SerializeTest object from disk\n");
    input  = File.OpenRead("serialized.xml");
    SoapFormatter sread = new SoapFormatter(); 
    fromdisk = (SerializeTest)sread.Deserialize(input); 
    input.Close(); 


    /* x will be 0 because it won't be read from disk since non-serialized */ 
    Console.WriteLine("After SOAP(XML) Serialization := " + fromdisk);

    
    Console.WriteLine("\n\nPrinting XML Representation of Object");

    XmlDocument doc = new XmlDocument(); 
    doc.Load("serialized.xml"); 
    Console.WriteLine(doc.OuterXml);

    }

}

Java Code
import java.io.*; 

class SerializeTest implements Serializable{

    transient int x; 

    private int y; 

    public SerializeTest(int a, int b){

    x = a; 
    y = b; 

    }

    public String toString(){

    return "{x=" + x + ", y=" + y + "}"; 

    }

    public static void main(String[] args) throws Exception{

    SerializeTest st = new SerializeTest(66, 61); 
    System.out.println("Before Write := " + st);

    System.out.println("\n Writing SerializeTest object to disk");
    FileOutputStream out  = new FileOutputStream("serialized.txt");
    ObjectOutputStream so = new ObjectOutputStream(out);    
    so.writeObject(st);
    so.flush();

    System.out.println("\n Reading SerializeTest object from disk\n");
    FileInputStream in     = new FileInputStream("serialized.txt");
    ObjectInputStream si   = new ObjectInputStream(in); 
    SerializeTest fromdisk = (SerializeTest)si.readObject();

    /* x will be 0 because it won't be read from disk since transient */ 
    System.out.println("After Read := " + fromdisk);


    }

}

Documentation Generation from Source Code Comments
Both C# and Java provide a mechanism for extracting specially formatted comments from source code and placing them in an alternate document. These comments are typically API specifications and are very useful way to provide API documentation to the users of a library. The generated documentation is also useful to share the specifications for an API between designers, developers and QA.
Javadoc is the tool used to extract API documentation from source code. Javadoc generates HTML documentation from the source code comment, an example of which is the Java™ Platform, Standard Edition API Documentation which was all generated using Javadoc. Javadoc can be used to describe information at the package, class, member and method level. Descriptions of classes and member variables can be provided with the option to add references to other classes, class members and methods.
Javadoc allows one to document the following metadata about a method:
- Description of the method.
- Exceptions thrown by the method.
- Parameters the method accepts
- Return type of the method.
- Associated methods and members.
- Indication as to whether the API has been deprecated or not.
- Version of the API the method was first added.
The deprecated information is also used by the compiler which issues a warning if a call to a method marked with the deprecated tag is encountered during compilation.

Javadoc also provides the following information automatically:
- Inherited API
- List of derived classes
- List of implementing classes for interfaces
- Serialized form of the class
- Alphabetical class listing.
- Package hierarchy in a tree format.
Since Javadoc generates HTML documentation, it is valid to use HTML in Javadoc comments. There is support for linking the generated documentation with other generated documentation available over the web. Such linking is useful when one wants readers of the documentation to be able to read the API documentation from the related sources. An example of this is the following generated documentation which contains links to the Java 2 API documentation. If no such linking is specified then the generated documentation contains no links to other API documentation. Below is an example of how Javadoc comments are used
```
Java Code

/**
 * Calculates the square of a number. 
 * @param num the number to calculate. 
 * @return the square of the number. 
 * @exception NumberTooBigException this occurs if the square of the number 
 * is too big to be stored in an int. 
 */
 public static int square(int num) throws NumberTooBigException{}
```
C# uses XML as the format for the documentation. The generated documentation is an XML file that contains the metadata specified by the user with very little additional information generated automatically. All the C# XML documentation tags have an analogous Javadoc construct while the same cannot be said for the Javadoc tags having C# XML documentation analogs. For instance, the default C# XML documentation does not have analogs to Javadoc's @author, @version, or @deprecated tags although such metadata can be generated by reflecting on the assembly, as Microsoft's documentation build process does. One could also create custom tags that are analogous to the Javadoc tags and more but they would be ignored by standard tools used for handling C# XML documentation including Visual Studio.NET. Also of note is that C#'s XML documentation when generated does not contain metadata about the class such as listings of inherited API, derived classes or implementing interfaces. Here is an example of an XML file generated from C# source code.
The primary benefit of an XML format is that the documentation specification can now be used in many different ways. XSLT stylesheets can then be used to convert the generated documentation to ASCII text, HTML, or Postscript files. Also of note is that the generated documentation can be fed to tools that use it for spec verification or other similar tasks. It should be noted that C# currently does not have a tool analogous to Javadoc for converting the XML documentation into HTML. Microsoft is in the process of developing such a tool which is currently codenamed SandCastle.
Below is an example of how C# XML documentation is used.
```
C# Code

///Calculates the square of a number.
///The number to calculate.
///The square of the number. 
///NumberTooBigException - this occurs if the square of the number 
///is too big to be stored in an int. 
 public static int square(int num){}
```
Multiple Classes in a Single File
Multiple classes can be defined in a single file in both languages with some significant differences. In Java, there can only be one class per source file that has public access and it must have the same name as the source file minus the file extension. C# does not have a restriction on the number of public classes that can exist in a source file and neither is there a requirement for the name of any of the classes in the file to match that of the source file.
Importing Libraries
Using libraries in an application is a two-step process. First the needed libraries must be referenced somewhere in the source file which is done via the using keyword in C# and the import keyword in Java. Secondly, there must be a way to tell the compiler where to find the location of the needed library. Specifying the location of libraries that will be used by a Java program is done using the CLASSPATH environment variable or the -classpath compiler option. Assembly locations are specified with the /r compiler switch in C#.

Events

Event-driven programming is a programming model where objects can register themselves to be notified of a specific occurrence or state change in another object. Event-driven programming is also referred to as the publish-subscribe model or the observer design pattern and is very popular in graphical user interface (GUI) programming. Java and C# both have mechanisms that support events but there are significant differences. The typical publish-subscribe model has a one to many relationship between an object (publisher) and its event handlers (subscribers). A subscriber is registered by invoking a method on the publisher which then adds the subscriber to an internal collection of interested objects. When the state change that a registered subscriber is interested in occurs, a method is invoked in the publisher that cycles through the collection of subscribers and invokes a callback method on each one.
There is no general mechanism for event handling in Java. Instead there are design patterns that are used by the GUI classes which developers can take their cue from. An event is typically a subclass of the java.util.EventObject class, which has methods that enable setting or getting of the object that was the source of the event. A subscriber in the Java model usually implements an interface that ends with the word Listener (e.g. MouseListener, ActionListener, KeyListener, etc) which should contain a callback method that would be called by the publisher on the occurrence of the event. The publisher typically has a method that begins with add and ends with Listener (e.g. addMouseListener, addActionListener, addKeyListener, etc) which is used to register subscribers. The publisher also has remove methods for unregistering the subscribers. The aforementioned components are the primary entities in an event-driven Java program.
C# uses delegates to provide an explicit mechanism for creating a publish-subscribe model. An event is typically a subclass of the System.EventArgs class. Like all data classes, the event class should have a constructor that allows complete initialization without calling any other methods so that you can pass new YourEventArgs(inits) to the subscriber delegate. The publisher has a protected method preceded with the word "On" (e.g. OnClick, OnClose, OnInit, etc) which is invoked when a specified event occurs, this method would then invoke the delegate passing it the source and an instance of the EventArgs object. Making the method protected allows derived classes to call it directly without the need to register a delegate. The subscriber is a method that accepts the same argument and returns the same type as the event delegate. The event delegate usually returns void and accepts two parameters; an Object which should be the source of the event and the EventArgs subclass which should represent the event that occured.
In C#, the event is used to automatically specify that a field within a subscriber is a delegate that will be used as a callback during an event-driven situation. During compilation the compiler adds overloaded versions of the += and -= operators that are analogous to the add and remove methods that are used in Java to register and unregister a subscriber.
The example below shows a class that generates 20 random numbers and fires an event whenever one of the numbers is even.

C# Code
using System; 

class EvenNumberEvent: EventArgs{

    /* HACK: fields are typically private, but making this internal so it
     * can be accessed from other classes. In practice should use properties.
     */ 
    internal int number; 

    public EvenNumberEvent(int number):base(){

    this.number = number;
    }

}

class Publisher{

    public delegate void EvenNumberSeenHandler(object sender, EventArgs e); 
    
    public event EvenNumberSeenHandler EvenNumHandler; 
    
    protected void OnEvenNumberSeen(int num){

    if(EvenNumHandler!= null)
        EvenNumHandler(this, new EvenNumberEvent(num));
    }
    

    //generates 20 random numbers between 1 and 20 then causes and 
    //event to occur if the current number is even. 
    public void RunNumbers(){
    
    Random r = new Random((int) DateTime.Now.Ticks); 

    for(int i=0; i < 20; i++){     
        int current = (int) r.Next(20); 

        Console.WriteLine("Current number is:" + current);

        //check if number is even and if so initiate callback call
        if((current % 2) == 0)
        OnEvenNumberSeen(current);

    }//for
    
    }
    

}//Publisher


public class EventTest{

    //callback function that will be called when even number is seen
    public static void EventHandler(object sender, EventArgs e){

    Console.WriteLine("\t\tEven Number Seen:" + ((EvenNumberEvent)e).number);
    
    }


    public static void Main(string[] args){

    Publisher pub = new Publisher(); 
    
    //register the callback/subscriber 
    pub.EvenNumHandler += new Publisher.EvenNumberSeenHandler(EventHandler); 
    
    pub.RunNumbers(); 

    //unregister the callback/subscriber 
    pub.EvenNumHandler -= new Publisher.EvenNumberSeenHandler(EventHandler); 
    
    }

}

Java Code
import java.util.*;

class EvenNumberEvent extends EventObject{

    public int number; 

    public EvenNumberEvent(Object source, int number){
    
    super(source); 
    this.number = number;
    }

}

interface EvenNumberSeenListener{

    void evenNumberSeen(EvenNumberEvent ene); 

}

class Publisher{

    Vector subscribers = new Vector(); 
    

    private void OnEvenNumberSeen(int num){

    for(int i=0, size = subscribers.size(); i < size; i++)
        ((EvenNumberSeenListener)subscribers.get(i)).evenNumberSeen(new EvenNumberEvent(this, num));
    }
    

    public void addEvenNumberEventListener(EvenNumberSeenListener ensl){

    subscribers.add(ensl); 

    }

     public void removeEvenNumberEventListener(EvenNumberSeenListener ensl){

    subscribers.remove(ensl); 
    }

    //generates 20 random numbers between 1 and 20 then causes and 
    //event to occur if the current number is even. 
    public void RunNumbers(){
    
    Random r = new Random(System.currentTimeMillis()); 

    for(int i=0; i < 20; i++){     
        int current = (int) r.nextInt() % 20; 

        System.out.println("Current number is:" + current);

        //check if number is even and if so initiate callback call
        if((current % 2) == 0)
        OnEvenNumberSeen(current);

    }//for
    
    }
    

}//Publisher


public class EventTest implements EvenNumberSeenListener{

    //callback function that will be called when even number is seen
    public void evenNumberSeen(EvenNumberEvent e){

    System.out.println("\t\tEven Number Seen:" + ((EvenNumberEvent)e).number);
    
    }


    public static void main(String[] args){

    EventTest et = new EventTest();

    Publisher pub = new Publisher(); 
    
    //register the callback/subscriber 
    pub.addEvenNumberEventListener(et); 
    
    pub.RunNumbers(); 

    //unregister the callback/subscriber 
    pub.removeEvenNumberEventListener(et); 
    
    }

}

Cross Language Interoperability
Cross language interoperability is the ability to access constructs written in one programming language from another. There are a number of ways cross language interoperability works in Java. First of all, there is the Java Native Interface (JNI) which is a mechanism that allows Java programs call native methods written in C, C++ or assembly language. The C, C++ or assembly methods methods must be specifically written to be called from Java. Native methods can use JNI to access Java features such as calling Java language methods, instantiating and modifying Java classes, throwing and catching exceptions, performing runtime type checking, and loading Java classes dynamically. To create a JNI program one performs the following steps:
1. Create a Java program that contains the declaration of the native method(s) marked with the native keyword.
2. Write a main method that loads the library created in step 6 and uses the native method(s).
3. Compile the class containing the declaration of the native method(s) and the main with the javac compiler.
4. Use the javah compiler with the -jni compiler option to generate a header file for the native method(s).
5. Write the native method in your language of choice (currently C, C++ or assembly).
6. Compile the header file and native source file into a shared library (i.e. a .dll on Windows or a .so file on UNIX).
Java also has the ability to interact with distributed objects that use the common object request broker architecture (CORBA) via Java IDL. CORBA is a technology that allows developers to make procedure calls on objects in a location and language agnostic manner. A CORBA application usually consists of an object request broker (ORB), a client and a server. An ORB is responsible for matching a requesting client to the server that will perform the request, using an object reference to locate the target object. When the ORB examines the object reference and checks if the target object is remote or not. If the target of the call is local then the ORB performs an inter-process communication (IPC) call. On calls to remote objects the ORB marshals the arguments and routes the invocation out over the network to the remote object's ORB. The remote ORB then invokes the method locally and sends the results back to the client via the network. CORBA has a language-agnostic interface definition language (IDL) which for which languages that support CORBA have various mappings. Java IDL supports the mappings from Java objects to CORBA IDL objects. Various ORBs support CORBA language bindings for a number of languages including C, C++, Java, Python, Lisp, Perl, and Scheme.
The most seamless way to do cross language interop in Java is when the language is compiled directly to Java byte code. This means that objects in that language are available to Java programs and Java objects are available to programs written in the target language. A good example of this is the Jython scripting language which is a version of the Python programming language that is integrated with the Java platform. Below is an example of an interactive session with Jython shows how a user could create an instance of the Java random number class (found in java.util.Random) and then interact with that instance which was taken from the Jython Documentation
```
C:\jython>jython
Jython 2.0 on java1.2.1
Type "copyright", "credits" or "license" for more information.
>>> from java.util import Random
>>> r = Random()
>>> r.nextInt()
-790940041
>>> for i in range(5):
...     print r.nextDouble()
...
0.23347681506123852
0.8526595592189546
0.3647833839988137
0.3384865260567278
0.5514469740469587
>>>
```
There are a number of projects in various degrees of completion that are aimed at providing a similar degree of cross language interoperability within the confines of the Java Virtual Machine. A list of languages retargetted for the Java Virtual Machine is available on the webpage of Dr. Robert Tolksdorf. Currently, Sun Microsystems (creators of the Java language and platform) seems to be uninterested in this level of cross language interoperability and has decided to leave this to independent developers and researchers.

With seamless cross langauge interoperability, objects can inherit implementation from other types, instantiate and invoke methods defined on other types, and otherwise interact with objects regardless of the language the types are originally implemented in. Also tools such as class browsers, debuggers, and profilers only need to understand one format (be it Java byte codes or .NET instruction language) but can support a multitude of languages as long as they target the appropriate runtime. Also error handling across languages via exceptions is possible.
C# and the .NET runtime were created with seamless cross-language interoperability as a design goal. A language targeting the .NET common language runtime (CLR) is able to interact with other languages that conform to the common type system and when compiled include certain metadata. The common type system defines how types are declared, used, and managed in the .NET runtime thus creating a framework that allows for type safety and ensures that objects written in various languages can share type information. Metadata is binary information describing the assemblies, types and attributes defined in the application that are stored either in a CLR portable executable (PE) or in memory if the assembly has been loaded. Langauges that are currently being developed to target the .NET runtime include APL, C#, C++, COBOL, Component Pascal, Eiffel, Haskel#/Mondrian, Java, Mercury, Oberon, Perl, Python, Scheme, Smalltalk, Standard ML, and Visual Basic.
Since it is very possible that certain features in one language have no analog in another, the .NET Framework provides the Common Language Specification (CLS), which describes a fundamental set of language features and defines rules for how those features are used. The CLS rules are a subset of the common type system that is aimed at ensuring cross-language interoperability by defining a set of features that are most common in programming languages. The C# compiler is a CLS compliant compiler meaning that it can be used to generate code that complies with the CLS. The C# compiler can check for CLS compliance and issues an error when a program code uses functionality that is not supported by the CLS. To get the C# compiler to check for the CLS compliance of a piece of code, mark it with the [CLSCompliantAttribute(true)] attribute.
Another aspect of cross language interoperability supported by C# is interaction with COM based objects. There are mechanisms that allow developers to use COM objects from C# code and vice versa.
C# objects can utilize COM objects if a wrapper class is first created that defines the functions available in the COM object as well as some additional information. The wrapper class can then be used as if it were a regular C# object while the .NET runtime handles the complexities of marshalling arguments and the like. Creating the wrapper class can be done automatically using the tlbimp utility. If the utility is unable to create a type library then one must be written by hand with foreknowledge of the coclasses and interfaces being defined as well as the type library-to-assembly conversion rules.
For a COM object to utilize a C# object, a typelib must be created that describes the C# object to COM aware applications. The tlbexp can be used to create a typelib that describes the C# object's interface in a COM-like manner. Also the regasm utility can be used to register an assembly so it is available to COM. When COM objects interact with the C# object, the runtime handles whatever marshalling of data that needs to occur between COM and .NET automatically.
C# programs can also call almost any function in any DLL using a combination of the extern keyword and the DllImport attribute on the method declaration. A major advantage of this is that the method being called does not have to be specifically written to be called from C#, nor is any "wrapper" necessary-so calling existing code in DLLs is relatively simple.

Now For Something Completely Different

Deterministic Object Cleanup

To provide total control of releasing resources used by classes, C# provides the System.IDisposable interface which contains the Dispose() method that can be called by users of the class to release resources on completion of whatever task is at hand. Classes that manage resources such as database or file handles benefit from being disposable. Being diposable provides a deterministic way to release these resources when the class is no longer in use, which is not the case with finalizers in Java or C#. It is typical to call the SupressFinalize method of the GC class in the implementation of the Dispose method since it is likely that finalization by the runtime won't be needed since it will be provided explicitly via the Dispose method. C# also has some syntactic sugar via the using keyword that makes releasing the resources used by classes occur in a more deterministic manner via the Dispose method.
If a class is disposable, it is best to make usage of the Dispose() method idempotent (i.e. multiple calls to Dispose() have no ill effects) which can be done by providing a flag that is checked within the Dispose() method to see if the class has already been disposed or not. The example below shows a program where a class keeps a file open up until the Dispose() method is called which indicates that the file no longer needs to be open.

C# Code
using System; 
using System.IO; 

public class MyClass : IDisposable {     

    bool disposed = false; 
    FileStream f; 
    StreamWriter sw; 
    private String name;
    private int numShowNameCalls = 0; 

    MyClass(string name){
             
        
    f = new FileStream("logfile.txt", FileMode.OpenOrCreate); 
    sw = new StreamWriter(f);
    this.name = name;
    Console.WriteLine("Created " + name);   
    }


    ~MyClass(){

    Dispose(false); 
    }

     public void Dispose(){

    if(!disposed){
        Dispose(true);
    }

    }


    
    private void Dispose(bool disposing){

    lock(this){ /* prevents multiple threads from disposing simultaneously */ 
        
        /* disposing variable is used to indicate if this method was called from a 
         * Dispose() call or during finalization. Since finalization order is not 
         * deterministic, the StreamWriter may be finalized before this object in 
         * which case, calling Close() on it would be inappropriate so we try to 
         * avoid that. 
         */
        if(disposing){     
        Console.WriteLine("Finalizing " + name);      
        sw.Close(); /* close file since object is done with */ 
        GC.SuppressFinalize(this);
        disposed = true; 
        }
        
    }

    }
    
   
    public string ShowName(){

    if(disposed)            
           throw new ObjectDisposedException("MyClass");

    numShowNameCalls++; 
    sw.Write("ShowName() Call #" + numShowNameCalls.ToString() + "\n");         
    
        return "I am " + name; 
    
    }

    public static void Main(string[] args){
    

    using (MyClass mc = new MyClass("A MyClass Object")){

        for(int i = 0; i < 10; i++){
      
        Console.WriteLine(mc.ShowName()); 
      
        } //for

    }/* runtime calls Dispose on MyClass object once "using" code block is exited, even if exception thrown  */ 
    
    }//Main 

}

The above idiom is practically the same as having C++ style destructors without the worry of having to deal with memory allocation woes, making it the best of both worlds. The non-deterministic nature of finalization has long been bemoaned by Java developers, it is a welcome change to see that this will not be the case when using C#.

NOTE: Calling the Dispose() method does not request that the object is garbage collected , although it does speed up collection by eliminating the need for finalization. .

Delegates

Delegates are a mechanism for providing callback functions. Delegates are akin to function pointers in C or functors in C++ and are useful in the same kinds of situation. One use of delegates is passing operations to a generic algorithm based on the types being used in the algorithm. The C function qsort() is an example of this as are a variety of the C++ functions in like replace_if() and transform(). Another use of delegates is as a means to register handlers for a particular event (i.e. the publish-subscribe model). To get the same functionality as C# delegates in Java, once can create interfaces that specify the signature of the callback method such as is done with the Comparable interface although this has the drawback of forcing the method to be an instance method when it most likely should be static.
To use delegates, one first declares a delegate that has the return type and accepts the same number of parameters as the methods one will want to invoke as callback functions. Secondly one needs to define a method that accepts an instance of the delegate as a parameter. Once this is done, a method that has the same signature as the delegate (i.e. accepts same parameters and returns the same type) or has covariant return types and contravariant parameter types (i.e return type is derived from the return type of the delegate and the parameter types are ancestors of the corresponding parameters) can be created and used to initialize an instance of the delegate which can then be passed to the method that accepts that delegate as a parameter. Note that the same delegate can refer to static and instance methods, even at the same time, since delegates are multicast. The example below shows the process of creating and using instance delegates.

C# Code
using System;

/* Mammal class hierarchy used to show return type covariance */
public class Mammal {
    public Mammal(){;}

    public virtual void Speak(){;} 
}

public class Cat : Mammal{
    public Cat(){;}

    public override void Speak(){
	Console.WriteLine("Meow");
    }
}

public class Dog : Mammal{
    public Dog(){;}

    public override void Speak(){
	Console.WriteLine("Woof");
    } 
}


public class Test {

    // delegate declaration, similar to a function pointer declaration
    public delegate Mammal CallbackFunction(Dog d);  
    
    public static Cat BarkAndScareCat(Dog d) 
    {
	d.Speak(); 
	Cat c = new Cat();
	c.Speak(); 
	return c; 
    }

     public static Mammal BarkAndReturnHome(Dog d) 
    {
	d.Speak(); 
	return d; 
    }
 
    public static void Main(string[] args){
    
    Dog dog            = new Dog(); 

    //create delegate using delegate object (old way)
    CallbackFunction myCallback = new CallbackFunction(BarkAndReturnHome); 
    myCallback(dog);

    //create delegate using delegate inference (new way) 
    CallbackFunction myCallback2 = BarkAndScareCat;
    myCallback2(dog);

    }
}

A delegate can be passed as a parameter to a method in the same way that a function pointer is passed in languages like C and C++. The following code sample shows how this is done.

C# Code
using System;

//delegate base
public class HasDelegates
{
       
    // delegate declaration, similar to a function pointer declaration
    public delegate bool CallbackFunction(string a, int b);
        
    //method that uses the delegate 
    public bool execCallback(CallbackFunction doCallback, string x, int y)
    {   
    Console.WriteLine("Executing Callback function...");
    return doCallback(x, y);                    
    }

}


public class FunctionDelegates
{
   
    public static readonly HasDelegates.CallbackFunction BarFuncCallback = 
        new HasDelegates.CallbackFunction(FunctionBar); 

    public static bool FunctionBar(string a, int b)
    {   
    Console.WriteLine("Bar: {0} {1}", b, a);
    return true;

    }

}

public class DelegateTest {

  
    public static void Main(string[] args){
    
    HasDelegates MyDel = new HasDelegates();

    // with static delegate, no need to know how to create delegate
    MyDel.execCallback(FunctionDelegates.BarFuncCallback, "Thirty Three", 33);

    }
} // DelegateTest

Value Types (Structs)
In both Java and C#, items on the heap have to be garbage collected to reclaim the memory allocated to them when they are no longer in use while stack based objects are automatically reclaimed by the system. Memory on the stack is typically faster to allocate than heap based memory.
In Java, all classes are created on the heap while primitives are created on the stack. This can lead to situations where objects that are used similarly to primitives in a program tend to hang around and wait for garbage collection thus adding overhead to the program. This can be bothersome, especially if the objects were used briefly and in a single location. To avoid the problem of allocating heap space for such classes and then having to garbage collect them, C# has a mechanism that allows one to specify that objects of a certain class should be stack based (In fact, C#'s built-in types such as int are actually implemented as structs in the runtime library). Unlike classes, value types are always passed by value and are not garbage collected. And arrays of value types contain the actual value type objects, not references to dynamically-allocated objects-a savings of both memory and time.
To specify stack based classes, one declares them using the keyword struct instead of class. To create C# structs (also known as value types) one uses the new keyword to create it as is done with classes. If the struct is instantiated with the default constructor syntax then a struct with its fields zeroed out is created. However, it is not possible to define a default constructor for a struct and override this behavior.
```
C# Code
using System; 

struct Point {

    public int x; 
    public int y; 

    public Point( int x, int y){
  
    this.x = x; 
    this.y = y;

    }
  
    public override string ToString(){

    return String.Format("({0}, {1})", x, y); 

    }


    public static void Main(string[] args){

    Point start = new Point(5, 9); 
    Console.WriteLine("Start: " + start);

    /* The line below wouldn't compile if Point was a class */ 
    Point end = new Point(); 
    Console.WriteLine("End: " + end);

    }

} // Point
```
Run Time Type Identification (as operator)
The C# as operator is completely analogous to C++'s dynamic_cast construct. The semantics of the as operator are that it attempts to perform an explict cast to a type and returns null if the operation was unsuccessful.
```
C# Code
MyClass mc = o as MyClass; 

if(mc !=  null)      //check if cast successful 
   mc.doStuff(); 
```
NOTE: The as operator cannot be used to convert to or from value types.
Properties
Properties are a way to abstract away from directly accessing the members of a class, similar to how accessors (getters) and modifiers (setters) are used in the Java world. A property is accessed by users of a class as if it was a field or member variable but in actuality is a method call. Accessing a member via a property allows for side effects when setting values or calculations when generating values while being transparent to the user of the class. Properties thus provide an explicit way to decouple the implementation of the member access from how it is actually used.
It is possible to create, read-only, write-only or read-write properties depending on if the getter and setter are implemented or not. In addition, it is possible to create a property whose getter and setter have different visibility (e.g. a public getter but a private setter). The example below shows different kinds of properties.
```
C# Code
using System; 

public class User {


 public User(string name){

 this.name = name; 

 } 

 private string name; 

 //property with public getter and private setter
 public string Name{

 get{
 return name; 
 } 

 private set { 
 name = value; 
 }
 }

 private static int minimum_age = 13; 

 //read-write property for class member, minimum_age
 public static int MinimumAge{
 
 get{
 return minimum_age; 
 }

 set{
 
 if(value > 0 && value < 100)
 minimum_age = value; 
 else 
 Console.WriteLine("{0} is an invalid age, so minimum age remains at {1}", value, minimum_age);

 }
 }

 public static void Main(string[] args){
 
 User newuser = new User("Bob Hope"); 

 User.MinimumAge = -5; /* prints error to screen since value invalid */ 
 User.MinimumAge = 18; 
 //newuser.Name = "Kevin Nash"; Causes compiler error since Name property is read-only 

 Console.WriteLine("Minimum Age: " + User.MinimumAge); 
 Console.WriteLine("Name: {0}", newuser.Name);
 }
} // User
```
The use of properties as an abstraction away from whether a member access is a method call or not may fall apart if the property throws an exception. When this occurs users of the object must then treat operations that look like member accesses as if they were method calls which can lead to unintuitive looking code. The example below shows code that sets the values for the fields of a Clock class that where the setters throw an exception if the value is invalid.
```
C# Code

try{

myClock.Hours = 28; /* setter throws exception because 28 is an invalid hour value */
myClock.Minutes = 15;
myClock.Seconds = 39;

}catch(InvalidTimeValueException itve){
 
/* figure out which field was invalid and report error */ 

}
```
To avoid situations like the one in the above example it is best that one avoids throwing exceptions in properties and handle the exceptions that are thrown by methods used in the property. If throwing an exception is avoidable in some situations then the documentation for the property must adequately describe the exceptions that can be thrown and the circumstances that lead to them being thrown.
Multidimensional Arrays
C# makes the distinction between multidimensional and jagged arrays. A multidimensional array is akin to a multidimensional array in C or C++ that is a contiguous block containing members of the same type. A jagged array is akin to an array in Java which is an array of arrays, meaning that it contains references to other arrays which may contain members of the same type or other arrays depending on how many levels the array has. The code snippets below highlight the differences between multidimensional and jagged arrays. The lack of true multidimensional arrays in Java has made it problematic to use Java in certain aspects of technical computing which has lead to various efforts to improve this position including research efforts by IBM which involved writing their own Array class to get around the shortcomings in Java arrays.
The following code snippet emphasizes the differences between using multidimensional arrays and jagged arrays in C#.
```
C# Code
using System;


public class ArrayTest {

 
 public static void Main(string[] args){

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

 for(int i=0, size = multi.GetLength(0); i < size; i++){

 for(int j=0, size2 = multi.GetLength(1); j < size2; j++){
 Console.WriteLine("multi[" + i + "," + j + "] = " + multi[i,j]);
 }

 }


 int[][] jagged = new int[4][];
 jagged[0] = new int[2]{0, 1};
 jagged[1] = new int[2]{2, 3};
 jagged[2] = new int[2]{4, 5};
 jagged[3] = new int[2]{6, 7};

 for(int i=0, size = jagged.Length; i < size; i++){

 for(int j=0, size2 = jagged[1].Length; j < size2; j++){
 Console.WriteLine("jagged[" + i + "][" + j + "] = " + jagged[i][j]);
 }

 }
 }

} // ArrayTest
```

Indexers

An indexer is a special syntax for overloading the [] operator for a class. An indexer is useful when a class is a container for another kind of object. Indexers are flexible in that they support any type, such as integers or strings, as indexes. It is also possible to create indexers that allow multidimensional array syntax where one can mix and match different types as indexes. Finally, indexers can be overloaded.

C# Code
using System;
using System.Collections;

public class IndexerTest: IEnumerable, IEnumerator {

    private Hashtable list; 

    public IndexerTest (){

    index = -1; 
    list = new Hashtable();     
    }

    //indexer that indexes by number
    public object this[int column]{


    get{
    
        return list[column];
    
    }


    set{
      
        list[column] = value; 
    }

    }


    /* indexer that indexes by name */ 
    public object this[string name]{


    get{
    
        return this[ConvertToInt(name)];
    
    }

    set{
        this[ConvertToInt(name)] = value; 
    }

    }


    /* Convert strings to integer equivalents */
    private int ConvertToInt(string value){

    string loVal = value.ToLower(); 

    switch(loVal){
        
    case "zero": return 0;
    case "one": return 1;
    case "two": return 2;
    case "three":  return 3;
    case "four": return 4;
    case "five": return 5; 

    default:
        return 0; 
    }

    return 0; 

    }


    /** 
     * Needed to implement IEnumerable interface. 
     */
    public IEnumerator GetEnumerator(){ return (IEnumerator) this; }


    /** 
     * Needed for IEnumerator. 
     */ 
    private int index; 

    /** 
     * Needed for IEnumerator. 
     */ 
    public bool MoveNext(){

    index++;
    if(index >= list.Count)
        return false; 
    else
        return true; 
    }

    /** 
     * Needed for IEnumerator. 
     */ 
    public void Reset(){
    index = -1; 
    }


    /** 
     * Needed for IEnumerator. 
     */ 
    public object Current{

    get{
        return list[index];
    }
    }


    public static void Main(string[] args){

    IndexerTest it = new IndexerTest(); 
    it[0] = "A"; 
    it[1] = "B";
    it[2] = "C";
    it[3] = "D"; 
    it[4] = "E";


    Console.WriteLine("Integer Indexing: it[0] = " + it[0]);    
    Console.WriteLine("String  Indexing: it[\"Three\"] = " + it["Three"]);

    Console.WriteLine("Printing entire contents of object via enumerating through indexer :");

    foreach( string str in it){
        Console.WriteLine(str);
    }

    }

} // IndexerTest

Preprocessor Directives
C# includes a preprocessor that has a limited subset of the functionality of the C/C++ preprocessor. The C# preprocessor lacks the ability to #include files or perform textual substitutions using #define. The primary functionality that remains is the ability to #define and #undef identifiers and also the ability to select which sections of code to compile based on the validity of certain expressions via #if, #elif, and #else. The #error and #warning directives cause the errors or warnings messages following these directives to be printed on compilation. The #pragma directive is used to supress compiler warning messages. Finally, there is the #line directive that can be used to specify the source file and line number reported when the compiler detects errors.
```
C# Code
#define DEBUG /* #define must be first token in file */ 
using System; 

#pragma warning disable 169 /* Disable 'field never used' warning */

class PreprocessorTest{

    int unused_field; 

    public static void Main(string[] args){
    
    #if DEBUG
      Console.WriteLine("DEBUG Mode := On");
    #else
      Console.WriteLine("DEBUG Mode := Off");
    #endif

    }

}
```
Aliases
The using keyword can be used to alias the fully qualified name for a type similar to the way typedef is used in C and C++. This is useful in creating readable code where the fully qualified name of a class is needed to resolve namespace conflicts.
```
C# Code
using Terminal = System.Console; 

class Test{

     public static void Main(string[] args){

       Terminal.WriteLine("Terminal.WriteLine is equivalent to System.Console.Writeline"); 

     }

}
```
Runtime Code Generation
The Reflection.Emit namespace contains classes that can be used to generate .NET instruction language (IL) and use it to build classes in memory at runtime or even write portable executable (PE) files to disk. This is analagous to a Java library that would allow one to create Java classes at runtime by generating Java byte codes which could then be written to disks or loaded and used within the program.
It is expected that the primary users of the Reflection.Emit namespace will be authors of compilers and script engines. For instance, the regular expression classes in System.Text.RegularExpressions use the Reflection.Emit library to generate a custom matching engine for each regular expression compiled.
Pointers and Unsafe Code
Although core C# is like Java in that there is no access to a pointer type that is analogous to pointer types in C and C++, it is possible to have pointer types if the C# code is executing in an unsafe context. When C# code is executing in an unsafe context, a lot of runtime checking is disabled which means that the program must have full trust on the machine it is running on.
Certain situations call for the use of unsafe code such as when interfacing with the underlying operating system, during interactions with COM objects that take structures that contain pointers, when accessing a memory-mapped device or in situations where performance is critical. The syntax and semantics for writing unsafe code is similar to the syntax and semantics for using pointers in C and C++. To write unsafe code, the unsafe keyword must be used to specify the code block as unsafe and the program must be compiled with the /unsafe compiler switch.
Since garbage collection may relocate managed (i.e. safe) variables during the execution of a program, the fixed keyword is provided so that the address of a managed variable is pinned during the execution of the parts of the program within the fixed block. Without the fixed keyword there would be little purpose in being able to assign a pointer to the address of a managed variable since the runtime may move the variable from that address as part of the mark & compact garbage collection process.
```
C# Code
using System; 

class UnsafeTest{


 public static unsafe void Swap(int* a, int*b){

 int temp = *a; 
 *a = *b; 
 *b = temp; 
 }


 public static unsafe void Sort(int* array, int size){

 for(int i= 0; i < size - 1; i++)
 for(int j = i + 1; j < size; j++)
 if(array[i] > array[j])
 Swap(&array[i], &array[j]); 

 }

 public static unsafe void Main(string[] args){

 int[] array = {9, 1, 3, 6, 11, 99, 37, 17, 0, 12}; 

 Console.WriteLine("Unsorted Array:"); 
 
 foreach(int x in array)
 Console.Write(x + " "); 

 fixed( int* iptr = array ){ // must use fixed to get address of array

 Sort(iptr, array.Length);
 
 }//fixed 
 
 Console.WriteLine("\nSorted Array:"); 
 
 foreach(int x in array)
 Console.Write(x + " "); 

 }

}
```
Pass by Reference
In Java the arguments to a method are passed by value meaning that a method operates on copies of the items passed to it instead of on the actual items. In C#, as in C++ and in a sense C, it is possible to specify that the arguments to a method actually be references to the items being passed to the method instead of copies. This feature is particularly useful when one wants to create a method that returns more than one object. In Java trying to return multiple values from a method is not supported and leads to interesting anomalies like the fact that a method that swaps two numbers which has been the hallmark of freshman computer science classes for years is impossible to do in Java without resorting to coding tricks.
The C# keywords used to specify that a parameter is being passed by reference are ref and out. The difference between the keywords is that parameters passed using ref must be initialized to some value while those passed using out do not have to be.
A more detailed explanation of Java's lack of Pass By Reference semantics is available in the Javaworld article, Does Java pass by reference or pass by value? Why can't you swap in Java? by Tony Sintes
```
Java Code
class PassByRefTest{

    public static void changeMe(String s){

    s = "Changed"; 

    }

    public static void swap(int x, int y){

    int z = x;
    x = y;
    y = z;

    }

    public static void main(String[] args){

    int a = 5, b = 10; 
    String s = "Unchanged"; 

    swap(a, b); 
    changeMe(s); 

    System.out.println("a := " + a + ", b := " + b + ", s = " + s);
    }
}

OUTPUT
a := 5, b := 10, s = Unchanged

C# Code

using System; 

class PassByRefTest{

    public static void ChangeMe(out string s){

    s = "Changed"; 

    }

    public static void Swap(ref int x, ref int y){

    int z = x;
    x = y;
    y = z;

    }

    public static void Main(string[] args){

    int a = 5, b = 10; 
    string s; 

    Swap(ref a, ref b); 
    ChangeMe(out s); 

    Console.WriteLine("a := " + a + ", b := " + b + ", s = " + s);
    }
}

OUTPUT
a := 10, b := 5, s = Changed
```

Verbatim Strings

C# provides the ability to avoid the usage of escape sequences within string constants and instead declare strings literally. Thus backslashes, tabs, quotes and newlines can be part of a string without using escape sequences. The only caveat is that double quotes that appear within verbatim strings should be doubled. Verbatim strings are specified by prepending the @ symbol to string declarations.

C# Code
using System; 

class VerbatimTest{

    public static void Main(){

    //verbatim string 
    string filename  = @"C:\My Documents\My Files\File.html"; 
    
    Console.WriteLine("Filename 1: " + filename);

    //regular string 
    string filename2 =  "C:\\My Documents\\My Files\\File.html"; 

    Console.WriteLine("Filename 2: " + filename2);

    string snl_celebrity_jeopardy_skit = @"
        Darrell Hammond (Sean Connery) : I'll take ""Swords"" for $400
        Will Farrell    (Alex Trebek)  : That's S-Words, Mr Connery.
        ";

    Console.WriteLine(snl_celebrity_jeopardy_skit);

    }

}

Overflow Detection
C# provides the option to explicitly detect or ignore overflow conditions in expressions and type conversions. Overflow conditions detected in code throw a System.OverFlowException. Since overflow detection causes a performance hit it can be explicitly enabled by using the /checked+ compiler option. One can also mandate code that must always be checked for overflow conditions by placing it in a checked block or that must always be ignored with regards to overflow detection by placing it in an unchecked block.
```
C# Code
using System; 

class CheckedTest{


    public static void Main(){

    int num = 5000; 

    /* OVERFLOW I */
    byte a  = (byte) num; /* overflow detected only if /checked compiler option on */

    /* OVERFLOW II */
    checked{
                
        byte b = (byte) num; /* overflow ALWAYS detected */     
    }

    /* OVERFLOW III */
    unchecked{
                
        byte c = (byte) num; /* overflow NEVER detected */      
    }

    }//Main
}
```
Explicit Interface Implementation
Sometimes when a class implements an interface it is possible for there to be namespace collisions with regards to method names. For instance, a FileRepresentation class which has a graphical user interface may implement an IWindow and an IFileHandler interface. Both of these classes may have a Close method where in the case of IWindow it means to close the GUI window while in the case of IFileHandler it means to close the file. In Java, there is no solution to this problem besides writing one Close method that does the same thing when invoked via an IWindow handle or an IFileHandler handle. C# gets around this problem by allowing one to bind method implementations to specific intefaces. Thus in the aformentioned example, the FileRepresentation class would have different Close methods that would be invoked depending on whether the class was being treated as an IWindow or an IFileHandler.
NOTE: Explicit interface methods are private and can only be accessed if the object is cast to the required type before invoking the method.
```
C# Code
using System;

interface IVehicle{
    
    //identify vehicle by model, make, year
    void IdentifySelf();    

}

interface IRobot{

    //identify robot by name
    void IdentifySelf();

}

class TransformingRobot : IRobot, IVehicle{

    string model; 
    string make;
    short  year; 
    string name;
    

    TransformingRobot(String name, String model, String make, short year){

    this.name  = name;
    this.model = model; 
    this.make  = make; 
    this.year  = year; 

    }

    
    void IRobot.IdentifySelf(){

    Console.WriteLine("My name is " + this.name);
    }

    void IVehicle.IdentifySelf(){

    Console.WriteLine("Model:" + this.model + " Make:" + this.make + " Year:" + this.year);
    }


    public static void Main(){

    TransformingRobot tr = new TransformingRobot("SedanBot", "Toyota", "Corolla", 2001); 

    // tr.IdentifySelf(); ERROR 

    IVehicle v = (IVehicle) tr; 

    IRobot r   = (IRobot) tr; 

    v.IdentifySelf(); 
    
    r.IdentifySelf();   
   
   }
}

OUTPUT
Model:Toyota Make:Corolla Year:2001
My name is SedanBot
```

Friend Assemblies

The friend assembly feature allows an internal type or internal member of an assembly to be accessed from another assembly. To give one assembly access to another assembly's internal types and members, the [InternalsVisibleToAttribute] attribute is used.
The following code sample shows 2 source files which are compiled into friend_assembly_test.dll and friend_assembly_test_2.exe which utilize the friend's assembly feature

C# Code
// friend_assembly_test.cs
// compile with: /target:library
using System.Runtime.CompilerServices;
using System;

[assembly:InternalsVisibleTo("friend_assembly_test_2")]

// internal by default
class Friend 
{
    public void Hello() 
    {
        Console.WriteLine("Hello World!");
    }
}

// public type with internal member
public class Friend2 
{
 internal string secret = "I like jelly doughnuts";  
}

C# Code 2
// friend_assembliy_test_2.cs
// compile with: /reference:friend_assembly_test.dll /out:friend_assembly_test_2.exe
using System;

public class FriendFinder 
{
    static void Main() 
    {
        // access an internal type
        Friend f = new Friend();
        f.Hello();

        Friend2 f2 = new Friend2();
        // access an internal member of a public type
        Console.WriteLine(f2.secret);
    }
}

The Namespace Qualifier
The larger a project gets, the more likely it is that namespace collisions will occur. C# has the :: operator which is used for specifying at what scope a namespace should be resolved. The left operand indicates the scope at which to resolve the name while the right operand is the name to resolve. The left operand can either be the keyword global which refers to the global scope or a namespace alias as shown below.
```
C# Code
using System;
using sys = System; 

namespace TestLib{

class Test{

 public class System {} 

 static DateTime Console = DateTime.Now;   

    public static void Main(){
    //Console.WriteLine("Hello world"); doesn't work due to static member variable named 'Console'
    //System.Console.WriteLine("Hello world"); doesn't work due to nested class named 'System'
        
    global::System.Console.WriteLine("The time is " + Console); 

    sys::Console.WriteLine("Hello again"); 
    }
 }
}
```
NOTE: The extern alias statement can be used to attach an alias to an assembly which can then be used as the left operand of the :: operator. When this is done the scope used for name resolution is the top level namespace(s) within the assembly.
Iterators (Continuations)
For a data structure to support being a target of the foreach loop it must implement or return an instance of System.Collections.IEnumerable. However writing an Enumerator can be somewhat cumbersome which is where the yield keyword comes in. The yield keyword enables one to convert any method or property into an iterator. In an iterator, one simply traverses the data structure and returns its contents one by one using the yield return statement and indicates the end of the sequence of values with the yield break statement. The method or property must return one of IEnumerable, IEnumerable, IEnumerator or IEnumerator.
```
C# Code
using System;
using System.Collections;

class Test{

 public static string[] fruit = {"banana", "apple", "orange", "pear", "grape"};
 public static string[] vegetables = {"lettuce", "cucumber", "peas", "carrots"};

 public static IEnumerable FruitAndVeg{
 
  get{
   
   foreach(string f in fruit){
    yield return f; 
   }

   foreach(string v in vegetables){
    yield return v; 
   }

   yield break; //optional
  }
 
 }

 public static void Main(){
 
   foreach (string produce in Test.FruitAndVeg){
     Console.WriteLine(produce);
   }
 }

}
```
Partial Types
The partial types feature enables one to define a single class, struct or interface across multiple source files. This is particularly useful when dealing with automatically generated code. Prior to the existence of this feature,it was problematic to make changes to a class that contained automatically generated code because any change that required regeneration of the code could alter or remove parts of the code written by hand. With this feature the automatically generated parts of a class can live in one source file while the user generated parts of the class can live in another. This makes it less likely that changes to one will affect the other negatively and vice versa.
A partial class is specified by prefixing the keyword partial to the class declaration. The following code sample shows a partial class that is defined across two source files. Note how methods and properties from one source file can reference members defined in another.
```
C# Code
using System;

partial class Test{

 public static string[] fruit = {"banana", "apple", "orange", "pear", "grape"};
 public static string[] vegetables = {"lettuce", "cucumber", "peas", "carrots"};
 
 public static void Main(){
 
   foreach (string produce in Test.FruitAndVeg){
     Console.WriteLine(produce);
   }
 }

}
C# Code 2
using System;
using System.Collections; 

partial class Test{

 public static IEnumerable FruitAndVeg{
 
  get{
   foreach(string f in fruit){
    yield return f; 
   }
   foreach(string v in vegetables){
    yield return v; 
   }
  }
 
 }
```
It should be noted that all of the class attributes are merged across all definitions of a class. This means that contradictory attributes (e.g. class declared as private in one file and public in another) are disallowed.
Static Classes
A static class is a class that has no instance members, no instance constructors and cannot be used as a base class. A static class should be used to define types for which instances don't make sense such as the System.Environment and System.Math classes.
A static class is specified by prefixing the class declaration with the keyword static.
```
C# Code
using System;

public static class StaticClass{

 public static void HelloWorld(){
   Console.WriteLine("Hello World");
 } 

}

public class Test{

 public static void Main(string[] args){
 StaticClass.HelloWorld(); 
 }

}
```
Nullable Types
A nullable types is an instance of the System.Nullable type. A nullable type can represent the normal range of values for an underlying value type as well as the null value. For example, the type Nullable can represent the values true, false and null. A nullable type can be declared by appending the operator '?' to the name of a value type when declaring the variable. This means that bool? is equivalent to Nullable. Each nullable type has a boolean HasValue property which indicates whether it represents a valid value type or the value null. The actual value of the nullable type is stored in its Value property. There is also the GetValueOrDefault() method which either returns the value of the nullable type or the default value of the underlying value type if it is null.
Nullable types are particularly useful when mapping C# objects to relational database schemas since null is a valid value for all data types in SQL databases.
```
C# Code
using System;

public class Test{

 public static void Main(string[] args){

  int? x = 5; 
 
  if(x.HasValue){
   Console.WriteLine("The value of x is " + x.Value);
  }

  x = null; 

  //prints 0 
  Console.WriteLine(x.GetValueOrDefault());
 }

}
```
The ?? operator is called the null coalescing operator and is used for testing the value of a nullable type and returning its value or an alternate if its value is null. Thus x ?? y is equivalent to x == (null ? y : x).
```
C# Code
using System;

public class Test{

 public static void Main(string[] args){

  int? x = null; 
  int  y = x ?? 5;

  //prints 5 
  Console.WriteLine(y);
 }

}
```

Anonymous Methods

Anonymous methods are a companion feature to delegates. An anonymous method is a code block that can be used where a delegate method is expected. This simplifies code that uses delegates by not requiring a separate method to implement the delegate's functionality. The following code sample compares the anonymous method approach to using a named delegate

C# Code
using System;

public class Test {

    // delegate declaration, similar to a function pointer declaration
    public delegate void CallbackFunction(string a, int b);
  
    public static void PrintString(string a, int b){
      for(int i = 0; i < b ; i++)
	Console.WriteLine("{0}.) {1}", i + 1, a);
    }

    public static void Main(string[] args){
    
    /* anonymous code block */
    CallbackFunction cf = delegate (string a, int b){ 
                             for(int i = 0; i < b ; i++)
                               Console.WriteLine("{0}.) {1}", i + 1, a);
                          };

    cf("Thirty Three", 10); 


    /* using a named delegate function */
    CallbackFunction cf2 = new CallbackFunction(Test.PrintString); 
    cf2("Twenty Two", 5); 
    }
}

There are a number of restrictions to anonymous methods that must be kept in mind. For one, jump statements like break, goto and continue cannot be used o jump into an anonymous method from outside the code block or vice versa. Also anonymous methods cannot refer to ref or out parameters that are defined outside the scope of the method.

Wish You Were Here

Checked Exceptions

Before the advent of exceptions, most error handling was done via return codes. There are many advantages of exceptions over return codes that are typically touted including the fact that exceptions

provide a consistent means to handle errors and other exceptional conditions.
enable an error to propagate up the call stack if not handled in the current context.
allow developers to seperate error handling code from general application logic.

Java creates an additional wrinkle by possessing both checked and unchecked exceptions. Checked exceptions are exceptions that the calling method must handle either by catching the exception or declaring that the exception should be handled by its calling method via the throws clause. On the other hand, unchecked exceptions (also called runtime exceptions) do not have to be caught or declared in the throws clause. In a sense unchecked exceptions are similar to return codes in that they can be ignored without warnings or errors being issued by the compiler. Although if an exception is ignored at runtime, your program will terminate.
Checked exceptions are typically used to indicate to a calling method that the callee failed in its task as well as pass information as to how and why it failed. One must either catch a checked exception or declare it in the throws clause of the method or the Java compiler will issue an error. The reasoning behind the fact that the exception must be declared in the throws clause is that handling whatever errors that can occur when the method is used is just as important as knowing what parameters it accepts and the kind of type it returns.
Unchecked exceptions are typically exceptions that can occur in most parts of the program and thus the overhead of explicitly checking for them outweighs their usefulness due to the massive code bloat that would ensue. Examples of situations that throw unchecked exceptions are accessing a null object reference, trying to access an out of bounds index of an array or a division by zero. In all of the aforementioned cases it would be cumbersome to put try...catch blocks around every the code (for instance a try...catch block around every object access or every array access) and they are better off as unchecked exceptions.

In C#, all exceptions are unchecked and there is no analog to the throws clause. One major side effect of this is that unless the creator of the API explicitly documents the exceptions thrown then it is not possible for the users of the API to know what exceptions to catch in their code leading to unrobust applications that can fail unexpectedly. Thus users of C# are reliant on the documentation skill of programmers as their primary error handling mechanism which is a less than optimal situation.
For instance in the following code snippet, the only way to know what exceptions can be thrown by the method below is to either have the source code for all the methods called within it or if the developer of the method documents all the exceptions thrown by all the methods called within it (meaning that the developers of those methods must have done the same ad infinitum).

C# Code


public string GetMessageFromServer(string server) 
 {
    //Set up variables and String to write to the server
    Encoding ASCII = Encoding.ASCII;
    string Get = "GET / HTTP/1.1\r\nHost: " + server + 
                 "\r\nConnection: Close\r\n\r\n";
    Byte[] ByteGet = ASCII.GetBytes(Get);
    Byte[] RecvBytes = new Byte[256];
    String strRetPage = null;
 
    // IPAddress and IPEndPoint represent the endpoint that will
    //   receive the request
    // Get first IPAddress in list return by DNS
    IPAddress hostadd = Dns.Resolve(server).AddressList[0];
    IPEndPoint EPhost = new IPEndPoint(hostadd, 80);
 
    //Create the Socket for sending data over TCP
    Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
       ProtocolType.Tcp );
 
    // Connect to host using IPEndPoint
    s.Connect(EPhost);
    if (!s.Connected)
    {
       strRetPage = "Unable to connect to host";
       return strRetPage;
    }
 
    // Sent the GET text to the host
    s.Send(ByteGet, ByteGet.Length, 0);
 
    // Receive the page, loop until all bytes are received
    Int32 bytes = s.Receive(RecvBytes, RecvBytes.Length, 0);
    strRetPage = "Default HTML page on " + server + ":\r\n";
    strRetPage = strRetPage + ASCII.GetString(RecvBytes, 0, bytes);
 
    while (bytes > 0)
    {
       bytes = s.Receive(RecvBytes, RecvBytes.Length, 0);
       strRetPage = strRetPage + ASCII.GetString(RecvBytes, 0, bytes);
    }
 
    return strRetPage;
 }

The above code snippet is from the .NET Framework Beta 2 documentation for the Socket class. Note how there no exceptions caught in the code. If this was a method in a real application as opposed to a sample, it would be impossible for the users of this method to know what exceptions to catch without access to the source code or without the author of the method painstakingly checking what exceptions are thrown by every single method called and then documenting them. Below is the list of exceptions that could be thrown within the method according to their entries in the Microsoft .NET framework Beta 2 documentation.

Method	Exception(s) thrown
Encoding.GetBytes	ArgumentNullException
Dns.Resolve	ArgumentNullException, SocketException
IPEndPoint constructor	ArgumentException
Socket constructor	SocketException
Socket.Connect	ArgumentNullException, SocketException
Socket.Receive	ArgumentNullException, SocketException
ASCII.GetString	[undocumented as of Beta 2]

If the author of the method does not have time to document the exceptions that may be thrown from this method or happens to leave out an important one, such as the SocketException in this case, then the users of the method could have their applications fail unexpectedly without an elegant means of recovery in place. In the above case, the main exception of interest to users would probably be the SocketException since the others are all related to the internal workings of the method and don't really have anything to do with the caller and in fact would probably be unchecked exceptions if they existed in Java. In practice the GetMessageFromServer method would check the validity of its string parameter and throw ArgumentNException or one of its subclasses depending the results of the check.
The rationale for excluding checked exceptions from C# has never been fully explained by Microsoft but this message from Eric Gunnerson of the C# team sheds some light on the reasoning behind this decision. The primary reason for this choice according to Gunnerson is that examination of small programs led to the conclusion that using checked exceptions could both enhance developer productivity and enhance code quality. On the other hand experience with large software projects suggested that using checked exceptions decreased productivity with little or no increase in code quality.

[updated 12/5/2001] It should be noted that there is agreement amongst some Java developers with Eric Gunnerson's assertion that checked exceptions have certain disadvantages. Alan Griffiths wrote an excellent article entitled Exceptional Java where he notes that checked exceptions lead to breaking encapsulation, loss of information and information overload. Bruce Eckel, author of Thinking In Java and Thinking In C++, also questions the wisdom of checked exceptions in his article entitled Does Java need Checked Exceptions?.
The lack of checked exceptions in C# will be very unsettling for Java developers and may lead to program designs which are flawed. One only has to remember the anecdote about how originally a considerable amount of the exceptions in the Java API were unchecked but upon changing them to checked exceptions a number of bugs and design flaws were found in the API. Hopefully this will be remedied in later versions of C# or a third party could develop a static source code analysis tool such as lint. Meanwhile C# developers must take care to document all exceptions thrown from their methods that callers should be aware of as a matter of consideration. This is not to say that documentation should not typically exist but since it is the only means to ensure exception safe C# code then its importance is now a much greater.

Cross Platform Portability (Write Once, Run Anywhere)
A major selling point of Java™ technologies is that applications written in Java are portable across a number of operating systems and platforms. Sun officially supports Linux, Windows and Solaris but other vendors have implemented Java on a large range of platforms including OS/2, AIX and MacOS. Binary compatibility across platforms using similar Java versions is the norm except for situations involving bugs in various VM implementations.
At the time of this writing C# is only available on Windows. Efforts are currently in place to port it to other platforms, including Linux and FreeBSD. Linux porting is being done as part of the Mono project developed by Ximian while the FreeBSD implementation is a Microsoft project codenamed rotor.
Extensions
The Java extension mechanism enables developers to extend the abilities of the core Java platform. Developers can create classes and packages which are treated by the Java runtime as if they are core Java classes and packages like java.lang, java.util, java.net,etc. This means that extensions do not have to be placed on the class path since they are treated as if they are part of the core libraries such as those in the Java runtime library, rt.jar. Extensions are contained within JAR files and once installed are available to all applications running on the target platform.
A C# parallel would be the ability to create assemblies that are treated as if they are part of the System namespace contained in the System.dll assembly.
strictfp
In Java, strictfp is a modifier that can be used for class, method or interface declarations to ensure strict floating point arithmetic that conforms to behavior specified in the IEEE standard 754 for binary floating-point arithmetic (IEEE 754). Within an FP-strict expression, all intermediate values must be members of the float or double value set, depending on whether the expression is evaluating floats or doubles. Within expressions that are not FP-strict, it is allowable for the JVM implementation to use an extended exponent range to represent intermediate results. The example below clarifies the difference between FP-strict and non-FP-strict expressions.
```
Java Code

public class FPTest {

    static strictfp double halfOfSquareFP(double n){

    return n * 4.0  * 0.5;
    }

    static double halfOfSquareNFP(double n){

    return n * 4.0 * 0.5;
    }

    public static void main(String[] args) {
    
    double d = 6.6e+307;
    
    System.out.println(halfOfSquareFP(d));

    System.out.println(halfOfSquareNFP(d)); 
    }

}//FPTest
```
In the above example the value printed by calling halfOfSquareFP() will be "Infinity" regardless of what JVM the application is run on. This is because Java enforces left-to-right evaluation of arguments and 6.6e+307 multiplied by 4.0 exceeds the maximum value for a double thus leading to all subsequent operations yielding Infinity. On the other hand the value printed on calling halfOfSquareNFP() may not be the same on different JVMs depending on whether the target platform and JVM implementation support storing intermediate values in an extended format that has a larger range than that of doubles. Thus on some platforms the value 1.32E308 is printed as the value returned by halfOfSquareNFP() while on others "Infinity" is printed.
Section 4.1.5 of the C# specification covers floating point numbers and states that due to the excessive performance costs of enforcing that certain architectures perform operations with less precision than is possible, there is no way to enforce FP-strictness in C#.
Dynamic Class Loading
The ability to dynamically load classes at runtime in Java is a very powerful feature especially when combined with a remote procedure call mechanism. Dynamic class loading enables Java applications to download the class files (i.e. byte codes) of classes that do not exist on the target machine. An object type that only exists on one machine can be transferred to other machines in a seamless and transparent manner. Thus new types can be introduced on a remote machine which allows the behavior of remote applications to be significantly extended at runtime. The following example shows an example of a remote application that accepts types that implement a certain interface, IStockTicker.
```
Java Code

public class MyRMIServer extends UnicastRemoteObject
    implements SomeInterface {
    
    public MyRMIServer() throws RemoteException{ super();}

      
    public String obtainName(IStockTicker ticker){

    String stock_ticker = ticker.getTicker(); 

    if(stock_ticker.equalsIgnoreCase("MSFT"))
        return "Microsoft Corporation"; 
    else  if(stock_ticker.equalsIgnoreCase("SUNW")) 
            return "Sun Microsystems"; 
    else
            return "Unknown Stock Ticker"; 

    }/* obtainName(IStockTicker) */
    
}
```
The obtainName() remote method in the above class accepts types that implement the IStockTicker interface. It is possible for this method to be invoked from a remote client which then passes a type that implements IStockTicker, for example NASDAQStock, that does not exist on the server where the MyRMIServer class lives. In this case the entire code needed for NASDAQStock class is transmitted from the client to the remote server automatically.

C# and the .NET Remoting mechanism also enable remotely downloading classes from one machine to the other but the client has to publish the assembly and the server can then load it via a URL.
For information on Java Remote Method Invokation (RMI) read the Java tutorial on RMI. Information on .NET Remoting with C# is explained in this introduction to .NET remoting and this technical overview on MSDN.
Interfaces That Contain Fields
In Java it is possible for constants to be declared in interfaces which are then available to implementing classes while in C# this is not allowed. This may not be a big issue in C# since the primary usage of constants declared in interfaces is as a poor emulation of enumerations.

Anonymous Inner Classes

An anonymous inner class is a class declaration that occurs at the same point where an instance of that class is created. Anonymous inner classes are typically used where only one instance of a type will exist in the application. The most popular usage of anonymous inner classes is for specifying callbacks especially in the Java GUI libraries but there are other situations where anonymous inner classes are beneficial as well. Below is an example of using anonymous inner classes to implement the State Design Pattern.

Java Code

 /* An instance of this class represents the current state of a ClientView GUI. */
  
public abstract class ClientState{

     // This instance of the class is used to signify that the user is not logged in.
     // The only thing a user can do in this state is login and exit.  
     
    public static ClientState NOT_LOGGED_IN = new ClientState() {
        public void setMenuState(ClientView cv) {
            
        cv.setMenuEnabledState(false); /* disable all menus */
        cv.menuLogin.setEnabled(true); 
        cv.menuExit.setEnabled(true); 

        //can't type 
        cv.textArea.setEnabled(false); 
        }

        public String toString(){
        return "ClientState: NOT_LOGGED_IN"; 
        }
    };
    
    
     // This instance of the class is used to signify that the user is logged in
     // but has not yet created a document to work with. The user cannot type or save 
     // anything in this mode. 
     
    public static ClientState NO_OPEN_DOCUMENT = new ClientState() {
        public void setMenuState(ClientView cv) {
            
        cv.setMenuEnabledState(false); /* disable all menus */
        cv.menuLogin.setEnabled(true); 
        cv.menuExit.setEnabled(true); 
        cv.menuOpenFile.setEnabled(true);
        cv.menuNewFile.setEnabled(true);

        //can't type 
        cv.textArea.setEnabled(false); 

        }

        public String toString(){
        return "ClientState: NO_OPEN_DOCUMENT"; 
        }
    }; 
    
    
     // This instance of the class is used to signify that the user is editting a file. 
     // In this mode the user can use any functionality he/she sees fit. 
     
    public static ClientState EDITTING_DOCUMENT = new ClientState() {
        public void setMenuState(ClientView cv) {
            
        cv.setMenuEnabledState(true);   /* enable all menus             
        cv.textArea.setEnabled(true); 
        }

        public String toString(){
        return "ClientState:EDITTING_DOCUMENT"; 
        }
    }; 

   
     
     // Default constructor private to stop people from directly creating instances 
     // of the class.        
    private ClientState() {;}

    
     // This disables various elements of the ClientView's menu dependent on which
     // ClientState object this is.      
    public abstract void setMenuState(ClientView cv);

} // ClientState


Below is an example of the code that would utilize the above ClientState class.  
  
    bool loginUser(String username, String passwd) {

        //check if already logged in
        if(myGUI.state == ClientState.NOT_LOGGED_IN)  
          return true; 

        //enable parts of the GUI if the user authenticates
        if(userAuthenticated(username, passwd)){

              myGUI.state = ClientState.NO_OPEN_DOCUMENT; 
              myGUI.state.setMenuState(myView); 
              return true; 

    }

        return false; 
    
 
   }/* loginUser(String, String) */

Static Imports
The static import feature makes it possible to access static members of a class without having specify the class name. This feature is intended to reduce the verbosity of code that frequently access the static members of a particular class (e.g. constants defined in a particular helper class).
A static import similar to a regular import statement except that the keyword static is used and instead of importing a package, a specific class is imported.
```
Java Code
import static java.awt.Color.*; 

public class Test{

    public static void main(String[] args) throws Exception{

	//constants not qualified thanks to static import
	System.out.println(RED + " plus " + YELLOW + " is " + ORANGE);
    }
}
```

Conclusion (2001)

Most developers, especially those with a background in C or C++, would probably agree that features like operator overloading, pointers, preprocessor directives, delegates and deterministic object cleanup make C# more expressive than Java in a number of cases. Similarly, Java developers who learn C# will be pleasantly surprised at features that are missing in Java that will seem glaring in their absence once one uses them in C#, such as boxing, enumerations and pass by reference. On the other hand the lack of checked exceptions, inner classes, cross platform portability or the fact that a class is not the smallest unit of distribution of code makes the choice of C# over Java not a clearcut case of choosing more language features without having to make any compromises.
It is my opinion that both languages are similar enough that they could be made to mirror each other without significant effort if so required by either user base. In this case, C# would have it easier than Java in that C# has less to borrow from Java than Java would have to borrow from C#. However, the true worth of a programming language that is intended for use outside of academia is how quickly the language evolves to adapt to the changing technological landscape and what kind of community surrounds the language. Some programming languages are akin to the French language under the Les Immortels of the Acad¨¦mie Française in France. Les immortels are charged with dictating what constitutes the official French language but they have been slow to adapt to the information age thus their edicts on what constitutes the proper French versions of new words, especially those related to technology, are usually ignored especially since they either conflict with what the general French public would rather call them and show up long after the unsanctioned words have already entered the lexicon. C++ is an example of a language that has undergone a process of balkanization closely resembling the French language under the Les Immortels of the Acad¨¦mie Française while Java under Sun Microsystems can be considered to be a language that has evolved with the times similar to how the English language has done.
Thus the question really becomes, which of these languages looks like it will evolve with the times and be easiest to adapt to new situations as they arise? So far, Sun has done a great job with Java although a lack of versioning support and the non-existence of a framework that enables extensibility of the language built into the platform makes drastic evolution difficult. C# with its support for versioning via the .NET framework and the existence of attributes which can be used to extend the features of the language looks like it would in the long run be the more adaptable language. Only time will tell however if this prediction is accurate.

Conclusion (2007)

As predicted in the original conclusion to this paper, a number of features have become common across both C# and Java since 2001. These features include generics, foreach loops, enumerations, boxing, variable length parameter lists and metadata annotations. However after years of convergence it seems that C# and Java are about to go in radically different directions. The current plans for C# 3.0 are highlighted in the Language Integrated Query (LINQ) Project which encompasses integrating a number of data oriented features including query, set operations, transformations and type inferencing directly into the C# language. In combination with some of C#'s existing features like anonymous methods and nullable types, the differences between C# and Java will become more stark over the next few years in contrast to the feature convergence that has been happening over the past few years.

Resources

Eckel, Bruce. Thinking In Java. Prentice Hall, 2000.
Gunnerson, Eric. A Programmer's Introduction To C#. Apress, 2001.
Sun Microsystems. The Java™ Tutorial.<http://java.sun.com/docs/books/tutorial/>
Microsoft Corporation. .NET Framework Programming. < http://msdn2.microsoft.com/en-us/library/ms229284(VS.80).aspx>
Microsoft Corporation. C# Language Reference. < http://msdn2.microsoft.com/en-us/library/618ayhy6(VS.80).aspx>

Acknowledgements

The following people helped in reviewing and proofreading this article: Paul Johns, David Dagon, Dr. Yannis Smaragdakis , Dmitri Alperovitch, Dennis Lu and Sanjay Bhatia.

Introduction to Object-oriented Programming (OOP)

2014-01-25T11:12:00.003+03:00

Posted by potty on January 20, 2014 at 11:52 PM PST

Why do we need to program?

Technology is part of our life. The world is changing daily and everything is getting automated. Learn to program is the creative way we can take our ideas to the next level and express solutions to society. By designing programs, we learn several abilities like critical reading, analytical thinking and create synthesis. The programmer defines the problem, plans a solution, codes the program, test the proposal and documents the features. But we can't program all the solutions with the same method, that's why programming paradigms appears.

Overview of Programming Paradigms

According to Vasappanavara, a programming paradigm "it is the manner in which programming elements such as functions, objects and variables are exploited to produce the desired output". It is important to understand that programming paradigms are not programming languages.
The following are typical examples of programming paradigms (according to Bhave):

What is Object-oriented Programming (OOP)?

The object-oriented is a programming paradigm where the program logic and data are weaved. As stated by Phil Ballard, it is a way of conceptualizing a program's data into discrete "things" referred to as objects, each having its own properties and methods.
Let's see an example. Suppose your friend is a bank manager and he wants you to help improving their system. The first object you might design is the general-purpose Account. The Account object has properties and methods. For each client your friend's bank have, you would have to create an Account object.

Characteristics

As follows the most important features of object-oriented programming:

Encapsulation. Capability to hide data and instructions inside an object.
Inheritance. Ability to create one object from another.
Polymorphism. The design of new classes is based on a single class.
Message Passing. It is the way objects communicate with each other.
Garbage Collection. Automatic memory management that destroys objects that are no longer in use by the program.

Benefits

As follows some benefits of using object-oriented programming:

Re-usability. You can write a program using a previous developed code.
Code Sharing. You are able to standardize the way your are programming with your colleagues.
Rapid Modeling. You can prototype the classes and their interaction through a diagram.

Drawbacks

As follows the disadvantages of using object-oriented programming:

Size. Are larger than other programs, consuming more memory and disk space.
Effort. Require a lot of work to create, including the diagramming on the planning phase and the coding on the execution phase.

Basic Concepts

Class
Basic template that specifies the properties and behaviours of something (real life or abstract).
Object
Particular instance of a class that responds consequently to events.
Attribute
Characteristics of the class. Often called instance variables.
Method
Algorithm associate to an class that represent a thing that the object does.
Subclass
Class based on another class.
Inheritance
Process where the subclass gets the attributes and methods from its parent class.
Interface
Specific template that enforces certain attributes and methods of a class.
Package
Namespace that organizes a set of related classes and interfaces.
Event
Alert the application when there is a state change of the object.

References

Vasappanavara, R. Object-oriented Programming Using C++ and Java. Chapter 1. Object-oriented Programming Basics. Section 1.3. Programming Paradigms. Pearson Education. India. May, 2011.
Bhave, M. Object Oriented Programming with C++, Second Edition. Chapter 4. Object Orientation: An Introduction. Section 4.1. Programming Paradigms. Pearson Education. India. May, 2012.
Ballard, P. Sams Teach Yourself JavaScript in 24 Hours, Fifth Edition. Hour 7. What is Object Oriented Programming (OOP)?. Pearson Education, Inc. United States. November, 2012.

Performance Tips and Tricks in .NET Applications

2013-07-18T22:40:00.001+03:00

Thanks Microsoft MSDN
Emmanuel Schanzer
Microsoft Corporation

August 2001

Summary: This article is for developers who want to tweak their applications for optimal performance in the managed world. Sample code, explanations and design guidelines are addressed for Database, Windows Forms and ASP applications, as well as language-specific tips for Microsoft Visual Basic and Managed C++. (25 printed pages)

Overview
Performance Tips for All Applications
Tips for Database Access
Performance Tips for ASP.NET Applications
Tips for Porting and Developing in Visual Basic
Tips for Porting and Developing in Managed C++
Additional Resources
Appendix: Cost of Virtual Calls and Allocations

Overview

This white paper is designed as a reference for developers writing applications for .NET and looking for various ways to improve performance. If you are a developer who is new to .NET, you should be familiar with both the platform and your language of choice. This paper strictly builds on that knowledge, and assumes that the programmer already knows enough to get the program running. If you are porting an existing application to .NET, it's worth reading this document before you begin the port. Some of the tips here are helpful in the design phase, and provide information you should be aware of before you begin the port.

This paper is divided into segments, with tips organized by project and developer type. The first set of tips is a must-read for writing in any language, and contains advice that will help you with any target language on the Common Language Runtime (CLR). A related section follows with ASP-specific tips. The second set of tips is organized by language, dealing with specific tips about using Managed C++ and Microsoft® Visual Basic®.

Due to schedule limitations, the version 1 (v1) run time had to target the broadest functionality first, and then deal with special-case optimizations later. This results in a few pigeonhole cases where performance becomes an issue. As such, this paper covers several tips that are designed to avoid this case. These tips will not be relevant in the next version (vNext), as these cases are systematically identified and optimized. I'll point them out as we go, and it is up to you to decide whether it is worth the effort.

Performance Tips for All Applications

There are a few tips to remember when working on the CLR in any language. These are relevant to everyone, and should be the first line of defense when dealing with performance issues.

Throw Fewer Exceptions

Throwing exceptions can be very expensive, so make sure that you don't throw a lot of them. Use Perfmon to see how many exceptions your application is throwing. It may surprise you to find that certain areas of your application throw more exceptions than you expected. For better granularity, you can also check the exception number programmatically by using Performance Counters.

Finding and designing away exception-heavy code can result in a decent perf win. Bear in mind that this has nothing to do with try/catch blocks: you only incur the cost when the actual exception is thrown. You can use as many try/catch blocks as you want. Using exceptions gratuitously is where you lose performance. For example, you should stay away from things like using exceptions for control flow.

Here's a simple example of how expensive exceptions can be: we'll simply run through a For loop, generating thousands or exceptions and then terminating. Try commenting out the throw statement to see the difference in speed: those exceptions result in tremendous overhead.

Copy

public static void Main(string[] args){
  int j = 0;
  for(int i = 0; i < 10000; i++){
    try{   
      j = i;
      throw new System.Exception();
    } catch {}
  }
  System.Console.Write(j);
  return;   
}

Beware! The run time can throw exceptions on its own! For example, Response.Redirect() throws a ThreadAbort exception. Even if you don't explicitly throw exceptions, you may use functions that do. Make sure you check Perfmon to get the real story, and the debugger to check the source.
To Visual Basic developers: Visual Basic turns on int checking by default, to make sure that things like overflow and divide-by-zero throw exceptions. You may want to turn this off to gain performance.
If you use COM, you should keep in mind that HRESULTS can return as exceptions. Make sure you keep track of these carefully.

Make Chunky Calls

A chunky call is a function call that performs several tasks, such as a method that initializes several fields of an object. This is to be viewed against chatty calls, that do very simple tasks and require multiple calls to get things done (such as setting every field of an object with a different call). It's important to make chunky, rather than chatty calls across methods where the overhead is higher than for simple, intra-AppDomain method calls. P/Invoke, interop and remoting calls all carry overhead, and you want to use them sparingly. In each of these cases, you should try to design your application so that it doesn't rely on small, frequent calls that carry so much overhead.

A transition occurs whenever managed code is called from unmanaged code, and vice versa. The run time makes it extremely easy for the programmer to do interop, but this comes at a performance price. When a transition happens, the following steps needs to be taken:

Perform data marshalling
Fix Calling Convention
Protect callee-saved registers
Switch thread mode so that GC won't block unmanaged threads
Erect an Exception Handling frame on calls into managed code
Take control of thread (optional)

To speed up transition time, try to make use of P/Invoke when you can. The overhead is as little as 31 instructions plus the cost of marshalling if data marshalling is required, and only 8 otherwise. COM interop is much more expensive, taking upwards of 65 instructions.

Data marshalling isn't always expensive. Primitive types require almost no marshalling at all, and classes with explicit layout are also cheap. The real slowdown occurs during data translation, such as text conversion from ASCI to Unicode. Make sure that data that gets passed across the managed boundary is only converted if it needs to be: it may turn out that simply by agreeing on a certain datatype or format across your program you can cut out a lot of marshalling overhead.

The following types are called blittable, meaning they can be copied directly across the managed/unmanaged boundary with no marshalling whatsoever: sbyte, byte, short, ushort, int, uint, long, ulong, float and double. You can pass these for free, as well as ValueTypes and single-dimensional arrays containing blittable types. The gritty details of marshalling can be explored further on the MSDN Library. I recommend reading it carefully if you spend a lot of your time marshalling.

Design with ValueTypes

Use simple structs when you can, and when you don't do a lot of boxing and unboxing. Here's a simple example to demonstrate the speed difference:

using System;

namespace ConsoleApplication{

Copy

  public struct foo{
    public foo(double arg){ this.y = arg; }
    public double y;
  }
  public class bar{
    public bar(double arg){ this.y = arg; }
    public double y;
  }
  class Class1{
    static void Main(string[] args){
      System.Console.WriteLine("starting struct loop...");
      for(int i = 0; i < 50000000; i++)
      {foo test = new foo(3.14);}
      System.Console.WriteLine("struct loop complete. 
                                starting object loop...");
      for(int i = 0; i < 50000000; i++)
      {bar test2 = new bar(3.14); }
      System.Console.WriteLine("All done");
    }
  }
}

When you run this example, you'll see that the struct loop is orders of magnitude faster. However, it is important to beware of using ValueTypes when you treat them like objects. This adds extra boxing and unboxing overhead to your program, and can end up costing you more than it would if you had stuck with objects! To see this in action, modify the code above to use an array of foos and bars. You'll find that the performance is more or less equal.

Tradeoffs ValueTypes are far less flexible than Objects, and end up hurting performance if used incorrectly. You need to be very careful about when and how you use them.

Try modifying the sample above, and storing the foos and bars inside arrays or hashtables. You'll see the speed gain disappear, just with one boxing and unboxing operation.

You can keep track of how heavily you box and unbox by looking at GC allocations and collections. This can be done using either Perfmon externally or Performance Counters in your code.

See the in-depth discussion of ValueTypes in Performance Considerations of Run-Time Technologies in the .NET Framework.

Use AddRange to Add Groups

Use AddRange to add a whole collection, rather than adding each item in the collection iteratively. Nearly all windows controls and collections have both Add and AddRange methods, and each is optimized for a different purpose. Add is useful for adding a single item, whereas AddRange has some extra overhead but wins out when adding multiple items. Here are just a few of the classes that support Add and AddRange:

StringCollection, TraceCollection, etc.
HttpWebRequest
UserControl
ColumnHeader

Trim Your Working Set

Minimize the number of assemblies you use to keep your working set small. If you load an entire assembly just to use one method, you're paying a tremendous cost for very little benefit. See if you can duplicate that method's functionality using code that you already have loaded.

Keeping track of your working set is difficult, and could probably be the subject of an entire paper. Here are some tips to help you out:

Use vadump.exe to track your working set. This is discussed in another white paper covering various tools for the managed environment.
Look at Perfmon or Performance Counters. They can give you detail feedback about the number of classes that you load, or the number of methods that get JITed. You can get readouts for how much time you spend in the loader, or what percent of your execution time is spent paging.

Use For Loops for String Iteration—version 1

In C#, the foreach keyword allows you to walk across items in a list, string, etc. and perform operations on each item. This is a very powerful tool, since it acts as a general-purpose enumerator over many types. The tradeoff for this generalization is speed, and if you rely heavily on string iteration you should use a For loop instead. Since strings are simple character arrays, they can be walked using much less overhead than other structures. The JIT is smart enough (in many cases) to optimize away bounds-checking and other things inside a For loop, but is prohibited from doing this on foreach walks. The end result is that in version 1, a For loop on strings is up to five times faster than using foreach. This will change in future versions, but for version 1 this is a definite way to increase performance.

Here's a simple test method to demonstrate the difference in speed. Try running it, then removing the For loop and uncommenting the foreach statement. On my machine, the For loop took about a second, with about 3 seconds for the foreach statement.

Copy

public static void Main(string[] args) {
  string s = "monkeys!";
  int dummy = 0;

  System.Text.StringBuilder sb = new System.Text.StringBuilder(s);
  for(int i = 0; i < 1000000; i++)
    sb.Append(s);
  s = sb.ToString();
  //foreach (char c in s) dummy++;
  for (int i = 0; i < 1000000; i++)
    dummy++;
  return;   
  }
}

Tradeoffs Foreach is far more readable, and in the future it will become as fast as a For loop for special cases like strings. Unless string manipulation is a real performance hog for you, the slightly messier code may not be worth it.

Use StringBuilder for Complex String Manipulation

When a string is modified, the run time will create a new string and return it, leaving the original to be garbage collected. Most of the time this is a fast and simple way to do it, but when a string is being modified repeatedly it begins to be a burden on performance: all of those allocations eventually get expensive. Here's a simple example of a program that appends to a string 50,000 times, followed by one that uses a StringBuilder object to modify the string in place. The StringBuilder code is much faster, and if you run them it becomes immediately obvious.

Copy

namespace ConsoleApplication1.Feedback{
  using System;
  
  public class Feedback{
    public Feedback(){
      text = "You have ordered: \n";
    }

    public string text;

    public static int Main(string[] args) {
      Feedback test = new Feedback();
      String str = test.text;
      for(int i=0;i<50000 0="" blue_toothbrush="" done="" i="" pre="" return="" str="str" system.console.out.writeline="">

Copy

namespace ConsoleApplication1.Feedback{
  using System;

  public class Feedback{
    public Feedback(){
      text = "You have ordered: \n";
    }

    public string text;

    public static int Main(string[] args) {
      Feedback test = new Feedback();
      System.Text.StringBuilder SB = 
        new System.Text.StringBuilder(test.text);
      for(int i=0;i<50000 0="" blue_toothbrush="" done="" i="" pre="" return="" sb.append="" system.console.out.writeline="">

Try looking at Perfmon to see how much time is saved without allocating thousands of strings. Look at the "% time in GC" counter under the .NET CLR Memory list. You can also track the number of allocations you save, as well as collection statistics.

Tradeoffs There is some overhead associated with creating a StringBuilder object, both in time and memory. On a machine with fast memory, a StringBuilder becomes worthwhile if you're doing about five operations. As a rule of thumb, I would say 10 or more string operations is a justification for the overhead on any machine, even a slower one.

Precompile Windows Forms Applications

Methods are JITed when they are first used, which means that you pay a larger startup penalty if your application does a lot of method calling during startup. Windows Forms use a lot of shared libraries in the OS, and the overhead in starting them can be much higher than other kinds of applications. While not always the case, precompiling Windows Forms applications usually results in a performance win. In other scenarios it's usually best to let the JIT take care of it, but if you are a Windows Forms developer you might want to take a look.

Microsoft allows you to precompile an application by calling ngen.exe. You can choose to run ngen.exe during install time or before you distribute you application. It definitely makes the most sense to run ngen.exe during install time, since you can make sure that the application is optimized for the machine on which it is being installed. If you run ngen.exe before you ship the program, you limit the optimizations to the ones available on your machine. To give you an idea of how much precompiling can help, I've run an informal test on my machine. Below are the cold startup times for ShowFormComplex, a winforms application with roughly a hundred controls.

Code State	Time
Framework JITed ShowFormComplex JITed	3.4 sec
Framework Precompiled, ShowFormComplex JITed	2.5 sec
Framework Precompiled, ShowFormComplex Precompiled	2.1sec

Each test was performed after a reboot. As you can see, Windows Forms applications use a lot of methods up front, making it a substantial performance win to precompile.

Use Jagged Arrays—Version 1

The v1 JIT optimizes jagged arrays (simply 'arrays-of-arrays') more efficiently than rectangular arrays, and the difference is quite noticeable. Here is a table demonstrating the performance gain resulting from using jagged arrays in place of rectangular ones in both C# and Visual Basic (higher numbers are better):

	C#	Visual Basic 7
Assignment (jagged) Assignment (rectangular)	14.16 8.37	12.24 8.62
Neural Net (jagged) Neural net (rectangular)	4.48 3.00	4.58 3.13
Numeric Sort (jagged) Numeric Sort (rectangular)	4.88 2.05	5.07 2.06

The assignment benchmark is a simple assignment algorithm, adapted from the step-by-step guide found in Quantitative Decision Making for Business (Gordon, Pressman, and Cohn; Prentice-Hall; out of print). The neural net test runs a series of patterns over a small neural network, and the numeric sort is self-explanatory. Taken together, these benchmarks represent a good indication of real-world performance.

As you can see, using jagged arrays can result in fairly dramatic performance increases. The optimizations made to jagged arrays will be added to future versions of the JIT, but for v1 you can save yourself a lot of time by using jagged arrays.

Keep IO Buffer Size Between 4KB and 8KB

For nearly every application, a buffer between 4KB and 8KB will give you the maximum performance. For very specific instances, you may be able to get an improvement from a larger buffer (loading large images of a predictable size, for example), but in 99.99% of cases it will only waste memory. All buffers derived from BufferedStream allow you to set the size to anything you want, but in most cases 4 and 8 will give you the best performance.

Be on the Lookout for Asynchronous IO Opportunities

In rare cases, you may be able to benefit from Asynchronous IO. One example might be downloading and decompressing a series of files: you can read the bits in from one stream, decode them on the CPU and write them out to another. It takes a lot of effort to use Asynchronous IO effectively, and it can result in a performance loss if it's not done right. The advantage is that when applied correctly, Asynchronous IO can give you as much as ten times the performance.

An excellent example of a program using Asynchronous IO is available on the MSDN Library.

One thing to note is that there is a small security overhead for asynchronous calls: Upon invoking an async call, the security state of the caller's stack is captured and transferred to the thread that'll actually execute the request. This may not be a concern if the callback executes lot of code, or if async calls aren't used excessively

Tips for Database Access

The philosophy of tuning for database access is to use only the functionality that you need, and to design around a 'disconnected' approach: make several connections in sequence, rather than holding a single connection open for a long time. You should take this change into account and design around it.

Microsoft recommends an N-Tier strategy for maximum performance, as opposed to a direct client-to-database connection. Consider this as part of your design philosophy, as many of the technologies in place are optimized to take advantage of a multi-tired scenario.

Use the Optimal Managed Provider

Make the correct choice of managed provider, rather than relying on a generic accessor. There are managed providers written specifically for many different databases, such as SQL (System.Data.SqlClient). If you use a more generic interface such as System.Data.Odbc when you could be using a specialized component, you will lose performance dealing with the added level of indirection. Using the optimal provider can also have you speaking a different language: the Managed SQL Client speaks TDS to a SQL database, providing a dramatic improvement over the generic OleDbprotocol.

Pick Data Reader Over Data Set When You Can

Use a data reader whenever when you don't need to keep the data lying around. This allows a fast read of the data, which can be cached if the user desires. A reader is simply a stateless stream that allows you to read data as it arrives, and then drop it without storing it to a dataset for more navigation. The stream approach is faster and has less overhead, since you can start using data immediately. You should evaluate how often you need the same data to decide if the caching for navigation makes sense for you. Here's a small table demonstrating the difference between DataReader and DataSet on both ODBC and SQL providers when pulling data from a server (higher numbers are better):

	ADO	SQL
DataSet	801	2507
DataReader	1083	4585

As you can see, the highest performance is achieved when using the optimal managed provider along with a data reader. When you don't need to cache your data, using a data reader can provide you with an enormous performance boost.

Use Mscorsvr.dll for MP Machines

For stand-alone middle-tier and server applications, make sure mscorsvr is being used for multiprocessor machines. Mscorwks is not optimized for scaling or throughput, while the server version has several optimizations that allow it to scale well when more than one processor is available.

Use Stored Procedures Whenever Possible

Stored procedures are highly optimized tools that result in excellent performance when used effectively. Set up stored procedures to handle inserts, updates, and deletes with the data adapter. Stored procedures do not have to be interpreted, compiled or even transmitted from the client, and cut down on both network traffic and server overhead. Be sure to use CommandType.StoredProcedure instead of CommandType.Text

Be Careful About Dynamic Connection Strings

Connection pooling is a useful way to reuse connections for multiple requests, rather than paying the overhead of opening and closing a connection for each request. It's done implicitly, but you get one pool per unique connection string. If you're generating connection strings dynamically, make sure the strings are identical each time so pooling occurs. Also be aware that if delegation is occurring, you'll get one pool per user. There are a lot of options that you can set for the connection pool, and you can track the performance of the pool by using the Perfmon to keep track of things like response time, transactions/sec, etc.

Turn Off Features You Don't Use

Turn off automatic transaction enlistment if it's not needed. For the SQL Managed Provider, it's done via the connection string:

Copy

SqlConnection conn = new SqlConnection(
"Server=mysrv01;
Integrated Security=true;
Enlist=false");

When filling a dataset with the data adapter, don't get primary key information if you don't have to (e.g. don't set MissingSchemaAction.Add with key):

Copy

public DataSet SelectSqlSrvRows(DataSet dataset,string connection,string query){
    SqlConnection conn = new SqlConnection(connection);
    SqlDataAdapter adapter = new SqlDataAdapter();
    adapter.SelectCommand = new SqlCommand(query, conn);
    adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
    adapter.Fill(dataset);
    return dataset;
}

Avoid Auto-Generated Commands

When using a data adapter, avoid auto-generated commands. These require additional trips to the server to retrieve meta data, and give you a lower level of interaction control. While using auto-generated commands is convenient, it's worth the effort to do it yourself in performance-critical applications.

Beware ADO Legacy Design

Be aware that when you execute a command or call fill on the adapter, every record specified by your query is returned.

If server cursors are absolutely required, they can be implemented through a stored procedure in t-sql. Avoid where possible because server cursor-based implementations don't scale very well.

If needed, implement paging in a stateless and connectionless manner. You can add additional records to the dataset by:

Making sure PK info is present
Changing the data adapter's select command as appropriate, and
Calling Fill

Keep Your Datasets Lean

Only put the records you need into the dataset. Remember that the dataset stores all of its data in memory, and that the more data you request, the longer it will take to transmit across the wire.

Use Sequential Access as Often as Possible

With a data reader, use CommandBehavior.SequentialAccess. This is essential for dealing with blob data types since it allows data to be read off of the wire in small chunks. While you can only work with one piece of the data at a time, the latency for loading a large data type disappears. If you don't need to work the whole object at once, using Sequential Access will give you much better performance.

Performance Tips for ASP.NET Applications

Cache Aggressively

When designing an app using ASP.NET, make sure you design with an eye on caching. On server versions of the OS, you have a lot of options for tweaking the use of caches on the server and client side. There are several features and tools in ASP that you can make use of to gain performance.

Output Caching—Stores the static result of an ASP request. Specified using the <@% OutputCache %> directive:

Duration—Time item exists in the cache
VaryByParam—Varies cache entries by Get/Post params
VaryByHeader—Varies cache entries by Http header
VaryByCustom—Varies cache entries by browser
Override to vary by whatever you want:
- Fragment Caching—When it is not possible to store an entire page (privacy, personalization, dynamic content), you can use fragment caching to store parts of it for quicker retrieval later.a) VaryByControl—Varies the cached items by values of a control
- Cache API—Provides extremely fine granularity for caching by keeping a hashtable of cached objects in memory (System.web.UI.caching). It also:a) Includes Dependencies (key, file, time)
  b) Automatically expires unused items
  c) Supports Callbacks

Caching intelligently can give you excellent performance, and it's important to think about what kind of caching you need. Imagine a complex e-commerce site with several static pages for login, and then a slew of dynamically-generated pages containing images and text. You might want to use Output Caching for those login pages, and then Fragment Caching for the dynamic pages. A toolbar, for example, could be cached as a fragment. For even better performance, you could cache commonly used images and boilerplate text that appear frequently on the site using the Cache API. For detailed information on caching (with sample code), check out the ASP. NET Web site.

Use Session State Only If You Need To

One extremely powerful feature of ASP.NET is its ability to store session state for users, such as a shopping cart on an e-commerce site or a browser history. Since this is on by default, you pay the cost in memory even if you don't use it. If you're not using Session State, turn it off and save yourself the overhead by adding <@% EnabledSessionState = false %> to your asp. This comes with several other options, which are explained at the ASP. NET Web site.

For pages that only read session state, you can choose EnabledSessionState=readonly. This carries less overhead than full read/write session state, and is useful when you need only part of the functionality and don't want to pay for the write capabilities.

Use View State Only If You Need To

An example of View State might be a long form that users must fill out: if they click Back in their browser and then return, the form will remain filled. When this functionality isn't used, this state eats up memory and performance. Perhaps the largest performance drain here is that a round-trip signal must be sent across the network each time the page is loaded to update and verify the cache. Since it is on by default, you will need to specify that you do not want to use View State with <@% EnabledViewState = false %>. You should read more about View State on the the ASP. NET Web site to learn about some of the other options and settings to which you have access.

Avoid STA COM

Apartment COM is designed to deal with threading in unmanaged environments. There are two kinds of Apartment COM: single-threaded and multithreaded. MTA COM is designed to handle multithreading, whereas STA COM relies on the messaging system to serialize thread requests. The managed world is free-threaded, and using Single Threaded Apartment COM requires that all unmanaged threads essentially share a single thread for interop. This results in a massive performance hit, and should be avoided whenever possible. If you can't port the Apartment COM object to the managed world, use <@%AspCompat = "true" %> for pages that use them. For a more detailed explanation of STA COM, see the MSDN Library.

Batch Compile

Always batch compile before deploying a large page into the Web. This can be initiated by doing one request to a page per directory and waiting until the CPU idles again. This prevents the Web server from being bogged down with compilations while also trying to serve out pages.

Remove Unnecessary Http Modules

Depending on the features used, remove unused or unnecessary http modules from the pipeline. Reclaiming the added memory and wasted cycles can provide you with a small speed boost.

Avoid the Autoeventwireup Feature

Instead of relying on autoeventwireup, override the events from Page. For example, instead of writing a Page_Load() method, try overloading the public void OnLoad() method. This allows the run time from having to do a CreateDelegate() for every page.

Encode Using ASCII When You Don't Need UTF

By default, ASP.NET comes configured to encode requests and responses as UTF-8. If ASCII is all your application needs, eliminated the UTF overhead can give you back a few cycles. Note that this can only be done on a per-application basis.

Use the Optimal Authentication Procedure

There are several different ways to authenticate a user and some of more expensive than others (in order of increasing cost: None, Windows, Forms, Passport). Make sure you use the cheapest one that best fits your needs.

Tips for Porting and Developing in Visual Basic

A lot has changed under the hood from Microsoft® Visual Basic® 6 to Microsoft® Visual Basic® 7, and the performance map has changed with it. Due to the added functionality and security restrictions of the CLR, some functions are simply unable to run as quickly as they did in Visual Basic 6. In fact, there are several areas where Visual Basic 7 gets trounced by its predecessor. Fortunately, there are two pieces of good news:

Most of the worst slowdowns occur during one-time functions, such as loading a control for the first time. The cost is there, but you only pay it once.
There are a lot of areas where Visual Basic 7 is faster, and these areas tend to lie in functions that are repeated during run time. This means that the benefit grows over time, and in several cases will outweigh the one-time costs.

The majority of the performance issues come from areas where the run time does not support a feature of Visual Basic 6, and it has to be added to preserve the feature in Visual Basic 7. Working outside of the run time is slower, making some features far more expensive to use. The bright side is that you can avoid these problems with a little effort. There are two main areas that require work to optimize for performance, and few simple tweaks you can do here and there. Taken together, these can help you step around performance drains, and take advantage of the functions that are much faster in Visual Basic 7.

Error Handling

The first concern is error handling. This has changed a lot in Visual Basic 7, and there are performance issues related to the change. Essentially, the logic required to implement OnErrorGoto and Resume is extremely expensive. I suggest taking a quick look at your code, and highlighting all the areas where you use the Err object, or any error-handling mechanism. Now look at each of these instances, and see if you can rewrite them to use try/catch. A lot of developers will find that they can convert to try/catch easily for most of these cases, and they should see a good performance improvement in their program. The rule of thumb is "if you can easily see the translation, do it."

Here's an example of a simple Visual Basic program that uses On Error Goto compared with the try/catch version.

Copy

Sub SubWithError()
  On Error Goto SWETrap
  Dim x As Integer
  Dim y As Integer
  x = x / y
SWETrap:
  Exit Sub
  End Sub
 

Sub SubWithErrorResumeLabel()
  On Error Goto SWERLTrap
  Dim x As Integer
  Dim y As Integer
  x = x / y 
SWERLTrap:
  Resume SWERLExit
  End Sub

SWERLExit:
  Exit Sub

Copy

Sub SubWithError()
  Dim x As Integer
  Dim y As Integer
  Try
    x = x / y
  Catch
    Return
  End Try
  End Sub
 
Sub SubWithErrorResumeLabel()
  Dim x As Integer
  Dim y As Integer
  Try
    x = x / y
  Catch
  Goto SWERLExit
  End Try
 
SWERLExit:
  Return
  End Sub

The speed increase is noticeable. SubWithError() takes 244 milliseconds using OnErrorGoto, and only 169 milliseconds using try/catch. The second function takes 179 milliseconds compared to 164 milliseconds for the optimized version.

Use Early Binding

The second concern deals with objects and typecasting. Visual Basic 6 does a lot of work under the hood to support casting of objects, and many programmers aren't even aware of it. In Visual Basic 7, this is an area that out of which you can squeeze a lot of performance. When you compile, use early binding. This tells the compiler to insert a Type Coercion is only done when explicitly mentioned. This has two major effects:

Strange errors become easier to track down.
Unneeded coercions are eliminated, leading to substantial performance improvements.

When you use an object as if it were of a different type, Visual Basic will coerce the object for you if you don't specify. This is handy, since the programmer has to worry about less code. The downside is that these coercions can do unexpected things, and the programmer has no control over them.

There are instances when you have to use late binding, but most of the time if you're not sure then you can get away with early binding. For Visual Basic 6 programmers, this can be a bit awkward at first, since you have to worry about types more than in the past. This should be easy for new programmers, and people familiar with Visual Basic 6 will pick it up in no time.

Turn On Option Strict and Explicit

With Option Strict on, you protect yourself from inadvertent late binding and enforce a higher level of coding discipline. For a list of the restrictions present with Option Strict, see the MSDN Library. The caveat to this is that all narrowing type coercions must be explicitly specified. However, this in itself may uncover other sections of your code that are doing more work than you had previously thought, and it may help you stomp some bugs in the process.

Option Explicit is less restrictive than Option Strict, but it still forces programmers to provide more information in their code. Specifically, you must declare a variable before using it. This moves the type-inference from the run time into compile time. This eliminated check translates into added performance for you.

I recommend that you start with Option Explicit, and then turn on Option Strict. This will protect you from a deluge of compiler errors, and allow you to gradually start working in the stricter environment. When both of these options are used, you ensure maximum performance for your application.

Use Binary Compare for Text

When comparing text, use binary compare instead of text compare. At run time, the overhead is much lighter for binary.

Minimize the Use of Format()

When you can, use toString() instead of format(). In most cases, it will provide you with the functionality you need, with much less overhead.

Use Charw

Use charw instead of char. The CLR uses Unicode internally, and char must be translated at run time if it is used. This can result in a substantial performance loss, and specifying that your characters are a full word long (using charw) eliminates this conversion.

Optimize Assignments

Use exp += val instead of exp = exp + val. Since exp can be arbitrarily complex, this can result in lots of unnecessary work. This forces the JIT to evaluate both copies of exp, and many times this is not needed. The first statement can be optimized far better than the second, since the JIT can avoid evaluating the exp twice.

Avoid Unnecessary Indirection

When you use byRef, you pass pointers instead of the actual object. Many times this makes sense (side-effecting functions, for example), but you don't always need it. Passing pointers results in more indirection, which is slower than accessing a value that is on the stack. When you don't need to go through the heap, it is best to avoid it.

Put Concatenations in One Expression

If you have multiple concatenations on multiple lines, try to stick them all on one expression. The compiler can optimize by modifying the string in place, providing a speed and memory boost. If the statements are split into multiple lines, the Visual Basic compiler will not generate the Microsoft Intermediate Language (MSIL) to allow in-place concatenation. See the StringBuilder example discussed earlier.

Include Return Statements

Visual Basic allows a function to return a value without using the return statement. While Visual Basic 7 supports this, explicitly using return allows the JIT to perform slightly more optimizations. Without a return statement, each function is given several local variables on stack to transparently support returning values without the keyword. Keeping these around makes it harder for the JIT to optimize, and can impact the performance of your code. Look through your functions and insert return as needed. It doesn't change the semantics of the code at all, and it can help you get more speed from your application.

Tips for Porting and Developing in Managed C++

Microsoft is targeting Managed C++ (MC++) at a specific set of developers. MC++ is not the best tool for every job. After reading this document, you may decide that C++ is not the best tool, and that the tradeoff costs are not worth the benefits. If you aren't sure about MC++, there are many good resources to help you make your decision This section is targeted at developers who have already decided that they want to use MC++ in some way, and want to know about the performance aspects of it.

For C++ developers, working Managed C++ requires that several decisions be made. Are you porting some old code? If so, do you want to move the entire thing to managed space or are you instead planning to implement a wrapper? I'm going to focus on the 'port-everything' option or deal with writing MC++ from scratch for the purposes of this discussion, since those are the scenarios where the programmer will notice a performance difference.

Benefits of the Managed World

The most powerful feature of Managed C++ is the ability to mix and match managed and unmanaged code at the expression level. No other language allows you to do this, and there are some powerful benefits you can get from it if used properly. I'll walk through some examples of this later on.

The managed world also gives you huge design wins, in that a lot of common problems are taken care of for you. Memory management, thread scheduling and type coercions can be left to the run time if you desire, allowing you to focus your energies on the parts of the program that need it. With MC++, you can choose exactly how much control you want to keep.

MC++ programmers have the luxury of being able to use the Microsoft Visual C® 7 (VC7) backend when compiling to IL, and then using the JIT on top of that. Programmers that are used to working with the Microsoft C++ compiler are used to things being lightning-fast. The JIT was designed with different goals, and has a different set of strengths and weaknesses. The VC7 compiler, not bound by the time restrictions of the JIT, can perform certain optimizations that the JIT cannot, such as whole-program analysis, more aggressive inlining and enregistration. There are also some optimizations that can be performed only in typesafe environments, leaving more room for speed than C++ allows.

Because of the different priorities in the JIT, some operations are faster than before while others are slower. There are tradeoffs you make for safety and language flexibility, and some of them aren't cheap. Fortunately, there are things a programmer can do to minimize the costs.

Porting: All C++ Code Can Compile to MSIL

Before we go any further, it's important to note that you can compile any C++ code into MSIL. Everything will work, but there's no guarantee of type-safety and you pay the marshalling penalty if you do a lot of interop. Why is it helpful to compile to MSIL if you don't get any of the benefits? In situations where you are porting a large code base, this allows you to gradually port your code in pieces. You can spend your time porting more code, rather than writing special wrappers to glue the ported and not-yet-ported code together if you use MC++, and that can result in a big win. It makes porting applications a very clean process. To learn more about compiling C++ to MSIL, take a look at the /clr compiler option.

However, simply compiling your C++ code to MSIL doesn't give you the security or flexibility of the managed world. You need to write in MC++, and in v1 that means giving up a few features. The list below is not supported in the current version of the CLR, but may be in the future. Microsoft chose to support the most common features first, and had to cut some others in order to ship. There is nothing that prevents them from being added later, but in the meantime you will need to do without them:

Multiple Inheritance
Templates
Deterministic Finalization

You can always interoperate with unsafe code if you need those features, but you will pay the performance penalty of marshalling data back and forth. And bear in mind that those features can only be used inside the unmanaged code. The managed space has no knowledge of their existence. If you are deciding to port your code, think about how much you rely on those features in your design. In a few cases, the redesign is too expensive and you will want to stick with unmanaged code. This is the first decision you should make, before you start hacking.

Advantages of MC++ Over C# or Visual Basic

Coming from an unmanaged background, MC++ preserves a lot of the ability to handle unsafe code. MC++'s ability to mix managed and unmanaged code smoothly provides the developer with a lot of power, and you can choose where on the gradient you want to sit when writing your code. On one extreme, you can write everything in straight, unadulterated C++ and just compile with /clr. On the other, you can write everything as managed objects and deal with the language limitations and performance problems mentioned above.

But the real power of MC++ comes when you choose somewhere in between. MC++ allows you to tweak some of the performance hits inherent in managed code, by giving you precise control over when to use unsafe features. C# has some of this functionality in the unsafe keyword, but it's not an integral part of the language and it is far less useful than MC++. Let's step through some examples showing the finer granularity available in MC++, and we'll talk about the situations where it comes in handy.

Generalized "byref" pointers

In C# you can only take the address of some member of a class by passing it to a ref parameter. In MC++, a byref pointer is a first-class construct. You can take the address of an item in the middle of an array and return that address from a function:

Copy

Byte* AddrInArray( Byte b[] ) {
   return &b[5];
}

We exploit this feature for returning a pointer to the "characters" in a System.String via our helper routine, and we can even loop through arrays using these pointers:

Copy

System::Char* PtrToStringChars(System::String*);   
for( Char*pC = PtrToStringChars(S"boo");
  pC != NULL;
  pC++ )
{
      ... *pC ...
}

You can also do a linked-list traversal with injection in MC++ by taking the address of the "next" field (which you cannot do in C#):

Copy

Node **w = &Head;
while(true) {
  if( *w == 0 || val < (*w)->val ) {
    Node *t = new Node(val,*w);
    *w = t;
    break;
  }
  w = &(*w)->next;
}

In C#, you can't point to "Head", or take the address of the "next" field, so you have make a special-case where you're inserting at the first location, or if "Head" is null. Moreover, you have to look one node ahead all the time in the code. Compare this to what a good C# would produce:

Copy

if( Head==null || val < Head.val ) {
  Node t = new Node(val,Head);
  Head = t;
}else{
  // we know at least one node exists,
  // so we can look 1 node ahead
  Node w=Head;
while(true) {
  if( w.next == null || val < w.next.val ){
    Node t = new Node(val,w.next.next);
    w.next = t;
    break;
  }
  w = w.next;
  }
}

User Access to Boxed Types

A performance problem common with OO languages is the time spent boxing and unboxing values. MC++ gives you a lot more control over this behavior, so you won't have to dynamically (or statically) unbox to access values. This is another performance enhancement. Just place __box keyword before any type to represent its boxed form:

Copy

__value struct V {
  int i;
};
int main() {
  V v = {10};
  __box V *pbV = __box(v);
  pbV->i += 10;           // update without casting
}

In C# you have to unbox to a "v", then update the value and re-box back to an Object:

Copy

struct B { public int i; }
static void Main() {
  B b = new B();
  b.i = 5;
  object o = b;         // implicit box
  B b2 = (B)o;            // explicit unbox
  b2.i++;               // update
  o = b2;               // implicit re-box
}

STL Collections vs. Managed Collections—v1

The bad news: In C++, using the STL Collections was often just as fast as writing that functionality by hand. The CLR frameworks are very fast, but they suffer from boxing and unboxing issues: everything is an object, and without template or generic support, all actions have to be checked at run time.

The good news: In the long term, you can bet that this problem will go away as generics are added to the run time. Code you deploy today will experience the speed boost without any changes. In the short term, you can use static casting to prevent the check, but this is no longer safe. I recommend using this method in tight code where performance is absolutely critical, and you've identified two or three hot spots.

Use Stack Managed Objects

In C++, you specify that an object should be managed by the stack or the heap. You can still do this in MC++, but there are restrictions you should be aware of. The CLR uses ValueTypes for all stack-managed objects, and there are limitations to what ValueTypes can do (no inheritance, for example). More information is available on the MSDN Library.

Corner Case: Beware Indirect Calls Within Managed Code—v1

In the v1 run time, all indirect function calls are made natively, and therefore require a transition into unmanaged space. Any indirect function call can only be made from native mode, which means that all indirect calls from managed code need a managed-to-unmanaged transition. This is a serious problem when the table returns a managed function, since a second transition must then be made to execute the function. When compared to the cost of executing a single Call instruction, the cost is fifty- to one hundred times slower than in C++!

Fortunately, when you are calling a method that resides within a garbage-collected class, optimization removes this. However, in the specific case of a regular C++ file that has been compiled using /clr, the method return will be considered managed. Since this cannot be removed by optimization, you are hit with the full double-transition cost. Below is an example of such a case.

Copy

//////////////////////// a.h:    //////////////////////////
class X {
public:
   void mf1();
   void mf2();
};

typedef void (X::*pMFunc_t)();


////////////// a.cpp: compiled with /clr  /////////////////
#include "a.h"

int main(){
   pMFunc_t pmf1 = &X::mf1;
   pMFunc_t pmf2 = &X::mf2;

   X *pX = new X();
   (pX->*pmf1)();
   (pX->*pmf2)();

   return 0;
}


////////////// b.cpp: compiled without /clr /////////////////
#include "a.h"

void X::mf1(){}


////////////// c.cpp: compiled with /clr ////////////////////
#include "a.h"
void X::mf2(){}

There are several ways to avoid this:

Make the class into a managed class ("__gc")
Remove the indirect call, if possible
Leave the class compiled as unmanaged code (e.g. do not use /clr)

Minimize Performance Hits—version 1

There are several operations or features that are simply more expensive in MC++ under version 1 JIT. I'll list them and give some explanation, and then we'll talk about what you can do about them.

Abstractions—This is an area where the beefy, slow C++ backend compiler wins heavily over the JIT. If you wrap an int inside a class for abstraction purposes, and you access it strictly as an int, the C++ compiler can reduce the overhead of the wrapper to practically nothing. You can add many levels of abstraction to the wrapper, without increasing the cost. The JIT is unable to take the time necessary to eliminate this cost, making deep abstractions more expensive in MC++.
Floating Point—The v1 JIT does not currently perform all the FP-specific optimizations that the VC++ backend does, making floating point operations more expensive for now.
Multidimensional Arrays—The JIT is better at handling jagged arrays than multidimensional ones, so use jagged arrays instead.
64 bit Arithmetic—In future versions, 64-bit optimizations will be added to the JIT.

What You Can Do

At every phase of development, there are several things you can do. With MC++, the design phase is perhaps the most important area, as it will determine how much work you end up doing and how much performance you get in return. When you sit down to write or port an application, you should consider the following things:

Identify areas where you use multiple inheritance, templates, or deterministic finalization. You will have to get rid of these, or else leave that part of your code in unmanaged space. Think about the cost of redesigning, and identify areas that can be ported.
Locate performance hot spots, such as deep abstractions or virtual function calls across managed space. These will also require a design decision.
Look for objects that have been specified as stack-managed. Make sure they can be converted into ValueTypes. Mark the others for conversion to heap-managed objects.

During the coding stage, you should be aware of the operations that are more expensive and the options you have in dealing with them. One of the nicest things about MC++ is that you come to grips with all the performance issues up front, before you start coding: this is helpful in paring down work later on. However, there are still some tweaks you can perform while you code and debug.

Determine which areas make heavy use of floating point arithmetic, multidimensional arrays or library functions. Which of these areas are performance critical? Use profilers to pick the fragments where the overhead is costing you most, and pick which option seems best:

Keep the whole fragment in unmanaged space.
Use static casts on the library accesses.
Try tweaking boxing/unboxing behavior (explained later).
Code your own structure.

Finally, work to minimize the number of transitions you make. If you have some unmanaged code or an interop call sitting in a loop, make the entire loop unmanaged. That way you'll only pay the transition cost twice, rather than for each iteration of the loop.

Additional Resources

Related topics on performance in the .NET Framework include:

Performance Considerations of Run-Time Technologies in the .NET Framework

Watch for future articles currently under development, including an overview of design, architectural and coding philosophies, a walkthrough of performance analysis tools in the managed world, and a performance comparison of .NET to other enterprise applications available today.

Appendix: Cost of Virtual Calls and Allocations

Call Type	# Calls/sec
ValueType Non-Virtual Call	809971805.600
Class Non-Virtual Call	268478412.546
Class Virtual Call	109117738.369
ValueType Virtual (Obj Method) Call	3004286.205
ValueType Virtual (Overridden Obj Method) Call	2917140.844
Load Type by Newing (Non-Static)	1434.720
Load Type by Newing (Virtual Methods)	1369.863

Note The test machine is a PIII 733Mhz, running Windows 2000 Professional with Service Pack 2.

This chart compares the cost associated with different types of method calls, as well as the cost of instantiating a type that contains virtual methods. The higher the number, the more calls/instantiations-per-second can be performed. While these numbers will certainly vary on different machines and configurations, the relative cost of performing one call over another remains significant.

ValueType Non-Virtual Call: This test calls an empty non-virtual method contained within a ValueType.
Class Non-Virtual Call: This test calls an empty non-virtual method contained within a class.
Class Virtual Call: This test calls an empty virtual method contained within a class.
ValueType Virtual (Obj Method) Call: This test calls ToString() (a virtual method) on a ValueType, which resorts to the default object method.
ValueType Virtual (Overridden Obj Method) Call: This test calls ToString() (a virtual method) on a ValueType that has overridden the default.
Load Type by Newing (Static): This test allocates space for a class with only static methods.
Load Type by Newing (Virtual Methods): This test allocates space for a class with virtual methods.

One conclusion you can draw is that Virtual Function calls are about two times as expensive as regular calls when you're calling a method in a class. Bear in mind that calls are cheap to begin with, so I wouldn't remove all virtual calls. You should always use virtual methods when it makes sense to do so.

The JIT cannot inline virtual methods, so you lose a potential optimization if you get rid of non-virtual methods.
Allocating space for an object that has virtual methods is slightly slower than the allocation for an object without them, since extra work must be done to find space for the virtual tables.

Notice that calling a non-virtual method within a ValueType is more than three times as fast as in a class, but once you treat it as a class you lose terribly. This is characteristic of ValueTypes: treat them like structs and they're lighting fast. Treat them like classes and they're painfully slow. ToString() is a virtual method, so before it can be called, the struct must be converted to an object on the heap. Instead of being twice as slow, calling a virtual method on a ValueType is now eighteen times as slow! The moral of the story? Don't treat ValueTypes as classes.

Generate insert statements from a specific table data using SQL Server 2005

2013-06-30T22:23:00.002+03:00

Generate insert statements from a specific table data using SQL Server 2005

Thanks Tharaka MTR, by Code Project

When you are deploying your application, sometimes you may want to generate SQL script with the insert statement of the specific database table. In this article I will show you two easiest ways to do this with SQL Server and SQL Server tools.
1. Using Database Publishing Wizard (“SqlPubWiz.exe”)
If you install Visual studio 2008 / Visual Studio 2008 Express full version, it will automatically install the Microsoft SQL Server Data Publishing Wizard on the following location.
SQL Server Installation Location]\90\Tools\Publishing\[version]\ SqlPubWiz.exe
If it is not there you can download it from the following URL
http://go.microsoft.com/fwlink/?LinkId=119368

SQLPubWiz location

When you run the “SqlPubWiz.exe”, it will open the database publishing wizard

Database Publishing Wizard

Click next and enter the database server connection information accordingly.

Database Publishing Wizard – Database Server Connection

Click next, and it will ask you to select the database, which you want to generate the data from

Database Publishing Wizard – Select Database

Next screen will ask to select the Object type. You can use this database publishing wizard to generate data and schema both. In here I consider only for the data generation part. Now choose “Tables” as an option and click next. (Make sure to uncheck “Script all objects in the selected database”)

Database Publishing Wizard – Choose Object Type

Then, the next ask to select the table which you want to generate the data from. Select whatever the table you want and click next.

Database Publishing Wizard – Choose Tables

Next step ask to specify the output location. You can enter the file name and the location there.

Database Publishing Wizard – Select an Output Location

By clicking Next, It shows to select the publishing options. There are three publishing types, Schema only, Data only, or Schema and data. Here you have to select “Data only”.

Database Publishing Wizard – Select Publishing Option

Click next and it will generate the insert data script for you.

Database Publishing Wizard – Publishing Progress

Database Publishing Wizard – Generated Script

2. Using SQL Server Generate Script wizard

SQL Server Generate Script

When you select “Generate Script” menu item, it will open the Generate SQL Server Scripts Wizard dialog.

SQL Server Generate Script – Wizard Dialog

By clicking next, it asks to select the database which you want to generate the script.

SQL Server Generate Script Wizard – Select Database

By clicking Next, It shows to select the script options dialog box. In here, you change the “Script Data” as “True” and click the next button

SQL Server Generate Script Wizard – Choose Script Option

Next screen will ask to select the Object type. Now choose “Tables” as an option and click next.

SQL Server Generate Script Wizard – Choose Object Type

Next screen ask you to select the tables which you want to generate the data from. Select whatever the tables and click next

SQL Server Generate Script Wizard – Choose Tables

Next step ask to specify the output options. If you select “Script to file” as an option, then you can enter the file name and the location there.

SQL Server Generate Script Wizard – Output Option

Next two steps are very strait forward. It shows the script generation summary, and by clicking next it will generate the script with insert statements for the selected tables.

SQL Server Generate Script Wizard – Script Summary

SQL Server Generate Script Wizard – Script Progress

SQL Server Generate Script Wizard – Generated Script

How to Put an iPhone Into DFU Mode

2013-05-27T23:11:00.001+03:00

DFU means Device Firmware Update. If a restore using Recovery Mode doesn't work you will want to use DFU Mode as a last resort. When placing your iPhone into DFU Mode it does not load the OS before attempting the restore

Watch the Video!
For your convenience this tutorial is available in video format also. Click the Watch It button to view the tutorial!

To put the iPhone into DFU mode so you can do an iTunes firmware restore follow these steps:

Step One
Open iTunes and connect the iPhone to your Mac.

Step Two
Press and hold the Home button and the Sleep/Wake button at the same time.

Step Three
After exactly 10 seconds release the Sleep/Wake button. Continue holding the home button until you iTunes pops up a message telling you that it has detected an iPhone in recovery mode.

The iPhone screen will remain black like this:

NOTE***: It may take a few attempts to get your iPhone into DFU mode. Generally, I hold down both buttons then release the Home button just before I think the Apple logo would appear. If you are still holding both buttons down and you see the Apple logo you are holding them down for too long!

Best Practices to Improve ASP.Net Web Application Performance

2013-05-16T09:35:00.002+03:00

Introduction
Performance tuning can be tricky. It's especially tough in Internet-related projects with lots of components running around, like HTML client, HTTP network, Web server, middle-tier components, database components, resource-management components, TCP/IP networks, and database servers. Performance tuning depends on a lot of parameters and sometimes, by changing a single parameter, performance can increase drastically.
This document lists out some tips for optimizing ASP.Net Web applications and many traps and pitfalls are discussed as follows :

Tips For Web Application

1) Turn off Tracing unless until required

Tracing is one of the wonderful features which enable us to track the application's trace and the sequences. However, again it is useful only for developers and you can set this to "false" unless you require monitoring the trace logging.

How it affects performance:

Enabling tracing adds performance overhead and might expose private information, so it should be enabled only while an application is being actively analyzed.

Solution:

When not needed, tracing can be turned off using

2) Turn off Session State, if not required

One extremely powerful feature of ASP.NET is its ability to store session state for users, such as a shopping cart on an e-commerce site or a browser history.

How it affects performance:

Since ASP.NET Manages session state by default, you pay the cost in memory even if you don't use it. I.e. whether you store your data in in-process or on state server or in a Sql Database, session state requires memory and it's also time consuming when you store or retrieve data from it.

Solution:

You may not require session state when your pages are static or when you do not need to store information captured in the page.

In such cases where you need not use session state, disable it on your web form using the directive,

<@%Page EnableSessionState="false"%>

In case you use the session state only to retrieve data from it and not to update it, make the session state read only by using the directive,

<@%Page EnableSessionState ="ReadOnly"%>

3) Disable View State of a Page if possible

View state is a fancy name for ASP.NET storing some state data in a hidden input field inside the generated page. When the page is posted back to the server, the server can parse, validate, and apply this view state data back to the page's tree of controls.

View state is a very powerful capability since it allows state to be persisted with the client and it requires no cookies or server memory to save this state. Many ASP.NET server controls use view state to persist settings made during interactions with elements on the page, for example, saving the current page that is being displayed when paging through data.

How it affects performance:

? There are a number of drawbacks to the use of view state, however.

? It increases the total payload of the page both when served and when requested. There is also an additional overhead incurred when serializing or deserializing view state data that is posted back to the server.

? View state increases the memory allocations on the server. Several server controls, the most well known of which is the DataGrid, tend to make excessive use of view state, even in cases where it is not needed.

Solution:

Pages that do not have any server postback events can have the view state turned off.

The default behavior of the ViewState property is enabled, but if you don't need it, you can turn it off at the control or page level. Within a control, simply set the EnableViewState property to false, or set it globally within the page using this setting:

<%@ Page EnableViewState="false" %>

If you turn view state off for a page or control, make sure you thoroughly test your pages to verify that they continue to function correctly.

4) Set debug=false in web.config

When you create the application, by default this attribute is set to "true" which is very useful while developing. However, when you are deploying your application, always set it to "false".

How it affects performance:

Setting it to "true" requires the pdb information to be inserted into the file and this results in a comparatively larger file and hence processing will be slow.

Solution:

Therefore, always set debug="false" before deployment.

5) Avoid Response.Redirect

Response.Redirect () method simply tells the browser to visit another page.

How it affects performance:

Redirects are also very chatty. They should only be used when you are transferring people to another physical web server.

Solution:

For any transfers within your server, use .transfer! You will save a lot of needless HTTP requests. Instead of telling the browser to redirect, it simply changes the "focus" on the Web server and transfers the request. This means you don't get quite as many HTTP requests coming through, which therefore eases the pressure on your Web server and makes your applications run faster.

Tradeoffs:

? ".transfer" process can work on only those sites running on the server. Only Response.Redirect can do that.

? Server.Transfer maintains the original URL in the browser. This can really help streamline data entry techniques, although it may make for confusion when debugging

5. A) To reduce CLR Exceptions count, Use Response.Redirect (".aspx", false) instead of response.redirect (".aspx").

6) Use the String builder to concatenate string

How it affects performance:

String is Evil when you want to append and concatenate text to your string. All the activities you do to the string are stored in the memory as separate references and it must be avoided as much as possible.

i.e. When a string is modified, the run time will create a new string and return it, leaving the original to be garbage collected. Most of the time this is a fast and simple way to do it, but when a string is being modified repeatedly it begins to be a burden on performance: all of those allocations eventually get expensive.

Solution:

Use String Builder when ever string concatenation is needed so that it only stores the value in the original string and no additional reference is created.

7) Avoid throwing exceptions

How it affects performance:

Exceptions are probably one of the heaviest resource hogs and causes of slowdowns you will ever see in web applications, as well as windows applications.

Solution:

You can use as many try/catch blocks as you want. Using exceptions gratuitously is where you lose performance. For example, you should stay away from things like using exceptions for control flow.

8) Use Finally Method to kill resources

?The finally method gets executed independent of the outcome of the Block.

?Always use the finally block to kill resources like closing database connection, closing files and other resources such that they get executed independent of whether the code worked in Try or went to Catch.

9) Use Client Side Scripts for validations

User Input is Evil and it must be thoroughly validated before processing to avoid overhead and possible injections to your applications.

How It improves performance:

Client site validation can help reduce round trips that are required to process user's request. In ASP.NET you can also use client side controls to validate user input. However, do a check at the Server side too to avoid the infamous Javascript disabled scenarios.

10) Avoid unnecessary round trips to the server

How it affects performance:

Round trips significantly affect performance. They are subject to network latency and to downstream server latency. Many data-driven Web sites heavily access the database for every user request. While connection pooling helps, the increased network traffic and processing load on the database server can adversely affect performance.

Solution:

? Keep round trips to an absolute minimum

? Implement Ajax UI whenever possible. The idea is to avoid full page refresh and only update the portion of the page that needs to be changed

11) Use Page.ISPostBack

Make sure you don't execute code needlessly. Use Page.ISPostBack property to ensure that you only perform page initialization logic when a page is first time loaded and not in response to client postbacks.

12) Include Return Statements with in the Function/Method

How it improves performance

Explicitly using return allows the JIT to perform slightly more optimizations. Without a return statement, each function/method is given several local variables on stack to transparently support returning values without the keyword. Keeping these around makes it harder for the JIT to optimize, and can impact the performance of your code. Look through your functions/methods and insert return as needed. It doesn't change the semantics of the code at all, and it can help you get more speed from your application.

13) Use Foreach loop instead of For loop for String Iteration

Foreach is far more readable, and in the future it will become as fast as a For loop for special cases like strings. Unless string manipulation is a real performance hog for you, the slightly messier code may not be worth it.

14) Avoid Unnecessary Indirection

How it affects performance:

When you use byRef, you pass pointers instead of the actual object.

Many times this makes sense (side-effecting functions, for example), but you don't always need it. Passing pointers results in more indirection, which is slower than accessing a value that is on the stack.

Solution:

When you don't need to go through the heap, it is best to avoid it there by avoiding indirection.

15) Use "ArrayLists" in place of arrays

How it improves performance

An ArrayList as everything that is good about an array PLUS automatic sizing, Add, Insert, Remove, Sort, Binary Search. All these great helper methods are added when implementing the IList interface.

Tradeoffs:

The downside of an ArrayList is the need to cast objects upon retrieval.

16) Always check Page.IsValid when using Validator Controls

Always make sure you check Page.IsValid before processing your forms when using Validator Controls.

17) Use Paging

Take advantage of paging's simplicity in .net. Only show small subsets of data at a time, allowing the page to load faster.

Tradeoffs:

Just be careful when you mix in caching. Don't cache all the data in the grid.

18) Store your content by using caching

How it improves performance:

ASP.NET allows you to cache entire pages, fragment of pages or controls. You can cache also variable data by specifying the parameters that the data depends. By using caching you help ASP.NET engine to return data for repeated request for the same page much faster.

When and Why Use Caching:

A Proper use and fine tune of caching approach of caching will result on better performance and scalability of your site. However improper use of caching will actually slow down and consume lots of your server performance and memory usage.

Good candidate to use caching is if you have infrequent chance of data or static content of web page.

19) Use low cost authentication

Authentication can also have an impact over the performance of your application. For example passport authentication is slower than form-base authentication which in here turn is slower than Windows authentication.

20) Minimize the number of web server controls

How it affects performance:

The use of web server controls increases the response time of your application because they need time to be processed on the server side before they are rendered on the client side.

Solution:

One way to minimize the number of web server controls is to taking into consideration, the usage of HTML elements where they are suited, for example if you want to display static text.

21) Avoid using unmanaged code

How it affects performance:

Calls to unmanaged code are a costly marshaling operation.

Solution:

Try to reduce the number calls between the managed and unmanaged code. Consider to do more work in each call rather than making frequent calls to do small tasks.

22) Avoid making frequent calls across processes

If you are working with distributed applications, this involves additional overhead negotiating network and application level protocols. In this case network speed can also be a bottleneck. Try to do as much work as possible in fewer calls over the network.

23) Cleaning Up Style Sheets and Script Files

? A quick and easy way to improve your web application's performance is by going back and cleaning up your CSS Style Sheets and Script Files of unnecessary code or old styles and functions. It is common for old styles and functions to still exist in your style sheets and script files during development cycles and when improvements are made to a website.

? Many websites use a single CSS Style Sheet or Script File for the entire website. Sometimes, just going through these files and cleaning them up can improve the performance of your site by reducing the page size. If you are referencing images in your style sheet that are no longer used on your website, it's a waste of performance to leave them in there and have them loaded each time the style sheet is loaded.

? Run a web page analyzer against pages in your website so that you can see exactly what is being loaded and what takes the most time to load.

24) Design with ValueTypes

Use simple structs when you can, and when you don't do a lot of boxing

and unboxing.

Tradeoffs:

ValueTypes are far less flexible than Objects, and end up hurting performance if used incorrectly. You need to be very careful about when you treat them like objects. This adds extra boxing and unboxing overhead to your program, and can end up costing you more than it would if you had stuck with objects.

25) Minimize assemblies

Minimize the number of assemblies you use to keep your working set small. If you load an entire assembly just to use one method, you're paying a tremendous cost for very little benefit. See if you can duplicate that method's functionality using code that you already have loaded.

26) Encode Using ASCII When You Don't Need UTF

By default, ASP.NET comes configured to encode requests and responses as UTF-8.

If ASCII is all your application needs, eliminated the UTF overhead can give you back a few cycles. Note that this can only be done on a per-application basis.

27) Avoid Recursive Functions / Nested Loops

These are general things to adopt in any programming language, which consume lot of memory. Always avoid Nested Loops, Recursive functions, to improve performance.

28) Minimize the Use of Format ()

When you can, use toString () instead of format (). In most cases, it will provide you with the functionality you need, with much less overhead.

29) Place StyleSheets into the Header

Web developers who care about performance want browser to load whatever content it has as soon as possible. This fact is especially important for pages with a lot of content and for users with slow Internet connections. When the browser loads the page progressively the header, the logo, the navigation components serve as visual feedback for the user.

When we place style sheets near the bottom part of the html, most browsers stop rendering to avoid redrawing elements of the page if their styles change thus decreasing the performance of the page. So, always place StyleSheets into the Header

30) Put Scripts to the end of Document

Unlike StyleSheets, it is better to place scripts to the end of the document. Progressive rendering is blocked until all StyleSheets have been downloaded. Scripts cause progressive rendering to stop for all content below the script until it is fully loaded. Moreover, while downloading a script, browser does not start any other component downloads, even on different hostnames.

So,always have scripts at the end of the document.

31) Make JavaScript and CSS External

Using external files generally produces faster pages because the JavaScript and CSS files are cached by the browser. Inline JavaScript and CSS increases the HTML document size but reduces the number of HTTP requests. With cached external files, the size of the HTML is kept small without increasing the number of HTTP requests thus improving the performance.

Tips For Database Operations

1) Return Multiple Resultsets

The database code if has request paths that go to the database more than once then, these round-trips decreases the number of requests per second your application can serve.

Solution:

Return multiple resultsets in a single database request, so that you can cut the total time spent communicating with the database. You'll be making your system more scalable, too, as you'll cut down on the work the database server is doing managing requests.

2) Connection Pooling and Object Pooling

Connection pooling is a useful way to reuse connections for multiple requests, rather than paying the overhead of opening and closing a connection for each request. It's done implicitly, but you get one pool per unique connection string. Make sure you call Close or Dispose on a connection as soon as possible. When pooling is enabled, calling Close or Dispose returns the connection to the pool instead of closing the underlying database connection.

Account for the following issues when pooling is a part of your design:

? Share connections

? Avoid per-user logons to the database

? Do not vary connection strings

? Do not cache connections

3) Use SqlDataReader Instead of Dataset wherever it is possible

If you are reading a table sequentially you should use the DataReader rather than DataSet. DataReader object creates a read only stream of data that will increase your application performance because only one row is in memory at a time.

4) Keep Your Datasets Lean

Remember that the dataset stores all of its data in memory, and that the more data you request, the longer it will take to transmit across the wire.

Therefore Only put the records you need into the dataset.

5) Avoid Inefficient queries

How it affects performance:

Queries that process and then return more columns or rows than necessary, waste processing cycles that could best be used for servicing other requests.

Cause of Inefficient queries:

? Too much data in your results is usually the result of inefficient queries.

? The SELECT * query often causes this problem. You do not usually need to return all the columns in a row. Also, analyze the WHERE clause in your queries to ensure that you are not returning too many rows. Try to make the WHERE clause as specific as possible to ensure that the least number of rows are returned.

? Queries that do not take advantage of indexes may also cause poor performance.

6) Unnecessary round trips

How it affects performance:

Round trips significantly affect performance. They are subject to network latency and to downstream server latency. Many data-driven Web sites heavily access the database for every user request. While connection pooling helps, the increased network traffic and processing load on the database server can adversely affect performance.

Solution:

Keep round trips to an absolute minimum.

7) Too many open connections

Connections are an expensive and scarce resource, which should be shared between callers by using connection pooling. Opening a connection for each caller limits scalability.

Solution:

To ensure the efficient use of connection pooling, avoid keeping connections open and avoid varying connection strings.

8) Avoid Transaction misuse

How it affects performance:

If you select the wrong type of transaction management, you may add latency to each operation. Additionally, if you keep transactions active for long periods of time, the active transactions may cause resource pressure.

Solution:

Transactions are necessary to ensure the integrity of your data, but you need to ensure that you use the appropriate type of transaction for the shortest duration possible and only where necessary.

9) Avoid Over Normalized tables

Over Normalized tables may require excessive joins for simple operations. These additional steps may significantly affect the performance and scalability of your application, especially as the number of users and requests increases.

10) Reduce Serialization

Dataset serialization is more efficiently implemented in .NET Framework version 1.1 than in version 1.0. However, Dataset serialization often introduces performance bottlenecks.

You can reduce the performance impact in a number of ways:

? Use column name aliasing

? Avoid serializing multiple versions of the same data

? Reduce the number of DataTable objects that are serialized

11) Do Not Use CommandBuilder at Run Time

How it affects performance:

CommandBuilder objects such as as SqlCommandBuilder and OleDbCommandBuilder are useful when you are designing and prototyping your application. However, you should not use them in production applications. The processing required to generate the commands affects performance.

Solution:

Manually create stored procedures for your commands, or use the Visual Studio® .NET design-time wizard and customize them later if necessary.

12) Use Stored Procedures Whenever Possible

?Stored procedures are highly optimized tools that result in excellent performance when used effectively.

?Set up stored procedures to handle inserts, updates, and deletes with the data adapter

?Stored procedures do not have to be interpreted, compiled or even transmitted from the client, and cut down on both network traffic and server overhead.

?Be sure to use CommandType.StoredProcedure instead of CommandType.Text

13) Avoid Auto-Generated Commands

When using a data adapter, avoid auto-generated commands. These require additional trips to the server to retrieve meta data, and give you a lower level of interaction control. While using auto-generated commands is convenient, it's worth the effort to do it yourself in performance-critical applications.

14) Use Sequential Access as Often as Possible

With a data reader, use CommandBehavior.SequentialAccess. This is essential for dealing with blob data types since it allows data to be read off of the wire in small chunks. While you can only work with one piece of the data at a time, the latency for loading a large data type disappears. If you don't need to work the whole object at once, using

Sequential Access will give you much better performance.

Tips for Asp.Net applications developed using VB

1) Enable Option Strict and Option Explicit for your pages

With Option Strict on, you protect yourself from inadvertent late binding and enforce a higher level of coding discipline.

2) Use early binding in Visual Basic or JScript code

Visual Basic 6 does a lot of work under the hood to support casting of objects, and many programmers aren't even aware of it. In Visual Basic 7, this is an area that out of which you can squeeze a lot of performance.

Solution:

When you compile, use early binding. This tells the compiler to insert a Type Coercion is only done when explicitly mentioned.

This has two major effects:

? Strange errors become easier to track down.

? Unneeded coercions are eliminated, leading to substantial performance improvements.

When you use an object as if it were of a different type, Visual Basic will coerce the object for you if you don't specify. This is handy, since the programmer has to worry about less code.

3) Put Concatenations in One Expression
If you have multiple concatenations on multiple lines, try to stick them all on one expression. The compiler can optimize by modifying the string in place, providing a speed and memory boost. If the statements are split into multiple lines, the Visual Basic compiler will not generate the Microsoft Intermediate Language (MSIL) to allow in-place concatenation.

Summary
When we talk about ASP.Net performance, there are lots of factors in place.
Above discussed are the most critical of the speed improvements you can make in ASP.net that will have a dramatic impact on the user experience of your web application.

Expatriates Procedures in Saudi Arabia

2013-03-06T17:17:00.001+03:00

Dear Resident:

To ensure your application is completed promptly, please ensure that your traffic police record is free from traffic fines before applying for your Iqama ID.

To check your traffic fines please visit the Traffic Department Website.

Following is a table listing Administrations that receive fees through authorised banks (saving fees for Saudi Passport, which are paid through prepaid vouchers temporarily), until listed administrations are included within administrations charging fees via automated system.

No.	Administration	No.	Administration
1	Riyadh passports (Muzahmeya/Deri'yah)	2	Al-Madinah passports (Yanbu)
3	Makkah passports (Makkah/Jeddah/Taif/Qunfutha)	4	Eastern Province passports (Damma/Khobar/Ahsa)
5	Aseer passports	6	Al-Qassim passports
7	Najran passports	8	Northern Borders passports
9	Jazzan passports	10	Tabouk passports
11	Hayel passports	12	Al-Baha passports
13	Al-Jauf passports

Note: Other administrations receive fees in cash or through prepaid vouchers until they are included within administrations charging fees via automated system.

	Report runaway expatriate Requirements to report runaway expatriate: Reporting Runaway Expatriate form duly filled in with 2 photocopies Attach a copy of the expatriate's Resident Permit (Iqama) or passport Attach a copy of the informant's National ID If the informant's is not the employer, an authorisation letter must be provided (sanctioned by police or Chamber of Commerce) Requirements to invalidate report against runaway expatriate: Invalidating report against runaway expatriate form duly filled in Provide the runaway report Pay the statutory fees Presence of employer or his representative
	Issue Hajj Permits for residents Requirements to issue Hajj Permits for residents Hajj Permit request form duly filled in Provide two recent coloured photographs, 4X6 cm in size The applicant must not have performed Hajj in the past five years Provide an approval letter from the employer Provide passport and Resident Permit (Iqama) Provide a contract with one of the authorised Hajj campaign Vaccinate against meningitis
	Procedures to lend manpower Housemaids (includes private drivers, babysitters and guards) Lending of household help is restricted to employer's relatives only (brother / uncle / sister / aunt or their sons and daughters) This lending is valid until its validity date or until the Resident Permit (Iqama) is expires, and it can be renewed by following same procedures This lending is temporary for the employer's relative (beneficiary) The employer must cooperate with the beneficiary regarding the housemaid dues to other parties Lending duration is calculated within the housemaid service duration as agreed with the employer The beneficiary is not permitted to employ the housemaid until Passports Department issue the lending permit The employer and the beneficiary are provided with a copy of the contract, and the expatriate is provided with lending permit Agricultural Manpower: Permission to lend agricultural manpower is granted to farmers, and the beneficiary is required to provide property document or certificate from the Ministry of Agriculture. Lending duration is for three months only and may not be extended Lending agreement will not release the original employer from his responsibilities towards the employee Lending duration is calculated within the manpower service duration as agreed with the employer The original employer must keep the manpower passport with him The original employer must not allow the expatriate to leave the Kingdom without acquiring the beneficiary's approval The original employer must ensure his employee will resume working for him by the end of lending duration The employer must cooperate with the beneficiary regarding the expatriate dues to other parties The beneficiary is not permitted to employ the expatriate before issuing lending permit from passports The beneficiary must report to the employer any expatriate absence from duties Shepherds: Permission to lend shepherds is granted to cattle owners, and the beneficiary is required to provide Zakat certificate. Lending duration is for three months only and may not be extended Presence of the employer and the beneficiary or their legal representative is required The beneficiary must not have manpower practicing the same occupation
	Application for a residence permit for citizens' non-Saudi wives Procedures for a residence permit for citizens' non-Saudi wives Fill the relevant form (information as written in the passport of the wife) and sign the form. Attach a valid wife's passport with the name of the husband written in it. Submit two (2) recent photographs, size (4×6). Submit original valid husband's civil affairs card and a copy of it. Pay the issuance fee (S.R. 500) for each year. Attach a medical report. After completing the required documents and submitting the application, the husband shall review the passports department the next day to get the residence permit for his wife.
	Application for a residence permit for the first time for institutions and companies Procedures for issuing a residence permit for institutions and companies Fill the relevant form (information as written in the passport); and get the form signed and stamped with the seal of the employer. Submit expat's valid passport. Submit two (2) recent photographs, size (4×6). Pay the issuance fee (S.R. 500) for each year in any of authorised banks. Pay the human resources fees (S.R. 150). Submit a valid work permit covering the required period of stay and attach a copy through the Labour Office. Attach a medical report. Attach a health insurance. Fingerprint enrolment is a must. After completing the required documents and submitting the application, the applicant shall review the passports department the next day to get his residence permit.
	Application to renew residence permit for individuals and government agencies Procedures for renewal of residence permit for individuals and government agencies Fill the relevant form (information as written in the passport); and get the form signed and sealed by the government agency). Submit expat's valid passport. Submit two (2) recent photographs, size (4×6). Attach a clear photocopy of employer's civil affairs (for individuals). Pay the issuance fee for each year: (S.R. 500) for governmental agencies, and (S.R. 250) for the household labour in any authorised bank. Pay (S.R. 100) work permit fee. Attach a medical examination (by nationality). African countries: (Ethiopia, Eritrea, Kenya, Somalia, Djibouti, Nigeria, and the Sudan). Asian countries: (Thailand, Nepal and Vietnam) Fingerprint enrolment is a must; click here to inquire on fingerprint. After completing the required documents and submitting the application, the applicant shall review the passports department the next day to get his residence permit.
	Issuing residence permit for dependents who reach 18 years of age Procedures to get a residence permit for a dependent after reaching 18 years Fill the relevant form (information as it is written in the passport); and get the form signed by the family guardian. Submit a valid passport of the dependent. Submit two (2) photos, size (4×6). Pay (S.R. 500) issuance fees for each year. Submit a medical examination (by nationality). Fingerprint enrollment is a must. After completing the required documents and submitting the application, the applicant or family guardian shall review the department passports the next day to get the residence permit.
	Adding (wives and minor children) to the residence permit of the family guardian Procedures to apply for adding (wives and minor children) to the residence permit of the family guardian Fill the relevant form (information as it is written in the passport); and get the form signed by the family guardian. Submit the wife's passports and minor children to be added, with an entry visa issued by the Saudi embassy enabling children to stay with their guardian or formal document to add them. Submit two (2) group-photos, recent, size (6×4). Submit the original residence permit of the family guardian, to where children would be added. If the religion of the wife to be added is different from the religion of the husband, she should get a separate residence permit and pay the prescribed fees, (S.R. 500). If the wife is to be added has been married in the Kingdom, her sponsorship must first be transferred to the husband after submitting a copy of the marriage contract and pay the prescribed fees; then she could be added to her husband's residence permit. If minor children to be added were born in Saudi Arabia, the original birth certificates and copies of them should be submitted. After completing the required documents and submitting the application, the applicant or family guardian shall review the department of passport the next day to get the residence permit.
	Procedure to cancel exit/reentry Procedure to cancel exit/reentry Fill the relevant form (information as written in the passport); attach a photo of the applicant; and get the form singed by the employer. Submit a letter from the employer asking cancellation of the visa. Attendance of the sponsor or his representative. After completing the required documents and submitting the application, the applicant shall review the passports department the next day to get his passport after the abolition of the visa.
	Issue Resident Permit for the first time Requirements to issue Resident Permit (Iqama) for the first time: The applicant must have an entry visa issued by the Saudi embassy from the country of origin of the expatriate Iqama Application Form duly filled (by a typewriter or a computer) data as appear in the passport, signed and stamped by the employer. Provide a valid passport. Provide two recent colour photographs, size (4X6) Iqama fees are 500 Saudi Riyals per year paid at one of the authorised banks. Expatriate working for private sector must have work licence issued by the Labour Office. For individuals, a photocopy of employer's Civil Affairs ID must be attached. For restaurant and kitchen labourer, chef, maid and private driver, a medical report by an authorised hospital or clinic is required.
	Cancelling a final exit visa in order to issue a residence permit Procedures to cancel a final exit visa in order to issue a residence permit Fill the relevant form (information as it is written in the passport); attach a picture of the applicant; and get the form signed and stamped with the seal of the employer if the worker is an employee in a company or institution. A letter from the employer asking cancellation of the final exit visa. Attendance of the sponsor or his representative. Pay a fee (S.R. 650) for each year if the residence permit is expired; and (S.R. 600) for the household labour. Submit a valid work permit covering the required period of stay and attach a copy thereof, while domestic workers are exempted from getting a work permit, as the permit fee is paid within the re-issuance fee, (S.R. 600). After completing the required documents and submitting the application, the applicant shall review the department of passports the next day to get the passport and residence permit after cancellation of the final exit visa.
	Application for a lost visa replacement Procedures for getting a lost visa replacement The sponsor or his representative or head of household. Get out of the establishment of the beneficiary. Get out your passport. After completing the required documents and submitting the application, the applicant shall wait to get the visa replacement.
	Adding births Procedures to add babies born outside the Kingdom Pay entry visa fees, (S.R. 2000) through Sadad payment system. Submit a medical examination (by nationality). Fill the relevant form in the baby's name and submit two (2) group-photos excluding the family guardian, size (6×4). The Addition is done within 3 months as of entry stamp date. If 3 months elapsed without completing the addition, a fine of (S.R. 500) is imposed under Article 61 of the Residence Law. Baby must be inside the kingdom during the adding process. Procedures for adding babies born inside the Kingdom Add the baby to the passport of one of the parents at the embassy or get him a separate passport. Submit birth certificate and a copy thereof. Fill the relevant form in the baby's name and submit two (2) group-photos excluding the family guardian, size (6×4). If baby is not added while a year elapses as of the birthdate, a fine equals to (S.R. 1000) by certified check is imposed under Article 61 of the Residence Law. Baby must be inside the kingdom during the adding process. After completing the required documents and submitting the application, the applicant or family guardian shall review the department of passports the next day to get the residence permit.
	Sponsorship transfer Procedures to apply for transfer of sponsorship Fill the relevant form; stamp and sign the form by the current employer and new employer; and attach an applicant's photograph. Submit a letter of waiver from the current employer certified by the Chamber of Commerce and attach Chamber's receipt for companies, institutions and individuals; and if the sponsor is individual, the waiver letter must be certified from the mayor and the police. Submit a letter from the new employer requesting release, accompanied by a computer chip containing number of workers he has. Submit a copy of valid CR or licence of the municipality along with the originals for matching with the family book of the new employer. New employer must fill a pledge form to keep the new labourer, and not to let him work for others. Submit valid originals of the passport and residence permit of the worker whose services to be transferred, and attach a copy of same. Worker's profession must be appropriate to activity of new employer. Pay the transfer fees (2000 SR for the first time, 4000 SR for the second time and 6000 SR for the third time) but only after the submission and approval of the application by the relevant officer, in any of the authorised banks. If the expat has transferred service already and listed in former passports, all these passports must be submitted. Fingerprint enrollment is a must. After completing the required documents and submitting the application, the applicant shall await the employee to finalise the service, and get the passport and residence permit.
	Transfer of wife sponsorship Procedures to apply for wife sponsorship transfer Fill the relevant form for the transfer of sponsorship of individuals. A letter for transfer of sponsorship "prepared by the husband." Submit two (2) photos, size (4×6). Submit a copy of husband's residence permit or a copy of civil affairs card if the husband is Saudi. Submit the marriage contract and a clear copy of it. If the marriage contract is issued abroad, it must be authenticated from the embassy and the Saudi foreign ministry. The name of the husband must be added on the wife's passport by the embassy of the country of the wife. A waiver certified by the former sponsor. If the releaser is the wife's father a copy of the residence permit and letter of waiver must be submitted. Pay (S.R. 2000) sponsorship transfer fee in one of the authorised banks. After completing the required documents and submitting the application, the applicant shall wait for the employee to finalise transfer procedures.
	Copy information of old passport to new passport Procedures to apply for copying information of an old passport to a new passport Attendance of the employer or his representative. Submit the original old passport provided it contains a cancellation stamp. Submit the original new passport. After completing the required documents and submitting the application, the applicant shall wait to get his passport after completing relevant procedures.
	Change profession Procedures to apply for profession change Applicant must submit an application for profession change from his country's embassy. Should review the Labour Office to check if applicant is suitable to work according to his qualifications; and then the labour office reports to the passports department to approve the change or otherwise. The department of passports shall in the light of the labour office approval collect the change fees (S.R. 1000), via ATMs of authorised banks i.e. Riyadh and Al Rajhi Banks. After completing the required documents and submitting the application, the applicant shall review the passports department the next day to get the passport and residence permit after the completion of profession change.
	Rreporting loss of expat's passport Procedures to report loss of expat's passport A letter from the employer or his deputy, which must be sealed and certified by a Chamber of Commerce; and if the sponsor could not attended in person at the date, location, number, date and source of the lost passport, and that the passport is not reserved or in custody of any government body. Declaration of the lost passport in one of the local newspapers. A copy of the lost passport, if any. Attach a copy of the residence permit of the lost passport holder. Holder of the lost passport shall fill the case investigation documents and stamp them with the seal of the enterprise or the employer.
	Non-transfer of sponsorship notification Procedures to notify about non-transfer of sponsorship Personal attendance of sponsor or his deputy. Fill the relevant form. A copy of the release letter sent by the institution to the sponsor.
	Issue Resident Permit to family member Requirements to issue Resident Permit (Iqama) to family member for the first time: The family member must have an entry visa issued by the Saudi embassy from the country of origin of him/her The family member must be present in the Kingdom Iqama Form duly filled (by a typewriter or a computer) data as appear in the passport and signed by guardian. Provide valid passport of the member. Provide two recent, collective and colour photographs of the wife and children, size (4X6). If the child is born in saudi Arabia, a copy of birth certificate must be provided within one year from date of birth. If the wife was married in Saudi Arabia, she must be added to her husband's Resident Permit (Iqama) and a copy of the marriage contract must be provided. If the wife's religion is different from her husband's, her own Iqama must be issued with the statutory fees. Upon reaching 18 years of age the family member should be separated from guardian's Iqama and issued an individual Iqama, and a letter from the school must be provided confirming the student status. Iqama fees must be paid at an authorised bank.
	Renew Resident Permit Requirements to renew Resident Permit (Iqama): Iqama Renewal Form duly filled (by a typewriter or computer) data as appear in the passport, signed and stamped by employer. Valid passport. Provide two recent colour photographs, size (4X6). Iqama fees paid at an authorised bank. Expatriate who works for private sector must have work licence issued by Labour Office. For individuals, a photocopy of employer's Civil Affairs ID must be attached. For restaurant and kitchen labourer, chef, maid and private driver; a medical report by an authorised hospital or clinic is required. Provide expired Resident Permit (Iqama).
	Issue Loss Replacement Resident Permit Requirements to issue loss replacement Resident Permit (Iqama) Report to the nearest Passports Administration within 24 hours. Provide valid passport. Provide a copy of the lost Iqama if available. Fill the Specified Form duly (by a typewriter or computer) data as appear in the passport, signed and stamped by employer. Iqama fees are 500 Saudi Riyals valid for a year, this must paid at any authorised bank. Provide two recent colour photos, size (4X6) cm. Pay the statutory fines.
	Issue Damage Replacement Resident Permit Requirements to issue Damage Replacement Resident Permit (Iqama) Damage Replacement Iqama form duly filled in (by a typewriter or a computer) as it appears in the passport, signed and stamped by the employer Provide the original damaged Iqama Provide two recent colour photographs, 4X6 cm in size Provide a valid passport of the expatriate Iqama loss replacement fees are 500 S.R. valid for a year, this must be paid at an authorised bank
	Issue Exit/ Re-Entry Visa (single/ multiple) Requirements to issue Exit/ Re-Entry Visa (single/ multiple) Exit Re-Entry Visa Form duly filled. Specify visa duration. The passport and Resident Permit (Iqama) must be valid. If the visa is for medical employees, approval letter from the Health Affairs Administration must be attached. Pay the required fees in an authorised bank.
	Issue Final Exit Visa Requirements to issue Final Exit Visa Final Exit Visa Form duly filled. Provide valid Resident Permit (Iqama). Provide valid passport. For household help, employer must provide evidence that the employee has received all his/her dues.
	Extend Visit Visa Requirements to extend Visit Visa: Extend Visa request form duly filled in Sign and stamp the approval form by the host Provide a photocopy of the passport including the visit visa Provide a photocopy of the expatriate's host ID Pay the required fees at an authorised bank and provide a receipt

How to Change Default Browser (or Make Firefox / Chrome / IE Default Browser)

2013-03-06T17:14:00.000+03:00

So the other day I downloaded and installed the latest version of Opera. I had heard good things about this new version and wanted to give it a shot. Strangely, during the installation process, I didn’t see any option to not set it as default browser. It quickly installed and set itself as the default browser.

I probably missed a step or two in the installation process because as far as I know, all the browsers let the user decide if it wants to choose them as default. This was just an example and this can happen sometimes when some changes to the system change default browser without letting you know. You only find that out when you click on a link on, lets say, a chat window on your IM client and it suddenly opens the link in the new browser you installed, instead of your favorite browser.
The purpose of this article is to teach people – who are facing this problem – how to change default browser back to the old one manually.
We will take up Firefox, Chrome and IE in this post, and Safari and Opera in the next one.

Make Firefox Your Default Browser

In my case, I had Firefox set as the default browser and wanted it to remain like that. Hence when Opera set itself as the default browser without my permission, it didn’t make me jump with joy. I kinda like external links to open in Firefox.
Turned out that it wasn’t that difficult to revert the change. I first had to visit Tools –> Options to find where the setting was. It was under the Advanced tab. You can see below that there’s a way to check if Firefox is the default browser, without the need to restart it.

When you click on Check Now, it’ll pop up a box where you can set it as your default browser by clicking on Yes.

Simple, isn’t it? Now lets see how we can do it in Chrome.

Make Chrome Your Default Browser

Making Chrome your default browser is more simple because the setting is there right on the first page of the Options.
You can visit Chrome Options by clicking on the wrench icon at the top, and there under Basics, at the very bottom you’ll find a button that says Make Google Chrome my default browser. Clicking on it should get the job done.

Make Internet Explorer Default Browser

Considering the rave reviews IE 9 has received, it is possible that many people – who were not IE users previously – are now using it as their default browser. And then, there are millions of other IE users to consider (Lest you forget, IE is still the most widely used browser).
No matter what version of IE you are using, the Internet Options window is the answer to setting it as your default browser. You would need to go to Tools –> Internet Options, and then to Programs. There you’ll find the button that will set IE as default browser. Click on it, click OK and you’re done!

That was about manually setting Firefox, Chrome or IE as the default browser. Tomorrow, we will take up Safari and Opera, and see how to change default browser in that case.

Passing Data Between Forms

2013-01-14T17:13:00.005+03:00

There are so many methods (How many? I don't know) to pass data between forms in Windows application. In this article, let me take four important (easiest) ways of accomplishing this:

Using constructor
Using objects
Using properties
Using delegates

Let us see all the above methods in detail in the following sections.
For data to be passed between forms using any of the above methods, we need two forms and some controls. Let us start by following the steps given below.

Thanks Code Project

Passing Data Between Forms

Step 1

Create a new project and select Windows application. This will create a default form as “Form1”. We can use this form for sending data.

Step 2

Add a textbox and a button to the form.

Step 3

Add another Windows Form for receiving the data and to display it. Right click the project and select Add->Add Windows Form. Enter a name or use the default name “Form2.cs” and click ok button.

Step 4

Add a label to the second form to display the text from form1.

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 steps given below:

Step 1

Code a constructor for form2 class as below:

Collapse | Copy Code

public Form2(string strTextBox)
{
  InitializeComponent(); 
  label1.Text=strTextBox;
}

Step 2

Instantiate form2 class in form1’s button click event handler as below:

Collapse | Copy Code

private void button1_Click(object sender, System.EventArgs e)
{
    Form2 frm=new Form2(textBox1.Text);
    frm.Show();
}

The Object Approach

Objects are reference types, and are created on the heap, using the keyword new. Here we are going to pass data using objects. The approach is simple; in form2 we are going to instantiate form1 class.
Then instantiate form2 in the button click event handler of form1. After this we are going to pass form1 object to the form2 using form2’s form1 object. The last step is to invoke the form2 window by calling the form2’s show method.
Follow the below steps:

Step 1

Change the access modifier for textbox in form1 to public:

Collapse | Copy Code

public class Form1 : System.Windows.Forms.Form
{  
 public System.Windows.Forms.TextBox textBox1;

Step 2

In the button click event-handler, add the following code:

Collapse | Copy Code

private void btnSend_Click(object sender, System.EventArgs e)
{
    Form2 frm= new Form2();
    frm.frm1=this;
    frm.Show();
}

Step 3

In form2.cs, instantiate form1 class:

Collapse | Copy Code

public class Form2 : System.Windows.Forms.Form
{
     private System.Windows.Forms.Label label1;
     public Form1 frm1;

Step 4

In Form2’s Load method, type cast the object (frm1) of form1 to Form1 and access form1’s textbox and assign its text to label’s text.

Collapse | Copy Code

private void Form2_Load(object sender, System.EventArgs e)
{
    label1.Text=((Form1)frm1).textBox1.Text;
}

The Properties Approach

Properties allow clients to access class state as if they were accessing member fields directly, while actually implementing that access through a class method. In this method, we are going to add one property to each form. In form1 we are going to use one property for retrieving value from the textbox and in form2, one property to set the label’s text property. Then, in form1’s button click event handler, we are going to instantiate form2 and use the form2’s property to set the label’s text.
Follow the below steps:

Step 1

Add a property in form1 to retrieve value from textbox:

Collapse | Copy Code

public string _textBox1
{
    get{return textBox1.Text;}
}

Step 2

Add a property in form2 to set the labels’ text:

Collapse | Copy Code

public string _textBox
{
   set{label1.Text=value;}
}

Step 3

In form1’s button click event handler, add the following code:

Collapse | Copy Code

private void button1_Click(object sender, System.EventArgs e)
{
     Form2 frm=new Form2();
     frm._textBox=_textBox1;
     frm.Show();
}

The Delegates Approach

Technically, a delegate is a reference type used to encapsulate a method with a specific signature and return type. You can encapsulate any matching method in that delegate. Here we are going to create a delegate with some signature and assign a function to the delegate to assign the text from textbox to label.
Follow the below steps:

Step 1

Add a delegate signature to form1 as below:

Collapse | Copy Code

public delegate void delPassData(TextBox text);

Step 2

In form1’s button click event handler, instantiate form2 class and delegate. Assign a function in form2 to the delegate and call the delegate as below:

Collapse | Copy Code

private void btnSend_Click(object sender, System.EventArgs e)
{
    Form2 frm= new Form2();
    delPassData del=new delPassData(frm.funData);
    del(this.textBox1);
    frm.Show();
}

Step 3

In form2, add a function to which the delegate should point to. This function will assign textbox’s text to the label:

Collapse | Copy Code

public void funData(TextBox txtForm1)
{
    label1.Text = txtForm1.Text;
}

Conclusion

These four approaches are very simple in implementing data passing between forms. There are also other methods available in accomplishing the same. Source code for the methods I stated above is given at the top for download. It is time for you to put on your thinking cap and find other ways of doing this. Happy coding!!!

Custom Date and Time Format Strings in C#

2013-01-14T14:51:00.000+03:00

Thanks: Microsoft

A date and time format string defines the text representation of a DateTime or DateTimeOffset value that results from a formatting operation . It can also define the representation of a date and time value that is required in a parsing operation in order to successfully convert the string to a date and time. A custom format string consists of one or more custom date and time format specifiers. Any string that is not a standard date and time format string is interpreted as a custom date and time format string.
Custom date and time format strings can be used with both DateTime and DateTimeOffset values.

DateTime thisDate1 = new DateTime(2011, 6, 10);
Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".");

DateTimeOffset thisDate2 = new DateTimeOffset(2011, 6, 10, 15, 24, 16,
                                              TimeSpan.Zero);
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
                   thisDate2);
// The example displays the following output:
// Today is June 10, 2011.
// The current date and time: 06/10/11 15:24:16 +00:00
In parsing operations, custom date and time format strings can be used with the DateTimeParseExact, DateTimeTryParseExact, DateTimeOffsetParseExact, and DateTimeOffsetTryParseExact methods. These methods require that an input string conform exactly to a particular pattern for the parse operation to succeed. The following example illustrates a call to the DateTimeOffsetParseExact(String, String, IFormatProvider) method to parse a date that must include a day, a month, and a two-digit year.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateValues = { "30-12-2011", "12-30-2011",
                              "30-12-11", "12-30-11" };
      string pattern = "MM-dd-yy";
      DateTime parsedDate;

      foreach (var dateValue in dateValues) {
         if (DateTime.TryParseExact(dateValue, pattern, null,
                                   DateTimeStyles.None, out parsedDate))
            Console.WriteLine("Converted '{0}' to {1:d}.",
                              dateValue, parsedDate);
         else
            Console.WriteLine("Unable to convert '{0}' to a date and time.",
                              dateValue);
      }
   }
}
// The example displays the following output:
// Unable to convert '30-12-2011' to a date and time.
// Unable to convert '12-30-2011' to a date and time.
// Unable to convert '30-12-11' to a date and time.
// Converted '12-30-11' to 12/30/2011.
The following table describes the custom date and time format specifiers and displays a result string produced by each format specifier. If a particular format specifier produces a localized result string, the example also notes the culture to which the result string applies. See the Notes section for additional information about using custom date and time format strings.

Format specifier	Description	Examples
"d"	The day of the month, from 1 through 31. More information: The "d" Custom Format Specifier.	6/1/2009 1:45:30 PM -> 1 6/15/2009 1:45:30 PM -> 15
"dd"	The day of the month, from 01 through 31. More information: The "dd" Custom Format Specifier.	6/1/2009 1:45:30 PM -> 01 6/15/2009 1:45:30 PM -> 15
"ddd"	The abbreviated name of the day of the week. More information: The "ddd" Custom Format Specifier.	6/15/2009 1:45:30 PM -> Mon (en-US) 6/15/2009 1:45:30 PM -> Пн (ru-RU) 6/15/2009 1:45:30 PM -> lun. (fr-FR)
"dddd"	The full name of the day of the week. More information: The "dddd" Custom Format Specifier.	6/15/2009 1:45:30 PM -> Monday (en-US) 6/15/2009 1:45:30 PM -> понедельник (ru-RU) 6/15/2009 1:45:30 PM -> lundi (fr-FR)
"f"	The tenths of a second in a date and time value. More information: The "f" Custom Format Specifier.	6/15/2009 13:45:30.617 -> 6 6/15/2009 13:45:30.050 -> 0
"ff"	The hundredths of a second in a date and time value. More information: The "ff" Custom Format Specifier.	6/15/2009 13:45:30.617 -> 61 6/15/2009 13:45:30.005 -> 00
"fff"	The milliseconds in a date and time value. More information: The "fff" Custom Format Specifier.	6/15/2009 13:45:30.617 -> 617 6/15/2009 13:45:30.0005 -> 000
"ffff"	The ten thousandths of a second in a date and time value. More information: The "ffff" Custom Format Specifier.	6/15/2009 13:45:30.6175 -> 6175 6/15/2009 13:45:30.00005 -> 0000
"fffff"	The hundred thousandths of a second in a date and time value. More information: The "fffff" Custom Format Specifier.	6/15/2009 13:45:30.61754 -> 61754 6/15/2009 13:45:30.000005 -> 00000
"ffffff"	The millionths of a second in a date and time value. More information: The "ffffff" Custom Format Specifier.	6/15/2009 13:45:30.617542 -> 617542 6/15/2009 13:45:30.0000005 -> 000000
"fffffff"	The ten millionths of a second in a date and time value. More information: The "fffffff" Custom Format Specifier.	6/15/2009 13:45:30.6175425 -> 6175425 6/15/2009 13:45:30.0001150 -> 0001150
"F"	If non-zero, the tenths of a second in a date and time value. More information: The "F" Custom Format Specifier.	6/15/2009 13:45:30.617 -> 6 6/15/2009 13:45:30.050 -> (no output)
"FF"	If non-zero, the hundredths of a second in a date and time value. More information: The "FF" Custom Format Specifier.	6/15/2009 13:45:30.617 -> 61 6/15/2009 13:45:30.005 -> (no output)
"FFF"	If non-zero, the milliseconds in a date and time value. More information: The "FFF" Custom Format Specifier.	6/15/2009 13:45:30.617 -> 617 6/15/2009 13:45:30.0005 -> (no output)
"FFFF"	If non-zero, the ten thousandths of a second in a date and time value. More information: The "FFFF" Custom Format Specifier.	6/1/2009 13:45:30.5275 -> 5275 6/15/2009 13:45:30.00005 -> (no output)
"FFFFF"	If non-zero, the hundred thousandths of a second in a date and time value. More information: The "FFFFF" Custom Format Specifier.	6/15/2009 13:45:30.61754 -> 61754 6/15/2009 13:45:30.000005 -> (no output)
"FFFFFF"	If non-zero, the millionths of a second in a date and time value. More information: The "FFFFFF" Custom Format Specifier.	6/15/2009 13:45:30.617542 -> 617542 6/15/2009 13:45:30.0000005 -> (no output)
"FFFFFFF"	If non-zero, the ten millionths of a second in a date and time value. More information: The "FFFFFFF" Custom Format Specifier.	6/15/2009 13:45:30.6175425 -> 6175425 6/15/2009 13:45:30.0001150 -> 000115
"g", "gg"	The period or era. More information: The "g" or "gg" Custom Format Specifier.	6/15/2009 1:45:30 PM -> A.D.
"h"	The hour, using a 12-hour clock from 1 to 12. More information: The "h" Custom Format Specifier.	6/15/2009 1:45:30 AM -> 1 6/15/2009 1:45:30 PM -> 1
"hh"	The hour, using a 12-hour clock from 01 to 12. More information: The "hh" Custom Format Specifier.	6/15/2009 1:45:30 AM -> 01 6/15/2009 1:45:30 PM -> 01
"H"	The hour, using a 24-hour clock from 0 to 23. More information: The "H" Custom Format Specifier.	6/15/2009 1:45:30 AM -> 1 6/15/2009 1:45:30 PM -> 13
"HH"	The hour, using a 24-hour clock from 00 to 23. More information: The "HH" Custom Format Specifier.	6/15/2009 1:45:30 AM -> 01 6/15/2009 1:45:30 PM -> 13
"K"	Time zone information. More information: The "K" Custom Format Specifier.	With DateTime values: 6/15/2009 1:45:30 PM, Kind Unspecified -> 6/15/2009 1:45:30 PM, Kind Utc -> Z 6/15/2009 1:45:30 PM, Kind Local -> -07:00 (depends on local computer settings) With DateTimeOffset values: 6/15/2009 1:45:30 AM -07:00 --> -07:00 6/15/2009 8:45:30 AM +00:00 --> +00:00
"m"	The minute, from 0 through 59. More information: The "m" Custom Format Specifier.	6/15/2009 1:09:30 AM -> 9 6/15/2009 1:09:30 PM -> 9
"mm"	The minute, from 00 through 59. More information: The "mm" Custom Format Specifier.	6/15/2009 1:09:30 AM -> 09 6/15/2009 1:09:30 PM -> 09
"M"	The month, from 1 through 12. More information: The "M" Custom Format Specifier.	6/15/2009 1:45:30 PM -> 6
"MM"	The month, from 01 through 12. More information: The "MM" Custom Format Specifier.	6/15/2009 1:45:30 PM -> 06
"MMM"	The abbreviated name of the month. More information: The "MMM" Custom Format Specifier.	6/15/2009 1:45:30 PM -> Jun (en-US) 6/15/2009 1:45:30 PM -> juin (fr-FR) 6/15/2009 1:45:30 PM -> Jun (zu-ZA)
"MMMM"	The full name of the month. More information: The "MMMM" Custom Format Specifier.	6/15/2009 1:45:30 PM -> June (en-US) 6/15/2009 1:45:30 PM -> juni (da-DK) 6/15/2009 1:45:30 PM -> uJuni (zu-ZA)
"s"	The second, from 0 through 59. More information: The "s" Custom Format Specifier.	6/15/2009 1:45:09 PM -> 9
"ss"	The second, from 00 through 59. More information: The "ss" Custom Format Specifier.	6/15/2009 1:45:09 PM -> 09
"t"	The first character of the AM/PM designator. More information: The "t" Custom Format Specifier.	6/15/2009 1:45:30 PM -> P (en-US) 6/15/2009 1:45:30 PM -> 午 (ja-JP) 6/15/2009 1:45:30 PM -> (fr-FR)
"tt"	The AM/PM designator. More information: The "tt" Custom Format Specifier.	6/15/2009 1:45:30 PM -> PM (en-US) 6/15/2009 1:45:30 PM -> 午後 (ja-JP) 6/15/2009 1:45:30 PM -> (fr-FR)
"y"	The year, from 0 to 99. More information: The "y" Custom Format Specifier.	1/1/0001 12:00:00 AM -> 1 1/1/0900 12:00:00 AM -> 0 1/1/1900 12:00:00 AM -> 0 6/15/2009 1:45:30 PM -> 9
"yy"	The year, from 00 to 99. More information: The "yy" Custom Format Specifier.	1/1/0001 12:00:00 AM -> 01 1/1/0900 12:00:00 AM -> 00 1/1/1900 12:00:00 AM -> 00 6/15/2009 1:45:30 PM -> 09
"yyy"	The year, with a minimum of three digits. More information: The "yyy" Custom Format Specifier.	1/1/0001 12:00:00 AM -> 001 1/1/0900 12:00:00 AM -> 900 1/1/1900 12:00:00 AM -> 1900 6/15/2009 1:45:30 PM -> 2009
"yyyy"	The year as a four-digit number. More information: The "yyyy" Custom Format Specifier.	1/1/0001 12:00:00 AM -> 0001 1/1/0900 12:00:00 AM -> 0900 1/1/1900 12:00:00 AM -> 1900 6/15/2009 1:45:30 PM -> 2009
"yyyyy"	The year as a five-digit number. More information: The "yyyyy" Custom Format Specifier.	1/1/0001 12:00:00 AM -> 00001 6/15/2009 1:45:30 PM -> 02009
"z"	Hours offset from UTC, with no leading zeros. More information: The "z" Custom Format Specifier.	6/15/2009 1:45:30 PM -07:00 -> -7
"zz"	Hours offset from UTC, with a leading zero for a single-digit value. More information: The "zz" Custom Format Specifier.	6/15/2009 1:45:30 PM -07:00 -> -07
"zzz"	Hours and minutes offset from UTC. More information: The "zzz" Custom Format Specifier.	6/15/2009 1:45:30 PM -07:00 -> -07:00
":"	The time separator. More information: The ":" Custom Format Specifier.	6/15/2009 1:45:30 PM -> : (en-US) 6/15/2009 1:45:30 PM -> . (it-IT) 6/15/2009 1:45:30 PM -> : (ja-JP)
"/"	The date separator. More Information: The "/" Custom Format Specifier.	6/15/2009 1:45:30 PM -> / (en-US) 6/15/2009 1:45:30 PM -> - (ar-DZ) 6/15/2009 1:45:30 PM -> . (tr-TR)
"string" 'string'	Literal string delimiter.	6/15/2009 1:45:30 PM ("arr:" h:m t) -> arr: 1:45 P 6/15/2009 1:45:30 PM ('arr:' h:m t) -> arr: 1:45 P
%	Defines the following character as a custom format specifier. More information: Using Single Custom Format Specifiers.	6/15/2009 1:45:30 PM (%h) -> 1
\	The escape character.	6/15/2009 1:45:30 PM (h \h) -> 1 h
Any other character	The character is copied to the result string unchanged. More information: Using the Escape Character.	6/15/2009 1:45:30 AM (arr hh:mm t) -> arr 01:45 A

The following sections provide additional information about each custom date and time format specifier. Unless otherwise noted, each specifier produces an identical string representation regardless of whether it is used with a DateTime value or a DateTimeOffset value.

The "d" Custom Format Specifier

The "d" custom format specifier represents the day of the month as a number from 1 through 31. A single-digit day is formatted without a leading zero.
If the "d" format specifier is used without other custom format specifiers, it is interpreted as the "d" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "d" custom format specifier in several format strings.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15); 

Console.WriteLine(date1.ToString("d, M", 
                  CultureInfo.InvariantCulture)); 
// Displays 29, 8

Console.WriteLine(date1.ToString("d MMMM", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays 29 August
Console.WriteLine(date1.ToString("d MMMM", 
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays 29 agosto

Back to table

The "dd" Custom Format Specifier

The "dd" custom format string represents the day of the month as a number from 01 through 31. A single-digit day is formatted with a leading zero.
The following example includes the "dd" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM", 
                  CultureInfo.InvariantCulture)); 
// 02, 01

Back to table

The "ddd" Custom Format Specifier

The "ddd" custom format specifier represents the abbreviated name of the day of the week. The localized abbreviated name of the day of the week is retrieved from the DateTimeFormatInfoAbbreviatedDayNames property of the current or specified culture.
The following example includes the "ddd" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août

Back to table

The "dddd" Custom Format Specifier

The "dddd" custom format specifier (plus any number of additional "d" specifiers) represents the full name of the day of the week. The localized name of the day of the week is retrieved from the DateTimeFormatInfoDayNames property of the current or specified culture.
The following example includes the "dddd" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", 
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto

Back to table

The "f" Custom Format Specifier

The "f" custom format specifier represents the most significant digit of the seconds fraction; that is, it represents the tenths of a second in a date and time value.
If the "f" format specifier is used without other format specifiers, it is interpreted as the "f" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
When you use "f" format specifiers as part of a format string supplied to the ParseExact, TryParseExact, ParseExact, or TryParseExact method, the number of "f" format specifiers indicates the number of most significant digits of the seconds fraction that must be present to successfully parse the string.
The following example includes the "f" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018

Back to table

The "ff" Custom Format Specifier

The "ff" custom format specifier represents the two most significant digits of the seconds fraction; that is, it represents the hundredths of a second in a date and time value.
following example includes the "ff" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018

Back to table

The "fff" Custom Format Specifier

The "fff" custom format specifier represents the three most significant digits of the seconds fraction; that is, it represents the milliseconds in a date and time value.
The following example includes the "fff" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018

Back to table

The "ffff" Custom Format Specifier

The "ffff" custom format specifier represents the four most significant digits of the seconds fraction; that is, it represents the ten thousandths of a second in a date and time value.
Although it is possible to display the ten thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT version 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "fffff" Custom Format Specifier

The "fffff" custom format specifier represents the five most significant digits of the seconds fraction; that is, it represents the hundred thousandths of a second in a date and time value.
Although it is possible to display the hundred thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "ffffff" Custom Format Specifier

The "ffffff" custom format specifier represents the six most significant digits of the seconds fraction; that is, it represents the millionths of a second in a date and time value.
Although it is possible to display the millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "fffffff" Custom Format Specifier

The "fffffff" custom format specifier represents the seven most significant digits of the seconds fraction; that is, it represents the ten millionths of a second in a date and time value.
Although it is possible to display the ten millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "F" Custom Format Specifier

The "F" custom format specifier represents the most significant digit of the seconds fraction; that is, it represents the tenths of a second in a date and time value. Nothing is displayed if the digit is zero.
If the "F" format specifier is used without other format specifiers, it is interpreted as the "F" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The number of "F" format specifiers used with the ParseExact, TryParseExact, ParseExact, or TryParseExact method indicates the maximum number of most significant digits of the seconds fraction that can be present to successfully parse the string.
The following example includes the "F" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018

Back to table

The "FF" Custom Format Specifier

The "FF" custom format specifier represents the two most significant digits of the seconds fraction; that is, it represents the hundredths of a second in a date and time value. However, trailing zeros or two zero digits are not displayed.
The following example includes the "FF" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018

Back to table

The "FFF" Custom Format Specifier

The "FFF" custom format specifier represents the three most significant digits of the seconds fraction; that is, it represents the milliseconds in a date and time value. However, trailing zeros or three zero digits are not displayed.
The following example includes the "FFF" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018

Back to table

The "FFFF" Custom Format Specifier

The "FFFF" custom format specifier represents the four most significant digits of the seconds fraction; that is, it represents the ten thousandths of a second in a date and time value. However, trailing zeros or four zero digits are not displayed.
Although it is possible to display the ten thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "FFFFF" Custom Format Specifier

The "FFFFF" custom format specifier represents the five most significant digits of the seconds fraction; that is, it represents the hundred thousandths of a second in a date and time value. However, trailing zeros or five zero digits are not displayed.
Although it is possible to display the hundred thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "FFFFFF" Custom Format Specifier

The "FFFFFF" custom format specifier represents the six most significant digits of the seconds fraction; that is, it represents the millionths of a second in a date and time value. However, trailing zeros or six zero digits are not displayed.
Although it is possible to display the millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On tfhe Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "FFFFFFF" Custom Format Specifier

The "FFFFFFF" custom format specifier represents the seven most significant digits of the seconds fraction; that is, it represents the ten millionths of a second in a date and time value. However, trailing zeros or seven zero digits are not displayed.
Although it is possible to display the ten millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.
Back to table

The "g" or "gg" Custom Format Specifier

The "g" or "gg" custom format specifiers (plus any number of additional "g" specifiers) represents the period or era, such as A.D. The formatting operation ignores this specifier if the date to be formatted does not have an associated period or era string.
If the "g" format specifier is used without other custom format specifiers, it is interpreted as the "g" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "g" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(70, 08, 04);

Console.WriteLine(date1.ToString("MM/dd/yyyy g", 
                  CultureInfo.InvariantCulture));
// Displays 08/04/0070 A.D.                        
Console.WriteLine(date1.ToString("MM/dd/yyyy g", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));                         
// Displays 08/04/0070 ap. J.-C.

Back to table

The "h" Custom Format Specifier

The "h" custom format specifier represents the hour as a number from 1 through 12; that is, the hour is represented by a 12-hour clock that counts the whole hours since midnight or noon. A particular hour after midnight is indistinguishable from the same hour after noon. The hour is not rounded, and a single-digit hour is formatted without a leading zero. For example, given a time of 5:43 in the morning or afternoon, this custom format specifier displays "5".
If the "h" format specifier is used without other custom format specifiers, it is interpreted as a standard date and time format specifier and throws a FormatException. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "h" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ                        
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ

Back to table

The "hh" Custom Format Specifier

The "hh" custom format specifier (plus any number of additional "h" specifiers) represents the hour as a number from 01 through 12; that is, the hour is represented by a 12-hour clock that counts the whole hours since midnight or noon. A particular hour after midnight is indistinguishable from the same hour after noon. The hour is not rounded, and a single-digit hour is formatted with a leading zero. For example, given a time of 5:43 in the morning or afternoon, this format specifier displays "05".
The following example includes the "hh" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.

Back to table

The "H" Custom Format Specifier

The "H" custom format specifier represents the hour as a number from 0 through 23; that is, the hour is represented by a zero-based 24-hour clock that counts the hours since midnight. A single-digit hour is formatted without a leading zero.
If the "H" format specifier is used without other custom format specifiers, it is interpreted as a standard date and time format specifier and throws a FormatException. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "H" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("H:mm:ss", 
                  CultureInfo.InvariantCulture));
// Displays 6:09:01

Back to table

The "HH" Custom Format Specifier

The "HH" custom format specifier (plus any number of additional "H" specifiers) represents the hour as a number from 00 through 23; that is, the hour is represented by a zero-based 24-hour clock that counts the hours since midnight. A single-digit hour is formatted with a leading zero.
The following example includes the "HH" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("HH:mm:ss", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01

Back to table

The "K" Custom Format Specifier

The "K" custom format specifier represents the time zone information of a date and time value. When this format specifier is used with DateTime values, the result string is defined by the value of the DateTimeKind property:

For the local time zone (a DateTimeKind property value of DateTimeKindLocal), this specifier is equivalent to the "zzz" specifier and produces a result string containing the local offset from Coordinated Universal Time (UTC); for example, "-07:00".
For a UTC time (a DateTimeKind property value of DateTimeKindUtc), the result string includes a "Z" character to represent a UTC date.
For a time from an unspecified time zone (a time whose DateTimeKind property equals DateTimeKindUnspecified), the result is equivalent to StringEmpty.

For DateTimeOffset values, the "K" format specifier is equivalent to the "zz" format specifier, and produces a result string containing the DateTimeOffset value's offset from UTC.
If the "K" format specifier is used without other custom format specifiers, it is interpreted as a standard date and time format specifier and throws a FormatException. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example displays the string that results from using the "K" custom format specifier with various DateTime and DateTimeOffset values on a system in the U.S. Pacific Time zone.

Copy

Console.WriteLine(DateTime.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTime.UtcNow.ToString("%K"));
// Displays Z      
Console.WriteLine("'{0}'", 
                  DateTime.SpecifyKind(DateTime.Now, 
                       DateTimeKind.Unspecified).ToString("%K"));
// Displays ''      
Console.WriteLine(DateTimeOffset.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"));
// Displays +00:00
Console.WriteLine(new DateTimeOffset(2008, 5, 1, 6, 30, 0, 
                      new TimeSpan(5, 0, 0)).ToString("%K"));
// Displays +05:00

Back to table

The "m" Custom Format Specifier

The "m" custom format specifier represents the minute as a number from 0 through 59. The minute represents whole minutes that have passed since the last hour. A single-digit minute is formatted without a leading zero.
If the "m" format specifier is used without other custom format specifiers, it is interpreted as the "m" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "m" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ                        
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ

Back to table

The "mm" Custom Format Specifier

The "mm" custom format specifier (plus any number of additional "m" specifiers) represents the minute as a number from 00 through 59. The minute represents whole minutes that have passed since the last hour. A single-digit minute is formatted with a leading zero.
The following example includes the "mm" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.

Back to table

The "M" Custom Format Specifier

The "M" custom format specifier represents the month as a number from 1 through 12 (or from 1 through 13 for calendars that have 13 months). A single-digit month is formatted without a leading zero.
If the "M" format specifier is used without other custom format specifiers, it is interpreted as the "M" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "M" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 18);
Console.WriteLine(date1.ToString("(M) MMM, MMMM", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays (8) Aug, August
Console.WriteLine(date1.ToString("(M) MMM, MMMM", 
                  CultureInfo.CreateSpecificCulture("nl-NL")));                       
// Displays (8) aug, augustus
Console.WriteLine(date1.ToString("(M) MMM, MMMM", 
                  CultureInfo.CreateSpecificCulture("lv-LV")));                        
// Displays (8) Aug, augusts

Back to table

The "MM" Custom Format Specifier

The "MM" custom format specifier represents the month as a number from 01 through 12 (or from 1 through 13 for calendars that have 13 months). A single-digit month is formatted with a leading zero.
The following example includes the "MM" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM", 
                  CultureInfo.InvariantCulture)); 
// 02, 01

Back to table

The "MMM" Custom Format Specifier

The "MMM" custom format specifier represents the abbreviated name of the month. The localized abbreviated name of the month is retrieved from the DateTimeFormatInfoAbbreviatedMonthNames property of the current or specified culture.
The following example includes the "MMM" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août

Back to table

The "MMMM" Custom Format Specifier

The "MMMM" custom format specifier represents the full name of the month. The localized name of the month is retrieved from the DateTimeFormatInfoMonthNames property of the current or specified culture.
The following example includes the "MMMM" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM", 
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", 
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto

Back to table

The "s" Custom Format Specifier

The "s" custom format specifier represents the seconds as a number from 0 through 59. The result represents whole seconds that have passed since the last minute. A single-digit second is formatted without a leading zero.
If the "s" format specifier is used without other custom format specifiers, it is interpreted as the "s" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "s" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ                        
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ

Back to table

The "ss" Custom Format Specifier

The "ss" custom format specifier (plus any number of additional "s" specifiers) represents the seconds as a number from 00 through 59. The result represents whole seconds that have passed since the last minute. A single-digit second is formatted with a leading zero.
The following example includes the "ss" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.

Back to table

The "t" Custom Format Specifier

The "t" custom format specifier represents the first character of the AM/PM designator. The appropriate localized designator is retrieved from the DateTimeFormatInfoAMDesignator or DateTimeFormatInfoPMDesignator property of the current or specific culture. The AM designator is used for all times from 0:00:00 (midnight) to 11:59:59.999. The PM designator is used for all times from 12:00:00 (noon) to 23:59:59.999.
If the "t" format specifier is used without other custom format specifiers, it is interpreted as the "t" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "t" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ                        
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", 
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ

Back to table

The "tt" Custom Format Specifier

The "tt" custom format specifier (plus any number of additional "t" specifiers) represents the entire AM/PM designator. The appropriate localized designator is retrieved from the DateTimeFormatInfoAMDesignator or DateTimeFormatInfoPMDesignator property of the current or specific culture. The AM designator is used for all times from 0:00:00 (midnight) to 11:59:59.999. The PM designator is used for all times from 12:00:00 (noon) to 23:59:59.999.
Make sure to use the "tt" specifier for languages for which it is necessary to maintain the distinction between AM and PM. An example is Japanese, for which the AM and PM designators differ in the second character instead of the first character.
The following example includes the "tt" custom format specifier in a custom format string.

Copy

DateTime date1; 
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", 
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.

Back to table

The "y" Custom Format Specifier

The "y" custom format specifier represents the year as a one-digit or two-digit number. If the year has more than two digits, only the two low-order digits appear in the result. If the first digit of a two-digit year begins with a zero (for example, 2008), the number is formatted without a leading zero.
If the "y" format specifier is used without other custom format specifiers, it is interpreted as the "y" standard date and time format specifier. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "y" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010

Back to table

The "yy" Custom Format Specifier

The "yy" custom format specifier represents the year as a two-digit number. If the year has more than two digits, only the two low-order digits appear in the result. If the two-digit year has fewer than two significant digits, the number is padded with leading zeros to produce two digits.
In a parsing operation, a two-digit year that is parsed using the "yy" custom format specifier is interpreted based on the CalendarTwoDigitYearMax property of the format provider's current calendar. The following example parses the string representation of a date that has a two-digit year by using the default Gregorian calendar of the en-US culture, which, in this case, is the current culture. It then changes the current culture's CultureInfo object to use a GregorianCalendar object whose TwoDigitYearMax property has been modified.

Copy

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      string fmt = "dd-MMM-yy";
      string value = "24-Jan-49";

      Calendar cal = (Calendar) CultureInfo.CurrentCulture.Calendar.Clone();
      Console.WriteLine("Two Digit Year Range: {0} - {1}", 
                        cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);

      Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
      Console.WriteLine();

      cal.TwoDigitYearMax = 2099;
      CultureInfo culture = (CultureInfo) CultureInfo.CurrentCulture.Clone();
      culture.DateTimeFormat.Calendar = cal;
      Thread.CurrentThread.CurrentCulture = culture;

      Console.WriteLine("Two Digit Year Range: {0} - {1}", 
                        cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);
      Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
   }
}
// The example displays the following output: 
//       Two Digit Year Range: 1930 - 2029 
//       1/24/1949 
//        
//       Two Digit Year Range: 2000 - 2099 
//       1/24/2049

The following example includes the "yy" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010

Back to table

The "yyy" Custom Format Specifier

The "yyy" custom format specifier represents the year with a minimum of three digits. If the year has more than three significant digits, they are included in the result string. If the year has fewer than three digits, the number is padded with leading zeros to produce three digits.

Note
For the Thai Buddhist calendar, which can have five-digit years, this format specifier displays all significant digits.

The following example includes the "yyy" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010

Back to table

The "yyyy" Custom Format Specifier

The "yyyy" custom format specifier represents the year with a minimum of four digits. If the year has more than four significant digits, they are included in the result string. If the year has fewer than four digits, the number is padded with leading zeros to produce four digits.

Note
For the Thai Buddhist calendar, which can have five-digit years, this format specifier displays a minimum of four digits.

The following example includes the "yyyy" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010

Back to table

The "yyyyy" Custom Format Specifier

The "yyyyy" custom format specifier (plus any number of additional "y" specifiers) represents the year with a minimum of five digits. If the year has more than five significant digits, they are included in the result string. If the year has fewer than five digits, the number is padded with leading zeros to produce five digits.
If there are additional "y" specifiers, the number is padded with as many leading zeros as necessary to produce the number of "y" specifiers.
The following example includes the "yyyyy" custom format specifier in a custom format string.

Copy

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010

Back to table

The "z" Custom Format Specifier

With DateTime values, the "z" custom format specifier represents the signed offset of the local operating system's time zone from Coordinated Universal Time (UTC), measured in hours. It does not reflect the value of an instance's DateTimeKind property. For this reason, the "z" format specifier is not recommended for use with DateTime values.
With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in hours.
The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus sign (-) indicates hours behind UTC. A single-digit offset is formatted without a leading zero.
If the "z" format specifier is used without other custom format specifiers, it is interpreted as a standard date and time format specifier and throws a FormatException. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
The following example includes the "z" custom format specifier in a custom format string.

Copy

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", 
                  date1));
// Displays -7, -07, -07:00                     

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0, 
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", 
                  date2));
// Displays +6, +06, +06:00

Back to table

The "zz" Custom Format Specifier

With DateTime values, the "zz" custom format specifier represents the signed offset of the local operating system's time zone from UTC, measured in hours. It does not reflect the value of an instance's DateTimeKind property. For this reason, the "zz" format specifier is not recommended for use with DateTime values.
With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in hours.
The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus sign (-) indicates hours behind UTC. A single-digit offset is formatted with a leading zero.
The following example includes the "zz" custom format specifier in a custom format string.

Copy

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", 
                  date1));
// Displays -7, -07, -07:00                     

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0, 
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", 
                  date2));
// Displays +6, +06, +06:00

Back to table

The "zzz" Custom Format Specifier

With DateTime values, the "zzz" custom format specifier represents the signed offset of the local operating system's time zone from UTC, measured in hours and minutes. It does not reflect the value of an instance's DateTimeKind property. For this reason, the "zzz" format specifier is not recommended for use with DateTime values.
With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in hours and minutes.
The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus sign (-) indicates hours behind UTC. A single-digit offset is formatted with a leading zero.
The following example includes the "zzz" custom format specifier in a custom format string.

Copy

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", 
                  date1));
// Displays -7, -07, -07:00                     

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0, 
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", 
                  date2));
// Displays +6, +06, +06:00

Back to table

The ":" Custom Format Specifier

The ":" custom format specifier represents the time separator, which is used to differentiate hours, minutes, and seconds. The appropriate localized time separator is retrieved from the DateTimeFormatInfoTimeSeparator property of the current or specified culture.
If the ":" format specifier is used without other custom format specifiers, it is interpreted as a standard date and time format specifier and throws a FormatException. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
Back to table

The "/" Custom Format Specifier

The "/" custom format specifier represents the date separator, which is used to differentiate years, months, and days. The appropriate localized date separator is retrieved from the DateTimeFormatInfoDateSeparator property of the current or specified culture.
If the "/" format specifier is used without other custom format specifiers, it is interpreted as a standard date and time format specifier and throws a FormatException. For more information about using a single format specifier, see Using Single Custom Format Specifiers later in this topic.
Back to table

Notes

Using Single Custom Format Specifiers

A custom date and time format string consists of two or more characters. Date and time formatting methods interpret any single-character string as a standard date and time format string. If they do not recognize the character as a valid format specifier, they throw a FormatException. For example, a format string that consists only of the specifier "h" is interpreted as a standard date and time format string. However, in this particular case, an exception is thrown because there is no "h" standard date and timeformat specifier.
To use any of the custom date and time format specifiers as the only specifier in a format string (that is, to use the "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":", or "/" custom format specifier by itself), include a space before or after the specifier, or include a percent ("%") format specifier before the single custom date and time specifier.
For example, "%h" is interpreted as a custom date and time format string that displays the hour represented by the current date and time value. You can also use the " h" or "h " format string, although this includes a space in the result string along with the hour. The following example illustrates these three format strings.

Copy

DateTime dat1 = new DateTime(2009, 6, 15, 13, 45, 0);

Console.WriteLine("'{0:%h}'", dat1);
Console.WriteLine("'{0: h}'", dat1);
Console.WriteLine("'{0:h }'", dat1);
// The example displays the following output: 
//       '1' 
//       ' 1' 
//       '1 '

Using the Escape Character

The "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":", or "/" characters in a format string are interpreted as custom format specifiers rather than as literal characters. To prevent a character from being interpreted as a format specifier, you can precede it with a backslash (\), which is the escape character. The escape character signifies that the following character is a character literal that should be included in the result string unchanged.
To include a backslash in a result string, you must escape it with another backslash (\\).

Note
Some compilers, such as the C++ and C# compilers, may also interpret a single backslash character as an escape character. To ensure that a string is interpreted correctly when formatting, you can use the verbatim string literal character (the @ character) before the string in C#, or add another backslash character before each backslash in C# and C++. The following C# example illustrates both approaches.

Note

Some compilers, such as the C++ and C# compilers, may also interpret a single backslash character as an escape character. To ensure that a string is interpreted correctly when formatting, you can use the verbatim string literal character (the @ character) before the string in C#, or add another backslash character before each backslash in C# and C++. The following C# example illustrates both approaches.

The following example uses the escape character to prevent the formatting operation from interpreting the "h" and "m" characters as format specifiers.

Copy

DateTime date = new DateTime(2009, 06, 15, 13, 45, 30, 90);
string fmt1 = "h \\h m \\m";
string fmt2 = @"h \h m \m";

Console.WriteLine("{0} ({1}) -> {2}", date, fmt1, date.ToString(fmt1));
Console.WriteLine("{0} ({1}) -> {2}", date, fmt2, date.ToString(fmt2));
// The example displays the following output: 
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m 
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m

Control Panel Settings

The Regional and Language Options settings in Control Panel influence the result string produced by a formatting operation that includes many of the custom date and time format specifiers. These settings are used to initialize the DateTimeFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Computers that use different settings generate different result strings.
In addition, if you use the CultureInfo#ctor(String) constructor to instantiate a new CultureInfo object that represents the same culture as the current system culture, any customizations established by the Regional and Language Options item in Control Panel will be applied to the new CultureInfo object. You can use the CultureInfo#ctor(String, Boolean) constructo to create a CultureInfo object that does not reflect a system's customizations.

DateTimeFormatInfo Properties

Formatting is influenced by properties of the current DateTimeFormatInfo object, which is provided implicitly by the current thread culture or explicitly by the IFormatProvider parameter of the method that invokes formatting. For the IFormatProvider parameter, you should specify a CultureInfo object, which represents a culture, or a DateTimeFormatInfo object.
The result string produced by many of the custom date and time format specifiers also depends on properties of the current DateTimeFormatInfo object. Your application can change the result produced by some custom date and time format specifiers by changing the corresponding DateTimeFormatInfo property. For example, the "ddd" format specifier adds an abbreviated weekday name found in the AbbreviatedDayNames string array to the result string. Similarly, the "MMMM" format specifier adds a full month name found in the MonthNames string array to the result string.

How to: Format Data in the Windows Forms DataGridView Control

2013-01-10T14:20:00.001+03:00

.NET Framework 4.5

Other Versions

1 out of 3 rated this helpful - Rate this topic

The following procedures demonstrate basic formatting of cell values using the DefaultCellStyle property of a DataGridView control and of specific columns in a control. For information about advanced data formatting, see How to: Customize Data Formatting in the Windows Forms DataGridView Control.

To format currency and date values

Set the Format property of a DataGridViewCellStyle. The following code example sets the format for specific columns using the DefaultCellStyle property of the columns. Values in the UnitPrice column appear in the current culture-specific currency format, with negative values surrounded by parentheses. Values in the ShipDate column appear in the current culture-specific short date format. For more information about Format values, see Formatting Types.
C#

VB
Copy
this.dataGridView1.Columns["UnitPrice"].DefaultCellStyle.Format = "c"; this.dataGridView1.Columns["ShipDate"].DefaultCellStyle.Format = "d";

To customize the display of null database values

Set the NullValue property of a DataGridViewCellStyle. The following code example uses the DataGridViewDefaultCellStyle property to display "no entry" in all cells containing values equal to DBNullValue.
C#

VB
Copy
this.dataGridView1.DefaultCellStyle.NullValue = "no entry";

To enable wordwrap in text-based cells

Set the WrapMode property of a DataGridViewCellStyle to one of the DataGridViewTriState enumeration values. The following code example uses the DataGridViewDefaultCellStyle property to set the wrap mode for the entire control.
C#

VB
Copy
this.dataGridView1.DefaultCellStyle.WrapMode = DataGridViewTriState.True;

To specify the text alignment of DataGridView cells

Set the Alignment property of a DataGridViewCellStyle to one of the DataGridViewContentAlignment enumeration values. The following code example sets the alignment for a specific column using the DefaultCellStyle property of the column.
C#

VB
Copy
this.dataGridView1.Columns["CustomerName"].DefaultCellStyle .Alignment = DataGridViewContentAlignment.MiddleRight;

Example

Copy

private void SetFormatting()
{
    this.dataGridView1.Columns["UnitPrice"].DefaultCellStyle.Format = "c";
    this.dataGridView1.Columns["ShipDate"].DefaultCellStyle.Format = "d";
    this.dataGridView1.Columns["CustomerName"].DefaultCellStyle
        .Alignment = DataGridViewContentAlignment.MiddleRight;
    this.dataGridView1.DefaultCellStyle.NullValue = "no entry";
    this.dataGridView1.DefaultCellStyle.WrapMode =
        DataGridViewTriState.True;
}

Compiling the Code

These examples require:

A DataGridView control named dataGridView1 that contains a column named UnitPrice, a column named ShipDate, and a column named CustomerName.
References to the System, System.Drawing, and System.Windows.Forms assemblies.

Using Meta Tags with Master Pages in ASP.NET

2013-01-03T23:41:00.003+03:00

By Jim Azar, 24 May 2007

Download source code (C#) - 3 Kb

Download source code (VB) - 3 Kb

Introduction

The Master Pages introduced in ASP.NET 2.0 are a great feature, however, they don't provide a good way to perform the most basic search engine optimization. If you want your web pages to be listed properly and ranked well in search engines, then you need to specify good titles and meta tag descriptions on each page. This article explains how to extend the @Page directive on your ASP.NET pages so that you can specify the meta tag description and meta tag keywords on each content page when using master pages.

Background

When optimizing your web pages for search engines, some of the most important elements on the page are the tag and the description meta tag. The <title> and meta tags are usually specified in the <head> section of the HTML on each page as seen in the example below from the <a href="http://www.rhinoback.com/" target="_blank">Rhinoback online backup site</a>: <div class="pre-action-link" id="premain0" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="0">Copy Code</a></div> <div class="article-text"> <pre id="pre0" lang="html" style="margin-top: 0px;"><html xmlns="http://www.w3.org/1999/xhtml" > <head> <title> Rhinoback Professional Secure Online Backup Services for Small and Medium Business - SMB </title> <meta name="description" content="Professional Online Backup Services. Rhinoback provides robust backup functionality at affordable prices. Premium features, premium services, low prices. Get the most for your money with Rhinoback!" /> <meta name="keywords" content="backup, online backup, secure backup, cheap backup, free backup, offsite backup,internet backup, secure files, offsite data storage, privacy, security, features, low prices, premium service, remote backup" /> </head> <body>  </body> </html> </pre> </div> The text from the <title> tag is displayed at the top of most browsers. See the title of the Internet Explorer window in the example below: <a href="http://www.rhinoback.com/" target="_blank"> </a> The meta description text is displayed by the search engine when your page is listed. The example below is from a Google search. The text below the underlined title comes directly from the meta description tag. Without a meta description tag, your page may be listed with a description that was extracted from text found somewhere on the page. It is always better to specify the text for the description of each page rather than leave it up to a search engine robot. <a href="http://www.rhinoback.com/" target="_blank"> </a> Master Pages were introduced in ASP.NET 2.0 and have proven to be a valuable feature. This article does not attempt to explain the details of master pages or how to implement them, that is well covered in numerous other articles. When using master pages the <head> section is part of the master page and is automatically included on all of the content pages. Fortunately the developers at Microsoft included the Title attribute on the @Page directive that enables the developer to specify the title of the page on the content pages rather than on the master page. <div class="pre-action-link" id="premain1" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="1">Copy Code</a></div> <div class="article-text"> <pre id="pre1" lang="html" style="margin-top: 0px;"><%@ Page Language="C#" MasterPageFile="~/PageTags.master" AutoEventWireup="true" CodeFile="home.aspx.cs" Inherits="home" Title="My home page title" %> </pre> </div> The @Page directive above is from a content page in an ASP.NET 2.0 website that uses a master page. As discussed above, you may need to specify some meta tags at the content page level rather than at the master page level. You may have discovered that the @Page directive does have a Description attribute, however, it does not create a meta description tag for your page. In fact, anything that you specify on the Description attribute is completely ignored and not used for anything. In my case, it was completely unacceptable to have the same description on all pages of my site. I also wanted to specify keywords for each page that may vary from page to page. My first cut at a solution to this problem involved using the code-behind to insert the desired meta tags onto each pages' <head> section as shown in the Page_Load method of a content page below: <h3 class="article-text"> C#</h3> <div class="pre-action-link" id="premain2" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="2">Copy Code</a></div> <div class="article-text"> <pre id="pre2" lang="cs" style="margin-top: 0px;"> protected void Page_Load(object sender, EventArgs e) { HtmlMeta tag = new HtmlMeta(); tag.Name = "description"; tag.Content = "My description for this page"; Header.Controls.Add(tag); } </pre> </div> <h3 class="article-text"> VB</h3> <div class="pre-action-link" id="premain3" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="3">Copy Code</a></div> <div class="article-text"> <pre id="pre3" lang="vb" style="margin-top: 0px;"> Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) Dim tag As HtmlMeta = New HtmlMeta() tag.Name = "description" tag.Content = "My description for this page" Header.Controls.Add(tag) End Sub </pre> </div> The problem with this solution is that the title of the page, the meta description, and the content of a page are all related and I really want the title and description to be together and also in the same ASPX file as the content. The <code>Page_Load</code> method can easily be placed within <script> tags on the ASPX page, but I wanted to find a solution that was easier to maintain and would allow for quick and easy inspection of the tags on each page. The following solution meets my objectives by extending the @Page directive to include the meta tags that I want to specify for each page individually. <h2 class="article-text"> Solution</h2> I created a base page class that inherits from <code>System.Web.UI.Page</code> and then I modified my content pages to inherit from my <code>BasePage</code> class. The <code>BasePage</code> class contains the code that adds the meta tags to the header controls collection on the page. Since all of my content pages are inheriting from <code>BasePage</code>, this code only needs to exist in one place and not on every page. <h3 class="article-text"> C#</h3> <div class="pre-action-link" id="premain4" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="4">Copy Code</a></div> <div class="article-text"> <pre id="pre4" lang="cs" style="margin-top: 0px;">/* ********************************************** * Page directive extender - base page class * * by Jim Azar - http://www.rhinoback.com * * **********************************************/ using System; using System.Web.UI; using System.Web.UI.HtmlControls; using System.Text.RegularExpressions; /// <SUMMARY> /// Base class with properties for meta tags for content pages /// </SUMMARY> public class BasePage : Page { private string _keywords; private string _description; // Constructor // Add an event handler to Init event for the control // so we can execute code when a server control (page) // that inherits from this base class is initialized. public BasePage() { Init += new EventHandler(BasePage_Init); } // Whenever a page that uses this base class is initialized // add meta keywords and descriptions if available void BasePage_Init(object sender, EventArgs e) { if (!String.IsNullOrEmpty(Meta_Keywords)) { HtmlMeta tag = new HtmlMeta(); tag.Name = "keywords"; tag.Content = Meta_Keywords; Header.Controls.Add(tag); } if (!String.IsNullOrEmpty(Meta_Description)) { HtmlMeta tag = new HtmlMeta(); tag.Name = "description"; tag.Content = Meta_Description; Header.Controls.Add(tag); } } /// <SUMMARY> /// Gets or sets the Meta Keywords tag for the page /// </SUMMARY> public string Meta_Keywords { get { return _keywords; } set { // strip out any excessive white-space, newlines and linefeeds _keywords = Regex.Replace(value, "\\s+", " "); } } /// <SUMMARY> /// Gets or sets the Meta Description tag for the page /// </SUMMARY> public string Meta_Description { get { return _description; } set { // strip out any excessive white-space, newlines and linefeeds _description = Regex.Replace(value, "\\s+", " "); } } }</pre> </div> <h3 class="article-text"> VB</h3> <div class="pre-action-link" id="premain5" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="5">Copy Code</a></div> <div class="article-text"> <pre id="pre5" lang="vb" style="margin-top: 0px;">'* ********************************************** '* Page directive extender - base page class * '* by Jim Azar - http://www.rhinoback.com * '* **********************************************/ Imports System Imports System.Web.UI Imports System.Web.UI.HtmlControls Imports System.Text.RegularExpressions ' Base class with properties for meta tags for content pages Public Class BasePage Inherits Page Dim _keywords As String Dim _description As String ' Constructor ' Add an event handler to Init event for the control ' so we can execute code when a server control (page) ' that inherits from this base class is initialized. Public Sub New() AddHandler Init, New EventHandler(AddressOf BasePage_Init) End Sub ' Whenever a page that uses this base class is initialized ' add meta keywords and descriptions if available Sub BasePage_Init(ByVal sender As Object, ByVal e As EventArgs) If Not String.IsNullOrEmpty(Meta_Keywords) Then Dim tag As HtmlMeta = New HtmlMeta() tag.Name = "keywords" tag.Content = Meta_Keywords Header.Controls.Add(tag) End If If Not String.IsNullOrEmpty(Meta_Description) Then Dim tag As HtmlMeta = New HtmlMeta() tag.Name = "description" tag.Content = Meta_Description Header.Controls.Add(tag) End If End Sub 'Gets or sets the Meta Keywords tag for the page Public Property Meta_Keywords() As String Get Return _keywords End Get set ' strip out any excessive white-space, newlines and linefeeds _keywords = Regex.Replace(value, "\\s+", " ") End Set End Property ' Gets or sets the Meta Description tag for the page Public Property Meta_Description() As String Get Return _description End Get Set(ByVal value As String) ' strip out any excessive white-space, newlines and linefeeds _description = Regex.Replace(value, "\\s+", " ") End Set End Property End Class</pre> </div> The <code>Meta_Keywords</code> and <code>Meta_Description</code> properties are public and can be set when the class (or derived class) is instantiated. When a page that inherits from this class is initialized, the <code>Base_Init</code> event handler is invoked and adds the meta tags to the page. On each content page, simply change the inheritance so that they inherit from <code>BasePage</code> instead of <code>page</code> or <code>System.Web.UI.Page</code>. See below: <h3 class="article-text"> C#</h3> <div class="pre-action-link" id="premain6" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="6">Copy Code</a></div> <div class="article-text"> <pre id="pre6" lang="cs" style="margin-top: 0px;">public partial class home : BasePage { protected void Page_Load(object sender, EventArgs e) { } }</pre> </div> <h3 class="article-text"> VB</h3> <div class="pre-action-link" id="premain7" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="7">Copy Code</a></div> <div class="article-text"> <pre id="pre7" lang="vb" style="margin-top: 0px;">Partial Class home Inherits BasePage Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) End Sub End Class</pre> </div> Now that each content page is inheriting from <code>BasePage</code>, they have the properties and the code to insert the meta tags. Now we can specify the <code>Meta_Keywords</code> and <code>Meta_Description</code> values on the @Page directive on the ASPX file. See the examples below: <div class="pre-action-link" id="premain8" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="8">Copy Code</a></div> <div class="article-text"> <pre id="pre8" lang="html" style="margin-top: 0px;"><%@ Page Language="C#" MasterPageFile="~/PageTags.master" AutoEventWireup="true" CodeFile="home.aspx.cs" Inherits="home" CodeFileBaseClass="BasePage" Title="My home page title" Meta_Keywords="page directive, extension, dotnet, asp.net" Meta_Description="This is the meta description for my home page." %> <asp:Content ID="Content1" ContentPlaceHolderID="ContentPlaceHolder1" Runat="Server"> <h3>My home page content<h3> <p> This is the content on my home page. This page has an appropriate title tag and also has meta tags for keywords and description that are relative to this page. The title tag is essential to good search engine optimization and the meta description is the text that the search engine will display when your page is listed in search results. The title and meta description should be set specific to each page and should describe the content of the page. </p> </asp:Content> </pre> </div> Note the addition of the <code>CodeFileBaseClass</code> attribute. This is required so that page can reference the public properties specified in the <code>BasePage</code> class. <h2 class="article-text"> Points of Interest</h2> You may have noticed the regular expression in the <code>BasePage</code> class. This is here so that you can break the description and keyword tags up onto mulitple lines in your ASPX file, making them more readable and maintainable. Consider the following example from the <a href="http://www.ideascope.com/" target="_blank">IdeaScope Customer Feedback Management</a> website: <div class="pre-action-link" id="premain9" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="9">Copy Code</a></div> <div class="article-text"> <pre id="pre9" lang="html" style="margin-top: 0px;"><%@ Page Language="C#" MasterPageFile="~/IdeaScope.master" AutoEventWireup="true" CodeFile="is.aspx.cs" Inherits="_is" CodeFileBaseClass="BasePage" Title="Effective Customer Feedback Management, Improve Customer Commmunication" Meta_Keywords="Customer Feedback, Customer Opinion, feedback, opinion, idea, ideas, idea management, customer feedback management, product management, product manager, product marketing, product marketing manager" Meta_Description="IdeaScope is an on-demand and embedded solution that allows you to capture, prioritize and centrally manage customer feedback. Make your customer feedback process more efficient. Save time and involve more stakeholders without significant cost." %> </pre> </div> Without the regular expression replacement, these tags would contain new lines and excess spaces at the beginning and ending of each line. I suspect that some search engine spiders might get upset about that, and the primary reason for including these tags is to make search engines happy. There is one last thing that you might want to do to tidy up this solution. The ASP.NET validation in Visual Studio 2005 is not going to recognize Meta_Keywords or Meta_Description. You will get warnings from the compiler saying that these are not valid attributes for the @Page directive. You will also see those red squiggley lines under those attributes in Visual Studio. Your code will compile and run fine. If you are like me and don't want to see any warnings or validation errors, then you will want to add the following lines to Visual Studio's schema for the @Page directive. <div class="pre-action-link" id="premain10" style="display: block;" width="100%"> Collapse | <a href="http://www.codeproject.com/Articles/17368/Using-Meta-Tags-with-Master-Pages-in-ASP-NET#" preid="10">Copy Code</a></div> <div class="article-text"> <pre id="pre10" lang="xml" style="margin-top: 0px;"> <xsd:attribute name="Meta_Keywords" vs:nonfilterable="true" /> <xsd:attribute name="Meta_Description" vs:nonfilterable="true" /> </pre> </div> These nodes should be inserted as child nodes of <code lang="xml"><xsd:complexType name="PageDef"></code> The schema file is located at the following location if you installed Visual Studio 2005 in the default location: <div class="article-text"> <code>C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\schemas\html\page_directives.xsd </code></div> This article demonstrates how to extend the @Page directive to support meta keywords and meta descriptions. You can easily add other meta tags to the sample code. Complete source files and a sample project are included for C# and VB. Thanks to Scott Guthrie's blog post, <a href="http://weblogs.asp.net/scottgu/archive/2005/08/02/421405.aspx" target="_blank">Obsure but cool feature in ASP.NET 2.0</a> for the information that led up to this solution. Your comments and suggestions to improve this article are welcome. <h2> License</h2> <div id="LicenseTerms"> This article, along with any associated source code and files, is licensed under <a href="http://www.codeproject.com/info/cpol10.aspx" rel="license">The Code Project Open License (CPOL)</a> </div> </form>

HTML Tutorial - Introduction to tables

2012-11-28T20:54:00.001+03:00

11.1 Introduction to tables

The HTML table model allows authors to arrange data -- text, preformatted text, images, links, forms, form fields, other tables, etc. -- into rows and columns of cells.

Each table may have an associated caption (see the CAPTION element) that provides a short description of the table's purpose. A longer description may also be provided (via the summary attribute) for the benefit of people using speech or Braille-based user agents.

Table rows may be grouped into a head, foot, and body sections, (via the THEAD, TFOOT and TBODY elements, respectively). Row groups convey additional structural information and may be rendered by user agents in ways that emphasize this structure. User agents may exploit the head/body/foot division to support scrolling of body sections independently of the head and foot sections. When long tables are printed, the head and foot information may be repeated on each page that contains table data.

Authors may also group columns to provide additional structural information that may be exploited by user agents. Furthermore, authors may declare column properties at the start of a table definition (via the COLGROUP and COL elements) in a way that enables user agents to render the table incrementally rather than having to wait for all the table data to arrive before rendering.

Table cells may either contain "header" information (see the TH element) or "data" (see the TD element). Cells may span multiple rows and columns. The HTML 4 table model allows authors to label each cell so that non-visual user agents may more easily communicate heading information about the cell to the user. Not only do these mechanisms greatly assist users with visual disabilities, they make it possible for multi-modal wireless browsers with limited display capabilities (e.g., Web-enabled pagers and phones) to handle tables.

Tables should not be used purely as a means to layout document content as this may present problems when rendering to non-visual media. Additionally, when used with graphics, these tables may force users to scroll horizontally to view a table designed on a system with a larger display. To minimize these problems, authors should use style sheets to control layout rather than tables.

Note. This specification includes more detailed information about tables in sections on table design rationale and implementation issues.

Here's a simple table that illustrates some of the features of the HTML table model. The following table definition:


A test table with merged cells
Average
    Red
eyes
height weight
Males 1.9 0.003 40%
Females 1.7 0.002 43%

*A test table with merged cells*
	Average	Red eyes
height	weight
Males	1.9	0.003	40%
Females	1.7	0.002	43%

might be rendered something like this on a tty device:

          A test table with merged cells
    /-----------------------------------------\
    |          |      Average      |   Red    |
    |          |-------------------|  eyes    |
    |          |  height |  weight |          |
    |-----------------------------------------|
    |  Males   | 1.9     | 0.003   |   40%    |
    |-----------------------------------------|
    | Females  | 1.7     | 0.002   |   43%    |
    \-----------------------------------------/

or like this by a graphical user agent:

11.2 Elements for constructing tables

11.2.1 The `TABLE` element

TABLE

- - (CAPTION?, (COL*|COLGROUP*), THEAD?, TFOOT?, TBODY+)> %attrs; -- %coreattrs, %i18n, %events -- summary %Text; #IMPLIED -- purpose/structure for speech output-- width %Length; #IMPLIED -- table width -- border %Pixels; #IMPLIED -- controls frame width around table -- frame %TFrame; #IMPLIED -- which parts of frame to render -- rules %TRules; #IMPLIED -- rulings between rows and cols -- cellspacing %Length; #IMPLIED -- spacing between cells -- cellpadding %Length; #IMPLIED -- spacing within cells -- >
Start tag: required, End tag: required

Attribute definitions

summary = text [CS]

This attribute provides a summary of the table's purpose and structure for user agents rendering to non-visual media such as speech and Braille.

align = left|center|right [CI]

Deprecated. This attribute specifies the position of the table with respect to the document. Permitted values:

left: The table is to the left of the document.
center: The table is to the center of the document.
right: The table is to the right of the document.

width = length [CN]

This attribute specifies the desired width of the entire table and is intended for visual user agents. When the value is a percentage value, the value is relative to the user agent's available horizontal space. In the absence of any width specification, table width is determined by the user agent.

Attributes defined elsewhere

The TABLE element contains all other elements that specify caption, rows, content, and formatting.

The following informative list describes what operations user agents may carry out when rendering a table:

Make the table summary available to the user. Authors should provide a summary of a table's content and structure so that people using non-visual user agents may better understand it.
Render the caption, if one is defined.
Render the table header, if one is specified. Render the table footer, if one is specified. User agents must know where to render the header and footer. For instance, if the output medium is paged, user agents may put the header at the top of each page and the footer at the bottom. Similarly, if the user agent provides a mechanism to scroll the rows, the header may appear at the top of the scrolled area and the footer at the bottom.
Calculate the number of columns in the table. Note that the number of rows in a table is equal to the number of TR elements contained by the TABLE element.
Group the columns according to any column group specifications.
Render the cells, row by row and grouped in appropriate columns, between the header and footer. Visual user agents should format the table according to HTML attributes and style sheet specification.

The HTML table model has been designed so that, with author assistance, user agents may render tables incrementally (i.e., as table rows arrive) rather than having to wait for all the data before beginning to render.

In order for a user agent to format a table in one pass, authors must tell the user agent:

The number of columns in the table. Please consult the section on calculating the number of columns in a table for details on how to supply this information.
The widths of these columns. Please consult the section on calculating the width of columns for details on how to supply this information.

More precisely, a user agent may render a table in a single pass when the column widths are specified using a combination of COLGROUP and COL elements. If any of the columns are specified in relative or percentage terms (see the section on calculating the width of columns), authors must also specify the width of the table itself.

Table directionality

The directionality of a table is either the inherited directionality (the default is left-to-right) or that specified by the dir attribute for the TABLE element.

For a left-to-right table, column zero is on the left side and row zero is at the top. For a right-to-left table, column zero is on the right side and row zero is at the top.

When a user agent allots extra cells to a row (see the section on calculating the number of columns in a table), extra row cells are added to the right of the table for left-to-right tables and to the left side for right-to-left tables.

Note that TABLE is the only element on which dir reverses the visual order of the columns; a single table row (TR) or a group of columns (COLGROUP) cannot be independently reversed.

When set for the TABLE element, the dir attribute also affects the direction of text within table cells (since the dir attribute is inherited by block-level elements).

To specify a right-to-left table, set the dir attribute as follows:

...the rest of the table...

The direction of text in individual cells can be changed by setting the dir attribute in an element that defines the cell. Please consult the section on bidirectional text for more information on text direction issues.

11.2.2 Table Captions: The `CAPTION` element

CAPTION

- - (%inline;)* -- table caption --> %attrs; -- %coreattrs, %i18n, %events -- >
Start tag: required, End tag: required

Attribute definitions

align = top|bottom|left|right [CI]

Deprecated. For visual user agents, this attribute specifies the position of the caption with respect to the table. Possible values:

top: The caption is at the top of the table. This is the default value.
bottom: The caption is at the bottom of the table.
left: The caption is at the left of the table.
right: The caption is at the right of the table.

Attributes defined elsewhere

When present, the CAPTION element's text should describe the nature of the table. The CAPTION element is only permitted immediately after the TABLE start tag. A TABLE element may only contain one CAPTION element.

Visual user agents allow sighted people to quickly grasp the structure of the table from the headings as well as the caption. A consequence of this is that captions will often be inadequate as a summary of the purpose and structure of the table from the perspective of people relying on non-visual user agents.

Authors should therefore take care to provide additional information summarizing the purpose and structure of the table using the summary attribute of the TABLE element. This is especially important for tables without captions. Examples below illustrate the use of the summary attribute.

Visual user agents should avoid clipping any part of the table including the caption, unless a means is provided to access all parts, e.g., by horizontal or vertical scrolling. We recommend that the caption text be wrapped to the same width as the table. (See also the section on recommended layout algorithms.)

11.2.3 Row groups: the `THEAD`, `TFOOT`, and `TBODY` elements

THEAD

- O (TR)+ -- table header --> TFOOT - O (TR)+ -- table footer -->
Start tag: required, End tag: optional

TBODY

O O (TR)+ -- table body -->
Start tag: optional, End tag: optional

%attrs;

-- %coreattrs, %i18n, %events -- %cellhalign; -- horizontal alignment in cells -- %cellvalign; -- vertical alignment in cells -- >

Attributes defined elsewhere

id, class (document-wide identifiers)
lang (language information), dir (text direction)
title (element title)
style (inline style information )
onclick, ondblclick, onmousedown, onmouseup, onmouseover, onmousemove, onmouseout, onkeypress, onkeydown, onkeyup (intrinsic events )
align, char, charoff, valign (cell alignment)

Table rows may be grouped into a table head, table foot, and one or more table body sections, using the THEAD, TFOOT and TBODY elements, respectively. This division enables user agents to support scrolling of table bodies independently of the table head and foot. When long tables are printed, the table head and foot information may be repeated on each page that contains table data.

The table head and table foot should contain information about the table's columns. The table body should contain rows of table data.

When present, each THEAD, TFOOT, and TBODY contains a row group. Each row group must contain at least one row, defined by the TR element.

This example illustrates the order and structure of table heads, feet, and bodies.

...header information......footer information......first row of block one data......second row of block one data......first row of block two data......second row of block two data......third row of block two data...

TFOOT must appear before TBODY within a TABLE definition so that user agents can render the foot before receiving all of the (potentially numerous) rows of data. The following summarizes which tags are required and which may be omitted:

The TBODY start tag is always required except when the table contains only one table body and no table head or foot sections. The TBODY end tag may always be safely omitted.
The start tags for THEAD and TFOOT are required when the table head and foot sections are present respectively, but the corresponding end tags may always be safely omitted.

Conforming user agent parsers must obey these rules for reasons of backward compatibility.

The table of the previous example could be shortened by removing certain end tags, as in:

...header information......footer information......first row of block one data......second row of block one data......first row of block two data......second row of block two data......third row of block two data...

The THEAD, TFOOT, and TBODY sections must contain the same number of columns.

11.2.4 Column groups: the `COLGROUP` and `COL` elements

Column groups allow authors to create structural divisions within a table. Authors may highlight this structure through style sheets or HTML attributes (e.g., the rules attribute for the TABLE element). For an example of the visual presentation of column groups, please consult the sample table.

A table may either contain a single implicit column group (no COLGROUP element delimits the columns) or any number of explicit column groups (each delimited by an instance of the COLGROUP element).

The COL element allows authors to share attributes among several columns without implying any structural grouping. The "span" of the COL element is the number of columns that will share the element's attributes.

The `COLGROUP` element

COLGROUP

- O (COL)* -- table column group --> %attrs; -- %coreattrs, %i18n, %events -- span NUMBER 1 -- default number of columns in group -- width %MultiLength; #IMPLIED -- default width for enclosed COLs -- %cellhalign; -- horizontal alignment in cells -- %cellvalign; -- vertical alignment in cells -- >
Start tag: required, End tag: optional

Attribute definitions

span = number [CN]

This attribute, which must be an integer > 0, specifies the number of columns in a column group. Values mean the following:

In the absence of a span attribute, each COLGROUP defines a column group containing one column.
If the span attribute is set to N > 0, the current COLGROUP element defines a column group containing N columns.

User agents must ignore this attribute if the COLGROUP element contains one or more COL elements.

width = multi-length [CN]

This attribute specifies a default width for each column in the current column group. In addition to the standard pixel, percentage, and relative values, this attribute allows the special form "0*" (zero asterisk) which means that the width of the each column in the group should be the minimum width necessary to hold the column's contents. This implies that a column's entire contents must be known before its width may be correctly computed. Authors should be aware that specifying "0*" will prevent visual user agents from rendering a table incrementally.
This attribute is overridden for any column in the column group whose width is specified via a COL element.

Attributes defined elsewhere

id, class (document-wide identifiers)
lang (language information), dir (text direction)
title (element title)
style (inline style information )
onclick, ondblclick, onmousedown, onmouseup, onmouseover, onmousemove, onmouseout, onkeypress, onkeydown, onkeyup (intrinsic events )
align, char, charoff, valign (cell alignment)

The COLGROUP element creates an explicit column group. The number of columns in the column group may be specified in two, mutually exclusive ways:

The element's span attribute (default value 1) specifies the number of columns in the group.
Each COL element in the COLGROUP represents one or more columns in the group.

The advantage of using the span attribute is that authors may group together information about column widths. Thus, if a table contains forty columns, all of which have a width of 20 pixels, it is easier to write:

than:

   
      
      
      ...a total of forty COL elements...

When it is necessary to single out a column (e.g., for style information, to specify width information, etc.) within a group, authors must identify that column with a COL element. Thus, to apply special style information to the last column of the previous table, we single it out as follows:

The width attribute of the COLGROUP element is inherited by all 40 columns. The first COL element refers to the first 39 columns (doing nothing special to them) and the second one assigns an id value to the fortieth column so that style sheets may refer to it.

The table in the following example contains two column groups. The first column group contains 10 columns and the second contains 5 columns. The default width for each column in the first column group is 50 pixels. The width of each column in the second column group will be the minimum required for that column.

...

The `COL` element

COL

- O EMPTY -- table column --> %attrs; -- %coreattrs, %i18n, %events -- span NUMBER 1 -- COL attributes affect N columns -- width %MultiLength; #IMPLIED -- column width specification -- %cellhalign; -- horizontal alignment in cells -- %cellvalign; -- vertical alignment in cells -- >
Start tag: required, End tag: forbidden

Attribute definitions

span = number [CN]: This attribute, whose value must be an integer > 0, specifies the number of columns "spanned" by the COL element; the COL element shares its attributes with all the columns it spans. The default value for this attribute is 1 (i.e., the COL element refers to a single column). If the span attribute is set to N > 1, the current COL element shares its attributes with the next N-1 columns.
width = multi-length [CN]: This attribute specifies a default width for each column spanned by the current COL element. It has the same meaning as the width attribute for the COLGROUP element and overrides it.

Attributes defined elsewhere

id, class (document-wide identifiers)
lang (language information), dir (text direction)
title (element title)
style (inline style information )
onclick, ondblclick, onmousedown, onmouseup, onmouseover, onmousemove, onmouseout, onkeypress, onkeydown, onkeyup (intrinsic events )
align, char, charoff, valign (cell alignment)

The COL element allows authors to group together attribute specifications for table columns. The COL does not group columns together structurally -- that is the role of the COLGROUP element. COL elements are empty and serve only as a support for attributes. They may appear inside or outside an explicit column group (i.e., COLGROUP element).

The width attribute for COL refers to the width of each column in the element's span.

Calculating the number of columns in a table

There are two ways to determine the number of columns in a table (in order of precedence):

If the TABLE element contains any COLGROUP or COL elements, user agents should calculate the number of columns by summing the following:
- For each COL element, take the value of its span attribute (default value 1).
- For each COLGROUP element containing at least one COL element, ignore the span attribute for the COLGROUP element. For each COL element, perform the calculation of step 1.
- For each empty COLGROUP element, take the value of its span attribute (default value 1).
Otherwise, if the TABLE element contains no COLGROUP or COL elements, user agents should base the number of columns on what is required by the rows. The number of columns is equal to the number of columns required by the row with the most columns, including cells that span multiple columns. For any row that has fewer than this number of columns, the end of that row should be padded with empty cells. The "end" of a row depends on the table directionality.

It is an error if a table contains COLGROUP or COL elements and the two calculations do not result in the same number of columns.

Once the user agent has calculated the number of columns in the table, it may group them into column groups.

For example, for each of the following tables, the two column calculation methods should result in three columns. The first three tables may be rendered incrementally.



 ...
...rows...







 ...
...rows...







 ...
...rows...

Calculating the width of columns

Authors may specify column widths in three ways:

Fixed: A fixed width specification is given in pixels (e.g., width="30"). A fixed-width specification enables incremental rendering.
Percentage: A percentage specification (e.g., width="20%") is based on the percentage of the horizontal space available to the table (between the current left and right margins, including floats). Note that this space does not depend on the table itself, and thus percentage specifications enable incremental rendering.
Proportional: Proportional specifications (e.g., width="3*") refer to portions of the horizontal space required by a table. If the table width is given a fixed value via the width attribute of the TABLE element, user agents may render the table incrementally even with proportional columns. However, if the table does not have a fixed width, user agents must receive all table data before they can determine the horizontal space required by the table. Only then may this space be allotted to proportional columns.

If an author specifies no width information for a column, a user agent may not be able to incrementally format the table since it must wait for the entire column of data to arrive in order to allot an appropriate width.

If column widths prove to be too narrow for the contents of a particular table cell, user agents may choose to reflow the table.

The table in this example contains six columns. The first one does not belong to an explicit column group. The next three belong to the first explicit column group and the last two belong to the second explicit column group. This table cannot be formatted incrementally since it contains proportional column width specifications and no value for the width attribute for the TABLE element.
Once the (visual) user agent has received the table's data: the available horizontal space will be alloted by the user agent as follows: First the user agent will allot 30 pixels to columns one and two. Then, the minimal space required for the third column will be reserved. The remaining horizontal space will be divided into six equal portions (since 2* + 1* + 3* = 6 portions). Column four (2*) will receive two of these portions, column five (1*) will receive one, and column six (3*) will receive three.

    


   

   
   
   

   
   

 ...
...rows...

We have set the value of the align attribute in the third column group to "center". All cells in every column in this group will inherit this value, but may override it. In fact, the final COL does just that, by specifying that every cell in the column it governs will be aligned along the ":" character.

In the following table, the column width specifications allow the user agent to format the table incrementally:

    



   
   

 ...
...rows...

The first ten columns will be 15 pixels wide each. The last two columns will each receive half of the remaining 50 pixels. Note that the COL elements appear only so that an id value may be specified for the last two columns.

Note. Although the width attribute on the TABLE element is not deprecated, authors are encouraged to use style sheets to specify table widths.

11.2.5 Table rows: The `TR` element

TR

- O (TH|TD)+ -- table row --> %attrs; -- %coreattrs, %i18n, %events -- %cellhalign; -- horizontal alignment in cells -- %cellvalign; -- vertical alignment in cells -- >
Start tag: required, End tag: optional

Attributes defined elsewhere

id, class (document-wide identifiers)
lang (language information), dir (text direction)
title (element title)
style (inline style information )
onclick, ondblclick, onmousedown, onmouseup, onmouseover, onmousemove, onmouseout, onkeypress, onkeydown, onkeyup (intrinsic events )
bgcolor (background color)
align, char, charoff, valign (cell alignment)

The TR elements acts as a container for a row of table cells. The end tag may be omitted.

This sample table contains three rows, each begun by the TR element:

...A header row......First row of data......Second row of data......the rest of the table...
Cups of coffee consumed by each senator

11.2.6 Table cells: The `TH` and `TD` elements

TH

|TD) - O (%flow;)* -- table header cell, table data cell--> %attrs; -- %coreattrs, %i18n, %events -- abbr %Text; #IMPLIED -- abbreviation for header cell -- axis CDATA #IMPLIED -- comma-separated list of related headers-- headers IDREFS #IMPLIED -- list of id's for header cells -- scope %Scope; #IMPLIED -- scope covered by header cells -- rowspan NUMBER 1 -- number of rows spanned by cell -- colspan NUMBER 1 -- number of cols spanned by cell -- %cellhalign; -- horizontal alignment in cells -- %cellvalign; -- vertical alignment in cells -- >
Start tag: required, End tag: optional

Attribute definitions

headers = idrefs [CS]

This attribute specifies the list of header cells that provide header information for the current data cell. The value of this attribute is a space-separated list of cell names; those cells must be named by setting their id attribute. Authors generally use the headers attribute to help non-visual user agents render header information about data cells (e.g., header information is spoken prior to the cell data), but the attribute may also be used in conjunction with style sheets. See also the scope attribute.

scope = scope-name[CI]

This attribute specifies the set of data cells for which the current header cell provides header information. This attribute may be used in place of the headers attribute, particularly for simple tables. When specified, this attribute must have one of the following values:

row: The current cell provides header information for the rest of the row that contains it (see also the section on table directionality).
col: The current cell provides header information for the rest of the column that contains it.
rowgroup: The header cell provides header information for the rest of the row group that contains it.
colgroup: The header cell provides header information for the rest of the column group that contains it.

abbr = text [CS]

This attribute should be used to provide an abbreviated form of the cell's content, and may be rendered by user agents when appropriate in place of the cell's content. Abbreviated names should be short since user agents may render them repeatedly. For instance, speech synthesizers may render the abbreviated headers relating to a particular cell before rendering that cell's content.

axis = cdata [CI]

This attribute may be used to place a cell into conceptual categories that can be considered to form axes in an n-dimensional space. User agents may give users access to these categories (e.g., the user may query the user agent for all cells that belong to certain categories, the user agent may present a table in the form of a table of contents, etc.). Please consult the section on categorizing cells for more information. The value of this attribute is a comma-separated list of category names.

rowspan = number [CN]

This attribute specifies the number of rows spanned by the current cell. The default value of this attribute is one ("1"). The value zero ("0") means that the cell spans all rows from the current row to the last row of the table section (THEAD, TBODY, or TFOOT) in which the cell is defined.

colspan = number [CN]

This attribute specifies the number of columns spanned by the current cell. The default value of this attribute is one ("1"). The value zero ("0") means that the cell spans all columns from the current column to the last column of the column group (COLGROUP) in which the cell is defined.

nowrap [CI]

Deprecated. When present, this boolean attribute tells visual user agents to disable automatic text wrapping for this cell. Style sheets should be used instead of this attribute to achieve wrapping effects. Note. if used carelessly, this attribute may result in excessively wide cells.

width = length [CN]

Deprecated. This attribute supplies user agents with a recommended cell width.

height = length [CN]

Deprecated. This attribute supplies user agents with a recommended cell height.

Attributes defined elsewhere

id, class (document-wide identifiers)
lang (language information), dir (text direction)
title (element title)
style (inline style information )
onclick, ondblclick, onmousedown, onmouseup, onmouseover, onmousemove, onmouseout, onkeypress, onkeydown, onkeyup (intrinsic events )
bgcolor (background color)
align, char, charoff, valign (cell alignment)

Table cells may contain two types of information: header information and data. This distinction enables user agents to render header and data cells distinctly, even in the absence of style sheets. For example, visual user agents may present header cell text with a bold font. Speech synthesizers may render header information with a distinct voice inflection.

The TH element defines a cell that contains header information. User agents have two pieces of header information available: the contents of the TH element and the value of the abbr attribute. User agents must render either the contents of the cell or the value of the abbr attribute. For visual media, the latter may be appropriate when there is insufficient space to render the full contents of the cell. For non-visual media abbr may be used as an abbreviation for table headers when these are rendered along with the contents of the cells to which they apply.

The headers and scope attributes also allow authors to help non-visual user agents process header information. Please consult the section on labeling cells for non-visual user agents for information and examples.

The TD element defines a cell that contains data.

Cells may be empty (i.e., contain no data).

For example, the following table contains four columns of data, each headed by a column description.


Cups of coffee consumed by each senator

   Name
   Cups
   Type of Coffee
   Sugar?

   T. Sexton
   10
   Espresso
   No

   J. Dinnen
   5
   Decaf
   Yes

Cups of coffee consumed by each senator
Name	Cups	Type of Coffee	Sugar?
T. Sexton	10	Espresso	No
J. Dinnen	5	Decaf	Yes

A user agent rendering to a tty device might display this as follows:

Name         Cups       Type of Coffee   Sugar?
T. Sexton    10         Espresso         No
J. Dinnen    5          Decaf            Yes

Cells that span several rows or columns

Cells may span several rows or columns. The number of rows or columns spanned by a cell is set by the rowspan and colspan attributes for the TH and TD elements.

In this table definition, we specify that the cell in row four, column two should span a total of three columns, including the current column.


Cups of coffee consumed by each senator
Name Cups Type of Coffee Sugar?
T. Sexton 10 Espresso No
J. Dinnen 5 Decaf Yes
A. Soria Not available

Cups of coffee consumed by each senator
Name	Cups	Type of Coffee	Sugar?
T. Sexton	10	Espresso	No
J. Dinnen	5	Decaf	Yes
A. Soria	Not available

This table might be rendered on a tty device by a visual user agent as follows:

Cups of coffee consumed by each senator
 --------------------------------------
 |   Name  |Cups|Type of Coffee|Sugar?|
 --------------------------------------
 |T. Sexton|10  |Espresso      |No    |
 --------------------------------------
 |J. Dinnen|5   |Decaf         |Yes   |
 --------------------------------------
 |A. Soria |Not available             |
 --------------------------------------

The next example illustrates (with the help of table borders) how cell definitions that span more than one row or column affect the definition of later cells. Consider the following table definition:


1 2 3
4 6
7 8 9

As cell "2" spans the first and second rows, the definition of the second row will take it into account. Thus, the second TD in row two actually defines the row's third cell. Visually, the table might be rendered to a tty device as:

-------------
| 1 | 2 | 3 | 
----|   |----
| 4 |   | 6 |
----|---|----
| 7 | 8 | 9 |
-------------

while a graphical user agent might render this as:

Note that if the TD defining cell "6" had been omitted, an extra empty cell would have been added by the user agent to complete the row.
Similarly, in the following table definition:


1 2 3
4 6
7 8 9

cell "4" spans two columns, so the second TD in the row actually defines the third cell ("6"):

-------------
| 1 | 2 | 3 | 
--------|----
| 4     | 6 |
--------|----
| 7 | 8 | 9 |
-------------

A graphical user agent might render this as:

Defining overlapping cells is an error. User agents may vary in how they handle this error (e.g., rendering may vary).

The following illegal example illustrates how one might create overlapping cells. In this table, cell "5" spans two rows and cell "7" spans two columns, so there is overlap in the cell between "7" and "9":


1 2 3
4 5 6
7 9

11.3 Table formatting by visual user agents

Note. The following sections describe the HTML table attributes that concern visual formatting. When this specification was first published in 1997, [CSS1] did not offer mechanisms to control all aspects of visual table formatting. Since then, [CSS2] has added properties to allow visual formatting of tables.

HTML 4 includes mechanisms to control:

border styles
horizontal and vertical alignment of cell contents
and cell margins

11.3.1 Borders and rules

The following attributes affect a table's external frame and internal rules.

Attribute definitions

This attribute specifies which sides of the frame surrounding a table will be visible. Possible values:

void: No sides. This is the default value.
above: The top side only.
below: The bottom side only.
hsides: The top and bottom sides only.
vsides: The right and left sides only.
lhs: The left-hand side only.
rhs: The right-hand side only.
box: All four sides.
border: All four sides.

rules = none|groups|rows|cols|all [CI]

This attribute specifies which rules will appear between cells within a table. The rendering of rules is user agent dependent. Possible values:

none: No rules. This is the default value.
groups: Rules will appear between row groups (see THEAD, TFOOT, and TBODY) and column groups (see COLGROUP and COL) only.
rows: Rules will appear between rows only.
cols: Rules will appear between columns only.
all: Rules will appear between all rows and columns.

border = pixels [CN]

This attributes specifies the width (in pixels only) of the frame around a table (see the Note below for more information about this attribute).

To help distinguish the cells of a table, we can set the border attribute of the TABLE element. Consider a previous example:


Cups of coffee consumed by each senator

   Name
   Cups
   Type of Coffee
   Sugar?

   T. Sexton
   10
   Espresso
   No

   J. Dinnen
   5
   Decaf
   Yes

Cups of coffee consumed by each senator
Name	Cups	Type of Coffee	Sugar?
T. Sexton	10	Espresso	No
J. Dinnen	5	Decaf	Yes

In the following example, the user agent should show borders five pixels thick on the left-hand and right-hand sides of the table, with rules drawn between each column.


 1 2 3
 4 5 6
 7 8 9

The following settings should be observed by user agents for backwards compatibility.

Setting border="0" implies frame="void" and, unless otherwise specified, rules="none".
Other values of border imply frame="border" and, unless otherwise specified, rules="all".
The value "border" in the start tag of the TABLE element should be interpreted as the value of the frame attribute. It implies rules="all" and some default (non-zero) value for the border attribute.

For example, the following definitions are equivalent:

as are the following:

Note. The border attribute also defines the border behavior for the OBJECT and IMG elements, but takes different values for those elements.

11.3.2 Horizontal and vertical alignment

The following attributes may be set for different table elements (see their definitions).


align

Attribute definitions

align = left|center|right|justify|char [CI]

This attribute specifies the alignment of data and the justification of text in a cell. Possible values:

left: Left-flush data/Left-justify text. This is the default value for table data.
center: Center data/Center-justify text. This is the default value for table headers.
right: Right-flush data/Right-justify text.
justify: Double-justify text.
char: Align text around a specific character. If a user agent doesn't support character alignment, behavior in the presence of this value is unspecified.

valign = top|middle|bottom|baseline [CI]

This attribute specifies the vertical position of data within a cell. Possible values:

top: Cell data is flush with the top of the cell.
middle: Cell data is centered vertically within the cell. This is the default value.
bottom: Cell data is flush with the bottom of the cell.
baseline: All cells in the same row as a cell whose valign attribute has this value should have their textual data positioned so that the first text line occurs on a baseline common to all cells in the row. This constraint does not apply to subsequent text lines in these cells.

char = character [CN]

This attribute specifies a single character within a text fragment to act as an axis for alignment. The default value for this attribute is the decimal point character for the current language as set by the lang attribute (e.g., the period (".") in English and the comma (",") in French). User agents are not required to support this attribute.

charoff = length [CN]

When present, this attribute specifies the offset to the first occurrence of the alignment character on each line. If a line doesn't include the alignment character, it should be horizontally shifted to end at the alignment position. When charoff is used to set the offset of an alignment character, the direction of offset is determined by the current text direction (set by the dir attribute). In left-to-right texts (the default), offset is from the left margin. In right-to-left texts, offset is from the right margin. User agents are not required to support this attribute.

The table in this example aligns a row of currency values along a decimal point. We set the alignment character to "." explicitly.





Vegetable Cost per kilo

Lettuce        $1
Silver carrots $10.50
Golden turnips $100.30

Vegetable	Cost per kilo
Lettuce	$1
Silver carrots	$10.50
Golden turnips	$100.30

The formatted table may resemble the following:

------------------------------
|   Vegetable  |Cost per kilo|
|--------------|-------------|
|Lettuce       |        $1   |
|--------------|-------------|
|Silver carrots|       $10.50|
|--------------|-------------|
|Golden turnips|      $100.30|
------------------------------

When the contents of a cell contain more than one instance of the alignment character specified by char and the contents wrap, user agent behavior is undefined. Authors should therefore be attentive in their use of char.

Note. Visual user agents typically render TH elements vertically and horizontally centered within the cell and with a bold font weight.

Inheritance of alignment specifications

The alignment of cell contents can be specified on a cell by cell basis, or inherited from enclosing elements, such as the row, column or the table itself.

The order of precedence (from highest to lowest) for the attributes align, char, and charoff is the following:

An alignment attribute set on an element within a cell's data (e.g., P).
An alignment attribute set on a cell (TH and TD).
An alignment attribute set on a column grouping element (COL and COLGROUP). When a cell is part of a multi-column span, the alignment property is inherited from the cell definition at the beginning of the span.
An alignment attribute set on a row or row grouping element (TR, THEAD, TFOOT, and TBODY). When a cell is part of a multi-row span, the alignment property is inherited from the cell definition at the beginning of the span.
An alignment attribute set on the table (TABLE).
The default alignment value.

The order of precedence (from highest to lowest) for the attribute valign (as well as the other inherited attributes lang, dir, and style) is the following:

An attribute set on an element within a cell's data (e.g., P).
An attribute set on a cell (TH and TD).
An attribute set on a row or row grouping element (TR, THEAD, TFOOT, and TBODY). When a cell is part of a multi-row span, the attribute value is inherited from the cell definition at the beginning of the span.
An attribute set on a column grouping element (COL and COLGROUP). When a cell is part of a multi-column span, the attribute value is inherited from the cell definition at the beginning of the span.
An attribute set on the table (TABLE).
The default attribute value.

Furthermore, when rendering cells, horizontal alignment is determined by columns in preference to rows, while for vertical alignment, rows are given preference over columns.

The default alignment for cells depends on the user agent. However, user agents should substitute the default attribute for the current directionality (i.e., not just "left" in all cases).

User agents that do not support the "justify" value of the align attribute should use the value of the inherited directionality in its place.

Note. Note that a cell may inherit an attribute not from its parent but from the first cell in a span. This is an exception to the general attribute inheritance rules.

11.3.3 Cell margins

Attribute definitions

cellspacing = length [CN]: This attribute specifies how much space the user agent should leave between the left side of the table and the left-hand side of the leftmost column, the top of the table and the top side of the topmost row, and so on for the right and bottom of the table. The attribute also specifies the amount of space to leave between cells.
cellpadding = length [CN]: This attribute specifies the amount of space between the border of the cell and its contents. If the value of this attribute is a pixel length, all four margins should be this distance from the contents. If the value of the attribute is a percentage length, the top and bottom margins should be equally separated from the content based on a percentage of the available vertical space, and the left and right margins should be equally separated from the content based on a percentage of the available horizontal space.

These two attributes control spacing between and within cells. The following illustration explains how they relate:

In the following example, the cellspacing attribute specifies that cells should be separated from each other and from the table frame by twenty pixels. The cellpadding attribute specifies that the top margin of the cell and the bottom margin of the cell will each be separated from the cell's contents by 10% of the available vertical space (the total being 20%). Similarly, the left margin of the cell and the right margin of the cell will each be separated from the cell's contents by 10% of the available horizontal space (the total being 20%).


 Data1 Data2 Data3

If a table or given column has a fixed width, cellspacing and cellpadding may demand more space than assigned. User agents may give these attributes precedence over the width attribute when a conflict occurs, but are not required to.

11.4 Table rendering by non-visual user agents

11.4.1 Associating header information with data cells

Non-visual user agents such as speech synthesizers and Braille-based devices may use the following TD and TH element attributes to render table cells more intuitively:

For a given data cell, the headers attribute lists which cells provide pertinent header information. For this purpose, each header cell must be named using the id attribute. Note that it's not always possible to make a clean division of cells into headers or data. You should use the TD element for such cells together with the id or scope attributes as appropriate.
For a given header cell, the scope attribute tells the user agent the data cells for which this header provides information. Authors may choose to use this attribute instead of headers according to which is more convenient; the two attributes fulfill the same function. The headers attribute is generally needed when headers are placed in irregular positions with respect to the data they apply to.
The abbr attribute specifies an abbreviated header for header cells so that user agents may render header information more rapidly.

In the following example, we assign header information to cells by setting the headers attribute. Each cell in the same column refers to the same header cell (via the id attribute).


Cups of coffee consumed by each senator

   Name
   Cups
   Type of Coffee
   Sugar?

   T. Sexton
   10
   Espresso
   No

   J. Dinnen
   5
   Decaf
   Yes

Cups of coffee consumed by each senator
Name	Cups	Type of Coffee	Sugar?
T. Sexton	10	Espresso	No
J. Dinnen	5	Decaf	Yes

A speech synthesizer might render this table as follows:

Caption: Cups of coffee consumed by each senator
Summary: This table charts the number of cups
         of coffee consumed by each senator, the type 
         of coffee (decaf or regular), and whether 
         taken with sugar.
Name: T. Sexton,   Cups: 10,   Type: Espresso,   Sugar: No
Name: J. Dinnen,   Cups: 5,    Type: Decaf,      Sugar: Yes

Note how the header "Type of Coffee" is abbreviated to "Type" using the abbr attribute.

Here is the same example substituting the scope attribute for the headers attribute. Note the value "col" for the scope attribute, meaning "all cells in the current column":


Cups of coffee consumed by each senator

   Name
   Cups
   Type of Coffee
   Sugar?

   T. Sexton
   10
   Espresso
   No

   J. Dinnen
   5
   Decaf
   Yes

Cups of coffee consumed by each senator
Name	Cups	Type of Coffee	Sugar?
T. Sexton	10	Espresso	No
J. Dinnen	5	Decaf	Yes

Here's a somewhat more complex example illustrating other values for the scope attribute:



    Community Courses -- Bath Autumn 1997
  

    Course Name
    Course Tutor
    Summary
    Code
    Fee
  

    After the Civil War
    Dr. John Wroughton
    
       The course will examine the turbulent years in England
       after 1646. 6 weekly meetings starting Monday 13th
      October.
    
    H27
    £32
  

    An Introduction to Anglo-Saxon England
    Mark Cottle
    
       One day course introducing the early medieval
       period reconstruction the Anglo-Saxons and
       their society. Saturday 18th October.
    
    H28
    £18
  

    The Glory that was Greece
    Valerie Lorenz
    
     Birthplace of democracy, philosophy, heartland of theater, home of
     argument. The Romans may have done it but the Greeks did it
     first. Saturday day school 25th October 1997
    
    H30
    £18

Community Courses -- Bath Autumn 1997
Course Name	Course Tutor	Summary	Code	Fee
After the Civil War	Dr. John Wroughton	The course will examine the turbulent years in England after 1646. 6 weekly meetings starting Monday 13th October.	H27	£32
An Introduction to Anglo-Saxon England	Mark Cottle	One day course introducing the early medieval period reconstruction the Anglo-Saxons and their society. Saturday 18th October.	H28	£18
The Glory that was Greece	Valerie Lorenz	Birthplace of democracy, philosophy, heartland of theater, home of argument. The Romans may have done it but the Greeks did it first. Saturday day school 25th October 1997	H30	£18

A graphical user agent might render this as:

Note the use of the scope attribute with the "row" value. Although the first cell in each row contains data, not header information, the scope attribute makes the data cell behave like a row header cell. This allows speech synthesizers to provide the relevant course name upon request or to state it immediately before each cell's content.

11.4.2 Categorizing cells

Users browsing a table with a speech-based user agent may wish to hear an explanation of a cell's contents in addition to the contents themselves. One way the user might provide an explanation is by speaking associated header information before speaking the data cell's contents (see the section on associating header information with data cells).

Users may also want information about more than one cell, in which case header information provided at the cell level (by headers, scope, and abbr) may not provide adequate context. Consider the following table, which classifies expenses for meals, hotels, and transport in two locations (San Jose and Seattle) over several days:

Users might want to extract information from the table in the form of queries:

"What did I spend for all my meals?"
"What did I spend for meals on 25 August?"
"What did I spend for all expenses in San Jose?"

Each query involves a computation by the user agent that may involve zero or more cells. In order to determine, for example, the costs of meals on 25 August, the user agent must know which table cells refer to "Meals" (all of them) and which refer to "Dates" (specifically, 25 August), and find the intersection of the two sets.

To accommodate this type of query, the HTML 4 table model allows authors to place cell headers and data into categories. For example, for the travel expense table, an author could group the header cells "San Jose" and "Seattle" into the category "Location", the headers "Meals", "Hotels", and "Transport" in the category "Expenses", and the four days into the category "Date". The previous three questions would then have the following meanings:

"What did I spend for all my meals?" means "What are all the data cells in the "Expenses=Meals" category?
"What did I spend for meals on 25 August?" means "What are all the data cells in the "Expenses=Meals" and "Date=Aug-25-1997" categories?
"What did I spend for all expenses in San Jose?" means "What are all the data cells in the "Expenses=Meals, Hotels, Transport" and "Location=San Jose" categories?

Authors categorize a header or data cell by setting the axis attribute for the cell. For instance, in the travel expense table, the cell containing the information "San Jose" could be placed in the "Location" category as follows:

  San Jose

Any cell containing information related to "San Jose" should refer to this header cell via either the headers or the scope attribute. Thus, meal expenses for 25-Aug-1997 should be marked up to refer to id attribute (whose value here is "a6") of the "San Jose" header cell:

  
  37.74

Each headers attribute provides a list of id references. Authors may thus categorize a given cell in any number of ways (or, along any number of "headers", hence the name).

Below we mark up the travel expense table with category information:



  Travel Expense Report


  
  Meals
  Hotels
  Transport
  subtotals


  San Jose
  
  
  
  


  25-Aug-97
  37.74
  112.00
  45.00
  


  26-Aug-97
  27.28
  112.00
  45.00
  


  subtotals
  65.02
  224.00
  90.00
  379.02


  Seattle
  
  
  
  


  27-Aug-97
  96.25
  109.00
  36.00
  


  28-Aug-97
  35.00
  109.00
  36.00
  


  subtotals
  131.25
  218.00
  72.00
  421.25


  Totals
  196.27
  442.00
  162.00
  800.27

Travel Expense Report
	Meals	Hotels	Transport	subtotals
San Jose
25-Aug-97	37.74	112.00	45.00
26-Aug-97	27.28	112.00	45.00
subtotals	65.02	224.00	90.00	379.02
Seattle
27-Aug-97	96.25	109.00	36.00
28-Aug-97	35.00	109.00	36.00
subtotals	131.25	218.00	72.00	421.25
Totals	196.27	442.00	162.00	800.27

Note that marking up the table this way also allows user agents to avoid confusing the user with unwanted information. For instance, if a speech synthesizer were to speak all of the figures in the "Meals" column of this table in response to the query "What were all my meal expenses?", a user would not be able to distinguish a day's expenses from subtotals or totals. By carefully categorizing cell data, authors allow user agents to make important semantic distinctions when rendering.

Of course, there is no limit to how authors may categorize information in a table. In the travel expense table, for example, we could add the additional categories "subtotals" and "totals".

This specification does not require user agents to handle information provided by the axis attribute, nor does it make any recommendations about how user agents may present axis information to users or how users may query the user agent about this information.

However, user agents, particularly speech synthesizers, may want to factor out information common to several cells that are the result of a query. For instance, if the user asks "What did I spend for meals in San Jose?", the user agent would first determine the cells in question (25-Aug-1997: 37.74, 26-Aug-1997:27.28), then render this information. A user agent speaking this information might read it:

   Location: San Jose. Date: 25-Aug-1997. Expenses, Meals: 37.74
   Location: San Jose. Date: 26-Aug-1997. Expenses, Meals: 27.28

or, more compactly:

   San Jose, 25-Aug-1997, Meals: 37.74
   San Jose, 26-Aug-1997, Meals: 27.28

An even more economical rendering would factor the common information and reorder it:

   San Jose, Meals, 25-Aug-1997: 37.74
                    26-Aug-1997: 27.28

User agents that support this type of rendering should allow user agents a means to customize rendering (e.g., through style sheets).

11.4.3 Algorithm to find heading information

In the absence of header information from either the scope or headers attribute, user agents may construct header information according to the following algorithm. The goal of the algorithm is to find an ordered list of headers. (In the following description of the algorithm the table directionality is assumed to be left-to-right.)

First, search left from the cell's position to find row header cells. Then search upwards to find column header cells. The search in a given direction stops when the edge of the table is reached or when a data cell is found after a header cell.
Row headers are inserted into the list in the order they appear in the table. For left-to-right tables, headers are inserted from left to right.
Column headers are inserted after row headers, in the order they appear in the table, from top to bottom.
If a header cell has the headers attribute set, then the headers referenced by this attribute are inserted into the list and the search stops for the current direction.
TD cells that set the axis attribute are also treated as header cells.

11.5 Sample table

This sample illustrates grouped rows and columns. The example is adapted from "Developing International Software", by Nadine Kano.

In "ascii art", the following table:


CODE-PAGE SUPPORT IN MICROSOFT WINDOWS






Code-Page
ID
Name
ACP
OEMCP
Windows
NT 3.1
Windows
NT 3.51
Windows
95

1200 Unicode (BMP of ISO/IEC-10646) X X *
1250 Windows 3.1 Eastern European X X X X
1251 Windows 3.1 Cyrillic X X X X
1252 Windows 3.1 US (ANSI) X X X X
1253 Windows 3.1 Greek X X X X
1254 Windows 3.1 Turkish X X X X
1255 Hebrew X X
1256 Arabic X X
1257 Baltic X X
1361 Korean (Johab) X ** X

437 MS-DOS United States X X X X
708 Arabic (ASMO 708) X X
709 Arabic (ASMO 449+, BCON V4) X X
710 Arabic (Transparent Arabic) X X
720 Arabic (Transparent ASMO) X X

CODE-PAGE SUPPORT IN MICROSOFT WINDOWS
Code-Page ID	Name	ACP	OEMCP	Windows NT 3.1	Windows NT 3.51	Windows 95
1200	Unicode (BMP of ISO/IEC-10646)			X	X	*
1250	Windows 3.1 Eastern European	X		X	X	X
1251	Windows 3.1 Cyrillic	X		X	X	X
1252	Windows 3.1 US (ANSI)	X		X	X	X
1253	Windows 3.1 Greek	X		X	X	X
1254	Windows 3.1 Turkish	X		X	X	X
1255	Hebrew	X				X
1256	Arabic	X				X
1257	Baltic	X				X
1361	Korean (Johab)	X			**	X
437	MS-DOS United States		X	X	X	X
708	Arabic (ASMO 708)		X			X
709	Arabic (ASMO 449+, BCON V4)		X			X
710	Arabic (Transparent Arabic)		X			X
720	Arabic (Transparent ASMO)		X			X

would be rendered something like this:

                  CODE-PAGE SUPPORT IN MICROSOFT WINDOWS
===============================================================================
Code-Page | Name                         | ACP  OEMCP | Windows Windows Windows
    ID    |                              |            |  NT 3.1 NT 3.51    95
-------------------------------------------------------------------------------
   1200   | Unicode (BMP of ISO 10646)   |            |    X       X       *
   1250   | Windows 3.1 Eastern European |  X         |    X       X       X
   1251   | Windows 3.1 Cyrillic         |  X         |    X       X       X
   1252   | Windows 3.1 US (ANSI)        |  X         |    X       X       X
   1253   | Windows 3.1 Greek            |  X         |    X       X       X
   1254   | Windows 3.1 Turkish          |  X         |    X       X       X
   1255   | Hebrew                       |  X         |                    X
   1256   | Arabic                       |  X         |                    X
   1257   | Baltic                       |  X         |                    X
   1361   | Korean (Johab)               |  X         |            **      X
-------------------------------------------------------------------------------
    437   | MS-DOS United States         |        X   |    X       X       X
    708   | Arabic (ASMO 708)            |        X   |                    X
    709   | Arabic (ASMO 449+, BCON V4)  |        X   |                    X
    710   | Arabic (Transparent Arabic)  |        X   |                    X
    720   | Arabic (Transparent ASMO)    |        X   |                    X
===============================================================================

A graphical user agent might render this as:

C# Uppercase First Letter

2012-11-25T20:29:00.000+03:00

Strings sometimes have lowercase first letters. Uppercasing the first letter is often necessary. The string has its first letter uppercased. It is then returned with the remaining part unchanged. This is the functionality of the ucfirst function from PHP and Perl. And strings with multiple words can be changed to title case.

Input and output

Input:  samuel
	julia
	john smith

Output: Samuel
	Julia
	John smith [only first letter]

Examples

First, the goal of these methods is to return correctly uppercased strings in an efficient way. We provide an example of a C# method that uppercases the first letter. The method first here is the slower of the two. The benchmark is presented after the two programs.

Program that uppercases words [C#]

using System;

class Program
{
    static void Main()
    {
	Console.WriteLine(UppercaseFirst("samuel"));
	Console.WriteLine(UppercaseFirst("julia"));
	Console.WriteLine(UppercaseFirst("john smith"));
    }

    static string UppercaseFirst(string s)
    {
	// Check for empty string.
	if (string.IsNullOrEmpty(s))
	{
	    return string.Empty;
	}
	// Return char and concat substring.
	return char.ToUpper(s[0]) + s.Substring(1);
    }
}

Output

Samuel
Julia
John smith

Next,we look at a method that uses the ToCharArray method instead. I investigated ToCharArray and its performance impact on this sort of character-based method. The following is the faster version, and it returns the same results.

Another program that uppercases [C#]

using System;

class Program
{
    static void Main()
    {
	Console.WriteLine(UppercaseFirst("samuel"));
	Console.WriteLine(UppercaseFirst("julia"));
	Console.WriteLine(UppercaseFirst("john smith"));
    }

    static string UppercaseFirst(string s)
    {
	if (string.IsNullOrEmpty(s))
	{
	    return string.Empty;
	}
	char[] a = s.ToCharArray();
	a[0] = char.ToUpper(a[0]);
	return new string(a);
    }
}

Output

Samuel
Julia
John smith

Here are my resultsfrom testing 1,000,000 iterations of these functions in a loop over the string "michael". This test is in my ASP.NET application, so the environment is the same as it will be in my ASP.NET app as it is updated on the Internet.

Benchmark results

UppercaseFirst method:           0.1636 seconds
UppercaseFirst with ToCharArray: 0.0920 seconds [faster]

The second approachis faster because it only allocates one new string in the return statement. The first approach allocates two strings: the Substring(1), and then a new string with string.Concat.
Return Substring Concat

Uppercase words

This program defines a method named UppercaseWords that is equivalent to the ucwords function in scripting languages such as PHP. The UppercaseWords method internally converts the string to a character array buffer.The char array data is mutable,which means you can change it without reallocating or filling up the managed heap. The method mutates the character buffer and then returns a new string from the string constructor based on the mutated buffer.

Program that uppercases first letters [C#]

using System;

class Program
{
    static string UppercaseWords(string value)
    {
	char[] array = value.ToCharArray();
	// Handle the first letter in the string.
	if (array.Length >= 1)
	{
	    if (char.IsLower(array[0]))
	    {
		array[0] = char.ToUpper(array[0]);
	    }
	}
	// Scan through the letters, checking for spaces.
	// ... Uppercase the lowercase letters following spaces.
	for (int i = 1; i < array.Length; i++)
	{
	    if (array[i - 1] == ' ')
	    {
		if (char.IsLower(array[i]))
		{
		    array[i] = char.ToUpper(array[i]);
		}
	    }
	}
	return new string(array);
    }

    static void Main()
    {
	// Uppercase words in these strings.
	const string value1 = "something in the way";
	const string value2 = "dot net PERLS";
	const string value3 = "String_two;three";
	const string value4 = " sam";
	// ... Compute the uppercase strings.
	Console.WriteLine(UppercaseWords(value1));
	Console.WriteLine(UppercaseWords(value2));
	Console.WriteLine(UppercaseWords(value3));
	Console.WriteLine(UppercaseWords(value4));
    }
}

Output

Something In The Way
Dot Net PERLS
String_two;three
 Sam

The program definesthe UppercaseWords static method, which is equivalent to the ucwords function in scripting languages. Internally, the method body of the UppercaseWords method first tests the first character of the string.

Note:It special-cases the first character because the loop in the next part does not correctly allow for the very first character. The if-statement is validated in the test cases when the first two strings have their first letters uppercased.

If
For-loop.The next part of the UppercaseWords method does a for-loop through all the characters in the string starting at the second character with index of one. In each iteration it tests the previous character for a space. If it detects a space, it modifies the character array buffer to have an uppercase character.
For
Efficiency notes.The UppercaseWords method could be implemented by first splitting on the sub-words in the string based on a regular expression or the Split method. But this would result in many more allocations—one for the array reference data and one for each word.
Split

However:You could use the Regex.Split method for a better algorithm of breaking up the words.

Regex.Split

Note:The method does not contain sophisticated error correction and does not handle some words—such as and, the, and a—differently.

ToTitleCase

You might not be in the mood for deploying a custom method for uppercasing the first letter in each word in a string. You can use the ToTitleCase method on the TextInfo type—it does the same thing. Using ToTitleCase will make handling certain special cases harder.
ToTitleCase

Summary

We looked at methods that uppercase the first character in strings using the C# language. They are useful for database results that may not be formatted correctly. Custom logic for certain names can be added.

Normally:The performance requirements are not strict here.

But:Occasionally the benchmarks here may be useful. We can capitalize also strings that have multiple words.

How to Capitalize the First Letter of All Words in a string in C#

2012-11-25T20:25:00.002+03:00

Often we need to capitalize the first letters of some word or some text (for example when we want to display users name or city name etc).
Since string class does not have a method to do this we could think that there is no built-in solution in C# for this problem...

But a little digging trough MSDN would help us find ToTitleCase method of TextInfo class in System.Globalization namespace that does exactly what we need: capitalizes the first letter of each word in the string.

here is how to use it:

using System.Globalization;

...

string capitalized = CultureInfo.CurrentCulture.TextInfo.ToTitleCase("asp.net simply rocks!!!");

After the execution, capitalized string would have this value: "Asp.Net Simply Rocks!!!" which is exactly what we needed, right?

Off course, how will string be capitalized depends on the current culture that is set on your ASP.NET page, but we can easily override this and use the culture we want like this:

TextInfo UsaTextInfo = new CultureInfo("en-US", false).TextInfo;

string capitalized = UsaTextInfo.ToTitleCase("asp.net simply rocks!!!");

Have fun!

=======================================================
For more Books / Ads / Lost-Found / Articles / Accommodation. We can help with your busy lifestyle. Take a look around and review our hundreds of free Ads or submit one of your own favorites. http://www.inhousetoday.com

ContactUs page with Capctcha in ASP.NET using C#

2012-11-24T20:35:00.000+03:00

Posted by Biswa Pujarini Mohapatra in Articles | Visual C#

Tags: Capctha using asp.net, Send Email using asp.net, ASP.NET , C#

Using a contact form on your website is very useful as it helps your web site visitors to communicate with you in an easy and simple way. But, there are spammers and hackers who are looking for exploitable web forms. It is essential to secure your form against all 'holes' that those hackers are searching for .

If you are not validating your form fields (on the serve side) before sending the emails, then hackers can alter your email headers to send the bulk unsolicited emails.

In this article will give tutorial how to create contact Us page with below key features

Key features:

Contact Us form

Validations

Send Email

Use of Captcha to avoid Spam

Contact Us Form

<div style="padding: 5px 0px 10px 150px">
<div id="ContentTitle">
<h1>
Contact Us</h1>
</div>
<div id="ContentBody">
<table cellpadding="2">

<tr>
<td class="fieldname">
Email:
</td>
<td>
<asp:TextBox runat="server" ID="txtEmail" Width="100%" />
</td>
<td>
<asp:RequiredFieldValidator runat="server" Display="dynamic" ID="RequiredFieldValidator1"
SetFocusOnError="true" ControlToValidate="txtEmail" ErrorMessage="Your Email is required">*</asp:RequiredFieldValidator>
</td>
</tr>

< /td>
</tr>
<tr>
<td class="fieldname">
<asp:Label runat="server" ID="lblBody" AssociatedControlID="txtBody" Text="Message:" />
</td>
<td>
<asp:TextBox runat="server" ID="txtBody" Width="100%" TextMode="MultiLine" Rows="8" />
</td>
<td>
<asp:RequiredFieldValidator runat="server" Display="dynamic" ID="valRequireBody"
SetFocusOnError="true" ControlToValidate="txtBody" ErrorMessage="The Message is required">*</asp:RequiredFieldValidator>
</td>
</tr>
<tr>
<td colspan="3" class="fieldname" align="center">
<img src="CaptchaPage.aspx" alt="Catcha" /> 

Enter the code shown above: 
<asp:TextBox ID="CodeNumberTextBox" runat="server"></asp:TextBox>


(Note: If you cannot read the numbers in the above 
image, reload the page to generate a new one.)


<asp:Label ID="MessageLabel" runat="server" ForeColor="#CC0000"></asp:Label>
</td>
</tr>
<tr>
<td colspan="3" align="right">
<asp:Label runat="server" ID="lblFeedbackOK" Text="Your message has been successfully sent."
SkinID="FeedbackOK" Visible="false" ForeColor="#006600" Font-Bold="True" />
<asp:Label runat="server" ID="lblFeedbackKO" Text="Sorry, there was a problem sending your message."
SkinID="FeedbackKO" Visible="false" ForeColor="#CC0000" />
<asp:Button runat="server" ID="txtSubmit" Text="Send"
onclick="txtSubmit_Click" />
<asp:ValidationSummary runat="server" ID="valSummary" ShowSummary="false" ShowMessageBox="true" />
</td>
</tr>
</table>
</div>
</div>

Validating Captcha Image and Send Email

Below example will show you how to validate captcha Image before sending an Email to avoid spam mails

MailMessage Message =new MailMessage();
Message.From = new MailAddress(txtEmail.Text, txtName.Text + Page.User.Identity.Name);
Message.To.Add(new MailAddress("contact@yourdomain.com"));
Message.Body = txtBody.Text;
Message.Subject = "Contact Us";
Message.IsBodyHtml = true;try
{
if (this.CodeNumberTextBox.Text == this.Session["CaptchaImageText"].ToString())
{
this.MessageLabel.Text ="";
SmtpClient mailClient = new SmtpClient();
mailClient.Send(Message);
lblFeedbackOK.Visible = true;

}else
{// Display an error message.
this.MessageLabel.Text = "ERROR: Incorrect, try again.";// Clear the input and create a new random code.
this.CodeNumberTextBox.Text = "";
lblFeedbackOK.Visible = false;
this.Session["CaptchaImageText"] = GenerateRandomCode();
}

}
catch (Exception ex)
{
lblFeedbackKO.Visible = true;
}

first off you must import using System.Net.Mail; namespace. Then define new SMTP email and collect all the information user entered in your webpage. Finally send all the information to recipient as an email.

<system.net>
<mailSettings>
<smtp from="yourdomain.com">
<network host="mail.yourdomain.com" port="25" userName="xxx" password="xxx"/>
</smtp>
</mailSettings>
</system.net>

URL Rewriting in ASP.NET using global.asax and web.config

2012-11-03T14:30:00.002+03:00

URL rewriting is very important for search engines like google, yahoo, etc. as we know website getting most of the traffic from search engines.

Here I am explaining 2 way to rewrite URL in asp.net.

URL rewrining using web.config and URL rewriting using global.asax

URL rewrining using web.config:

URL rewriting in web.config is only use for small number of pages. Here you have to rewrite every page manually in web.config. I am writing sample code for 4 urls.

xml version="1.0"?>

mappedUrl="~/index.aspx?id=1" />

mappedUrl="~/index.aspx?id=2" />

mappedUrl="~/index.aspx?id=3" />

mappedUrl="~/index.aspx?id=4" />

urlMappings>

. . .

configuration>

URL rewriting using global.aspx:

This very simple way and very use full. In this way we can rewrite N number of pages and there is no need extra server configuration. Only you have to use Application_BeginRequest event. Inside this event use Context.RewritePath method to set which URL will execute internally in code behind. Here is the code:

void Application_BeginRequest(object sender, EventArgs e)

{

// Get the current path

string CurrentURL_Path = Request.Path.ToLower();

if (CurrentURL_Path.StartsWith("/news/"))

{

CurrentURL_Path = CurrentURL_Path.Trim("/");

string NewsID = CurrentPath.Substring(CurrentPath.IndexOf("/"));

HttpContext MyContext = HttpContext.Current;

MyContext.RewritePath("/news-show.aspx?News=" + NewsID);

}

}

In next article i will write about URL rewriting using HttpModule.

Uploading Files in ASP.NET 2.0

2012-06-29T11:07:00.000+03:00

252 out of 370 rated this helpful - Rate this topic

Bill Evjen
Reuters
December 2005
Applies to:
Microsoft ASP.NET 2.0
Microsoft Visual Web Developer 2005 Express Edition

Summary: Learn how to use the new FileUpload server control in Microsoft ASP.NET 2.0. (18 printed pages)

Introduction
An Example of the FileUpload Server Control
Conclusion

Introduction

Ever since Microsoft ASP.NET was introduced with version 1.0, there has been the built-in means of building Web applications that had the ability to upload files to the hosting server. This was done through the use of the File Field HTML server control. I previously wrote an MSDN article on how to effectively use this control in your ASP.NET applications. This article is a reintroduction to the file upload process, but instead of using the File Field control, I will show you how to effectively use the new FileUpload server control that is offered through ASP.NET 2.0.
It is important to note that while this article introduces you to the new FileUpload server control, it is still quite possible to use the File Field control in your applications today.

An Example of the FileUpload Server Control

When using the File Field control in ASP.NET 1.x you had to take a few extra steps to get everything in line and working. For example, you were required to add enctype="multipart/form-data" to the page's
element on your own. The new FileUpload server control provided in ASP.NET 2.0 makes the process of uploading files to the hosting server as simple as possible.
In the end, you are trying to allow access to program the HTML tag. This tag is used to work with file data within an HTML form. In the past when using classic ASP (ASP 3.0 or earlier), many programmers worked with third-party components to upload files from the client to the server. Now, with .NET and this new control, uploading is taken care of for you. Listing 1 shows you how to use the FileUpload control to upload files to the server.

Note The sample code is provided in both Microsoft Visual Basic and C#.

Listing 1. Uploading files to the server using the FileUpload control

Visual Basic

Copy







    Upload Files

Copy







    Upload Files

Running this page, you will notice a few things if you look at the source code generated for the page. This source code is presented in Listing 2.

Listing 2. The source code generated from the FileUpload control

Copy


   Upload Files

The first thing to notice is that because the FileUpload control is on the page, ASP.NET 2.0 modified the page's
element on your behalf by adding the appropriate enctype attribute. You will also notice that the FileUpload control was converted to an HTML element.
When the page from Listing 1 is run, you can select a file and upload it to the server by clicking the Upload File button on the page. There are some important items we should go over for this example so you understand all the needed pieces to make this work. For the example in Listing 1 to work, you have to make the destination folder on the server writeable for the account used by ASP.NET so the file can be saved to the specified folder.
If you think your ASP.NET account is not enabled to write to the folder you want, simply open up Microsoft Windows Explorer and navigate to the folder to which you want to add this permission. Right-click on the folder (in this case, the Uploads folder), and then select Properties. In the Properties dialog box, click on the Security tab and make sure the ASP.NET Machine Account is included in the list and has the proper permissions to write to disk (see Figure 1).

Figure 1. Looking at the Security tab of the Uploads folder

If you don't see the ASP.NET Machine Account under the Security tab, you can add it by clicking the Add button and entering ASPNET (without the period) in the text area, as illustrated in Figure 2.

Figure 2. Adding the ASP.NET Machine Account to the folder security definition

Click OK to add the ASP.NET Machine Account to the list. From here, make sure you give this account the proper permissions and then click OK, and you are ready to go.
The Submit button on the page causes the Button1_Click event to occur. This event uploads the file and then displays a message telling you if the upload was successful by posting information about the file uploaded. If it was unsuccessful, the page displays an error message describing why the upload failed.
By using the FileUpload control that converts itself to an tag, the browser automatically places a Browse button next to the text field on the ASP.NET page. You don't have to program anything else for this to occur. When the end user clicks the Browse button, he can navigate through the local file system to find the file to be uploaded to the server. This is shown in Figure 3. Clicking Open will place that filename and the file's path within the text field.

Figure 3. Choosing a file

Working Around File Size Limitations

You may not realize it, but there is a limit to the size of a file that can be uploaded using this technique. By default, the maximum size of a file to be uploaded to the server using the FileUpload control is around 4MB. You cannot upload anything that is larger than this limit.
One of the great things about .NET, however, is that it usually provides a way around limitations. You can usually change the default settings that are in place. To change this size limit, you make some changes in either the web.config.comments (found in the ASP.NET 2.0 configuration folder at C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\CONFIG) or your application's web.config file.
In the web.config.comments file, find a node called that looks like the following:

Copy

A lot is going on in this single node, but the setting that takes care of the size of the files to be uploaded is the maxRequestLength attribute. By default, this is set to 4096 kilobytes (KB). Simply change this value to increase the size of the files that you can upload to the server. If you want to allow 10 megabyte (MB) files to be uploaded to the server, set the maxRequestLength value to 11264, meaning that the application allows files that are up to 11000 KB to be uploaded to the server.
Making this change in the web.config.comments file applies this setting to all the applications that are on the server. If you want to apply this to only the application you are working with, apply this node to the web.config file of your application, overriding any setting that is in the web.config.comments file. Make sure this node resides between the nodes in the configuration file.
Another setting involved in the size limitation of files to be uploaded is the value given to the executionTimeout attribute in the node.
The value given the executionTimeout attribute is the number of seconds the upload is allowed to occur before being shut down by ASP.NET. If you are going to allow large files to be uploaded to the server, you are also going to want to increase this value along with the maxRequestLength value.
One negative with increasing the size of a file that can be uploaded is that there are hackers out there who attack servers by throwing a large number of requests at them. To guard against this, you can actually decrease the size of the files that are allowed to be uploaded; otherwise, you may find hundreds or even thousands of 10 MB requests hitting your server.

Client-Side Validation of File Types Permissible to Upload

There are several methods you can use to control the types of files that are uploaded to the server. Unfortunately, there is no bullet-proof method to protect you from someone uploading files that would be considered malicious. You can take a few steps, however, to make this process of allowing end users to upload files a little more manageable.
One nice method you can employ is to use the ASP.NET validation controls that are provided for free with ASP.NET. These controls enable you to do a regular-expression check upon the file that is being uploaded to see if the extension of the file is one you permit to be uploaded.
This is ideal for browsers that allow client-side use of the validation controls because it forces the checking to be done on the client; the file is not uploaded to the server if the signature isn't one you allow. Listing 3 shows you an example of using validation controls to accomplish this task.

Note The use of validation controls is not explained here. Take a look at Validating ASP.NET Server Controls for a complete explanation of validation controls and how to use them in your ASP.NET pages.

Listing 3. Using validation controls to restrict the types of files uploaded to the server

Copy

This simple ASP.NET page uses validation controls so that the end user can only upload .mp3, .mpeg, or .m3u files to the server. If the file type is not one these three choices, a Validation control throws an exception onto the screen. This is shown in Figure 4.

Figure 4. Validating the file type using validation controls

Using Validation controls is not a foolproof way of controlling the files that are uploaded to the server. It wouldn't be too hard for someone to change the file extension of a file so it would be accepted and uploaded to the server, thereby bypassing this simple security model.

Adding Server-Side File Type Validation

You just saw an easy way to add some ASP.NET validation server controls to your ASP.NET page to perform a client side validation of the file extension (in just a textual manner). Now let's take a look at how to perform a similar operation on the server-side. This is presented in Listing 4.

Listing 4. Checking the file type on the server

Visual Basic

Copy

    Protected Sub Button1_Click(ByVal sender As Object, _
      ByVal e As System.EventArgs)
        If FileUpload1.HasFile Then
            Dim fileExt As String
            fileExt = System.IO.Path.GetExtension(FileUpload1.FileName)
            
            If (fileExt = ".mp3") Then
                Try
                    FileUpload1.SaveAs("C:\Uploads\" & _
                       FileUpload1.FileName)
                    Label1.Text = "File name: " & _
                      FileUpload1.PostedFile.FileName & "
" & _
                      "File Size: " & _
                      FileUpload1.PostedFile.ContentLength & " kb
" & _
                      "Content type: " & _
                      FileUpload1.PostedFile.ContentType
                Catch ex As Exception
                    Label1.Text = "ERROR: " & ex.Message.ToString()
                End Try
            Else
                Label1.Text = "Only .mp3 files allowed!"
            End If
        Else
            Label1.Text = "You have not specified a file."
        End If
    End Sub

Copy

    protected void Button1_Click(object sender, EventArgs e)
    {

        if (FileUpload1.HasFile)
        {
            string fileExt = 
               System.IO.Path.GetExtension(FileUpload1.FileName);

            if (fileExt == ".mp3")
            {
                try
                {
                    FileUpload1.SaveAs("C:\\Uploads\\" + 
                       FileUpload1.FileName);
                    Label1.Text = "File name: " +
                        FileUpload1.PostedFile.FileName + "
" +
                        FileUpload1.PostedFile.ContentLength + " kb
" +
                        "Content type: " +
                        FileUpload1.PostedFile.ContentType;
                }
                catch (Exception ex)
                {
                    Label1.Text = "ERROR: " + ex.Message.ToString();
                }
            }
            else
            {
                Label1.Text = "Only .mp3 files allowed!";
            }
        }
        else
        {
            Label1.Text = "You have not specified a file.";
        }
    }

Now, by using the GetExtension method from the System.IO.Path namespace, you can perform basically the same operation. It is important to note that this doesn't get around an end user's ability to simply change the file extension to something that works and upload that altered file to the hosting server.

Uploading Multiple Files at the Same Time

So far, you have seen some good examples of how to upload a file to the server without much hassle. Now let's take a look at how to upload multiple files to the server from a single page.
No built-in capabilities in the Microsoft .NET Framework enable you to upload multiple files from a single ASP.NET page. With a little work, however, you can easily accomplish this task just as you would have in the past using .NET 1.x.
The trick is to import the System.IO class into your ASP.NET page, and to then use the HttpFileCollection class to capture all the files that are sent in with the Request object. This approach enables you to upload as many files as you want from a single page.
If you wanted to, you could simply handle each and every FileUpload control on the page individually, as presented in Listing 5.

Listing 5. Handling each FileUpload control individually

Visual Basic

Copy

If FileUpload1.HasFile Then
   ' Handle file
End If

If FileUpload2.HasFile Then
   ' Handle file
End If

Copy

if (FileUpload1.HasFile) {
   // Handle file
}

if (FileUpload2.HasFile) {
   // Handle file
}

This approach works, but there may be instances where you are going to want to handle the files using the HttpFileCollection class instead—especially if you are working with a dynamically generated list of server controls.
For an example of this, you can build an ASP.NET page that has three FileUpload controls and one Submit button (using the Button control). After the user clicks the Submit button and the files are posted to the server, the code behind takes the files and saves them to a specific location on the server. After the files are saved, the file information that was posted is displayed in the ASP.NET page (see Listing 6).

Listing 6. Uploading multiple files to the server

Visual Basic

Copy

Protected Sub Button1_Click(ByVal sender As Object, _
   ByVal e As System.EventArgs)

   Dim filepath As String = "C:\Uploads"
   Dim uploadedFiles As HttpFileCollection = Request.Files
   Dim i As Integer = 0

   Do Until i = uploadedFiles.Count
     Dim userPostedFile As HttpPostedFile = uploadedFiles(i)

     Try
        If (userPostedFile.ContentLength > 0) Then
           Label1.Text += "File #" & (i + 1) & "
"
           Label1.Text += "File Content Type: " & _
              userPostedFile.ContentType & "
"
           Label1.Text += "File Size: " & _
              userPostedFile.ContentLength & "kb
"
           Label1.Text += "File Name: " & _
              userPostedFile.FileName & "
"

           userPostedFile.SaveAs(filepath & "\" & _
              System.IO.Path.GetFileName(userPostedFile.FileName))

           Label1.Text += "Location where saved: " & _
              filepath & "\" & _
              System.IO.Path.GetFileName(userPostedFile.FileName) & _
              ""
        End If
     Catch ex As Exception
        Label1.Text += "Error:
" & ex.Message
     End Try
     i += 1
   Loop
End Sub

Copy

protected void Button1_Click(object sender, EventArgs e)
{
   string filepath = "C:\\Uploads";
   HttpFileCollection uploadedFiles = Request.Files;
    
   for (int i = 0; i < uploadedFiles.Count; i++)
   {    
      HttpPostedFile userPostedFile = uploadedFiles[i];
    
      try
      {    
         if (userPostedFile.ContentLength > 0 )
         {
            Label1.Text += "File #" + (i+1) + 
               "
";
            Label1.Text += "File Content Type: " + 
               userPostedFile.ContentType + "
";
            Label1.Text += "File Size: " + 
               userPostedFile.ContentLength + "kb
";
            Label1.Text += "File Name: " + 
               userPostedFile.FileName + "
";
    
            userPostedFile.SaveAs(filepath + "\\" + 
               System.IO.Path.GetFileName(userPostedFile.FileName));
    
            Label1.Text += "Location where saved: " + 
               filepath + "\\" + 
               System.IO.Path.GetFileName(userPostedFile.FileName) + 
               "";
         }    
      } 
      catch (Exception Ex)
      {    
         Label1.Text += "Error: 
" + Ex.Message;    
      }    
   }    
}

The end user can select up to four files and click the Upload Files button, which initializes the Button1_Click event. Using the HttpFileCollection class with the Request.Files property lets you gain control over all the files that are uploaded from the page. When the files are in this state, you can do whatever you want with them. In this case, the files' properties are examined and written to the screen. In the end, the files are saved to the Uploads folder in the root directory of the server. The result of this action is illustrated in Figure 5.

Figure 5. Uploading four files at once to the server from a single ASP.NET page

As you may have noticed, one interesting point about this example is that the states of the file input text boxes are not saved with the postback. You can see this in Figure 5. In ASP.NET, the state of the file-input text boxes cannot be saved because doing so might pose a security risk.

Conclusion

The FileUpload server control provided by ASP.NET is a powerful control that was quite difficult to achieve in the days of Active Server Pages 3.0. This new capability allows your end-users to upload one or more files to your server. Remember, you can control the size of the files that are uploaded by working with settings in either the web.config.comments or web.config file.

About the authorBill Evjen is an active proponent of .NET technologies and community-based learning initiatives for .NET. He is a technical director for Reuters, the international news and financial services company based in St. Louis, Missouri. Bill is the founder and executive director of the International .NET Association (INETA), which represents more than 100,000 members worldwide. Bill is also an author and speaker and has written such books as ASP.NET Professional Secrets, XML Web Services for ASP.NET, Web Services Enhancements, and the Visual Basic .NET Bible (all from Wiley).

GridView Examples for ASP.NET 2.0: Drilling Down into Detailed Data

2012-06-29T10:53:00.002+03:00

In the Filtering the Data Shown in a GridView section we saw how to allow the user to display a list of products in a DropDownList and, for the selected product, list the product's order details in a GridView. That demo worked well for viewing order details for a specific product, but imagine if you wanted to put more of an emphasis on displaying product information, with viewing the order details for the products being a secondary concern. In such a situation you might want to show a GridView of the products with a way to "select" a particular GridView row. Doing so would then display the order details for the selected product in another GridView.
This common type of report is often called a drill-down report, since it shows data at one level—the list of products—with the ability to drill down into information specific to a particular product—the list of associated order details. Another common type of drill-down report is used when displaying data that has a lot of properties. For example, the Northwind database has a Customers table with numerous fields. When showing information about customers in a GridView, it might be impractical to list all of the fields of the Customers table in a GridView. Rather, it might make more sense to list only the most germane fields along with a "Details" button in each row that, when clicked, would display the particular customer's complete information.
Both of these types of drill-down reports are easily accomplished with the GridView and require no programming. In the next two sections we'll see just how easy building drill-down reports can be.

Drilling Down From One to Many

One of the many one-to-many relationships in the Northwind database can be found between the Orders or Order Details tables. The Orders table contains a record for each order placed. An order consists of one to many line items, each line item being stored as a record in the Order Details table. To illustrate a one-to-many drill-down report, let's create an ASP.NET page that lists all available orders in one GridView, where each row in this GridView has a "View Order Details" button that, when clicked, displays the particular order's line items in another GridView.
To accomplish this, start by adding a SqlDataSource to the page that retrieves all of the records from the Orders table. Next, add a GridView to the page and bind it to this SqlDataSource. In order to select an item from the GridView, check the Enable Selection link in the GridView's Smart Tag. This will add a CommandField to the GridView with a Select button.

Note The CommandField is another type of GridView column type, like the BoundField and ImageField that we examined earlier. The CommandField is used to display common command buttons, such as buttons for selection, deletion, and updating. We'll see more examples of the CommandField in the demos involving deletion and editing of the GridView's underlying data.

Next, we need a SqlDataSource that returns the right subset of order details for the selected order. To accomplish this, add another SqlDataSource to the page and configure it to select the appropriate columns from the Order Details table. Next, click the WHERE button and add a WHERE condition on the OrderID field, creating a parameter tied to the Orders GridView's SelectedValue (see Figure 29).

Figure 29

Finally, add another GridView to the page, binding it to the order details SqlDataSource. Once you have completed these two steps your ASP.NET page's declarative syntax should look similar to the following:

Copy

    Untitled Page


    

    

        
Select an Order from the Left...

            
            
                
                
                
                
                    
                    
                    
                        
                    
                
                
                
            
    


        
... and View the Order Details on the Right

When examining the markup be sure to note the following:

When adding a Select button to a GridView, a CommandField is added. By default, the text for the Select button will be "Select," but this can be changed through the SelectText property. You can even use an image for the Select button, if you'd rather, by providing the path to the image in the SelectImageUrl property.
The orderGridView GridView's DataKeyNames property is set to OrderID. When a particular record in the GridView is selected, the GridView's SelectedValue property will be set to that row's OrderID value.
The orderDetailsDataSource SqlDataSource contains a parameter in its WHERE clause (@OrderID) whose value is specified in the section. The indicates that the parameter is of type Int32 and its value should be set to the orderGridView GridView's SelectedValue property.

Figures 30 and 31 show the drill-down report in action. Note that on the first page load, only the GridView of orders is displayed (see Figure 30). When an order's "View Order Details" link is clicked, a postback occurs and the order details GridView is bound to the SqlDataSource that returns all Order Details records associated with the selected order (see Figure 31).

Figure 30 (Click on the graphic for a larger image)

Figure 31 (Click on the graphic for a larger image)

One minor issue with the demo is that the orders GridView's SelectedIndex does not change when the GridView is paged. What this implies is that if you are on page 1 and click on the second order's "View Order Details," you will see that order's details to the right, as expected. However, if you then click to visit page 2, the second order on page 2 will be selected and its details will be shown to the right. I wanted to have the SelectedIndex reset when stepping through the pages. To accomplish this simply create an event handler for the GridView's PageIndexChanged event. The PageIndexChanged event fires whenever the user requests a new page of data. In this event handler I reset the GridView's SelectedIndex to -1, as shown in the following code snippet:
The PageIndexChanged Event Handler (Visual Basic)

Copy

Sub orderGridView_PageIndexChanged(ByVal sender As Object, _
   ByVal e As System.EventArgs)
    orderGridView.SelectedIndex = -1
End Sub
The PageIndexChanged Event Handler (C#)
void orderGridView_PageIndexChanged(object sender, EventArgs e)
{
    orderGridView.SelectedIndex = -1;
}

Drilling Down From Summary to Detail

The other flavor of drill-down reports is expanding from a concise view to a detailed view. For example, the Customers table in the Northwind database contains a plethora of fields and displaying all fields in a GridView would result in a wide, unwieldy GridView that was difficult to read. Rather than displaying all customer-related fields, it might make more sense to just display the pertinent fields—CompanyName and ContactName—along with a "View Customer Details" link in each row. If the end user wants to see all of the fields of a particular customer, they can click that customer's details link.
Creating such a summary to a detail drill-down report is fairly simple in ASP.NET 2.0 thanks to the DetailsView Web control, which is designed for displaying information one record at a time (as opposed to displaying numerous records at once, like the GridView). As we'll see shortly, displaying a particular customer's full details using a DetailsView is as simple as adding and configuring a GridView.
To get started we need to get just the CustomerID, CompanyName, and ContactName fields from the Customers table and display them in a GridView. As with our previous drill-down report example, this is accomplished by adding and configuring a SqlDataSource and then binding a GridView to it. Next, add another SqlDataSource that retrieves all of the Customers table's fields.
At this point you could add a WHERE clause and bind the parameter to the customer's GridView, just like we did in the previous drill-down example, but for this exercise let's try an alternative approach for accessing the correct customer for the customer DetailsView. After configuring the second SqlDataSource without adding a WHERE clause, from the Design view go to the SqlDataSource's Properties and add the following into the SqlDataSource's FilterExpression property: CustomerID='{0}'. Next, open the Parameter Collection Editor dialog box by clicking on the FilterParameters property. This dialog box should look familiar, as it closely mimics the dialog box shown in Figure 29 when we configured the WHERE clause parameter for the earlier drill-down report example. Set up a parameter based on the customer's GridView.
The last step is to add a DetailsView to the page. Add a DetailsView by simply dragging and dropping the control from the Toolbox and then, from its Smart Tag, associate it with the data source control we just configured.
Once you have configured this page your page's declarative syntax should look similar to the following markup shown. As with our previous examples, no source code was needed to create this page. When examining this markup be sure to take note of the following things:

The customerGridView GridView's DataKeyNames property is set to CustomerID. As we discussed with the previous drill-down report example, this indicates that when a GridView row is selected, the GridView's SelectedValue property will be set to the value of that row's CustomerID.
The customerDetailsDataSource SqlDataSource's SelectCommand does not include a WHERE clause. Instead, it contains a FilterExpression—CustomerID='{0}'—along with a section that indicates the filter parameter ({0}) has the value of the customerGridView GridView's SelectedValue property.

Copy






    Untitled Page


    

    

        
Select a Customer from the Left...

        
        
            
            
            
            
                
                
                
            
            
            
        
    


        
... and See Their Detailed Information on the Right

Figures 32 and 33 show the drill-down report in action.

Figure 32 (Click on the graphic for a larger image)

Figure 33 (Click on the graphic for a larger image)

GridView Examples for ASP.NET 2.0: Displaying Images in a GridView Column

2012-06-29T10:46:00.000+03:00

In the ASP.NET 1.x class I teach, the course-long project for the students is to create an online photo album, one that allows visitors to upload images and provide metadata about the images, such as a description, a title, and so on. The data model my students typically use consists of a Pictures table with the following fields:

PictureID—a synthetic primary key, typically an integer field setup as an IDENTITY.
Title—a short title for the picture.
DateAdded—the date/time the picture was uploaded.
PictureUrl—the path to the uploaded image file.

When users want to add a new image to the photo album site, they must visit a particular page that contains a file upload control along with form input fields querying them for the other bits of information. When they submit the form, the picture on their computer is uploaded to the Web server's file system and a new row is added to the Pictures table. The PictureUrl field is set to the virtual path of the uploaded image file.
There's an additional page that lists all pictures in the photo album using a DataGrid. To display an image in a column in a DataGrid in ASP.NET 1.x you have to use a TemplateColumn with an Image Web control inside the TemplateColumn. With ASP.NET 2.0 the GridView includes an ImageField that can be used to display an image in a column of the GridView.
Imagine that we had the data model discussed previously and wanted to display all of the pictures in a GridView, displaying the PictureID, Title, and DateAdded fields each in a column and the actual image itself in an additional column.
To accomplish this we'd first grab the data using a data source control and then add a GridView bound to that data source control. This GridView would have four BoundField columns, meaning that instead of seeing the actual image we'd see the actual image path when viewing the GridView in a browser. To display the actual image, we need to edit the GridView's columns, removing the PictureUrl BoundField and replacing it with an ImageField. To edit a GridView's columns simply click on the Edit Columns link from the GridView's Smart Tag. This will bring up a dialog box like the one shown in Figure 25. Delete the PictureUrl BoundField and add in an ImageField. Finally, set the ImageField's DataImageUrlField to the name of the DataSource field that contains the image path—PictureUrl.

Figure 25

This will result in a GridView with the following declarative syntax:

Copy

Since the Northwind database does not have a table with an image path, we'll have to programmatically create our own data model to see this demo in action. The following code in our ASP.NET page creates a DataTable with the appropriate schema and populates the DataTable with four records.
Creating a DataTable Programmatically (Visual Basic)

Copy

Function GetData() As DataTable
    ' This method creates a DataTable with four rows.  Each row has the
    ' following schema:
    '   PictureID      int
    '   PictureURL     string
    '   Title          string
    '   DateAdded      datetime
    Dim dt As New DataTable()
    ' define the table's schema
    dt.Columns.Add(New DataColumn("PictureID", GetType(Integer)))
    dt.Columns.Add(New DataColumn("PictureURL", GetType(String)))
    dt.Columns.Add(New DataColumn("Title", GetType(String)))
    dt.Columns.Add(New DataColumn("DateAdded", GetType(DateTime)))
    ' Create the four records
    Dim dr As DataRow = dt.NewRow()
    dr("PictureID") = 1
    dr("PictureURL") = ResolveUrl("~/DisplayingImages/Images/Blue hills.jpg")
    dr("Title") = "Blue Hills"
    dr("DateAdded") = New DateTime(2005, 1, 15)
    dt.Rows.Add(dr)
    dr = dt.NewRow()
    dr("PictureID") = 2
    dr("PictureURL") = ResolveUrl("~/DisplayingImages/Images/Sunset.jpg")
    dr("Title") = "Sunset"
    dr("DateAdded") = New DateTime(2005, 1, 21)
    dt.Rows.Add(dr)
    dr = dt.NewRow()
    dr("PictureID") = 3
    dr("PictureURL") = _
      ResolveUrl("~/DisplayingImages/Images/Water lilies.jpg")
    dr("Title") = "Water Lilies"
    dr("DateAdded") = New DateTime(2005, 2, 1)
    dt.Rows.Add(dr)
    dr = dt.NewRow()
    dr("PictureID") = 4
    dr("PictureURL") = ResolveUrl("~/DisplayingImages/Images/Winter.jpg")
    dr("Title") = "Winter"
    dr("DateAdded") = New DateTime(2005, 2, 18)
    dt.Rows.Add(dr)
    Return dt
End Function

Creating a DataTable Programmatically (C#)

Copy

DataTable GetData()
{
    // This method creates a DataTable with four rows.  Each row has the
    // following schema:
    //   PictureID      int
    //   PictureURL     string
    //   Title          string
    //   DateAdded      datetime
    DataTable dt = new DataTable();
    // define the table's schema
    dt.Columns.Add(new DataColumn("PictureID", typeof(int)));
    dt.Columns.Add(new DataColumn("PictureURL", typeof(string)));
    dt.Columns.Add(new DataColumn("Title", typeof(string)));
    dt.Columns.Add(new DataColumn("DateAdded", typeof(DateTime)));
    // Create the four records
    DataRow dr = dt.NewRow();
    dr["PictureID"] = 1;
    dr["PictureURL"] = ResolveUrl("~/DisplayingImages/Images/Blue hills.jpg");
    dr["Title"] = "Blue Hills";
    dr["DateAdded"] = new DateTime(2005, 1, 15);
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["PictureID"] = 2;
    dr["PictureURL"] = ResolveUrl("~/DisplayingImages/Images/Sunset.jpg");
    dr["Title"] = "Sunset";
    dr["DateAdded"] = new DateTime(2005, 1, 21);
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["PictureID"] = 3;
    dr["PictureURL"] = 
      ResolveUrl("~/DisplayingImages/Images/Water lilies.jpg");
    dr["Title"] = "Water Lilies";
    dr["DateAdded"] = new DateTime(2005, 2, 1);
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["PictureID"] = 4;
    dr["PictureURL"] = ResolveUrl("~/DisplayingImages/Images/Winter.jpg");
    dr["Title"] = "Winter";
    dr["DateAdded"] = new DateTime(2005, 2, 18);
    dt.Rows.Add(dr);
    return dt;
}

To bind this data to the GridView we can set the GridView's DataSource property to the GetData() method like so:

Copy

...

Finally, we need to call Page.DataBind() in the Page_Load event handler to bind the GridView's DataSource.
Page_Load Event Handler (Visual Basic)

Copy

Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs)
    Page.DataBind()
End Sub
Page_Load Event Handler (C#)
void Page_Load(object sender, EventArgs e)
{
    Page.DataBind();
}

The end result is a GridView that shows the image referenced by the PictureUrl path (see Figure 26).

Figure 26

Don't be daunted by the length of this example's code—the length is due entirely to the fact that we had to synthetically create a data model with a table that has an image path field. Had the Northwind database had such a table, this example—like the previous ones—wouldn't have required a lick of code.

Upload and download a file from GridView in Asp.net using with C# and Vb || Gridview with file Download link button in Asp.net using with C# and Vb

2012-06-29T10:44:00.000+03:00

The following article is showing about file uploading and downloading with Gridview in Asp.net.

First Design the source code with fileupload control and Gridview from Toolbox in Visual studio 2010.

Default.aspx:

<title>title>

head>

<body>

<div>

<asp:FileUpload ID="fileUpload1" runat="server" />

<asp:Button ID="btnUpload" runat="server" Text="Upload" onclick="btnUpload_Click" />

div>

<div>

<asp:GridView ID="gvDetails" CssClass="Gridview" runat="server"AutoGenerateColumns="false" DataKeyNames="FilePath">

<asp:BoundField DataField="Id" HeaderText="Id" />

<asp:BoundField DataField="FileName" HeaderText="FileName" />

<asp:TemplateField HeaderText="FilePath">

<asp:LinkButton ID="lnkDownload" runat="server" Text="Download"OnClick="lnkDownload_Click">asp:LinkButton>

ItemTemplate>

asp:TemplateField>

Columns>

asp:GridView>

div>

form>

body>

html>

Write the following code in Upload button click event and download link button click event in code behind side:

Default.aspx.cs:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Data;

using System.Data.SqlClient;

using System.IO;

public partial class _Default : System.Web.UI.Page

{

SqlConnection con = new SqlConnection("Data Source=naresh;Initial Catalog=student;User ID=sa;Password=123");

protected void Page_Load(object sender, EventArgs e)

{

if (!IsPostBack)

{

BindGridviewData();

}

private void BindGridviewData()

{

con.Open();

SqlCommand cmd = new SqlCommand("select * from FilesTable", con);

SqlDataAdapter da = new SqlDataAdapter(cmd);

DataSet ds = new DataSet();

da.Fill(ds);

con.Close();

gvDetails.DataSource = ds;

gvDetails.DataBind();

}

protected void btnUpload_Click(object sender, EventArgs e)

{

string filename = Path.GetFileName(fileUpload1.PostedFile.FileName);

fileUpload1.SaveAs(Server.MapPath("Files/" + filename));

con.Open();

SqlCommand cmd = new SqlCommand("insert into FilesTable(FileName,FilePath) values(@Name,@Path)", con);

cmd.Parameters.AddWithValue("@Name", filename);

cmd.Parameters.AddWithValue("@Path", "Files/" + filename);

cmd.ExecuteNonQuery();

con.Close();

BindGridviewData();

}

protected void lnkDownload_Click(object sender, EventArgs e)

{

LinkButton lnkbtn = sender as LinkButton;

GridViewRow gvrow = lnkbtn.NamingContainer as GridViewRow;

string filePath = gvDetails.DataKeys[gvrow.RowIndex].Value.ToString();

Response.ContentType = "image/jpg";

Response.AddHeader("Content-Disposition", "attachment;filename=\"" + filePath +"\"");

Response.TransmitFile(Server.MapPath(filePath));

Response.End();

}

The following is the same code in Vb.net

Default.aspx.vb :

Imports System.Collections.Generic

Imports System.Linq

Imports System.Web

Imports System.Web.UI

Imports System.Web.UI.WebControls

Imports System.Data

Imports System.Data.SqlClient

Imports System.IO

Partial Public Class _Default

Inherits System.Web.UI.Page

Private con As New SqlConnection("Data Source=naresh;Initial Catalog=student;User ID=sa;Password=123")

Protected Sub Page_Load(sender As Object, e As EventArgs)

If Not IsPostBack Then

BindGridviewData()

End If

End Sub

Private Sub BindGridviewData()

con.Open()

Dim cmd As New SqlCommand("select * from FilesTable", con)

Dim da As New SqlDataAdapter(cmd)

Dim ds As New DataSet()

da.Fill(ds)

con.Close()

gvDetails.DataSource = ds

gvDetails.DataBind()

End Sub

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

Dim filename As String = Path.GetFileName(fileUpload1.PostedFile.FileName)

fileUpload1.SaveAs(Server.MapPath("Files/" & filename))

con.Open()

Dim cmd As New SqlCommand("insert into FilesTable(FileName,FilePath) values(@Name,@Path)", con)

cmd.Parameters.AddWithValue("@Name", filename)

cmd.Parameters.AddWithValue("@Path", "Files/" & filename)

cmd.ExecuteNonQuery()

con.Close()

BindGridviewData()

End Sub

Protected Sub lnkDownload_Click(sender As Object, e As EventArgs)

Dim lnkbtn As LinkButton = TryCast(sender, LinkButton)

Dim gvrow As GridViewRow = TryCast(lnkbtn.NamingContainer, GridViewRow)

Dim filePath As String = gvDetails.DataKeys(gvrow.RowIndex).Value.ToString()

Response.ContentType = "image/jpg"

Response.AddHeader("Content-Disposition", "attachment;filename=""" & filePath & """")

Response.TransmitFile(Server.MapPath(filePath))

Response.[End]()

End Sub

End Class

Build your application and run it then you will get output like the following:

Creating Dynamic Data Entry User Interfaces

2012-06-27T14:59:00.000+03:00

A Primer on Dynamic Controls in ASP.NET

As you know, ASP.NET Web pages are comprised of two parts:

An HTML portion that contains static HTML markup and Web controls, added through a declarative syntax.
A code portion that can be implemented as a separate class file (as with Visual Studio .NET), or in a

Accessing and Updating Data in ASP.NET: Filtering Database Data with Parameters

2012-06-25T17:54:00.001+03:00

Introduction
In Part 2 of this article series we looked at how to access relational database data using the AccessDataSource and SqlDataSource controls. However, in Part 2 we only looked at how to retrieve all of the records from a table, view, stored procedure, or ad-hoc SQL query. Often, we only want to retrieve a subset of data based on various criteria. When searching for a book on Amazon.com, for example, the search page retrieves only the data from the database that matches the search terms you entered; when viewing the details for a particular book, only the particular book's information is queried from the database.

Results are filtered in a SQL statement using the WHERE clause, which contains a boolean expression. For each record in the table being queried, the WHERE expression is evaluated to determine whether or not to include that record in the resultset.¹ For example, a SQL query like:

SELECT ProductID, ProductName FROM Products 
WHERE UnitPrice < 15.00

will return the ProductID and ProductName column values for all records in the Products table for which the statement UnitPrice < 15.00 evaluates to True. In English, it returns all products that cost strictly less than fifteen bucks.

The SqlDataSource and AccessDataSource controls can define the value by which the query is filtered by using parameters, and these parameters can retrieve their values from a variety of sources, including: the querystring, session variables, other Web controls on the page, and so on. Like the connection string and SELECT query, the filter parameters values for a data source control can be set declaratively, meaning you do not need to write a line of code. These parameter values can also be set programmatically, though, for cases where you might need to base the filter value on programmatic logic (such as the currently logged-in user's username).

In this article we will examine how to declaratively filter the results of a SQL query using parameters in a SqlDataSource. We'll see examples of how to use hard-coded filter values, and well as examples with filter values taken from the querystring and other Web controls on the page. Read on to learn more!

¹ - this is a gross oversimplification of how the database engine determines what rows, exactly, to return, but is an accurate description from a high-level perspective...

Filtering Basics

When filtering results there are two components of interest: the columns being filtered on, and the value being filtered by. In the example in the Introduction, the UnitPrice column is being filtered on, and 15.00 is the value being filtered by. Typically the value to filter by is not a hard-coded value, but depends on some sort of user input. To allow for a variable filter by value, SQL statements typically use parameters that indicate placeholders where a value can later be inserted. Parameters typically have the format @ParameterName or ?, depending on the underlying database being used. For example, when using parameterized queries with Microsoft Access databases, use ?; when using parameterized queries for Microsoft SQL Server, use @ParameterName. Rewriting the earlier SQL query to use parameters would result in:

-- For Microsoft SQL Server...
SELECT ProductID, ProductName
FROM 
Products
WHERE UnitPrice < @PriceFilter 

-- 
For Microsoft Access...
SELECT ProductID, ProductName
FROM Products
WHERE UnitPrice < ?

(The ParameterName can be any value; here I chose to use PriceFilter.)

With the parameter defined, its value can be set programmatically prior to executing the statement. If you're familiar with ADO.NET code, you know that when writing code to issue a query to a database you create a command object (such as SqlCommand) that specifies the SQL query or stored procedure to execute (via the CommandText property) as well as the connection object to use (via the Connection property). The command object also has a Parameters collection that allows you to programmatically specify the values for the parameters defined in the query (or used in the stored procedure). For more information on using parameterized queries with SQL Server see this article; for examples for parameterized queries with Microsoft Access, refer to this one.

With the data source controls you don't need to programmatically set the parameter (unless you want/need to), as the parameter value can be set declaratively, as we'll see shortly. When you set the parameter value declaratively, however, do understand that the data source control, behind the curtains, is programmatically adding the declaratively specified value to its underlying command object's Parameters collection. In short, the data source control is executing the same ADO.NET code you likely would if you were accessing the data programmatically.

Let's now turn our attention to filtering data with the SqlDataSource. In the following demos (which are downloadable at the end of this article), we'll be using a slimmed-down version of the Northwind Access database (as discussed in Part 2). We'll see how to specify the filter parameters both through the SqlDataSource's wizard and directly through its properties.

Getting Started with Filtering with the SqlDataSource

To start, create an ASP.NET page and go to the Design view. Next, drag on a SqlDataSource control from the Toolbox. As we saw in Part 2, you can configure the database to connect to and the SQL SELECT query to execute by clicking on the "Configure Data Source" link in the SqlDataSource control's smart tag. Recall that there are two screens for specifying the SELECT query:

Specify columns from a table or view - here you chose the table or view from a drop-down list and check those columns you want to return, or
Specify a custom SQL statement or stored procedure - with this option you can either pick a stored procedure from a drop-down list of manually type in your SQL query (or use the Query Builder)

If you use the "Specify columns from a table or view" option, after selecting the table or view to query and choosing the columns to return, click the WHERE button to add a filter parameter. This brings up the Add WHERE Clause dialog box (shown below), where you can specify the column to filter on, the operator to use (=, <, <=, >, and so on), and the source of the filter value (a hard-coded value, from the querystring, from another Web control on the page, and so on). We'll see how to specify different types of parameter values in a bit.

Limitations with the Add `WHERE` Clause Dialog Box
Filtering using the "Specify columns from a table or view" option has one potentially show-stopping drawback - while you can add multiple filter parameters, these parameters are joined using the `AND` operator. So if you need to filter values based on multiple clauses and need them joined together with `OR`s as well (such as `SELECT * FROM Products WHERE UnitPrice < 15.00 OR UnitPrice > 25.00`), you need to manually add the `SELECT` query and `WHERE` clause through the "Specify a custom SQL statement or stored procedure" option.

Limitations with the Add WHERE Clause Dialog Box

Filtering using the "Specify columns from a table or view" option has one potentially show-stopping drawback - while you can add multiple filter parameters, these parameters are joined using the AND operator. So if you need to filter values based on multiple clauses and need them joined together with ORs as well (such as

SELECT * FROM Products WHERE UnitPrice < 
15.00 OR UnitPrice > 25.00

), you need to manually add the SELECT query and WHERE clause through the "Specify a custom SQL statement or stored procedure" option.

If you use the "Specify a custom SQL statement or stored procedure" option you can either type in a SQL query by hand or pick a stored procedure from a drop-down list. To add filter parameters in the ad-hoc SQL query, simply add the parameters using the appropriate syntax. Since the Northwind database used in my demos is a Microsoft Access database I would use the ? character to indentify the parameters. For example, if I wanted to use an ad-hoc SQL statement I'd type into the SELECT textbox:

SELECT ProductID, ProductName FROM Products WHERE UnitPrice 
< ?

. If, however, you are using a SQL Server database, use the @ParameterName syntax instead. After specifying your parameters using the correct syntax, hit Next and you will see a screen that prompts you for the parameter values.

Step 1: Specify the Parameterized Ad-Hoc SQL Statement

Step 2: Click Next and Specify the Values for the Parameter(s)

If you are using a database that supports parameterized stored procedures (such as Microsoft SQL Server), you can select the stored procedure to use from the drop-down list and click next. In the next screen (the one shown above) you will see the parameters for the stored procedure and be able to define how their values are obtained.

Regardless of what approach you use, once you specify the parameter values and complete the SqlDataSource wizard, the SqlDataSource will have updated its properties. Specifically, the SelectCommand will now be a parameterized query, and there will be a series of SelectParameter instances. Since the types of SelectParameter instances vary depending on how the parameter value is obtained, we'll examine the resulting SqlDataSource markup in detail in each example.

If you are wizard-averse, you can always specify the parameterized query and SelectParameters by hand (through entering the markup directly), or by clicking on the SelectQuery property in the SqlDataSource's Properties pane in the Design view. Doing so will display the Command and Parameter Editor (see screen shot below).

Why Aren't We Using `FilterExpression` and `FilterParameters`?
If you explore the SqlDataSource's properties you'll notice the `FilterExpression` and `FilterParameters` properties. You may be wondering why we aren't using these two properties and how the `FilterParameters` collection differs from the `SelectParameters` collection. The `FilterExpression` and `FilterParameters` are properties designed for filtering the results returned by the database. That is, with these two properties, after the records have been returned from the backend database, these results are further filtered by the `FilterExpression` and `FilterParameters` before being handed over to the data Web control or programmer whose code is requesting the data source's data. Using a parameterized query and `SelectParameters`, on the other hand, performs the filtering on the database side. As you probably can guess, filtering on the database side is much more efficient than bringing back all data to the data source control and then having it filter the results. However, there are times when would want to use the `FilterExpression` and `FilterParameters` properties - in fact, both techniques can be used in tandem. For our examples now, stick with the parameterized queries and `SelectParameters` and just remember that the `SelectParameters` specify the parameter values that are sent in the database's `SELECT` query whereas the `FilterParameters` are those parameters used to filter the data returned from the database (and would only be set if there was a `FilterExpression` value defined).

Why Aren't We Using FilterExpression and FilterParameters?

If you explore the SqlDataSource's properties you'll notice the FilterExpression and FilterParameters properties. You may be wondering why we aren't using these two properties and how the FilterParameters collection differs from the SelectParameters collection. The FilterExpression and FilterParameters are properties designed for filtering the results returned by the database. That is, with these two properties, after the records have been returned from the backend database, these results are further filtered by the FilterExpression and FilterParameters before being handed over to the data Web control or programmer whose code is requesting the data source's data. Using a parameterized query and SelectParameters, on the other hand, performs the filtering on the database side.

As you probably can guess, filtering on the database side is much more efficient than bringing back all data to the data source control and then having it filter the results. However, there are times when would want to use the FilterExpression and FilterParameters properties - in fact, both techniques can be used in tandem. For our examples now, stick with the parameterized queries and SelectParameters and just remember that the SelectParameters specify the parameter values that are sent in the database's SELECT query whereas the FilterParameters are those parameters used to filter the data returned from the database (and would only be set if there was a FilterExpression value defined).

Filtering Based on a Hard-Coded Value

In both the "Specify columns from a table or view" and "Specify a custom SQL statement or stored procedure" options, when specifying the parameter value you are asked to choose the "Parameter source" with a drop-down list containing the following choices:

None
Cookie
Control
Form
Profile
QueryString
Session

To specify a hard-coded value, select the None option and then, in the value textbox, enter the hard-coded value. Once you have specified the parameter value and complete the wizard, the SqlDataSource control's declarative markup will look like:

ID" runat="server" ConnectionString="connectionString"
    ProviderName="providerName"

    SelectCommand="parameterizedQuery">
    
        hardCodedValue" 
                       Name="parameterName" 
                       Type="dataType" />

Specifically, there's one instance for each hard-coded parameter value you specified in the wizard. The parameter's DefaultValue attribute holds the value you entered into the value textbox, while the Name attribute refers to the parameter's name. (For Microsoft Access, which uses ? for the parameters, the Name attribute refers to the database column that the parameter applies to, although this value can be changed since the parameter name is really ?. The only important thing to note here is that the instances are applied in order to the ? parameters.) Finally, the Type parameter specifies the data type of the parameter value.

In the download available at the end of this article you'll find a demo called "Filter on Hard-Coded Value Demo." In this demo, the SqlDataSource is configured to retrieve all products, filtering them such that only those with a UnitPrice < 15.00 are returned. The resulting SqlDataSource markup, and a screen shot of the results when bound to a GridView, are shown below:

ID" runat="server" ConnectionString="connectionString"
    ProviderName="providerName"
    SelectCommand="SELECT 
[ProductID], [ProductName], [UnitPrice] FROM [Products] WHERE ([UnitPrice] = 
?)">
    
        15.00" 
            Name="UnitPrice" 
            Type="Decimal" 
/>

Filtering Based on a QueryString Value

In the Northwind database each product belongs to a category. Therefore, we might want a page that lists all of the categories in the database with each category having a hyperlink to a page that displays the products in the selected category. One way to accomplish this is to create two pages: Categories.aspx, which lists all of the categories, and ProductsInCategory.aspx, which lists all products for a category. The challenge here is how to specify what category's products to display in the ProductsInCategory.aspx page. While there are many techniques for passing information between pages in a website, a common one is to use the querystring. With this approach we'd visit the products page using the URL ProductsInCategory.aspx?CategoryID=categoryID and would then display the products in the categoryID category. (See Passing Parameters from One Page to Another for a class to help streamline the code needed to pass parameters from one page to another via the querystring.)

To use a querystring value to filter results, simply choose the QueryString option from the "Parameter source" drop-down list. Then, enter the name of the querystring value you want to use in the querystring field textbox. After doing so, the SqlDataSource's declarative markup will include an instance in its SelectParameters collection. The instance, as shown below, provides the parameter name (Name), the name of the querystring value (QueryStringField) and the Type:

ID" runat="server" ConnectionString="connectionString"
    ProviderName="providerName"
    SelectCommand="SELECT 
[ProductID], [ProductName], [UnitPrice] FROM [Products] WHERE ([CategoryID] = 
?)">
    
        Int32" 
            Name="CategoryID" 
            QueryStringField="CategoryID" />

The following screen shots show the Categories.aspx page, which lists all categories along with a View Products link, and the ProductsInCategory.aspx page, when visited as ProductsInCategory.aspx?CategoryID=1 (viewing products in the Beverages category).

The Complete List of Categories, Each With a View Products Link

The Products in the Beverages Category (`ProductsInCategory.aspx?CategoryID=1`)

Filtering Based on a Web Control Value

The parameter values for a SqlDataSource can also be set based on a value from a Web control on the page. Returning to the Categories/Products master-detail example from before, rather than having two pages we might want to have one page that uses a DropDownList control to list all categories and shows the Products for the selected category in a GridView. To accomplish this, start by creating a page that displays a DropDownList that contains the categories. Next, add a SqlDataSource to return the products whose CategoryID equals the selected category in the DropDownList. To accomplish this, choose Control as the "Parameter source." This will display a drop-down list of controls on the page, allowing your to choose which control's value should be used. Pick the DropDownList you added moments ago.

After performing these steps, the SqlDataSource's declarative markup will include an instance in its SelectParameters collection. The instance, as shown below, provides the parameter name (Name), the ID of the control to use (ControlID), the control property whose value will be used as the parameter's value (PropertyName), and the Type:

ID" runat="server" ConnectionString="connectionString"
    ProviderName="providerName"
    SelectCommand="SELECT 
[ProductID], [ProductName], [UnitPrice] FROM [Products] WHERE ([CategoryID] = 
?)">
    
        Int32" 
            Name="CategoryID" 
            ControlID="categoriesDDL"             PropertyName="SelectedValue" />

The following screen shot shows a page that lists the categories in a DropDownList and the selected categories corresponding products in a GridView. This page uses two SqlDataSource controls - one to retrieve all catgories (which is bound to the DropDownList) and one to return the corresponding products (which uses the and is bound to the GridView). I set the DropDownList's AutoPostBack property to True so that whenever the DropDownList changes a postback ensues and the GridView is updated to show the applicable products.

Conclusion

In this article we saw how to use parameterized queries along with the SqlDataSource's SelectParameters collection to filter the results returned from a database query. The SqlDataSource allows the values used in the parameters to come from a bevy of sources, including hard-coded values, querystring values, Web control property values, session variables, and so on. These parameter values can be specified declaratively, requiring no code on our part. These parameter values can also be set programmatically, a topic we'll address in a future article in this series!

Happy Programming!

C# access modifier	Java access modifier
private	private
public	public
internal	protected
protected	N/A
internal protected	N/A