Coding experience sharing...

Development Web Service Internal with standards

2008-11-26T02:01:00.000-08:00

I found an interested guide with suggests as 'Standard' for Web Service development, it's really worthy to take reading.

Coding Standards (HTML/ASP/JavaScript)

In general, Web Services uses a form of Hungarian notation for file, table, field, and variable naming where the first letter of the name is lowercase and capital letters are used to divide multiple words in a name (e.g., "itemAdd.asp," "rsStudentList," "mlHours," etc.).

File and folder names

All folders will contain an index.html (or .shtml, .asp) file.
Sites should be organized in a logical, hierarchical manner. Do not place all files in a single directory.
All file names will begin with lowercase letter or a number.
A letter following a number in a filename will be lowercase (e.g., "2editImage.asp").
Multiple word names will be separated by a capital letter (e.g., "itemEdit.asp").
Do not use underscores ("_") or dashes ("-") in file names.
Do not use spaces in file names.
Grouped pages will be begin with the same word or string (e.g., "itemAdd", "itemAdded", "itemEdit", "itemEdited"). This makes it easier to find related pages.
For files that use server side includes (all template-based files), .shtml will be used for the file extension, not .htm or .html.
Acronyms that are used at the beginning of a file or folder name shall be all lowercase (e.g., "atecStaffList.asp", "imcResources.shtml").

Examples

Right: tlpServices.shtml
Wrong: TLPServices.shtml
Wrong: tLPServices.shtml
Wrong: tlp-services.shtml
Wrong: tlp_services.shtml
Wrong: tlpServices.htm
Wrong: tlpservices.shtml

Standard Folder Names

Image files should be placed in a folder called "/images/."
1. For sites with few images, this folder should reside at the site's root level and contain all of the site's images.
2. For sites with many images on many pages at different levels, it may be better to create "images" folders within each subfolder of the site, and place all images used in each subfolder's pages in each "images" folder.
3. For sites that use small thumbnail images to represent larger images, all thumbnail images should reside in a "thumbnails" folder within the "images" folder. All thumbnail images should be named exactly the same as the full-size image file.
Include files should be placed in a folder called "/_include/" in the root directory of the site.
JavaScript files should be placed in a folder called "/_scripts/" in the root directory of the site.
CGI script files should be placed in a folder called "/cgi-bin/" in the root directory of the site, or in the directory where the script is used.
Style sheet files should be placed in a folder called "/_styles/" in the root directory of the site.
Files used in developing a new site should be placed in a folder called "/_dev/" in the root directory of the site.

Variable Names (JavaScript, ASP)

Variable names will also follow Hungarian notation.

All variable names will begin with lowercase letter (no numbers).
Multiple word names will be separated by a capital letter (e.g., "firstName").
Do not use underscores ("_") or dashes ("-") in variable names.
Avoid non-descriptive or highly abbreviated variable names; spell out what each variable stands for (e.g., "firstName" not "fn"); "i" or "x" are fine when just running a "for" loop.

HTML/ASP formatting

All pages, where practical, should be converted to XHTML Transitional and validated.
All ASP code (including Response.Write statements) should generate valid XHTML.
The first letter of all words within ASP commands and statements should be capitalized. (e.g. "Do While Not...", "Response.Write(...")
All connections will use an include file.
With a few exceptions, all recordset declarations will be placed above the tag at the top of the document.
All recordset names will begin with "rs" (e.g., "rsItemInfo").
All pages that use a connection shall close the connection at the end of the page (below the tag).
All QueryString variables will have an identifier (e.g., "itemEdit.asp?itemID=33", NOT "itemEdit.asp?33").
Variable, recordset, and querystring identifier names will
1. Begin with a lowercase letter
2. Use capital letters to divide words within the variable (e.g., "userFirstName")
3. Not use underscores
If the first letter is part of an acronym, the whole acronym will be lowercase (e.g., "sqlString," not "sQLString").
All but the shortest statements should include some inline documentation explaining their purpose.
Multi-line statements should be clearly formatted with brackets separated from code: <%
  If aspStatement Then
  ?
  ?
  End If
%>

Cascading Style Sheets

Style names will be all lowercase (caps are not allowed for XHTML validation), with no underscores.
Styles shall be used exclusively for formatting (all tags should be removed from all documents).
Use existing HTML elements as much as possible, do not add classes like .head1 when the existing h1 style will accomplish what's needed.
Use existing style sheets. Only create new styles when absolutely necessary. Link style sheets using root-based referencing.
List styles in alphabetical order within style sheets to make maintenance easier.
Styles created for specific pages will be defined within the page header.

JavaScript

For validation purposes, all tags must include a type and language. Use type="text/JavaScript". However, do not use language="JavaScript" because it won't validate when the Document Type is XHTML Strict.
JavaScript variables will follow ASP variable naming conventions.
All custom JavaScript functions (that are used on only one page) will be placed in the header of the page it is used on.
Functions that are used on more than one page must be placed in a .js file. Our standard is to place .js files in a root/_scripts/ folder.
The most commonly used functions are available in centralized JavaScript files. Use root-based referencing to reference these files on your page.

SQL Formatting

All SQL reserved words will be typed in all caps (e.g., SELECT * FROM tableName WHERE dtStartDate > '3/3/03').
Multiple table queries will always be declared using JOIN statements. Non-ANSI type multiple table queries are not allowed.

SQL Tables and Fields

Table and field names will
1. Begin with a lowercase letter
2. Use capital letters to divide words within the variable (e.g., "userFirstName")
3. Not use underscores
4. If the first letter is part of an acronym, the whole acronym will be lowercase (e.g., "sqlString", not "sQLString")
Tables that are grouped together shall begin with the same string (e.g., "atecCheckout", "atecFacility", "atecEquipment").
Avoid the use of plurals in table names.
Avoid the use of numbers in table and field names.
Field names will record the data type of the field in the first character
1. String datatypes (char, varChar, etc.) will begin with "s" (e.g. "sFirstName")
2. Integer datatypes will begin with "i" (e.g., "iFacilityID"), with the exception of primary key identity fields, which will be named "ID"
3. Floating point (decimal) datatypes will begin with "f"
4. DateTime datatypes will begin with "dt"
5. Bit datatypes will begin with "b"
6. Text datatypes will begin with "t"
All tables will have a primary key identity field named "ID." Do not name this field after the table name (e.g., "ID," not "userListID") since the table will be identified anyway in multiple table queries (e.g., "userList.ID").
Views and stored procedures will begin with "view" and "proc" respectively to separate them from tables (e.g., "viewCurrentStaff," "procCalcDaysLeft").

ORACLE Architecture and Terminology

2008-11-25T01:33:00.000-08:00

This section will provide a basic understanding of ORACLE including the concepts and terminology of the ORACLE Server. It is important that you read through this section to familiarize yourself with the concepts and terminology to be used throughout this manual. Most of the information contained in this section is DIRECTLY extracted from ``ORACLE7 Server Concepts Manual'' and all credit should be attributed to ORACLE.
Before you can begin to use ORACLE, you must have a basic understanding of the architecture of ORACLE to help you start thinking about an ORACLE database in the correct conceptual manner.
Figure 1 illustrates a typical variation of ORACLE's memory and process structures; some of the memory structures and processes in this diagram are discussed in the following section. For more information on these memory structures and processes, see page 1-15 of ``ORACLE7 Server Concepts Manual.''

Figure 1. ORACLE Architecture

Memory Structures and Processes

The mechanisms of ORACLE execute by using memory structures and processes. All memory structures exist in the main memory of the computers that constitute the database system. Processes are jobs or tasks that work in the memory of these computers.

Memory Structures

ORACLE creates and uses memory structures to complete several jobs. For example, memory is used to store program code being executed and data that is shared among users. Several basic memory structures are associated with ORACLE: the system global area (which includes the database and redo log buffers, and the shared pool) and the program global area.
System Global Area (SGA) is a shared memory region allocated by ORACLE that contains data and control information for one ORACLE instance.
An ORACLE instance contains the SGA and the background processes.
The SGA is allocated when an instance starts and deallocated when the instance shuts down. Each instance that is started has its own SGA.
The Program Global Area (PGA) is a memory buffer that contains data and control information for a server process. A PGA is created by ORACLE when a server process is started. The information in a PGA depends on the configuration of ORACLE.

Processes

A process is a ``thread of control'' or a mechanism in an operating system that can execute a series of steps. Some operating systems use the terms job or task. An ORACLE database system has two general types of processes: user processes and ORACLE processes.
A user process is created and maintained to execute the software code of an application program (such as a PRO*C program) or an ORACLE tool (such as SQL*PLUS). The user process also manages the communication with the server processes. User processes communicate with the server processes through the program interface.
ORACLE processes are called by other processes to perform functions on behalf of the invoking process. ORACLE creates a server process to handle requests from connected user processes. ORACLE also creates a set of background processes for each instance (see ``ORACLE7 Server Concepts Manual'' pages 1-18, 1-19).

Database Structures

The relational model has three major aspects:

Structures: Structures are well-defined objects that store the data of a database. Structures and the data contained within them can be manipulated by operations.
Operations: Operations are clearly defined actions that allow users to manipulate the data and structures of a database. The operations on a database must adhere to a pre-defined set of integrity rules.
Integrity Rule: Integrity rules are the laws that govern which operations are allowed on the data and structures of a database. Integrity rules protect the data and the structures of a database.

An ORACLE database has both a physical and a logical structure. By separating physical and logical database structure, the physical storage of data can be managed without affecting the access to logical storage structures.

Logical Database Structure

An ORACLE database's logical structure is determined by:

one or more tablespaces.
the database's schema objects (e.g., tables, views, indexes, clusters, sequences, stored procedures).

The logical storage structures, including tablespaces, segments, and extents, dictate how the physical space of a database is used. The schema objects and the relationships among them form the relational design of a database.

Tablespaces and Data Files Tablespaces are the primary logical storage structures of any ORACLE database. The usable data of an ORACLE database is logically stored in the tablespaces and physically stored in the data files associated with the corresponding tablespace. Figure 2 illustrates this relationship.
Although databases, tablespaces, data files, and segments are closely related, they have important differences:

databases and tablespaces: An ORACLE database is comprised of one or more logical storage units called tablespaces. The database's data is collectively stored in the database's tablespaces.
tablespaces and data files: Each tablespace in an ORACLE database is comprised of one or more operating system files called data files. A tablespace's data files physically store the associated database data on disk.
databases and data files: A database's data is collectively stored in the data files that constitute each tablespace of the database. For example, the simplest ORACLE database would have one tablespace, with one data file. A more complicated database might have three tablespaces, each comprised of two data files (for a total of six data files).
schema objects, segments, and tablespaces: When a schema object such as a table or index is created, its segment is created within a designated tablespace in the database. For example, suppose a table is created in a specific tablespace using the CREATE TABLE command with the TABLESPACE option. The space for this table's data segment is allocated in one or more of the data files that constitute the specified tablespace. An object's segment allocates space in only one tablespace of a database.

Figure 2. Data Files and Tablespaces

A database is divided into one or more logical storage units called tablespaces. A database administrator can use tablespaces to do the following:

Control disk space allocation for database data.
Assign specific space quotas for database users.
Control availability of data by taking individual tablespaces online or offline.
Perform partial database backup or recovery operations.
Allocate data storage across devices to improve performance.

Every ORACLE database contains a tablespace named SYSTEM, which is automatically created when the database is created. The SYSTEM tablespace always contains the data dictionary tables for the entire database. You can query these data dictionary tables to obtain pertinent information about the database; for example, the names of the tables that are owned by you or ones to which you have access. See Chapter 3 for more information on how to access data dictionary tables.
Data files associated with a tablespace store all the database data in that tablespace. One or more datafiles form a logical unit of database storage called a tablespace. A data file can be associated with only one tablespace, and only one database.
After a data file is initially created, the allocated disk space does not contain any data; however, the space is reserved to hold only the data for future segments of the associated tablespace - it cannot store any other program's data. As a segment (such as the data segment for a table) is created and grows in a tablespace, ORACLE uses the free space in the associated data files to allocate extents for the segment.
The data in the segments of objects (data segments, index segments, rollback segments, and so on) in a tablespace are physically stored in one or more of the data files that constitute the tablespace. Note that a schema object does not correspond to a specific data file; rather, a data file is a repository for the data of any object within a specific tablespace. The extents of a single segment can be allocated in one or more data files of a tablespace (see Figure 3); therefore, an object can ``span'' one or more data files. The database administrator and end-users cannot control which data file stores an object.

Data Blocks, Extents, and Segments ORACLE allocates database space for all data in a database. The units of logical database allocations are data blocks, extents, and segments. Figure 3 illustrates the relationships between these data structures.

Data Blocks: At the finest level of granularity, an ORACLE database's data is stored in data blocks (also called logical blocks, ORACLE blocks, or pages). An ORACLE database uses and allocates free database space in ORACLE data blocks. Figure 4 illustrates a typical ORACLE data block.
Extents: The next level of logical database space is called an extent. An extent is a specific number of contiguous data blocks that are allocated for storing a specific type of information.
Segments: The level of logical database storage above an extent is called a segment. A segment is a set of extents which have been allocated for a specific type of data structure, and all are stored in the same tablespace. For example, each table's data is stored in its own data segment, while each index's data is stored in its own index segment. ORACLE allocates space for segments in extents. Therefore, when the existing extents of a segment are full, ORACLE allocates another extent for that segment. Because extents are allocated as needed, the extents of a segment may or may not be contiguous on disk, and may or may not span files. An extent cannot span files, though.

Figure 3. The Relationship Among Segments, Extents and Data Blocks

ORACLE manages the storage space in the data files of a database in units called data blocks. A data block is the smallest unit of I/O used by a database. A data block corresponds to a block of physical bytes on disk, equal to the ORACLE data block size (specifically set when the database is created - 2048). This block size can differ from the standard I/O block size of the operating system that executes ORACLE.
The ORACLE block format is similar regardless of whether the data block contains table, index, or clustered data. Figure 4 shows the format of a data block.

Figure 4. Data Block Format

Header (Common and Variable): The header contains general block information, such as block address, segment type, such as data, index, or rollback. While some block overhead is fixed in size (about 107 bytes), the total block overhead size is variable.
Table Directory: The table directory portion of the block contains information about the tables having rows in this block.
Row Directory: This portion of the block contains row information about the actual rows in the block (including addresses for each row piece in the row data area). Once the space has been allocated in the row directory of a block's header, this space is not reclaimed when the row is deleted.
Row Data: This portion of the block contains table or index data. Rows can span blocks.
Free Space: Free space is used to insert new rows and for updates to rows that require additional space (e.g., when a trailing null is updated to a non-null value). Whether issued insertions actually occur in a given data block is a function of the value for the space management parameter PCTFREE and the amount of current free space in that data block.
Space Used for Transaction Entries: Data blocks allocated for the data segment of a table, cluster, or the index segment of an index can also use free space for transaction entries.

Two space management parameters, PCTFREE and PCTUSED, allow a developer to control the use of free space for inserts of and updates to the rows in data blocks. Both of these parameters can only be specified when creating or altering tables and clusters (data segments). In addition, the storage parameter PCTFREE can also be specified when creating or altering indicies (index segments). The PCTFREE parameter is used to set the percentage of a block to be reserved (kept free) for possible updates to rows that already are contained in that block. For example, assume that you specify the following parameter within a CREATE TABLE statement:
pctfree 20 This states that 20\% of each data block used for this table's data segment will be kept free and available for possible updates to the existing rows already within each block.
After a data block becomes full, as determined by PCTFREE, the block is not considered for the insertion of new rows until the percentage of the block being used falls below the parameter PCTUSED. Before this value is achieved, the free space of the data block can only be used for updates to rows already contained in the data block. For example, assume that you specify the following parameter within a CREATE TABLE statement:
pctused 40 In this case, a data block used for this table's data segment is not considered for the insertion of any new rows until the amount of used space in the blocks falls to 39\% or less (assuming that the block's used space has previously reached PCTFREE).
No matter what type, each segment in a database is created with at least one extent to hold its data. This extent is called the segment's initial extent.
If the data blocks of a segment's initial extent become full and more space is required to hold new data, ORACLE automatically allocates an incremental extent for that segment. An incremental extent is a subsequent extent of the same or incremented size of the previous extent in that segment.
Every non-clustered table in an ORACLE database has a single data segment to hold all of its data. The data segment for a table is indirectly created via the CREATE TABLE/SNAPSHOT command.
Storage parameters for a table, snapshot, or cluster control the way that a data segment's extents are allocated. Setting these storage parameters directly via the CREATE TABLE/SNAPSHOT/CLUSTER or ALTER TABLE/SNAPSHOT/CLUSTER commands affects the efficiency of data retrieval and storage for that data segment.
For more information on Data Blocks, Segments and Extents, see ``ORACLE7 Server Concepts Manual.''

Physical Database Structure

An ORACLE database's physical structure is determined by the operating system files that constitute the database. Each ORACLE database is comprised of these types of files: one or more data files, two or more redo log files, and one or more control files. The files of a database provide the actual physical storage for database information. For more information on these physical storage files, see ``ORACLE7 Server Concepts Manual.''

Figure 5. Maintaining the Free Space of Data Blocks with PCTFREE and PCTUSED

Response buffer limit exceeded : Error message when a Web browser sends a request for an active server page to a Web server that is running IIS 6.0

2008-11-24T01:22:00.000-08:00

SYMPTOMS

Consider the following scenario. A client Web browser sends a request for an active server page (ASP) to a Web server that is running Internet Information Services (IIS) 6.0. The ASP request generates a large response. In this scenario, the following symptoms may occur:

•	The response fails.
•	An HTTP 500 server error occurs, and you receive the following error message in the client Web browser: Response object error 'ASP 0251 : 80004005' Response Buffer Limit Exceeded /`PageName.asp`, line `LineNumber` Note `PageName.asp` represents the name of the ASP page that was requested. `LineNumber` represents the last line number in the file that was processed before the response buffer exceeded the limit.
•	The IIS log file contains the following error in the cs-uri-query field: \|0\|ASP_0251_:_80004005\|Response_Buffer_Limit_Exceeded

CAUSE

This issue occurs because of a change in behavior that was introduced in IIS 6.0 and added to IIS 5.0. These versions of IIS enforce a default ASP response buffer limit of 4 MB. This limit prevents large ASP responses from adversely affecting the IIS process that hosts the Web application. If an ASP request generates a response that is larger than the configured buffer limit, you experience the symptoms that are mentioned in the "Symptoms" section.

RESOLUTION

In most scenarios, the 4 MB buffer limit is sufficient for ASP responses that are sent to Web clients. If this limit is insufficient, use one of the following methods:

Method 1: Decrease the response size

If the response is larger than the 4 MB default value, this size frequently causes a poor user experience. The Web browser must receive the large response over the network. Then, the Web browser must parse and display a very large HTML response.

If the Web client that receives the response does not have to view the whole response as a single page, you can decrease the response size. For example, you can rewrite the ASP-based application so that data is presented in a grid. Therefore, the Web client can browse the data one page at a time. You can use the GridView class in Microsoft ASP.NET to achieve this effect. For more information about the GridView class in ASP.NET, visit the following Microsoft Developer Network (MSDN) Web site:

http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.gridview.aspx (http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.gridview.aspx)

Method 2: Use the Response.Flush method

If you use a loop in the ASP file to build a large table or construct data, you can use the Response.Flush method. When you use this method, you can still use buffering. However, you also have complete control over the amount of data that is sent to the Web client, and you can control the buffer size of the response. For more information about the Response.Flush method, visit the following MSDN Web site:

http://msdn2.microsoft.com/en-us/library/ms525560.aspx

Method 3: Disable buffering

You can disable buffering on the Web server, at the application level, or at the page level. When you disable buffering, the Web server uses HTTP chunked-transfer encoding to send the response to the Web client.

To disable buffering at the application level, you can use the AspBufferingOn IIS metabase property. For more information about the AspBufferingOn IIS metabase property, visit the following Microsoft Web site:

http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/fbe1bd5f-52d4-4a26-8ab1-7bb897bb3d53.mspx (http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/fbe1bd5f-52d4-4a26-8ab1-7bb897bb3d53.mspx)

To disable buffering at the page level, you can use the Response.Buffer property. For more information about the Response.Buffer property, visit the following MSDN Web site:

http://msdn2.microsoft.com/en-us/library/ms526001.aspx

Method 4: Increase the buffer limit

You can increase the buffering limit if one of the following conditions is true:

•	The client is not a Web browser.
•	You cannot redesign the application to take advantage of a paging technology, such as the GridView class.

If you must increase the buffer limit, select a buffer limit that allows for the largest known response size. If you do not know the largest response size in advance, you can increase the buffer limit to a large value during testing. After you finish testing, use the largest value that is in the sc-bytes field in the IIS log file for the response that is generated for the page.

To increase the buffering limit, follow these steps:

1.	Click Start, click Run, type cmd, and then click OK.
2.	Type the following command, and then press ENTER: cd /d %systemdrive%\inetpub\adminscripts
3.	Type the following command, and then press ENTER: cscript.exe adsutil.vbs SET w3svc/aspbufferinglimit `LimitSize` Note `LimitSize` represents the buffering limit size in bytes. For example, the number 67108864 sets the buffering limit size to 64 MB.

To confirm that the buffer limit is set correctly, follow these steps:

1.	Click Start, click Run, type cmd, and then click OK.
2.	Type the following command, and then press ENTER: cd /d %systemdrive%\inetpub\adminscripts
3.	Type the following command, and then press ENTER: cscript.exe adsutil.vbs GET w3svc/aspbufferinglimit

Blogger JSON feed and a JSON recent posts widget

2008-09-18T07:00:00.000-07:00

What is a JSON-Feed?

Your Blogger Blog generates newsfeeds that can be read by Newsreaders. The standard feeds are RSS-feeds, using the XML-standard, or Atom-feeds.
But if you want to use the contents of your feeds in another web-applications, you need access to the feed to read its contents and display them on your webpage. The XML-file that contains your feed is located on one of the servers of Blogger, inside the blogger.com domain. For security reasons, browsers will not allow accessing XML-files on other domains. So if your webpage is not inside the blogger.com domain, how can we get access to it?
This is where the JSON-feed comes in handy.
JSON means: JavaScript Object Notation. A JSON-feed is not formatted as an XML-file, but as a Javascript Object. To make it accessible cross-domain, we use a call-back function. In plain English: we ask the Blogger Server to hand over the JSON-object to a function that we have written, and this function parses the JSON-object to retrieve the feed. And because it is already a Javascript Object, parsing it is very easy.

Getting the JSON-feed

To get the JSON-feed, we need the following Javascript code on our Blog:

Replace yourblog with the name of your blog. You will also have to write a Javascript function showfeedcontent(json), that takes the JSON-object and parses it.

Examining the feed

Open Notepad, and copy the following code to a new document. Save the document as a HTML-document (e.g. parser.html). Again, replace yourblog with the name of your blog.
Then, open the document in your browser, and it will display the contents of your feed. In fact: it will display the contents of any JSON-object. Try it out with Google Calendar, and you will be able to see the contents of that feed too. This small and simple html-page is a powerfull tool to examine th structure of JSON-objects, so that you can write a parser for it.

How to parse a JSON-feed

In the table below the most important elements of the JSON object structure are explained.

Object	Meaning	Example content
json	The JSON-object	-
json.feed	The feed	-
json.feed.title.$t	Blog name	Beautiful Beta
json.feed.updated.$t	Date and time of last feed update	2007-03-18, 20:43
json.feed.author[]	Array of Blog author names	-
json.feed.author[0].name.$t	Name of first Blog author	Beta Bloke
json.feed.openSearch$totalResults	Number of posts in the Blog	74
json.feed.entry[]	Array of Blog entries	-
json.feed.entry[i].title.$t	Title of the i^th post	What's up here?
json.feed.entry[i].category[]	Array of labels of i^th post	-
json.feed.entry[i].category[j].term	j^th label of i^th post	tools
json.feed.entry[i].published.$t	Date and time i^th post was published	2007-03-18, 12:27
json.feed.entry[i].updated.$t	Date and time i^th post was updated	2007-03-18, 12:35
json.feed.entry[i].author[]	Array of i^th post author names	-
json.feed.entry[i].author[0].name.$t	Name of first author of i^th post	Beta Bloke
json.feed.entry[i].content.$t	The content of the i^th post, as html	It has been very quiet on ….
json.feed.entry[i].link[]	Array of links of the i^th post	Explained below

The feed contains links for each entry, in the array json.feed.entry[i].link[]. One of those links is the permalink to the post. Its "rel"-field is set to "alternate". Its "href"-field contains the url of the post-page.
Now let's take a look at the json.feed.link[]-array. This array contains some usefull links as well.
One of these links has its "rel"-field set to "alternate"; its "href"-field holds the url of your blog's main page. Another link has its "rel"-field set to "next"; its "href"-field holds the url for calling the next 25 feed entries.

A basic Recent Posts Widget

Now, with this knowledge, we can write a basic Recent Posts Widget, that has the following functionality:

List 5 most recent posts
Display post title
Display link to the post
Display post date
Display post author
Display first 100 characters of post content

You can copy the code below to a new Notepad-document, and save it as html. Replace yourblog with the name of your blog. Open the file in your browser to see your widget at work.

Beautiful Beta

beautifulbeta.blogspot.com

Forms Authentication - Redirect Page and http to https problem

2008-09-17T07:00:00.000-07:00

A worthy article by Harish Ranganathan about FormsAuthentication, my experience on this is when we didn't use RedirectFromLoginPage to navigate, must call SetAuthcookie() to authenticate our privilege. After that, just use ourself navigation. Some variable in Require.ServerVariables are useful for this purpose.

If Request.ServerVariables("SERVER_PORT")=80 Then 'If Request.ServerVariables("HTTPS")= "on"
      Dim strSecureURL
      strSecureURL = "https://"
      strSecureURL = strSecureURL & Request.ServerVariables("SERVER_NAME")
      strSecureURL = strSecureURL & Request.ServerVariables("URL")
      Response.Redirect strSecureURL
   End If

----

In this article I will explain how to redirect users to a specific page rather than the generic default.aspx upon successful authentication of the user.

While using ASP.NET Forms authentication, if we try to access a protected page, the user would be taken to the login.aspx page with the ReturnUrl parameter having the path for the originally requested page.

Once, the user's credentials are verified, the RedirectFromLoginPage method can be used to take the user back to the originally requested page.

However, if there is no specified ReturnUrl, then FormsAuthentication by default takes the user to the default.aspx page upon successful authentication.

If we do not have a default.aspx page or we want to take the users to our custom page etc., then we can use the Setauthcookie method to set the cookie and then redirect users to our desired page. The following code establishes the same.

// Once the user's entered credentials are verified //
if(Request.Params["ReturnUrl"] != null)
{
FormsAuthentication.RedirectFromLoginPage(txtUserName.text, false);
}
else
{
FormsAuthentication.SetAuthcookie(txtUserName.text, false);
Response.Redirect("CustomPage.aspx");
}

The above code first verifies whether there is any ReturnUrl parameter such that if exists, it should take to the originally requested page.

Else, it sets the authcookie and then redirects user to a custom page.

The txtUserName is the ID of the textbox which is used to capture the username.

This article applies to ASP.NET 1.0 & 1.1 Versions.

Harish Ranganathan

ASP.NET authentication with SSL and http to https, https to http problems

2008-09-16T07:00:00.000-07:00

So you read the available documentation an put together the basic Forms authentication framework for an ASP.NET application (for which there’s a good article by Abel Banda on O’Reilly) and you say to yourself, boy it really sucks that these passwords are being sent over the internet unencrypted; which leads to the next logical step of using SSL for the login.aspx page.

The steps to follow are these:

1. Add a server certificate to the web site root folder (Internet Information ServicesàDefault Web SiteàPropertiesàDirectory SecurityàServer Certificate…)

2. Create folder in your web app for which you will require SSL access. Call it “ssl”.

3. Move your login.aspx file to ssl/login.aspx.

4. Make sure the NTFS security settings on the web application folder includes the anonymous IIS user account (IUSR_machine typically).

5. Disable Integrated Windows authentication and make sure Anonymous access is enabled for the web app (Internet Information Servicesàweb app folderàPropertiesàDirectory SecurityàAnonymous access and authentication controlàEdit…)

6. Require SSL for your ssl folder (Internet Information Servicesàssl folderàPropertiesàDirectory SecurityàServer Certificate…àcheck the “Require Secure Channel” box.)

7. Modify the loginURL attribute of the Forms element in your web.config file to reference the new login.aspx location with an absolute url beginning with “https://”.

8. Test your application.

At this point if you’re like me, a few things will begin to annoy you. First you’ll be reminded that you can’t debug under Visual Studio 2003 without Integrated Windows authentication. That’s okay. Leave it off for now. Just open a browser and manually try to hit your test page.

Again, if you’re like me, you should be getting a 401.2 error attempting to get the login.aspx page.

You might even try directly accessing the login page from the browser with https – no good. And you might try changing the loginUrl back to a relative url (“ssl/login.aspx”) and requesting your test page with https. Wow! That works!?! Hmm… You might also test what happens if you change the “deny users=”?”” to “deny users=”bob””. Again it works accessing each page with https, but you’ve given up forcing the redirect to the login page. If you actually tried any of these things, put things back the way they were and move on to the solution.

Add this in front of your existing element in the web.config file:

<system.web>

authorization>

system.web>

location>

This block tells the authorization logic to explicitly allow the anonymous user to access the ssl/login.aspx page and overrides the blanket deny element that comes later. There seems to be some special case code that handles relative login URLs but fails on absolute login URLs.

Change your loginUrl attribute back to an absolute “https://” url and the authentication should work.

One annoyance remains: The ReturnUrl passed to the login page doesn’t include the request scheme (the “http://” part) so you end up stuck in SSL after you login.

So I tried taking charge of the redirect URL with the following code. Thanks to Scott Hanselman for the xml timeout hack, and yes, it needs better packaging for production:

System.Xml.XmlDocument x =new System.Xml.XmlDocument();

x.Load(Request.PhysicalApplicationPath + "web.config");

System.Xml.XmlNode node = x.SelectSingleNode("/configuration/system.web/authentication/forms");

int timeout = int.Parse(node.Attributes["timeout"].Value, System.Globalization.CultureInfo.InvariantCulture.NumberFormat);

string userData = "Place application specific data for this user here.";

FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(

UserName.Value,

System.DateTime.Now,

System.DateTime.Now.AddMinutes(timeout), // Should be timout from web.config

PersistCookie.Checked,

userData,

FormsAuthentication.FormsCookiePath);

string encTicket = FormsAuthentication.Encrypt(ticket);

Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));

string url = FormsAuthentication.GetRedirectUrl(UserName.Value, PersistCookie.Checked);

Uri uri = Request.Url;

url = uri.Scheme.Replace("https", "http") + "://" + uri.Host + url;

Response.Redirect(url, true);

That does the trick but generates a very annoying Security Alert dialog (“You are about to be redirected to a connection that is not secure.”).

To avoid this warning which is intended to remind naïve users that they are being taken away from the protection of https by the never-to-be-trusted server you must arrange for the client to request the shift back to non-SSL traffic.

Instead of the “Response.Redirect(url, true)” at the end of the previous block of code, replace it with:

(FindControl("RedirectUrl") as System.Web.UI.HtmlControls.HtmlInputHidden).Value = url;

And merge the following bit of code into the login.aspx file:

That should do it. Nothing could be simpler…. J

The following notes are from Jason Loader,

2005-04-08

Hi Tone,
You know, you're the only person whose posted a solution to this problem I could find. Anyway, I was getting a windows login prompt/401.2 error (I was using Anonymous/Integrated Authentication on IIS), which was odd, as my application uses role-based security, but I'd already given anonymous/all users access to the login page via a location element. I tried what you suggested, but it still didn't work (it did get rid of the windows login prompt though), I couldn't find an explicit solution to the problem, but it would appear that the answer is actually in the Duwamish 7.0 sample.
You need to give the login page subdirectory it's own web config file that gives access to it for all users (that's all that needs to be in there) if you want to hard code the absolute url in the forms loginurl e.g.
In the application web.config file, you'd put -

In the Secure subdirectory web.config file, you'd put -



then remove the location section for the login page from the main app config file (the bit below) -





From what I can tell, it's probably something to do with ASP.NET not picking up the authentication from the config file for the sub directories correctly when using absolute urls, as it works when you use relative urls and SSL for the whole site.
However, you still had to change the config file if you moved the directories, changed the server name etc. With a bit of playing about, I found that you can force Forms Authentication to use SSL without hard-coding HTTPS in the loginURL by using the following code in globals.aspx -
Sub Application_EndRequest(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.EndRequest
Dim responseURI As System.Uri
Dim responseURIBuilder As System.UriBuilder
Dim pageName As String
' check to see if we're being redirected to the login page
If Not Response.RedirectLocation Is Nothing AndAlso Response.RedirectLocation.Length > 0 Then
' load the redirect into the uri
responseURI = New System.Uri(Request.Url,
Response.RedirectLocation)
pageName = GetPageFromURL(responseURI.AbsolutePath).ToLower()
If pageName = "login.aspx" AndAlso responseURI.Scheme <> "https"
Then
' force it to be HTTPS
responseURIBuilder = New System.UriBuilder(responseURI)
responseURIBuilder.Scheme = "https"
' remove the port number from the url and write it back
Response.RedirectLocation = Replace(responseURIBuilder.ToString(), ":" & responseURIBuilder.Port & "/",
"/")
ElseIf pageName <> "login.aspx" AndAlso responseURI.Scheme = "https" Then
' force it to be HTTP
responseURIBuilder = New System.UriBuilder(responseURI)
responseURIBuilder.Scheme = "http"
' remove the port number from the url and write it back
Response.RedirectLocation = Replace(responseURIBuilder.ToString(), ":" & responseURIBuilder.Port & "/",
"/")
End If
End If
End Sub
GetPageFromURL is a function which gets the page from a URL string, there's plenty of examples out there if you need to do the same.
What Duwamish does is automatically prefix absolute urls in the aspx files so you can turn SSL on and off through web.config, but I prefer to do that in the vb code so I can use relative links. One thing I haven't done is check that the login page is always being requested over secure sockets and if not force it to be, but you can get round that through IIS configuration (just in case you don't configure IIS and someone tries to access the login page directly). The next step is to make this configurable, like Duwamish is, and possibly picking up the HTTP/HTTPS ports if you've changed them (I've only tried it on default ports with IE).

Cheers,

Jason Loader
Software Developer, GVAS
Wealth Management Software PLC
E-mail: jason.loader@wms-plc.com

Efficient debug in Visual Studio 2005

2008-09-15T07:00:00.000-07:00

What percentage of your development time would you say that you spend debugging code? Here are some useful debugging techniques for developer productivity.

Most developers I've talked to say they spend anywhere from 30% to 50% or more of their time -- not writing the code -- but debugging and fixing it. Not only do we use the debugger to check code we've written before we can go on to write some more, we also use it in testing a completed project under various scenarios. And when there is a complaint about deployed code, we often need to resort to running it in debug mode to attempt to isolate and identify the reported problem.

With Visual Studio 2005, the debugging environment has become vastly superior to anything previously available. Developers migrating from other platforms to .NET often revel in the greatly superior debugger support we have in .NET, compared to what they have to work with in other environments.

Common logic would dictate that the better you are at a particular skill, the less time you will spend doing it and therefore the more efficient you become at the overall process. However, its a known fact that the debugging skills of a majority of developers consist primarily of knowing how to set a breakpoint with the F9 key or clicking the left margin on a line to set a breakpoint. An even bigger advance we master is how to write "System.Diagnostics.Debug.WriteLine(e.Message +e.StackTrace)" inside a catch block, set a breakpoint on it, and read the exception information (doh!).

How many developers do you know that routinely use the locals, autos, call stack, watch, quickwatch, or the "this" window? Who know there are at least two documents in the documentation tree for Visual Studio that describe the debuggers? How many know you can change the value of a variable in any of the debug-related windows, or that you can set multi-statement breakpoints on a single line of code? Who knows how to debug a single thread in a multithreaded application?

In this short piece, I'll share a few of the (what I think are) cool debugger techniques I've learned, as well as point you to some resources on debugging, and if you have a particular technique or trick you'd like to share, you can post it on our article discussion board.

Tip: Call Stack Window Debugging: Many developers are not aware that you can set breakpoints in the Call Stack Window (except when doing SQL debugging). Just highlight the call you want to stop on and either press F9 or right-click on the line and select Insert Breakpoint from the shortcut menu. You can also right-click on any breakpoint in the Call Stack Window to enable, disable or set the properties of the breakpoint. For those unfamiliar with the Call Stack Window, this is how you find out "how did I get here" - it enables you to go back up the call stack to find out "from where" the method that you are in was called. Not only can you see where it was called from, you can actually go "Back there" and trace the exact execution path in the debugger. Not to be an evangelist, but if you haven't discovered it yet, please do so now and "get religion".

Tip: Use Run to Cursor for one-shot breakpoints: All you need to do is right-click on the line you want and choose "Run to Cursor" from the menu, and program execution will immediately continue to the point where you are at. Many developers are not aware that this is available from both debugging and editing. In edit mode, this will actually start the debugger and run your program to the cursor location. As with breakpoints, right-clicking in the Call Stack window pops up the shortcut menu that also offers this feature.

Tip: Set sub-expression breakpoints: For example, if you have the expression:

for (int j=0; m=0;j

when debugging, and you click in the margin next to the line, the breakpoint doesn't extend on the subexpressions that do the incrementing. By placing the cursor in the j++ or m-- portion of the line and hitting F9, you can set multiple breakpoints on the subexpressions and view these as separate entries in the Breakpoints window.

Tip: Use the BreakPoints Window: If you know the name of the class and method you want to break on, you can choose New from the Breakpoints window and type it directly into the Function area of the window. Developers can spend 15 minutes wandering through their projects opening files just so they can position the cursor over a line of code and hit the F9 key to set a breakpoint. If you know the name of the class and method, doing it this way will find it and set the breakpoint. In addition, you can click it in the Breakpoints list of the window and go to the location automatically.

You can also set a breakpoint by just entering the method name, if it is unique in your application. And, if it isn't you will actually get a list of ALL the locations where the method can be found, which is extremely useful for setting multiple breakpoints on a commonly used function throughout your project. It also displays for overloaded methods in the same class.

Tip: Use the Find ComboBox: If you enter a method name in the Find Box (that's on the top menu bar, just to the right of the Configuration dropdown that reads Debug, Release, Configuration Manager) and hit F9, this will also find the method and set a breakpoint.

Tip: Use Hit Counts: In the Breakpoints window, when you right-click and choose Properties and then click the Hit Counts button, you can modify a breakpoint with four possible combinations of choices. Experiment with this to see how useful it can be. What makes this especially useful is that when you have stopped in the Debugger, it tells you how many times your breakpoint has executed. You can also create conditional expressions that will trigger the debugger only if your expression evaluates to true or has changed since the last time it was evaluated.

Tip: Use the Watch window (and its brethren): The power offered by the Watch window and its close cousins, the Quick Watch Dialog, Autos window, Locals window, and the This / Me window are what can make the difference between hopping around aimlessly all day looking for a bug and quickly solving a problem. Also, you can use any of these windows to change a variable's value by simply typing in a new value.

Tip: Break only when a specific thread calls a method: To set a per-thread breakpoint, you need to uniquely identify a particular thread that you have given a name with its Name property. You can set a conditional breakpoint for a thread by creating a conditional expression such as "ThreadToStopOn" == Thread.CurrentThread.Name .

You can manually change the name of a thread in the Watch window by watching variable "myThread" and entering a Name value for it in the value window. If you don't have a current thread variable to work with, you can use Thread.CurrentThread.Name to set the current thread's name. There is also a private integer variable in the Thread class, DONT_USE_InternalThread, this is unique to each thread. You can use the Threads window to get to the thread you want to stop on, and in the Watch window, enter Thread.CurrentThread.DONT_USE_InternalThread to see the value of it so you can create the right conditional breakpoint expression.

Tip: Use Assertion Debugging: The idea behind asserts is very simple: When you are writing code, you understand that some condition is always expected to be true. If that condition is ever not true, then there is a bug. Asserts can be written so that if this condition is ever not true, the debugger will be launched at that exact point in your code:

System.Diagnostics.Debug.Assert (myValue >=0)

The nice thing about Assert windows is that they not only give you the opportunity to break or not, they also show you the stack trace at that point. A very powerful, yet highly under-utilized feature.

That's it for now. You can find out about the above tips and much more by reading some of the following books (there are many others besides these):

Debugging Applications for Microsoft .NET and Microsoft Windows by John Robbins (MS Press)

Debugging Strategies for .NET Developers by Darin Dillon (aPress)

Comprehensive VB.NET Debugging by Mark Pearce (aPress)

Finally, consider looking over the following documents:

in the Documentation or on MSDN Online in the section "Building Debugging and Testing":

http://msdn2.microsoft.com/en-us/library/d8k88a0k(vs.80).aspx

By Peter Bromberg

Pass parameters to Install Shield ( MSI ) setup project

2008-09-14T19:22:00.000-07:00

12-31-2003, 05:06 PM

I have an InstallScript MSI project and I am trying to pass the command line parameters /z”abc” to setup.exe through the CmdLine entry in the setup.ini. It doesn’t seem to be working. If I do it directly by typing:

setup.exe /z”abc”

Everything works great and CMDLINE is equal to “abc”. However, if I edit the setup.ini to read:

[Startup]
CmdLine=/z”abc”

It doesn’t seem that anything gets into the variable CMDLINE in InstallScript.

Does anyone have any ideas?

mr_anderson

01-02-2004, 03:27 AM

The values specified in the CmdLine get passed to msiexec and not to setup.exe. Thus the command line specified in setup.ini actually gets passed to msiexec's command line as /v"".

Hope this helps.

cindyj

01-12-2004, 04:47 PM

You might be correct that this is how it works. However, IS's documentation says nothing about that. If there is no way to get /z to work from CmdLine in setup.ini then functionality has been lost if you have upgraded from IS Professional. This seems like a bug to me and I hope IS has a work order for it.

http://documentation.installshield.com/robo/bin/robo.dll?tpc=%2frobo%2fprojects%2fhelplibdevstudio9%2fsetupini.htm%3frinolog28301%3dt&mgr=agm&wnd=installshieldlivinghelp%7cmain%20window

CmdLine
Setup reads the command line parameters specified in Setup.ini first, and then appends any command line parameters passed to Setup.exe from the command prompt.

kmoulton

06-29-2004, 02:18 PM

I am using DevStudio 9. I have an InstallScript MSI project.

How do you pass a command line parameter to setup.exe using Setup.ini?

Is it true that "CmdLine=" in Setup.ini only passes this command to msiexec and not to setup.exe?

I realize that I can pass a command line variable to setup.exe using:

setup.exe /z"Whatever".

I would have expected that using CmdLine=/z"Whatever" in setup.ini would have passed this command line variable to setup.exe. However, it does not.

Has this functionality been lost?

Thanks,

--Kim

cindyj

06-29-2004, 02:26 PM

Unfortunately, I have never been able to get this to work and it is my opinion that it is functionality that has been lost. I hope someone at IS will read this and do something about it. PLEASE!!!!

Christopher Painter

06-29-2004, 04:11 PM

Setup /Z and CMDLINE is for InstallScript MSI projects only, not Basic MSI projects.

If you really want to be able to pass data to MSI from the setup.ini then I suggest you just declare a public MSI property and pass the data with a setup /v"PROP=DATA"

For example public MSI property PROP

setup /v"PROP=DATA"

or setup.exe with setup.ini

[Startup]
CmdLine=TEST=OOPS

You have to remember MSI is not InstallShield Professional. Natively MSI only knows what an MSI file is and its processed by msiexec. Setup.exe is just a wrapper EXE that tries to bring the files along and transfer control to MSIEXEC. Basic MSI doesn't understand what CMDLINE is or what /Z is, only InstallScript projects do. Personally I avoid InstallScript projects because they are a combination of the worst of pure IShield Pro and MSI.

cindyj

06-29-2004, 05:03 PM

As both Kim and I clearly state we are using InstallScript MSI projects, not everyone wants to use a Basic MSI. If you are wondering why this post is in the Windows Installer projects section and not in the InstallScript projects section, maybe it should be in the other section, but InstallScript MSI projects are neither just one nor the other, so they have ended up in both sections from what I can tell.

Your suggestion sounds like a good work around, but this is still lost functionality. DevStudio was advertised as bring InstallShield Professional and InstallShield Developer together into one software package. Setup.exe is a wrapper but it is from InstallShield so they should be able to fix this issue. If you are using an InstallScript or an InstallScript MSI project you still should be able to get information to CMDLINE via the setup.ini. Just because MSI is being used as the engine to install your files, it shouldn’t have any impact on this issue.

Personally, for very complex installs I find InstallScript MSI projects much friendlier to work with. I find Basic MSI’s, just that basic.

Christopher Painter

06-29-2004, 07:56 PM

Originally posted by cindyj
As both Kim and I clearly state we are using InstallScript MSI projects, not everyone wants to use a Basic MSI. If you are wondering why this post is in the Windows Installer projects section and not in the InstallScript projects section, maybe it should be in the other section, but InstallScript MSI projects are neither just one nor the other, so they have ended up in both sections from what I can tell.

They used to have 3 seperate forums, Professional , BasicMSI and InstallScript MSI. Now they only have Professional and WindowsInstaller with no distinction made for InstallScript MSI projects. Sorry I didn't realize you were doing an InstallScript MSI based on your posts.

Personally, for very complex installs I find InstallScript MSI projects much friendlier to work with. I find Basic MSI’s, just that basic.

Many of us find InstallScript MSI projects are just a hacked up combination of MSI and Professional technology.

Detecting Session Timeout in ASP.NET 2.0 Web Application

2008-09-11T07:00:00.000-07:00

Problem: An ASP.NET 2.0 web application needs to detect a session timeout condition so that the user can be redirected to a different page and / or an error message is displayed.
Solution: There are three ways of approaching this problem, starting off with the simplest one to the most complicated one. So, here it goes:

Using Session["xxx"] value to determine the session timeout: This is a "quick and dirty" hack that can be introduced into an application to figure out whether a timeout has occured. We need to do two things here.
First, in Global.asax, create your own GUID and put it in the session object,
    void Session_Start(object sender, EventArgs e)
    {
       // Code that runs when a new session is started
       Session["CustomSessionId"] = Guid.NewGuid();
    }

Second, BasePage.cs which would have inherited Page, in PageLoad() event, check whether the Session["CustomSessionId"] == null, if it IS null, it means that the session was timed-out and AspNet runtime cleared it out.
    if( Session["CustomSessionId"] == null)
    {
        Response.Redirect("TimeoutPage.htm");
    }
Using a combination of Session.IsNewSession and Request.Cookies collection: Leveraging the behavior of ASP.NET runtime, we can check whether the Session.IsNewSession flag is true, if its true and we find that Request.Cookies["ASP.NET_SessionId"] has a valid value, it means that a timeout occured and a new request was generated by the runtime. This code fragment can be inserted into the OnInit(...) method in the BasePage class so that it applies across the application.
protected override void OnInit(EventArgs e)
{
    base.OnInit(e);
    if (Context.Session != null)
    {
        //check whether a new session was generated
        if (Session.IsNewSession)
        {
                //check whether a cookies had already been associated with this request
                        HttpCookie sessionCookie = Request.Cookies["ASP.NET_SessionId"];
                        if (sessionCookie != null)
                        {
                                string sessionValue = sessionCookie.Value;
                                if (!string.IsNullOrEmpty(sessionValue))
                                {
                                     // we have session timeout condition!
                                    // Response.Redirect("SessionTimeout.htm");
                                     Session["IsSessionTimeOut"] = true;
                                }
                        }
         }
    }
}

WARNING:- We will have to wireup the "void Session_Start(object sender, EventArgs e)" method in the Global.asax to use the Session.IsNewSession meaningfully. ASP.NET 2.0 runtime is a bit weird in the sense that it will always return the value of Session.IsNewSession as true in case the Event is not wireup!
Using HTTP Module: Arguably the most complex but robust way to tackle this situation. I would rather not go into this as this carries the risk of opening security holes in the HTTP stream

from Nikhil's Blog

Build an ASP.NET Session Timeout Redirect Control

2008-09-10T07:00:00.000-07:00

We often get forum posts here asking "How can I tell if a user's Session is timed out, and perform some action in response?" Often this involves the incorrect assumption that the Session_End event can be used for this. ASP.NET implements a rolling timeout mechanism that extinguishes the session information for a user if no request is received within the timeout period. Session_End happens on the server automatically regardless of whether a user has requested a page, so the idea of using it to do anything other than cleanup-type operations is a mistake; it is independent of the page lifecycle and there is no active Request or Response object to access there.
It is often important for the business logic of an ASP.NET site to know for a particular request if the user’s session information is valid (e.g., a timeout has not occurred). Without this technique it is difficult to know, when a session variable is not found, whether it was never set properly or that the user simply waited too long between requests. Logic normally dictates that if a session is expired, any saved state needs to be recycled back to its starting state, and typically the user should also be required to re-authenticate to the site in order to enable them to start whatever process they abandoned again from the beginning.

ASP.NET developers habitually reference Session variables without ever checking for null first to see if they are actually present, which causes the "Object reference not set" exception. That yellow error page doesn't look very professional to the user, either.
So, I set out to do some more research and see what solutions might be possible. One of the ideas I got was that a site-wide session-expiry mechanism might be overkill, since usually only certain pages (such as those involved in a shopping cart) are involved in the need for protection against expired sessions. That's what brought me to think of the idea of a "drop on the page" Session Timeout "Detect and Redirect" Control. You should be able to just drop it on the pages that need it, set the redirect url, and you would be "good to go". (I should add here that based on some reader confusion in the posts below, if you do not need a page-specific solution, you can just use the Base Page class approach, or if you don't want to use a base Page class, instead you could write an HttpModule to do this and register it in web.config.)
The only credible information I found came from a source whose work I have relied on before, Robert Boedigheimer. Robert's original article about this may be viewed here. In sum, what Robert found was that the ASP.NET HttpSessionState class's IsNewSession( ) method returns true if a new session was created for a given request. If this is a new session but the ASP.NET_SessionId cookie is present, this indicates a timeout situation. You may need to think about this for a while, but eventually the logic should make sense. In addition, he determined that one must access this cookie from the Request Headers collection rather than the expected Cookie collection. This is because the intrinsic Response.Cookies and Request.Cookies objects actually share the same collection, and in this test we only want to inspect the actual cookie from the Request Headers.
With this information in hand, it was very easy to create a "non-visible" ASP.NET Server control that would hook and override a late Page LifeCycle event, PreRender, to perform this check. Add a public property for the RedirectUrl, call SignOut on any Forms Authentication to force the user to login to the site over again, and send them to the login page. Let's take a look at the code for the control:

namespace PAB.WebControls

{

using System;

using System.ComponentModel;

using System.Web;

using System.Web.Security;

using System.Web.UI;

[DefaultProperty("Text"),

ToolboxData("<{0}:SessionTimeoutControl runat=server>")]

public class SessionTimeoutControl : Control

{

private string _redirectUrl;

[Bindable(true),

Category("Appearance"),

DefaultValue("")]

public string RedirectUrl

{

get { return _redirectUrl; }

set { _redirectUrl = value; }

}

public override bool Visible

{

get { return false; }

}

public override bool EnableViewState

{

get { return false; }

}

protected override void Render(HtmlTextWriter writer)

{

if (HttpContext.Current == null)

writer.Write("[ *** SessionTimeout: " + this.ID + " *** ]");

base.Render(writer);

}

protected override void OnPreRender(EventArgs e)

{

base.OnPreRender(e);

if (this._redirectUrl == null)

throw new InvalidOperationException("RedirectUrl Property Not Set.");

if (Context.Session != null)

{

if (Context.Session.IsNewSession)

{

string sCookieHeader = Page.Request.Headers["Cookie"];

if ((null != sCookieHeader) && (sCookieHeader.IndexOf("ASP.NET_SessionId") >= 0))

{

if (Page.Request.IsAuthenticated)

{

FormsAuthentication.SignOut();

}

Page.Response.Redirect(this._redirectUrl);

}

In the OnPreRender event, we let the page control tree do it's thing first, then we do ours. First I check to see if the developer forgot to set the RedirectUrl property on the Control, because without that we would be all dressed up with no place to go. Then we check to see if there is actually a Session, and if so, we check the IsNewSession property. If it is true, we need to check our cookie, so we strip it out of the Request's Headers Collection and test for the "ASP.NET_SessionId" standard cookie name. If the sCookieHeader string is not null and the "ASP.NET_SessionId" cookie name is there, we know we have a timeout situation for this user. First we check to see if Authentication is being used and call the Forms SignOut method. This will ensure that the user must re-authenticate. Finally, we redirect the user to the specified redirect page on the site.
The beauty of this arrangement is that it requires no base page class to inherit from; you simply drop the control onto any page that needs to be involved in this process. Not only that, but because there is a separate instance of the control on each page that needs it, you could even have more than one RedirectUrl depending on the particular business logic, each presenting different information to the user. The downloadable solution below contains the source code and project for the Control, as well as a test web project with a starting page (that has the control) and a redirect page. The Session Timeout in the web.config is set to 1 minute so you can easily test it. This should work equally well in Visual Studio 2005 with ASP.NET 2.0.

by Peter A. Bromberg, Ph.D.

2008-09-09T07:00:00.000-07:00

namespace PAB.WebControls

{

using System;

using System.ComponentModel;

using System.Web;

using System.Web.Security;

using System.Web.UI;

[DefaultProperty("Text"),

ToolboxData("<{0}:SessionTimeoutControl runat=server>")]

public class SessionTimeoutControl : Control

{

private string _redirectUrl;

[Bindable(true),

Category("Appearance"),

DefaultValue("")]

public string RedirectUrl

{

get { return _redirectUrl; }

set { _redirectUrl = value; }

}

public override bool Visible

{

get { return false; }

}

public override bool EnableViewState

{

get { return false; }

}

protected override void Render(HtmlTextWriter writer)

{

if (HttpContext.Current == null)

writer.Write("[ *** SessionTimeout: " + this.ID + " *** ]");

base.Render(writer);

}

protected override void OnPreRender(EventArgs e)

{

base.OnPreRender(e);

if (this._redirectUrl == null)

throw new InvalidOperationException("RedirectUrl Property Not Set.");

if (Context.Session != null)

{

if (Context.Session.IsNewSession)

{

string sCookieHeader = Page.Request.Headers["Cookie"];

if ((null != sCookieHeader) && (sCookieHeader.IndexOf("ASP.NET_SessionId") >= 0))

{

if (Page.Request.IsAuthenticated)

{

FormsAuthentication.SignOut();

}

Page.Response.Redirect(this._redirectUrl);

}

by Peter A. Bromberg, Ph.D.

Hướng dẫn config và sử dụng ASP.NET Session State

2008-09-08T07:00:00.000-07:00

Với ASP.net trạng thái của session (session state) có thể được server lưu trữ dưới nhiều dạng khác nhau và mỗi dạng lưu trữ sẽ có những ưu điểm riêng.

Môi trường minh họa
- Operation: Windows XP sp2
- Webserver: IIS 6
- .netframework: 2.0
- SQL server 2005
Giới thiệu:

Đa số các ứng dụng web đều quản lý thông tin session khi ứng dụng đó có phân quyền. Với ASP.net trạng thái của session (session state) có thể được server lưu trữ dưới nhiều dạng khác nhau và mỗi dạng lưu trữ sẽ có những ưu điểm riêng. Trong bài này chúng ta sẽ tìm hiểu về các dạng lưu trữ session của asp.net và cách sử dụng nó.

Nội dung:
Các vấn đề thường gặp khi sử dụng sesson với asp cổ điền và khắc phục với asp.net
Với các lập trình viên asp thì session là một tính năng thật tuyệt vời nhưng vẫn còn tồn tại nhiều giới hạn:
§ Vấn đề Độc lập trong xử lý: asp session tồn tại luồng xử lý (process) của server đặt website, các tác động lên luồng xử lý của server đặt website đồng nghĩa với sự tác động lên session.
§ Vấn đề giới hạn Server farm : Với những server load balancing (chạy song song 2 hoặc nhiều server cho 1 website) session không thể chia sẻ giữa các server.
§ Vấn đề phụ thuộc cookie : Nếu trình duyệt disable cookie thì coi như session cũng đi theo ông bà luôn :D.
Những cải tiến của asp.net session state giải quyết các giới hạn của session dùng trong asp cổ điển:
§ Vấn đề Độc lập trong xử lý: asp.net session state có thể load độc lập với tiến trình xử lý của web server đặt website (the ASP.NET host process) như thế session vẫn có thể tồn tại khi tiến trình sử lý của webserver bị ngắt hoặc dán đoạn. Tất nhiên bạn cũng có thể config cho asp.net state làm việc giống asp cổ điển.
§ Vấn đề giới hạn Server farm : Với việc xử lý độc lập session thì asp.net có thể support luôn mô hình load balancing.
§ Vấn đề phụ thuộc cookie: mặc dù giải pháp không phụ thuộc cookie (cookieless) đã có từ thời asp nhưng sử dụng nó rất phức tạp. Với asp.net chỉ cần 1 thông số config là mọi chuyện ok.
Nơi config asp.net session state và giải thích thuộc tính khi config
Các thông tin config cho asp.net session state đều nằm trong tập tin web.config:

Các thuộc tính config trong element "sessionState":

Một ví dụ :

mode="StateServer"
cookieless="false"
timeout="20"
sqlConnectionString="data source=127.0.0.1;userid sa;password = your passwords"
stateConnectionString="tcpip=127.0.0.1:42424"
/>
Thuộc tính mode:

Attribute	Option	Description
mode		Chỉ định nơi lưu trữ trạng thái session
	Off	Tắt chế độ session
	InProc	Sử dụng giống asp cổ điển, nghĩa là tiến trình xử lý session sẽ chung với tiến trình xử lý webserver.
	StateServer	Trạng thái session được lưu trữ độc lập với tiến trình xử lý của webserver và được quản lý bởi 1 service chạy trên nền windows.Thông tin về service này được quy định bởi thuộc tính stateConnectionString. Hỗ trợ Load Balancing Với dạng lưu trữ này session chỉ có thể bị mất khi service đề cập ở trên ngưng hoạt động (không tính dzụ time out và tắt trình duyệt nha ^_^)
	SQLServer	Giống như StateServer nhưng trạng thái session đươc lưu trữ dưới database và thuộc tính sqlConnectionString sẽ chứa thông tin về cần thiết để truy cập database. Hỗ trợ Load Balancing Với dạng lưu trữ này session chỉ có thể mất khi time out hoặc khi bạn tắt trình duyệt

Thuộc tính cookieless: khi thuộc tình này có giá trị là true thì asp.net session state sẽ không sử dụng cookie để xửlý session. Lúc đó thông tin sẽ được lưu trữ ngay trên url và asp.net sẽ tự thêm vào url bình thường của bạn những chuỗi ký tự mã hóa. Ví dụ:

http://localhost/(lit3py55t21z5v55vlm25s55)/Appliction/SessionTest.aspx

§ Thuộc tính timeout: chứa giá trị quy định thời gian time out của session (tính bằng phút).

§ Thuộc tính sqlConnectionString: chứa chuỗi kết nối databse khi thuộc tính mode là SQLServer.

§ Thuộc tính stateConnectionString: chứa thông tin về server, port, giao thức truy cập host chứa db khi thuộc tính mode là SQLServer

Cách config các dạng lưu trữ session state trong web.config

1. InProc: khi mode được set giá trị này thì chỉ có thuộc tính timeout có tác dụng, với thiết lập này session của asp.net sẽ làm việc giống asp cổ điển.
Ví dụ: <sessionState mode="InProc" timeout="20" />

2. StateServer: để sử dụng được chế độ này bạn hãy khởi động service “Asp.net State service“

ví dụ: <sessionstate mode="stateserver" cookieless="false" timeout="20" />

3. SQLServer: Để sử dụng chế độ này bạn phải:

o Khởi động service “asp.net state service” giống như trên.

o Cài đặt database cho asp.net sesssion :
vào start --> run --> cmd
gõ lệnh : CD C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
gõ lệnh : osql –S [server name] –U [user] –P [password]
với [server name] là tên hosting, [User] là tên truy cập sql, [password]là password truy cập sql.
(ví dụ: osql -S kokichi\sqlexpress -U sa -P 123456
sau khi lện này chạy thành công, một database với tên “ASPState” sẽ được tạo để chứa dữ liệu của session.

o          Thiết lập thông tin trong web.config
   ví dụ:
   <sessionState
   mode="InProc"
   cookieless="false"
   timeout="20"
   sqlConnectionString="data source=127.0.0.1;user id=sa;password=123456"
   stateConnectionString="tcpip=127.0.0.1:42424"
/>

Tham khảo

http://www.codeproject.com/aspnet/ASPNETSessionInternals.asp

http://msdn2.microsoft.com/en-us/library/ms972429.aspx

How ASP.NET Sessions Are Implemented

2008-09-07T18:29:00.000-07:00

ASP.NET provides a framework for storing data that is specific to an individual user with the Session object. A page can add information to the Session object, and any other page can then retrieve the information for the same user. In order to preserve server memory, ASP.NET implements a rolling timeout mechanism which discards the session information for a user if no request is seen within the timeout period (default 20 minutes which is reset with each request).
It is often useful in an ASP.NET site to know for a particular request if the user’s session information is still intact (that a timeout has not occurred). One common need is to be able to inform the user why they lost their session information, by redirecting to a page that describes the timeout amount and how to avoid the problem in the future. Without this technique it is difficult to know if a session variable is not present whether it was never set properly or the user waited too long between requests. Many ASP.NET developers just reference session variables without first ensuring they are actually present. This causes the infamous "Object reference not set" exception, which can be very difficult to trace back to the specific cause. Code that checks for null session values is useful, but does not help the developer understand if it was never set properly or if the user just lost her session. This technique can help to clearly identify that the user waited to long between requests and the session storage information was removed.

This is not the same as using the Session_OnEnd event which can be used for cleanup, logging, or other purposes. It is also not for enforcing security on a web site.

How Sessions Are Implemented

Since the HTTP protocol used by web browsers to request files from web servers is stateless, ASP.NET needs to determine which requests were from the same user. The primary mechanism utilizes a non-persistent cookie that is issued by the web server that contains a session id value. The id provided by this cookie is the key used to index into the session infrastructure to access the user's specific data. The session framework is implemented by the HTTP module System.Web.SessionState.SessionStateModule, which executes before the .aspx page events. The module uses the EnableSessionState attribute from the @Page directive to determine if it must retrieve the user’s session information (and whether it needs to write out changes when the request is complete). If the EnableSessionState attribute is true (which it is by default), the module retrieves all of the user’s session information and sets the Session property of the Page class to an instance of the HttpSessionState class. This article focuses on the cookie mechanism, although a cookie-less method of sessions is implemented in ASP.NET (the session id is embedded in the URL string). The Session information can be stored in-process (default, stores in web server memory), with a state service, or a SQL Server database. This article will focus on the in-process storage, but the technique applies to all three locations.

Example User Session

A user opens a browser instance and requests an ASP.NET page from a site. If the EnableSessionState attribute is true, the session module adds the ASP.NET_SessionId cookie to the response. On subsequent requests to the same web site, the browser supplies the ASP.NET_SessionId cookie which the server side module uses to access the proper user’s information.

The ASP.NET HttpSessionState class provides a useful IsNewSession( ) method that returns true if a new session was created for this request. The key to detecting a session timeout is to also look for the ASP.NET_SessionId cookie in the request. If this is a new session but the cookie is present, this indicates a timeout situation. In order to implement this effectively for an entire web site, it is useful to utilize the “Base Page” concept described in a previous article.

basePageSessionExpire.cs

 public class basePageSessionExpire : System.Web.UI.Page
 {
    public basePageSessionExpire()
    {
    }


  override protected void OnInit(EventArgs e)
  {
       base.OnInit(e);


   //It appears from testing that the Request and Response both share the 
   // same cookie collection.  If I set a cookie myself in the Reponse, it is 
   // also immediately visible to the Request collection.  This just means that 
   // since the ASP.Net_SessionID is set in the Session HTTPModule (which 
   // has already run), thatwe can't use our own code to see if the cookie was 
   // actually sent by the agent with the request using the collection. Check if 
   // the given page supports session or not (this tested as reliable indicator 
   // if EnableSessionState is true), should not care about a page that does 
   // not need session
   if (Context.Session != null)
   {
    //Tested and the IsNewSession is more advanced then simply checking if 
   // a cookie is present, it does take into account a session timeout, because 
   // I tested a timeout and it did show as a new session
    if (Session.IsNewSession)
    {
     // If it says it is a new session, but an existing cookie exists, then it must 
   // have timed out (can't use the cookie collection because even on first 
   // request it already contains the cookie (request and response
     // seem to share the collection)
     string szCookieHeader = Request.Headers["Cookie"];
     if ((null != szCookieHeader) && (szCookieHeader.IndexOf("ASP.NET_SessionId") >= 0))
     {
      Response.Redirect("sessionTimeout.htm");
     }  
    } 
   }
  }
}

sessionTimeout.htm
This can be any page on the site, example just redirects to this page so just show a simple "A timeout has occurred" message for this article.
Each other page on the site just needs to derive from this new base page instead of the default System.Web.UI.Page, so just change the line in the code behind class from ": System.Web.UI.Page" to ": basePageSessionExpire". Each page should also set the EnableSessionState variable as appropriate:

false - page request does not access any session information (the base page uses this to know that it does not need to check for timeout on this request since it does not require session information)
ReadOnly - page request uses session information but does not modify it
true - page request reads and updates session information

Conclusion

It is often useful to know for a given request whether the user’s session information is still present. The technique demonstrated is a straightforward implementation that can be easily applied to an entire web site that uses cookie based ASP.NET Session objects.

by Robert Boedigheimer

About Html encoding, remind character entity references

2008-08-25T21:14:00.000-07:00

Here is indexes table for remind ASCII and Latin character entity references

ASCII Characters

This table shows the hex code, decimal code and entity name (if known) for the printable ASCII character set, omitting the letters and numbers.

Description               Hex Code    Code (Dec.)    Entity
=======================   ========    ===========    ==============
space                       %20         &#32;  ->  
!                           %21         &#33;  -> !
"                           %22         &#34;  -> "    " -> "
#                           %23         &#35;  -> #
$                           %24         &#36;  -> $
%                           %25         &#37;  -> %
&                           %26         &#38;  -> &    & -> &
'                           %27         &#39;  -> '
(                           %28         &#40;  -> (
)                           %29         &#41;  -> )
*                           %2A         &#42;  -> *
+                           %2B         &#43;  -> +
,                           %2C         &#44;  -> ,
-                           %2D         &#45;  -> -
.                           %2E         &#46;  -> .
/                           %29         &#47;  -> /
 
:                           %3A         &#58;  -> :
;                           %3B         &#59;  -> ;
<                           %3C         &#60;  -> <    < -> <
=                           %3D         &#61;  -> =
>                           %3E         &#62;  -> >    > -> >
?                           %40         &#63;  -> ?
@                           %41         &#64;  -> @
 
^                           %5E         &#94;  -> ^
_                           %60         &#95;  -> _
`                           %61         &#96;  -> `
 
{                           %7B         &#123;  -> {
|                           %7C         &#124;  -> |
}                           %7D         &#125;  -> }
~                           %7E         &#126;  -> ~

ISO Latin 1Characters

This shows the ISO Latin 1 (also known as ISO 8859-1) character set, excluding ASCII characters. Not all browsers will display all these characters correctly, and browsers seem to handle even fewer named entities than numeric codes. The list may not be complete.
For more information on special characters, one source is this site in Germany.

Description                           Code           Entity
===================================   ===========    ==============
non-breaking space                    &#160; ->      &nbsp; ->  
inverted exclamation mark             &#161; -> ¡    &iexcl; -> ¡
cent sign                             &#162; -> ¢    &cent; -> ¢
pound sign                            &#163; -> £    &pound; -> £
currency sign                         &#164; -> ¤    &curren; -> ¤
yen sign                              &#165; -> ¥    &yen; -> ¥
broken vertical bar                   &#166; -> ¦    &brvbar; -> ¦
section sign                          &#167; -> §    &sect; -> §
spacing diaresis                      &#168; -> ¨    &uml; -> ¨
copyright sign                        &#169; -> ©    &copy; -> ©
feminine ordinal indicator            &#170; -> ª    &ordf; -> ª
angle quotation mark, left            &#171; -> «    &laquo; -> «
negation sign                         &#172; -> ¬    &not; -> ¬
soft hyphen                           &#173; -> &endash;    &shy; -> &endash;
circled R registered sign             &#174; -> ®    &reg; -> ®
spacing macron                        &#175; -> ¯    &hibar; -> &hibar;
degree sign                           &#176; -> °    &deg; -> °
plus-or-minus sign                    &#177; -> ±    &plusmn; -> ±
superscript 2                         &#178; -> ²    &sup2; -> ²
superscript 3                         &#179; -> ³    &sup3; -> ³
spacing acute                         &#180; -> ´    &acute; -> ´
micro sign                            &#181; -> µ    &micro; -> µ
paragraph sign                        &#182; -> ¶    &para; -> ¶
middle dot                            &#183; -> ·    &middot; -> ·
spacing cedilla                       &#184; -> ¸    &cedil; -> ¸
superscript 1                         &#185; -> ¹    &sup1; -> ¹
masculine ordinal indicator           &#186; -> º    &ordm; -> º
angle quotation mark, right           &#187; -> »    &raquo; -> »
fraction 1/4                          &#188; -> ¼    &frac14; -> ¼
fraction 1/2                          &#189; -> ½    &frac12; -> ½
fraction 3/4                          &#190; -> ¾    &frac34; -> ¾
inverted question mark                &#191; -> ¿    &iquest; -> ¿
capital A, grave accent               &#192; -> À    &Agrave; -> À
capital A, acute accent               &#193; -> Á    &Aacute; -> Á
capital A, circumflex accent          &#194; -> Â    &Acirc; -> Â
capital A, tilde                      &#195; -> Ã    &Atilde; -> Ã
capital A, dieresis or umlaut mark    &#196; -> Ä    &Auml; -> Ä
capital A, ring                       &#197; -> Å    &Aring; -> Å
capital AE diphthong (ligature)       &#198; -> Æ    &AElig; -> Æ
capital C, cedilla                    &#199; -> Ç    &Ccedil; -> Ç
capital E, grave accent               &#200; -> È    &Egrave; -> È
capital E, acute accent               &#201; -> É    &Eacute; -> É
capital E, circumflex accent          &#202; -> Ê    &Ecirc; -> Ê
capital E, dieresis or umlaut mark    &#203; -> Ë    &Euml; -> Ë
capital I, grave accent               &#204; -> Ì    &Igrave; -> Ì
capital I, acute accent               &#205; -> Í    &Iacute; -> Í
capital I, circumflex accent          &#206; -> Î    &Icirc; -> Î
capital I, dieresis or umlaut mark    &#207; -> Ï    &Iuml; -> Ï
capital Eth, Icelandic                &#208; -> Ð    &ETH; -> Ð
capital N, tilde                      &#209; -> Ñ    &Ntilde; -> Ñ
capital O, grave accent               &#210; -> Ò    &Ograve; -> Ò
capital O, acute accent               &#211; -> Ó    &Oacute; -> Ó
capital O, circumflex accent          &#212; -> Ô    &Ocirc; -> Ô
capital O, tilde                      &#213; -> Õ    &Otilde; -> Õ
capital O, dieresis or umlaut mark    &#214; -> Ö    &Ouml; -> Ö
multiplication sign                   &#215; -> ×    &times; -> ×
capital O, slash                      &#216; -> Ø    &Oslash; -> Ø
capital U, grave accent               &#217; -> Ù    &Ugrave; -> Ù
capital U, acute accent               &#218; -> Ú    &amp;Uacute; -> Ú
capital U, circumflex accent          &#219; -> Û    &Ucirc; -> Û
capital U, dieresis or umlaut mark    &#220; -> Ü    &Uuml; -> Ü
capital Y, acute accent               &#221; -> Ý    &Yacute; -> Ý
capital THORN, Icelandic              &#222; -> Þ    &THORN; -> Þ
small sharp s, German (sz ligature)   &#223; -> ß    &szlig; -> ß
small a, grave accent                 &#224; -> à    &agrave; -> à
small a, acute accent                 &#225; -> á    &aacute; -> á
small a, circumflex accent            &#226; -> â    &acirc; -> â
small a, tilde                        &#227; -> ã    &atilde; -> ã
small a, dieresis or umlaut mark      &#228; -> ä    &auml; -> ä
small a, ring                         &#229; -> å    &aring; -> å
small ae diphthong (ligature)         &#230; -> æ    &aelig; -> æ
small c, cedilla                      &#231; -> ç    &ccedil; -> ç
small e, grave accent                 &#232; -> è    &egrave; -> è
small e, acute accent                 &#233; -> é    &eacute; -> é
small e, circumflex accent            &#234; -> ê    &ecirc; -> ê
small e, dieresis or umlaut mark      &#235; -> ë    &euml; -> ë
small i, grave accent                 &#236; -> ì    &igrave; -> ì
small i, acute accent                 &#237; -> í    &iacute; -> í
small i, circumflex accent            &#238; -> î    &icirc; -> î
small i, dieresis or umlaut mark      &#239; -> ï    &iuml; -> ï
small eth, Icelandic                  &#240; -> ð    &eth; -> ð
small n, tilde                        &#241; -> ñ    &ntilde; -> ñ
small o, grave accent                 &#242; -> ò    &ograve; -> ò
small o, acute accent                 &#243; -> ó    &oacute; -> ó
small o, circumflex accent            &#244; -> ô    &ocirc; -> ô
small o, tilde                        &#245; -> õ    &otilde; -> õ
small o, dieresis or umlaut mark      &#246; -> ö    &ouml; -> ö
division sign                         &#247; -> ÷    &divide; -> ÷
small o, slash                        &#248; -> ø    &oslash; -> ø
small u, grave accent                 &#249; -> ù    &ugrave; -> ù
small u, acute accent                 &#250; -> ú    &uacute; -> ú
small u, circumflex accent            &#251; -> û    &ucirc; -> û
small u, dieresis or umlaut mark      &#252; -> ü    &uuml; -> ü
small y, acute accent                 &#253; -> ý    &yacute; -> ý
small thorn, Icelandic                &#254; -> þ    &thorn; -> þ
small y, dieresis or umlaut mark      &#255; -> ÿ    &yuml; -> ÿ

more information at
http://www.w3.org/TR/html4/charset.html

http://www.astro.washington.edu/owen/ROFM_CGI/Documentation/SpecialChars.html

Javascript get mouse position ( compatible IE and Firefox )

2008-08-05T20:21:00.000-07:00

following javascript help we get position of mouse event ( compatible IE and Firefox )

var posx = 0;
var posy = 0;
if (!e)
e = window.event;
if (e.pageX || e.pageY){
posx = e.pageX;
posy = e.pageY;
}
else if (e.clientX || e.clientY){
posx = e.clientX + document.body.scrollLeft
+ document.documentElement.scrollLeft;
posy = e.clientY + document.body.scrollTop
+ document.documentElement.scrollTop;
}

* One note is window.event can not be access direct inside function on FireFox. Solution is pass "event" as parameter when invoke the event. For example :

<div id="xx" onmouseover="DoSomthing(event);">...</div>

within IE, it's ok if we does not provide any parameter as handled in above snippet:

if (!e)
e = window.event;

Microsoft standard Numeric Format Strings

2008-07-29T01:48:00.000-07:00

An useful collected .Net articles about "Microsoft standard numeric format strings".

MSDN

Example:

Dim a as Decimal = 123456789,789

txt.Text = a.ToString("N0")

result : 123.456.790

Standard numeric format strings are used to format common numeric types. A standard format string takes the form Axx where A is a single alphabetic character called the format specifier, and xx is an optional integer called the precision specifier. The format specifier must be one of the built-in format characters. The precision specifier ranges from 0 to 99 and controls the number of significant digits or zeros to the right of a decimal. The format string cannot contain white spaces.

If the format string does not contain one of the standard format specifiers, then a FormatException is thrown. For example, the format string "z" is interpreted as a standard numeric format string because it contains one alphabetic character, but the alphabetic character is not one of the standard numeric format specifiers so a FormatException is thrown. Any numeric format string that does not fit the definition of a standard numeric format string is interpreted as a custom numeric format string. The format string "c!" is interpreted as a custom format string because it contains two alphabetic characters, even though the character "c" is a standard numeric format specifier.

The following table describes the standard numeric format strings. Note that the result string produced by these format specifiers is influenced by the settings in the Regional Options control panel. Computers using different settings will generate different result strings.

Format specifier	Name	Description
C or c	Currency	The number is converted to a string that represents a currency amount. The conversion is controlled by the currency format information of the NumberFormatInfo object used to format the number. The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the default currency precision given by the NumberFormatInfo is used.
D or d	Decimal	This format is supported for integral types only. The number is converted to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. The precision specifier indicates the minimum number of digits desired in the resulting string. If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.
E or e	Scientific (exponential)	The number is converted to a string of the form "-d.ddd...E+ddd" or "-d.ddd...e+ddd", where each 'd' indicates a digit (0-9). The string starts with a minus sign if the number is negative. One digit always precedes the decimal point. The precision specifier indicates the desired number of digits after the decimal point. If the precision specifier is omitted, a default of six digits after the decimal point is used. The case of the format specifier indicates whether to prefix the exponent with an 'E' or an 'e'. The exponent always consists of a plus or minus sign and a minimum of three digits. The exponent is padded with zeros to meet this minimum, if required.
F or f	Fixed-point	The number is converted to a string of the form "-ddd.ddd..." where each 'd' indicates a digit (0-9). The string starts with a minus sign if the number is negative. The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the default numeric precision given by the NumberFormatInfo is used.
G or g	General	The number is converted to the most compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated by the following list. Byte or SByte: 3 Int16 or UInt16: 5 Int32 or UInt32: 10 Int64 or UInt64: 19 Single: 7 Double: 15 Decimal: 29 Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. The result contains a decimal point if required and trailing zeroes are omitted. If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, then the excess trailing digits are removed by rounding. If scientific notation is used, the exponent in the result is prefixed with 'E' if the format specifier is 'G', or 'e' if the format specifier is 'g'. The exception to the preceding rule is if the number is a Decimal and the precision specifier is omitted. In that case, fixed-point notation is always used and trailing zeroes are preserved.
N or n	Number	The number is converted to a string of the form "-d,ddd,ddd.ddd...", where each 'd' indicates a digit (0-9). The string starts with a minus sign if the number is negative. Thousand separators are inserted between each group of three digits to the left of the decimal point. The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the default numeric precision given by the NumberFormatInfo is used.
P or p	Percent	The number is converted to a string that represents a percent as defined by the NumberFormatInfo.PercentNegativePattern property or the NumberFormatInfo.PercentPositivePattern property. If the number is negative, the string produced is defined by the PercentNegativePattern and starts with a minus sign. The converted number is multiplied by 100 in order to be presented as a percentage. The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the default numeric precision given by NumberFormatInfo is used.
R or r	Round-trip	The round-trip specifier guarantees that a numeric value converted to a string will be parsed back into the same numeric value. When a numeric value is formatted using this specifier, it is first tested using the general format, with 15 spaces of precision for a Double and 7 spaces of precision for a Single. If the value is successfully parsed back to the same numeric value, it is formatted using the general format specifier. However, if the value is not successfully parsed back to the same numeric value, then the value is formatted using 17 digits of precision for a Double and 9 digits of precision for a Single. Although a precision specifier can be appended to the round-trip format specifier, it is ignored. Round trips are given precedence over precision when using this specifier. This format is supported by floating-point types only.
X or x	Hexadecimal	The number is converted to a string of hexadecimal digits. The case of the format specifier indicates whether to use uppercase or lowercase characters for the hexadecimal digits greater than 9. For example, use 'X' to produce "ABCDEF", and 'x' to produce "abcdef". The precision specifier indicates the minimum number of digits desired in the resulting string. If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. This format is supported for integral types only.

About ASP.NET Session State

2008-07-20T20:00:00.000-07:00

ASP.NET Session State

ASP.NET session state solves all of the above problems associated with classic ASP session state:

Process independent. ASP.NET session state is able to run in a separate process from the ASP.NET host process. If session state is in a separate process, the ASP.NET process can come and go while the session state process remains available. Of course, you can still use session state in process similar to classic ASP, too.
Support for server farm configurations. By moving to an out-of-process model, ASP.NET also solves the server farm problem. The new out-of-process model allows all servers in the farm to share a session state process. You can implement this by changing the ASP.NET configuration to point to a common server.
Cookie independent. Although solutions to the problem of cookieless state management do exist for classic ASP, they're not trivial to implement. ASP.NET, on the other hand, reduces the complexities of cookieless session state to a simple configuration setting.

Let's look at each of these features in more detail, including how the settings are configured.

Using ASP.NET Session State

Session state settings in ASP.NET are configured through the ASP.NET XML configuration file web.config. We'll look at web.config in more detail in a later column, but for this discussion of session state let's look at it briefly.

Web.config

There are two types of configuration files: a machine configuration file and an application configuration file, both named web.config. The two are identical, except that the machine configuration file applies settings to all applications but the application configuration files are either restrictive or expansive on an application-by-application basis.
In Beta 1, the machine web.config file is in the WinNT\Microsoft.NET\Framework\v1.0.2204 directory, while the optional application configuration files exist in the application's directory. Application web.config files are optional in the sense that if an application config.web file doesn't exist, the machine web.config settings are used instead. ASP.NET session state settings can be made in the machine web.config file and overridden in a particular application's web.config file.
Note: Changes made to web.config are applied immediately, unlike classic ASP, where the server has to be stopped and started for settings to take affect.

Session configuration

Below is a sample web.config file used to configure the session state settings for an ASP.NET application:

<configuration>  <sessionstate>      mode="inproc"      cookieless="false"
timeout="20"       sqlconnectionstring="data source=127.0.0.1;user id=<user id="">
;password=<password>"      server="127.0.0.1"       port="42424"   />
</password></user></sessionstate></configuration>

;The settings above are used to configure ASP.NET session state. Let's look at each in more detail and cover the various uses afterward.

Mode. The mode setting supports three options: inproc, sqlserver, and stateserver. As stated earlier, ASP.NET supports two modes: in process and out of process. There are also two options for out-of-process state management: memory based (stateserver), and SQL Server based (sqlserver). We'll discuss implementing these options shortly.
Cookieless. The cookieless option for ASP.NET is configured with this simple Boolean setting.
Timeout. This option controls the length of time a session is considered valid. The session timeout is a sliding value; on each request the timeout period is set to the current time plus the timeout value
Sqlconnectionstring. The sqlconnectionstring identifies the database connection string that names the database used for mode sqlserver.
Server. In the out-of-process mode stateserver, it names the server that is running the required Windows NT service: ASPState.
Port. The port setting, which accompanies the server setting, identifies the port number that corresponds to the server setting for mode stateserver.
In-process Mode
In-process mode simply means using ASP.NET session state in a similar manner to classic ASP session state. That is, session state is managed in process and if the process is re-cycled, state is lost. Given the new settings that ASP.NET provides, you might wonder why you would ever use this mode. The reasoning is quite simple: performance. The performance of session state, e.g. the time it takes to read from and write to the session state dictionary, will be much faster when the memory read to and from is in process, as cross-process calls add overhead when data is marshaled back and forth or possibly read from SQL Server.
In-process mode is the default setting for ASP.NET. When this setting is used, the only other session web.config settings used are cookieless and timeout.
Performance and Reliability Considerations
It's worth mentioning, briefly, some of the performance and reliability issues you should consider when using ASP.NET session state modes.
In process. In process will perform best because the session state memory is kept within the ASP.NET process. For Web applications hosted on a single server, applications in which the user is guaranteed to be re-directed to the correct server, or when session state data is not critical (in the sense that it can be re-constructed or re-populated), this is the mode to choose.
Out of process. This mode is best used when performance is important but you can't guarantee which server a user will request an application from. With out-of-process mode, you get the performance of reading from memory and the reliability of a separate process that manages the state for all servers.
SQL Server. This mode is best used when the reliability of the data is fundamental to the stability of the application, as the database can be clustered for failure scenarios. The performance isn't as fast as out of process, but the tradeoff is the higher level of reliability.

Microsoft Custom Numeric Format Strings

2008-07-17T07:00:00.000-07:00

MSDN .NET Framework Developer's Guide

If the standard numeric format specifiers do not provide the type of formatting you require, you can use custom format strings to further enhance string output. A standard format string consists of a single alphabetic character optionally followed by a sequence of digits that form a value between 0 and 99; all other format strings are custom format strings.
The following table shows the characters you can use to create custom numeric format strings and their definitions. Note that the result strings produced by some of these characters are influenced by the settings in the Regional Options control panel of the NumberFormatInfo object associated with the current thread. Computers using different cultures will generate different result strings.

Format character	Name	Description
0	Zero placeholder	If the value being formatted has a digit in the position where the '0' appears in the format string, then that digit is copied to the result string. The position of the leftmost '0' before the decimal point and the rightmost '0' after the decimal point determines the range of digits that are always present in the result string. The "00" specifier causes the value to be rounded to the nearest digit preceding the decimal, where rounding away from zero is always used. For example, formatting 34.5 with "00" would result in the value 35.
#	Digit placeholder	If the value being formatted has a digit in the position where the '#' appears in the format string, then that digit is copied to the result string. Otherwise, nothing is stored in that position in the result string. Note that this specifier never displays the '0' character if it is not a significant digit, even if '0' is the only digit in the string. It will display the '0' character if it is a significant digit in the number being displayed. The "##" format string causes the value to be rounded to the nearest digit preceding the decimal, where rounding away from zero is always used. For example, formatting 34.5 with "##" would result in the value 35.
.	Decimal point	The first '.' character in the format string determines the location of the decimal separator in the formatted value; any additional '.' characters are ignored. The actual character used as the decimal separator is determined by the NumberDecimalSeparator property of the NumberFormatInfo that controls formatting.
,	Thousand separator and number scaling	The ',' character serves two purposes. First, if the format string contains a ',' character between two digit placeholders (0 or #) and to the left of the decimal point if one is present, then the output will have thousand separators inserted between each group of three digits to the left of the decimal separator. The actual character used as the decimal separator in the result string is determined by the NumberGroupSeparator property of the current NumberFormatInfo that controls formatting. Second, if the format string contains one or more ',' characters immediately to the left of the decimal point, then the number will be divided by the number of ',' characters multiplied by 1000 before it is formatted. For example, the format string "0,," will represent 100 million as simply 100. Use of the ',' character to indicate scaling does not include thousand separators in the formatted number. Thus, to scale a number by 1 million and insert thousand separators you would use the format string "#,##0,,".
%	Percentage placeholder	The presence of a '%' character in a format string causes a number to be multiplied by 100 before it is formatted. The appropriate symbol is inserted in the number itself at the location where the '%' appears in the format string. The percent character used is dependent on the current NumberFormatInfo class.
E0 E+0 E-0 e0 e+0 e-0	Scientific notation	If any of the strings "E", "E+", "E-", "e", "e+", or "e-" are present in the format string and are followed immediately by at least one '0' character, then the number is formatted using scientific notation with an 'E' or 'e' inserted between the number and the exponent. The number of '0' characters following the scientific notation indicator determines the minimum number of digits to output for the exponent. The "E+" and "e+" formats indicate that a sign character (plus or minus) should always precede the exponent. The "E", "E-", "e", or "e-" formats indicate that a sign character should only precede negative exponents.
\	Escape character	In C# and the Managed Extensions for C++, the backslash character causes the next character in the format string to be interpreted as an escape sequence. It is used with traditional formatting sequences like '\n' (new line). In some languages, the escape character itself must be preceded by an escape character when used as a literal. Otherwise, the compiler interprets the character as an escape sequence. Use the string "\\" to display '\'. Note that this escape character is not supported in Visual Basic; however, ControlChars provides the same functionality.
'ABC' "ABC"	Literal string	Characters enclosed in single or double quotes are copied to the result string literally, and do not affect formatting.
;	Section separator	The ';' character is used to separate sections for positive, negative, and zero numbers in the format string.
Other	All other characters	All other characters are copied to the result string as literals in the position they appear.

Note that for fixed-point format strings (strings not containing an "E0", "E+0", "E-0", "e0", "e+0", or "e-0"), numbers are rounded to as many decimal places as there are digit placeholders to the right of the decimal point. If the format string does not contain a decimal point, the number is rounded to the nearest integer. If the number has more digits than there are digit placeholders to the left of the decimal point, the extra digits are copied to the result string immediately before the first digit placeholder.
Different formatting can be applied to a string based on whether the value is positive, negative, or zero. To produce this behavior, a custom format string can contain up to three sections separated by semicolons:

One section: The format string applies to all values.
Two sections: The first section applies to positive values and zeros, and the second section applies to negative values. If the number to be formatted is negative, but becomes zero after rounding according to the format in the second section, then the resulting zero is formatted according to the first section.
Three sections: The first section applies to positive values, the second section applies to negative values, and the third section applies to zeros. The second section might be left empty (by having nothing between the semicolons), in which case the first section applies to all nonzero values. If the number to be formatted is nonzero, but becomes zero after rounding according to the format in the first or second section, then the resulting zero is formatted according to the third section.

This type of formatting ignores any preexisting formatting associated with a number when the final value is formatted. For example, negative values are always displayed without a minus sign when section separators are used. If you want the final formatted value to have a minus sign, you should explicitly include the minus sign as part of the custom format specifier. The following example illustrates how section separators can be used to produce formatted strings.

[Visual Basic]

Dim MyPos As Double = 19.95

Dim MyNeg As Double = -19.95

Dim MyZero As Double = 0

Dim MyString As String = MyPos.ToString("$#,##0.00;($#,##0.00);Zero")

' In the U.S. English culture, MyString has the value: $19.95.

MyString = MyNeg.ToString("$#,##0.00;($#,##0.00);Zero")

' In the U.S. English culture, MyString has the value: ($19.95).
' The minus sign is omitted by default.

MyString = MyZero.ToString("$#,##0.00;($#,##0.00);Zero")

' In the U.S. English culture, MyString has the value: Zero.
[C#]double MyPos = 19.95, MyNeg = -19.95, MyZero = 0.0;

string MyString = MyPos.ToString("$#,##0.00;($#,##0.00);Zero");

// In the U.S. English culture, MyString has the value: $19.95.

MyString = MyNeg.ToString("$#,##0.00;($#,##0.00);Zero");

// In the U.S. English culture, MyString has the value: ($19.95).
// The minus sign is omitted by default.

MyString = MyZero.ToString("$#,##0.00;($#,##0.00);Zero");

// In the U.S. English culture, MyString has the value: Zero.

The following example demonstrates custom number formatting.

[Visual Basic]

Dim myDouble As Double = 1234567890
Dim myString As String = myDouble.ToString( "(###) ### - ####" )
' The value of myString is "(123) 456 – 7890".

Dim MyInt As Integer = 42
MyString = MyInt.ToString( "My Number " + ControlChars.Lf + "= #" )
' In the U.S. English culture, MyString has the value: 
' "My Number
' = 42".

[C#]Double myDouble = 1234567890;
String myString = myDouble.ToString( "(###) ### - ####" );
// The value of myString is "(123) 456 – 7890".

int  MyInt = 42;
MyString = MyInt.ToString( "My Number \n= #" );
// In the U.S. English culture, MyString has the value: 
// "My Number
// = 42".

Javascript format numbers with custom string

2008-07-16T07:00:00.000-07:00

When playing with Google for how to format numbers to custom string in JavaScript (like Microsoft numeric custom format string ), I found an excellent article by Xaprb.

for example : 111111 with format ###,###.00 will result as 111,111.00.

Current script support format of us ( use "," for thousand separating ), it's simple to replace "," by "." for "eu" format.

Try demo and visit above link if you're interested in this ;)

Javascript Trim string

2008-07-15T19:27:00.000-07:00

var trimmed = str.replace(/^\s+|\s+$/g, '') ;

that's all.

Understand ASP.NET Response.Redirect & Server.Transfer

2008-06-05T02:57:00.000-07:00

Today, i just found an excellent articles by Joydip Kanjilal while learning ASP.Net technique related to my current project. Try this, a worthy reading :)
moongy

By default, an ASP.NET web form posts back to itself whenever a postback operation occurs. That behavior wasn't terribly common in web pages before ASP.NET appeared, and isn't always what you want to have happen: What if you want to post a web form to another web page in the application? ASP.NET made that fairly difficult in ASP.NET 1.0, but ASP.NET 2.0 makes developers lives easier in this regard by adding a new feature called "cross-page postbacks" that allows a web page to post its data back to a different web page. In cross-page postbacks, the page that initiates the postback is called the source page and the page to which the client posts is called the target page.

Conveniently, the target page can still retrieve any control values posted by the source web page in a cross-page postback operation. In other words, from a development point of view, you can process the posted data in much the same way you would process any normal ASP.NET postback.

The new feature means ASP.NET 2.0 developers now have three techniques for transferring processing from one web page to another in an application: Response.Redirect, Server.Transfer, and the new cross-page postback features. You're probably familiar with the first two, so I'll review them only briefly, and then concentrate on how to use the cross-page postback feature, showing how it works and how it differs from the Response.Redirect and Server.Transfer techniques.

The Response.Redirect Method
The Response.Redirect method is by far the simplest method of redirecting processing from a source page to a different destination or target page in the same or even across different applications. When the web server receives a request for redirection, it sends a response header to the client that causes the client to send a new request back to the server. In other words, a redirect causes two request/response cycles: one for the original and one for the new redirected request.

ASP.NET makes redirects easy. The following code snippet illustrates how to use the Response.Redirect method:

   protected void Redirect_Click(object sender, EventArgs e)
{
   Response.Redirect("menu.aspx");
}

Note that the redirect request is a GET request, meaning that you can't post data from the original page via the Response.Redirect command. You can work around that to pass data from the source to the target by using query strings in the Response.Redirect method call as shown below:

   protected void Redirect_Click(object sender, EventArgs e)
{
   Response.Redirect("menu.aspx?userName=" + UserName.Text));
}

The preceding example passes a query string as a parameter to the Response.Redirect method along with the target URL. The target can now use code such as the following to retrieve the source's data as shown below:

   protected void Page_Load(object sender, EventArgs e)
{
   string userName = Request["userName"];
   //Other code
}

The Server.Transfer Method
Instead of relying on the client to make a request to a new page, Server.Transfer is a server-side redirection technique that simply changes the code's "focus" on the web server to a new page. Server.Transfer is far more efficient than Response.Redirect when the target page resides on the same web server, because it avoids the extra roundtrip and uses only server resources for the redirection. Note that it has a side effectâ€”the URL shown in the web browser does not change eitherâ€”meaning clients may think they posted their data to one page while actually posting it to a different page. In most cases, that's not a problem, but it can make debugging more difficult.

Server.Transfer also preserves the HttpContext of the initiating page; therefore the target page can access the control values of the source page. Specifically, you can use the FormsCollection property to retrieve the source control values from the target page when using the Server.Transfer technique. First, make sure you use the overloaded Server.Transfer method, which accepts two parametersâ€”the target URL, and a Boolean preserveForm value which tells the server to preserve the query string and any control values from the source page. Set the preserveForm parameter to true in the source web page as shown below:

   Server.Transfer("Menu.aspx",true);

Then, from the target page, to retrieve the value of a textbox control called txtUserName for example, use the following code:

   object obj = Request.Form["txtUserName"];

Response.Redirect vs. Server.Transfer
Because Response.Redirect requires an extra round trip, you should avoid it for high-volume web sites due to associated performance and scalability issues. However, this is the only technique that you can use to redirect from one web server to another. In contrast, Server.Transfer is more efficient, but can transfer execution only to a different web page on the same server. In essence, you'd use Server.Transfer to eliminate unnecessary roundtrips when both the source and the target web page reside on the same server (they can be in different ASP.NET applications on that server), and use Response.Redirect when you need to redirect to a different server.

Interact window service with command line

2008-05-13T18:55:00.000-07:00

Window service can be started at system boot, or at any other time, without the
need for any wrapper code to start the service. The service can be managed
using command-line tools ("net start",
"net stop", or sc.exe) or GUI tools (the Services administrative tool).

Installation

Most Windows OSes derived from Windows NT (such as Windows XP, Windows 2000,
Windows 2003 Server) provide a command-line tool for installing
services, called SC.EXE for "Service Control". To create a service for
svnserve, use SC.EXE:

sc create
binpath= "c:\myservice.exe --service "
displayname= "My Service Name"
depend= Tcpip //* explain this line later

where is any service name you want, e.g. "My Service Name", and

are the arguments to svnserve, such as --root,
--listen-port, etc. (All of this should be specified on a single
line, of course.)

If the path to the service contains spaces or other characters that
must be escaped, then you must enclose the path to it with
double-quotes, which themselves must be quoted using a backslash.
Fortunately the syntax is similar to that on Unix platforms:

sc create
binpath= "\"c:\program files\My Service\bin\myservice.exe\" ..."

SC has many options; use "sc /?". The most relevant are:

sc create create a new service
sc qc query config for a service
sc query query status
sc delete delete any service -- BE CAREFUL!
sc config ... update service config; same args as sc create
sc start start a service (does NOT wait for completion!)
sc stop stop a service (does NOT wait for it to stop!)

Note that the command-line syntax for SC is rather odd. Key/value
pairs are specified as "key= value" (without the double-quotes). The
"key=" part must not have any spaces, and the "value" part MUST be
separated from the "key=" by a space.

If you want to be able to see the command shell, add these arguments
to the "sc create" command-line:

type= own type= interact

This sets the "interactive" bit on the service, which allows it to
interact with the local console session.

You can create as many services as you need; there is no restriction
on the number of services, or their names. I use a prefix, like
"msv.foo", "msv.bar", etc. Each service runs in a separate process.
As usual, it is your responsbility as an administrator to make sure
that no two service instances use the same repository root path, or
the same combination of --listen-port and --listen-host.

Uninstalling
------------

To uninstall a service, stop the service, then delete it, using "sc
delete ". Be very careful with this command, since you can
delete any system service, including essential Windows services,
accidentally.

Also, make sure that you stop the service before you delete it. If
you delete the service before stopping it, the Service Control Manager
will mark the service "deleted", but will intentionally not stop the
service. The service will be deleted when the system reboots, or when
the service finally exits. After all, you only asked to delete the
service, not to stop it.

Automatically Starting Service on System Boot
---------------------------------------------

By default, SC creates the service with the start mode set to "demand"
(manual). If you want the service to start automatically when the
system boots, add "start= auto" to the command line. You can change
the start mode for an existing service using "sc config start=
auto", or also by using the Windows GUI interface for managing
services. (Start, All Programs, Administrative Tools, Services, or
just run "services.msc" from Start/Run or from a command-line.)

* Note: If the service had dependecies, in order for it to start correctly
on system boot, you must properly declare its startup dependencies.
The Service Control Manager will start services as early as it can,
and if you do not properly declare its startup dependencies ( ex. tcp/ip ),
it can potentially start before the TCP/IP stack has been started.
This is why you must provide specify 'depend= Tcpip' to SC.EXE when
creating the service in above example.

Starting and Stopping the Service
---------------------------------

You start and stop the service like any other Windows service. You
can use the command-line "net start ", use the GUI Services
interface.

Debugging
---------

Debugging a Windows service can be difficult, because the service runs
in a very different context than a user who is logged in. By default,
services run in a non-desktop environment. They cannot interact
with the user (desktop) in any way, and vice versa.

Also, by default, services run as a special user, called LocalSystem.
LocalSystem is not a "user" in the normal sense; it is an NT security
ID (SID) that is sort of like root, but different. LocalSystem
typically does NOT have access to any network shares, even if you use
"net use" to connect to a remote file server. Again, this is because
services run in a different login session.

Depending on which OS you are running, you may have difficulty
attaching a debugger to a running service process. Also, if you are
having trouble *starting* a service, then you can't attach to the
process early enough to debug it.

So what's a developer to do? Well, there are several ways you can
debug services. First, you'll want to enable "interactive" access for
the service. This allows the service to interact with the local
desktop -- you'll be able to see the command shell that the service
runs in, see console output, etc. To do this, you can either use the
standard Windows Services tool (services.msc), or you can do it using
sc.exe.

* With the GUI tool, open the properties page for a service, and go
to the "Log On" page. Select "Local System account", and make
sure the "Allow service to interact with desktop" box is checked.

* With SC.EXE, configure the service using the command:

sc config type= own type= interact

Yes, you must specify type= twice, and with exactly the spacing
shown.

In both cases, you'll need to restart the service. When you do, if
the service started successfully, you'll see the console window of the
service. By default, it doesn't print anything out.

Next, you'll want to attach a debugger, or configure the service to
start under a debugger. Attaching a debugger should be
straightforward -- just find the process ID. But if you need to debug
something in the service startup path, you'll need to have a debugger
attached from the very beginning. There are two ways to do this.

In the first method, you alter the command-line of the service (called
the "binary path"). To do this, use SC.EXE to set the binary path to
whatever debugger you are going to use. I use the most recent version
of WinDbg, which is excellent, and is available at:

http://www.microsoft.com/whdc/devtools/debugging/installx86.mspx

For example, this command would configure the service to start under a
debugger:

sc config binpath= "d:\dbg\windbg.exe -g -G d:\bin\myservice.exe
--root d:\path\root --listen-port 9000"
depend= Tcpip

The entire command must be on a single line, of course, and the binary
path must be in double-quotes. Also, the spacing MUST be: binpath= "..."

Substitute whatever debugger you want, with whatever command-line you
want, in place of windbg.exe. Then start the service (sc start
), and the Service Control Manager should execute the
command-line you provided as the binary path. Then your debugger
should start, and should launch the "myservice" process.

User objects and resources

2008-05-13T02:41:00.000-07:00

In the following you will get an overview, how you can get information about your Oracle user environment. For the samples it is assumed, that you are already connected to the database via SQL*Plus.

Which tables do you have?

SQL> select table_name from user_tables;

How is my table defined, which columns has it?

SQL> describe table_name

Which database objects do I have currently?

SQL> select object_name, object_type from user_objects;

Which privileges has your Oracle account?

SQL> select * from session_privs;

Which quota do you actually have on which tablespace?

SQL> select tablespace_name, bytes, max_bytes from user_ts_quotas;

How big are your tables/objects for themselves?

SQL> select segment_name, tablespace_name, bytes from user_segments;

ref:

http://www-it.desy.de/systems/services/databases/oracle/at_desy/user_objects.html.en

Basic Introduction to SQLPLUS

2008-05-13T02:36:00.000-07:00

The SQL*PLUS (pronounced "sequel plus") program allows you to store and retrieve data in the relational database management system ORACLE. Databases consists of tables which can be manipulated by structured query language (SQL) commands.
A table is made up of columns (vertical) and rows (horizontal).
A row is made up of fields which contain a data value at the intersection of a row and a column.
Be aware that SQL*PLUS is a program and not a standard query language.

Getting Started

It is a prerequisite that users are registered for ORACLE, an ORACLE account is needed.
On Unix platforms you must start the script oraenv to set the ORACLE environment. Enter the command . oraenv and press <Return;>.
Don't forget to type a blanc between the dot and oraenv.
If you are working with a PC using MS Windows, simply use Netinstall to install the product. You can find the software in the database folder.
Enter sqlplus on unix systems or run it on Windows from the start menue. Answer the displayed prompts by entering your ORACLE user-name and password.
The SQL*PLUS command prompt SQL > indicates that you are ready to work.

Some elementary Commands

alter user user identified by newpassword	enables user to change the password
help	accesses the SQL*PLUS help system
exit, quit	terminates SQL*PLUS
ho[st]	leads to the operating system without leaving SQL*PLUS
ho[st] command	executes a host operating system command
ho[st] oerr	accesses the ORACLE error help for unix

Editing and Executing

All entered input is stored as a single SQL*PLUS statement in the command buffer. Pressing the <Return> key while editing will either open a new numbered line or, if the previous line ends with a semicolon or consists of a single slash, will execute the SQL*PLUS command. Opening new numbered lines allows you to structure statements and enables you to refer to particular lines by later using edit functions.

l[ist]	lists command buffer (the current line is marked with a star)
ln or n	makes line n the current line and lists it
ln m	lists lines n through m
a text	appends text to current line
c/oldstring/newstring	changes oldstring to newstring in current line
i	inserts a line after current line
del	deletes the current line
r[un]	runs and lists command buffer
/	runs command buffer
;	lists command buffer

If you use substitution variables, like &variable, instead of values or names in your SQL statement, SQL*PLUS will prompt you and substitute the entered value. A substitution variable is a user variable name preceded by an ampersand.

Working with Command Files

You can use command files to save complex commands. After creating a command file you can retrieve, edit, and run it. The default file extension is .sql . If you use other file extensions you must write the full file name like name.extension.

ed[it]	overwrites a scratch file with the contents of the command buffer
	edit enables you to edit this file with the defined host operating system
	editor. The name of the scratch file is afiedt.buf .
	After leaving the editor the buffer is listed and you can execute it.
ed[it] filename	enables you to edit an existing or new file filename.sql
sav[e] filename	creates file filename and stores the command buffer into it
sav[e] filename [option]	stores command buffer into file filename
	Possible options are cre[ate], app[end], rep[lace].
get filename	loads the host operating system file filename into the command buffer
sta[rt] filename [arg1 arg2 ..]	executes file filename
	arg1 arg2 .. are arguments you wish to pass to the command file

If you run a command file in which a substitution variable like &1 is used, you will be prompted for that value. You can avoid being prompted by passing an argument to the command file.

Queries and Subqueries

Retrieving data from the database is the most common SQL operation. A query is an SQL command (specifically a select) that retrieves information from one or more tables. A subquery is a select which is nested in another SQL command.

The Describe Command

desc[ribe] name

lists the column definition for table or view name

Basic Select Commands

The basic select command consists of two parts, called clauses: select some data from table.
Examples

*select from** tabname	selects all columns and rows from table tabname
select distinct col from tabname	selects column col from table tabname
	and returns only one copy of duplicate rows
select col1, col2 ... from tabname	selects specified columns from table tabname
select col1, col23* from tabname	selects col1,col2 from table tabname
	and lists col1, col2 multiplied by 3
select 23* from dual	calculates 23* and will display the result

Selecting Rows and Ordering

To retrieve specific rows from a table you need to add a where clause. A where clause consists of one or more search conditions which can be connected by logical operators. To display the retrieved data in a specific order you need to add an order by clause.
Examples
select col1,col2 from tabname
where col1 < col2 and col2 !=0
order by col2
Columns col1, col2 are selected from table tabname and all rows where col2 is not equal to zero and col1 is less than col2 are displayed in an ascending order (ordered by col2).
select col1,col2 from tabname
where col1 like '_A%' or col1 like '+++'
order by col2 desc
Columns col1,col2 are selected from table tabname and all rows where col1 is equal to '+++' or where the second letter in col1 is an 'A' are displayed in a descending order.
In this example two different escape characters are used. The underscore matches exactly one character whereas the percent sign can match zero or more characters.
select col1,col2 from tabname
where col1 in ( value1,value2 )
Columns col1,col2 are selected from table tabname and all rows where col1 is equal to value1 or to value2 are displayed.
select col1,col2 from tabname
where col1 not between value1 and value2
Columns col1,col2 are selected from table tabname and all rows where col1 is not in the range between value1 and value2 are displayed.

Using Set Operator

Set operators combine the results of two queries into a single result. If a statement contains multiple set operators, they will be evaluated from left to right.

set operator
union	returns all distinct rows selected by either query
union all	returns all rows selected by either query, including all duplicates
intersect	returns all distinct rows selected by both queries
minus	returns all distinct rows selected by the first query but not the second

Example
select * from table1
union all
select * from table2
This will combine all rows, columns of table1 and table2.

Querying Multiple Tables

If you want to retrieve information from different tables, you can do this by issuing different queries or a single JOIN query. In a JOIN query, you list the names of the tables you are querying in the from clause and the names of the linking columns in the where clause. The omission of the linking where clause causes a cartesian product of both tables. A JOIN combines rows from two or more tables where columns which the tables have in common match. If a column name is not unique, you must use a prefix to make clear which column from which table you want to select (e.g. tablename.columnname).

Simple Join

select col1,tab1.col2,col3 from tab1,tab2
where tab1.col2=tab2.col2
This is the most common type of join. It returns rows from two tables based on an equality condition, therefore it is also called an equi-join.

Non-Equi Join

select tab1.col1,tab2.col2 from tab1,tab2
where tab1.col1 between lowval and highval
Since this join doesn't return rows based on a equality condition, it is called a non-equi join.

Self Join

select alias1.col1,alias2.col1 "Header 2" from tabname alias1,tabname alias2
where alias1.col2=alias2.col3
In this example the table tabname is joined with itself. Using of two different alias names for the same table allows you to refer to it twice. Since the names of the resulting columns in this example are the same, the second column gets a new header.

Outer Join

select col1,col2 from tab1,tab2
where tab1.col1=tab2.col2(+)
Suppose you want to retrieve information from two tables where not all rows match but the result should contain all values from one or more columns. A simple join will select only matching rows whereas the outer join extends the result. All matching rows will be selected and when you append the outer join operator (+) to a column name, those rows which do not match will also be selected. In the example the number of rows which are selected is the number of rows in table tab2. If rows match, the outer join works as a simple join, if not, the values from tab2.col2 and a NULL value for the non existing value of tab1.col1 will be selected.

Data Definition Language DDL

DDL commands allow you to create, alter and delete objects (e.g tables, views) and also to grant and revoke privileges.
create table tabname (col1 type1,col2 type2,...) creates table tabname
col1 ... coln are the column names, type1,type2.. specifies the datatype of a column which can be number, date, char, varchar.
number(p,s) specifies a fixed point number having precision p (total number of digits) and scale s (number of digits to the right of the decimal point).
number(p) specifies a fixed point number.
number specifies a floating point number.
char(size) specifies fixed length (max 255) character data of length size.
varchar2(size) specifies variable length (max 2000) character string having a maximum length of size bytes.

create table tabname as subquery creates table tabname
subquery inserts rows into the table upon its creation. A subquery is a form of the select command which enables you to select columns from an existing table.

create view viewname as subquery creates view viewname
A view is a logical table based on one or more tables.

drop table tabname	removes table tabname from the database
alter table tabname add (col1 type1,col2 type2,...)	adds columns to table tabname
alter table tabname modify (col1 type1,col2 type2,...)	modifies column definitions
rename oldname to newname	renames table oldname
alter user user identified by newpassword;	enables user to change the password
	to newpassword
grant privilege on object to user	grants a privilege to user
revoke privilege on object from user	revokes a privilege from user

Data Manipulation Language DML

DML commands manipulate and query data in existing tables. These commands do not commit current actions.

insert into tabname (col1,col2...) values (val1,val 2...)	inserts rows into table tabname
insert into tabname subquery	inserts rows(selected by a subquery) into
&table tabname
update tabname set col1=expr1,col2=expr2... where cond	updates rows in table tabname
	columns are set to values of expressions if
	condition cond is true
update tabname set (col1,col2...)=(subquery) where cond	updates rows in table tabname
	columns are set to selected values if
	condition cond is true
delete from tabname [where cond]	either deletes all rows from table tabname
	or rows where cond is true

Schema

When you select data from a table or you insert data into a table then this object has to be in your own schema. In other words, you must be the owner.
If you are not the owner of the object, but the owner granted some privileges to you, you have to specify schema.tabname.
Example
select * from scott.emp

Transaction Control Commands

Transaction Control Commands manage changes made by Data Manipulation Language commands. A transaction (or logical unit of work) is a sequence of SQL statements that ORACLE treats as a single unit. A transaction ends with a commit, rollback , exit, or any DDL statement which issues an implicit commit. In most cases transactions are implicitly controlled.

commit	makes all changes since the beginning of a transaction permanent
rollback	rolls back (undoes) all changes since the beginning of a transaction
rollback to savepoint savep	rolls back to savepoint savep
savepoint savep	defines savepoint savep

user objects, user resources

SQL with Oracle

2008-05-12T03:48:00.000-07:00

A very useful resource when counter with Oracle.

SQL (Structured Query Language) is the structured query language used to manipulate relational databases. The concept of relational database was first proposed by Codd in 1970, and a language to extract and manipulate the data in it was developed theoretically during the following years. All SQL statements are instructions to the database. SQL is a non-procedural language, which means that commands are not executed step by step according to how they were written, but they are retained in memory, read through and executed in the most effective way. In relational database terminology, SQL provides 'automatic navigation' to the data in the database.
In these notes, you see an indication of two possible interfaces to SQL, namely sqlplus and activeSQL. Sqlplus is the standard Oracle interface while activeSQL is an experimental interface which Napier students have access to. For our tutorials we will all be using activeSQL.

Command Endings

Note that all SQL commands typed into sqlplus MUST end in a ; (semicolon) character. It will not work without it. The activeSQL interface is more forgiving, but even then if you enter more than 1 command into the interface at a time you MUST separate the commands with a semicolon.
When entering SQL, you can have as many space characters and return characters as you like. They are completely ignored by Oracle. Sqlplus will, when you hit return, tell you what line you are currently on. These numbers are not part of the command so do not let them confuse you. In sqlplus, if you hit return twice (return on a blank line) the current command is cancelled.
In activeSQL, no command is executed until you hit the submit button.

SELECT

SQL command SELECT is used to retrieve information from a table. SELECT informs Oracle which table(s) to use and which column(s) and row(s) to retrieve.
The asterisk can be used to denote all fields.
To list all fields and all records from the table employee.

SELECT *
FROM employee
;

To display only the fields empno and depno but all records

SELECT empno,depno
FROM employee;

SPECIAL TABLE

There is a special table called CAT, which contains the name and type of all tables in your namespace. Running

SELECT * from CAT:

produces the name and type of all local tables. This includes the 5 tables used in these tutorials: employee, empcourse, jobhistory, course, and department.
To find out about a particular table, you can look at the commands which created it, or you can use the DESCRIBE command. This tells you the attributes of the table in question. In sqlplus, this description does not include the Foreign Keys (the links to other tables - more of this in tutorial 2) but in activeSQL Foreign Keys ARE shown. For instance:

DESCRIBE employee;

empno               integer        primary key
surname             varchar(15)
forenames           varchar(30)
dob                 date
address             varchar(50)
telno               varchar(20)
depno               integer        references department(depno)

varchar(20) indicates a string which can be up to 20 characters long.
Date indicates that field is an Oracle date.
Integer indicates that that attribute is a number.
Depno integer References department(depno) tells us that depno in employee is a link to the department table's depno attribute. In this confusing case there are two attributes called depno, one in employee and one in department. These attributes are different attributes in different tables.

Predicates

Search conditions are made up of predicates. These are then combined together with ANDs, ORs, and NOTs.
There are seven types of predicate:

comparison
BETWEEN predicate
IN predicate
LIKE predicate
ANY or ALL predicate
EXISTS predicate
IS NULL

Comparisons

The comparisons available are

=	equal to
!=	not equal to
>	greater than
>=	greater than or equal to
<	less than
<=	less than or equal to

List the fields empno, surname, telno of all employees who have a surname Wright. Notice the quote marks required for character constants. Note also that anything within the quotes is case sensitive.

SELECT empno, surname, telno
FROM employee
WHERE surname = 'Wright'

List all current salaries in the range £20000 to £30000, listing their empno values.

SELECT empno, enddate, salary
FROM jobhistory
WHERE enddate IS NULL
AND salary >= 20000
AND salary <= 30000

List all the employees working in the company on January 1st 1980 and their position

SELECT empno, position, startdate, enddate
FROM jobhistory
WHERE (startdate < '01-JAN-1980' AND enddate > '01-JAN-1980')
OR (startdate < '01-JAN-1980' AND enddate IS NULL)

BETWEEN (Inclusive)

List all the courses which occurred during 1988

SELECT *
FROM course
WHERE cdate BETWEEN '01-JAN-1988' AND '31-DEC-1988'

List all the courses which did not occur in 1988

SELECT *
FROM course
WHERE cdate NOT BETWEEN '01-JAN-1988' AND '31-DEC -1988'

LIKE

The LIKE predicate provides the only pattern matching capability in SQL for the character data types. It takes the following form

columnname [NOT] LIKE pattern-to-match

The pattern match characters are the percent sign (%) to denote 0 or more arbitrary characters, and the underscore (_) to denote exactly one arbitrary character.
List the employee numbers and surnames of all employees who have a surname beginning with C.

SELECT empno,surname
FROM employee
WHERE surname LIKE 'C%'

List all course numbers and names for any course to do with accounting.

SELECT courseno,cname
FROM course
WHERE cname LIKE '%ccount%'

List all employees who have r as the second letter of their forename.

SELECT surname, forenames
FROM employee
WHERE forenames LIKE '_r%'

IS NULL

List all employees numbers and their current position

SELECT empno,position
FROM jobhistory
WHERE enddate IS NULL

The remaining predicates will be dealt with at a later stage.

Set Functions

A set function is a function that operates on an entire column of values, not just a single value.
List the total wage bill for the company at the moment.

SELECT SUM(salary)
FROM jobhistory
WHERE enddate IS NULL

This will retrieve the total salary for employees, where the enddate is empty or NULL.
The following are the set functions supported
Table 1: Set Functions

Name	Description
COUNT	Count of occurrences
SUM	Summation
AVG	Average (Sum/Count)	zero if Count = zero
MAX	Maximum value
MIN	Minimum value

Find the number of employees working currently.

SELECT COUNT(*)
FROM jobhistory
WHERE enddate IS NULL

The COUNT(*) function is used to count rows in a table, and is the exception to the following rule.
NULL values are ignored by the set functions.
Count how many jobs that employee number 25 has had previously.

SELECT COUNT(enddate)
FROM jobhistory
WHERE empno = 25

Count how many jobs employee number 25 has had, including current job.

SELECT COUNT(startdate)
FROM jobhistory
WHERE empno = 25

Calculate the average salary for all employees.

SELECT AVG(salary)
FROM jobhistory
WHERE enddate IS NULL

Note that a 'column label' might be usefully added. This will be output in uppercase format unless enclosed in double quotes as follows :--
Find out the greatest salary.

SELECT MAX(salary)    "Highest Salary"
FROM jobhistory
WHERE enddate IS NULL

Ordering rows of a query result

The order in which the selected rows are displayed is changed by adding an ORDER BY clause to the end of your SELECT command. The ordering is done numerically or alphabetically and can be ascending or descending.
List all the employee numbers and salaries, ordered by their salary.

SELECT empno, salary
FROM jobhistory
WHERE enddate IS NULL
ORDER BY salary

To order by descending order you need to add DESC in the ORDER BY command

SELECT empno, salary
FROM jobhistory
WHERE enddate IS NULL
ORDER BY salary DESC

Prevention of duplicate rows

If you print all the jobs in the jobhistory table you will get duplicate rows.

SELECT position
FROM jobhistory

To print out only one for each different job you need to add DISTINCT in the SELECT clause.

SELECT DISTINCT position
FROM jobhistory

Counting unique rows

Often you would like to count how many different rows exist in the result of a query. Doing:

SELECT DISTINCT count(position)
FROM jobhistory

result in an answer which is no different from the same query without the DISTINCT. This is caused by the fact that count() is done before DISTINCT, and therefore in this case DISTINCT does nothing. What is actually needed is a way of forcing DISTINCT to be done before the count. This can be achieved by doing:

SELECT count(DISTINCT position)
FROM jobhistory

.NET assembly and COM interoperation

2008-05-01T23:55:00.000-07:00

Recently, I just learned how to make .NET assembly visible for COM interoperation. I found that there are several ways to complete this task; on my view, two steps is needed are :

- Signing an assembly with a strong name: we must have a key pair (I can also create a new keypair by using sn.exe tool ), after that, sign the assembly by Assembly Linker al.exe provided by .Net SDK or use the AssemblyKeyFileAttribute or the AssemblyKeyNameAttribute , open the file AssemblyInfo.cs in your project and look at the last, pls read the list of articles below for more info.

- And customize the visible of .Net assembly:
At first, the .net assembly must match the qualify for COM interop. See this article to reach what's qualify : Qualifying .NET Types for Interoperation.
The assembly is OK, and ..in Visual Studio, I open my project ( class library ;) ) and I see there's a property named : "Register for COM interop", if check this, VS auto generates interface, implement in your classes and register your assembly; if success, a tlb ( type library ) is created in your project "bin" directory.
Or I can register manually by using the regasm.exe provided by .Net SDK.

The usually path ;)
sn.exe C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Bin
al.exe C:\WINDOWS\Microsoft.NET\Framework\(v1.1.4322) (choose .net version)
regasm.exe C:\WINDOWS\Microsoft.NET\Framework\(v1.1.4322)

Resources:

Debug javascript

2008-04-11T02:57:00.000-07:00

To debug JavaScript on the client side, you need to do a few things:

In case of you're using Internet Explorer, following this help and you also need a javascript develop environment to debugging.
In case of you're using FireFox, there's also has javascript debugging add-in, check the link to download at the end of post.

1. In Internet Explorer's Advanced Options, uncheck "Disable Script
Debugging"
2. If you want to insert a breakpoint in your JavaScript, add the following
statement:

debugger;

JavaScript errors that occur will always result in a prompt asking you if
you want to open the debugger to debug the script.

--
Kevin Spencer
Microsoft MVP-Net Developer
--

Get Firefox's javascript debugger addin

HttpWebRequest : Expect: 100-continue Header Problem

2008-04-08T01:24:00.000-07:00

I used the HttpWebRequest to POST request using HTTP 1.1, i received the following HTTP header "Expect: 100-Continue". After few time to play with google, i found a treasure article at Phil Haack site.

Here is solution :
System.Net.ServicePointManager class has a static property named Expect100Continue. Setting this to false will stop the header "Expect: 100-Continue" from being sent.

You may see code snippet below about how to implement it.

// create web request
HttpWebRequest webRequest = (HttpWebRequest) WebRequest.Create("http://something");
webRequest.Method = "POST";
webRequest.ServicePoint.Expect100Continue = false;

// post data
requestStream = webRequest.GetRequestStream();
StreamWriter requestWriter = new StreamWriter(requestStream);
requestWriter.Write(dataToPost);
requestWriter.Close();

//wait for server response
HttpWebResponse response = (HttpWebResponse) webRequest.GetResponse();

Hide/Show Console window in .Net 1.1 Console application

2008-04-07T23:46:00.000-07:00

In my previous post about how to hide console window in .Net 2.0 and higher Console application, some questions was how to do this in .Net 1.1 because in .net 1.1 there's not had the Console.Title property.
The way to do is the same, and we need revise some code with the FindWindow function to get the handle of console window. When we get it's handle, it's mean we can hide/show it.

please check the revised code below:


class MyClass
{
[DllImport("user32.dll")]
public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
[DllImport("user32.dll")]
static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

[STAThread]
static void Main(string[] args)
{ 
  if (args.Length == 0)
  {
// Hide console
HideConsole();
// Display manage UI
Application.Run(new mainForm());
  }
}
static void HideConsole()
{
System.Diagnostics.Process p =     System.Diagnostics.Process.GetCurrentProcess();  
IntPtr hWnd = FindWindow(null, p.MainWindowTitle);
if(hWnd != IntPtr.Zero)
{
ShowWindow(hWnd, 0); // 0 = SW_HIDE
}
}
static void ShowConsole()
{
System.Diagnostics.Process p = System.Diagnostics.Process.GetCurrentProcess();  
IntPtr hWnd = FindWindow(null, p.MainWindowTitle);
if (hWnd != IntPtr.Zero)
{
ShowWindow(hWnd, 1); //1 = SW_SHOWNORMA
}
}
}

If you have other better ways to hide/show console, i'm very happy and glad to read your comments.

NTLDR is Missing

2008-04-07T19:23:00.000-07:00

Issue:

NTLDR is Missing.

Related errors:

Below are the full error messages that may be seen when the computer is booting.

NTLDR is Missing
Press any key to restart

Boot: Couldn't find NTLDR
Please insert another disk

NTLDR is missing
Press Ctrl Alt Del to Restart

Cause:

Computer is booting from a non-bootable source.
Computer hard disk drive is not properly setup in BIOS.
Corrupt NTLDR and/or NTDETECT.COM file.
Misconfiguration with the boot.ini file.
Attempting to upgrade from a Windows 95, 98, or ME computer that is using FAT32.
New hard disk drive being added.
Corrupt boot sector / master boot record.
Seriously corrupted version of Windows 2000 or Windows XP.
Loose or Faulty IDE/EIDE hard disk drive cable.

Solutions:

Computer is booting from a non-bootable source

Many times this error is caused when the computer is attempting to boot from a non-bootable floppy disk or CD-ROM. First verify that no floppy diskette is in the computer, unless you are attempting to boot from a diskette.

If you are attempting to boot from a floppy diskette and are receiving this error message it is likely that the diskette does not have all the necessary files and/or is corrupt.

If you are attempting to install Windows XP or Windows 2000 and are receiving this error message as the computer is booting verify that your computer BIOS has the proper boot settings. For example, if you are attempting to run the install from the CD-ROM make sure the CD-ROM is the first boot device, and not the hard disk drive.

Second, when the computer is booting you should receive the below prompt.

Press any key to boot from the CD

Important: When you see this message press any key such as the Enter key immediately, otherwise it will try booting from the hard drive and likely get the NTLDR error again.

Note: If you are not receiving the above message and your BIOS boot options are set properly it's also possible that your CD-ROM drive may not be booting from the CD-ROM properly. Verify the jumpers are set properly on the CD-ROM drive. Additional information about checking the CD-ROM drive connections can be found on document CH000213.

Additional information: This error has also been known to occur when a memory stick is in a card reader and the computer is attempting to boot from it. If you have any type of card reader or flash reader make sure that no memory stick is inside the computer.

Computer hard disk drive is not properly setup in BIOS

Verify that your computer hard disk drive is properly setup in the BIOS / CMOS setup. Improper settings can cause this error. Additional information on how to enter the BIOS / CMOS setup can be found in document CH000192.

Corrupt NTLDR and/or NTDETECT.COM file

Windows 2000 users
Windows XP users

Windows 2000 users

If your computer is using Microsoft Windows 2000 and you are encountering the NTLDR error. Create the below boot.ini file on the floppy diskette drive.

[boot loader]
timeout=30
default=multi(0)disk(0)rdisk(0)partition(1)\WINNT
[operating systems]
multi(0)disk(0)rdisk(0)partition(1)\WINNT="Microsoft Windows 2000 Professional" /fastdetect

Copy the NTLDR and NTDETECT.COM files from another computer using the same Operating System. Both of these files are located in the root directory of the primary hard disk drive. For example, C:\NTLDR and C:\NTDETECT.COM should be the locations of these files on many computers.

Please keep in mind that these files are hidden system files, if you need additional help with viewing hidden files in Windows please see document CH000516.

Once these files have been copied to a floppy diskette reboot the computer and copy the NTLDR and NTDETECT.COM files to the root directory of the primary hard disk drive. Below is an example of what commonly should be performed from the A:\> drive.

copy ntldr c:
copy ntdetect.com c:

After the above two files have been copied, remove the floppy diskette and reboot the computer.

Windows XP users

Insert the Windows XP bootable CD into the computer.
When prompted to press any key to boot from the CD, press any key.
Once in the Windows XP setup menu press the "R" key to repair Windows.
Log into your Windows installation by pressing the "1" key and pressing enter.
You will then be prompted for your administrator password, enter that password.
Copy the below two files to the root directory of the primary hard disk. In the below example we are copying these files from the CD-ROM drive letter "E". This letter may be different on your computer.

copy e:\i386\ntldr c:\
copy e:\i386\ntdetect.com c:\

Once both of these files have been successfully copied, remove the CD from the computer and reboot.

Misconfiguration with the boot.ini file

Edit the boot.ini on the root directory of the hard disk drive and verify that it is pointing to the correct location of your Windows Operating System and that the partitions are properly defined. Additional information about the boot.ini can be found on document CH000492.

Attempting to upgrade from a Windows 95, 98, or ME computer that is using FAT32

If you are getting this error message while you are attempting to upgrade to Windows 2000 or Windows XP from Windows 95, Windows 98, or Windows ME running FAT32 please try the below recommendations.

Boot the computer with a Windows 95, Windows 98 or Windows ME bootable diskette.
At the A:\> prompt type:

sys c:

After pressing enter you should receive the "System Transferred" message. Once this has been completed remove the floppy diskette and reboot the computer.

New hard disk drive being added

If you are attempting to add a new hard disk drive to the computer make sure that drive is a blank drive. Adding a new hard disk drive to a computer that already has Windows installed on it may cause the NTLDR error to occur.

If you are unsure if the new drive is blank or not try booting from a bootable diskette and format the new hard disk drive.

Corrupt boot sector / master boot record

It's possible your computer's hard disk drive may have a corrupt boot sector and/or master boot record. These can be repaired through the Microsoft Windows Recovery console by running the fixboot and fixmbr commands.

Additional information and help in getting into the Microsoft Windows Recovery console can be found on document CH000627.

Seriously corrupted version of Windows 2000 or Windows XP

If you have tried each of the above recommendations that apply to your situation and you continue to experience this issue it is possible you may have a seriously corrupted version of Microsoft Windows. Therefore we would recommend you reinstall Microsoft Windows 2000 and Windows XP.

If you are encountering this issue during your setup you may wish to completely erase your computer hard disk drive and all of its existing data and then install Microsoft Windows 2000 / Windows XP. Additional information about erasing the computer and starting over can be found on document CH000186.

Loose or Faulty IDE/EIDE hard disk drive cable

This issue has been known to be caused by a loose or fault IDE/EIDE cable. If the above recommendation does not resolve your issue and your computer hard disk drive is using an IDE or EIDE interface. Verify the computer hard disk drive cable is firmly connected by disconnected and reconnecting the cable.

If the issue continues it is also a possibility that the computer has a faulty cable, try replacing the hard disk drive cable with another cable and/or a new cable.

http://www.computerhope.com

What Is Web 2.0? page5

2008-03-30T23:11:00.000-07:00

by Tim O'Reilly

7. Rich User Experiences

As early as Pei Wei's Viola browser in 1992, the web was being used to deliver "applets" and other kinds of active content within the web browser. Java's introduction in 1995 was framed around the delivery of such applets. JavaScript and then DHTML were introduced as lightweight ways to provide client side programmability and richer user experiences. Several years ago, Macromedia coined the term "Rich Internet Applications" (which has also been picked up by open source Flash competitor Laszlo Systems) to highlight the capabilities of Flash to deliver not just multimedia content but also GUI-style application experiences.

However, the potential of the web to deliver full scale applications didn't hit the mainstream till Google introduced Gmail, quickly followed by Google Maps, web based applications with rich user interfaces and PC-equivalent interactivity. The collection of technologies used by Google was christened AJAX, in a seminal essay by Jesse James Garrett of web design firm Adaptive Path. He wrote:

"Ajax isn't a technology. It's really several technologies, each flourishing in its own right, coming together in powerful new ways. Ajax incorporates:

standards-based presentation using XHTML and CSS;
dynamic display and interaction using the Document Object Model;
data interchange and manipulation using XML and XSLT;
asynchronous data retrieval using XMLHttpRequest;
and JavaScript binding everything together."

AJAX is also a key component of Web 2.0 applications such as Flickr, now part of Yahoo!, 37signals' applications basecamp and backpack, as well as other Google applications such as Gmail and Orkut. We're entering an unprecedented period of user interface innovation, as web developers are finally able to build web applications as rich as local PC-based applications.

Interestingly, many of the capabilities now being explored have been around for many years. In the late '90s, both Microsoft and Netscape had a vision of the kind of capabilities that are now finally being realized, but their battle over the standards to be used made cross-browser applications difficult. It was only when Microsoft definitively won the browser wars, and there was a single de-facto browser standard to write to, that this kind of application became possible. And while Firefox has reintroduced competition to the browser market, at least so far we haven't seen the destructive competition over web standards that held back progress in the '90s.

We expect to see many new web applications over the next few years, both truly novel applications, and rich web reimplementations of PC applications. Every platform change to date has also created opportunities for a leadership change in the dominant applications of the previous platform.

Gmail has already provided some interesting innovations in email, combining the strengths of the web (accessible from anywhere, deep database competencies, searchability) with user interfaces that approach PC interfaces in usability. Meanwhile, other mail clients on the PC platform are nibbling away at the problem from the other end, adding IM and presence capabilities. How far are we from an integrated communications client combining the best of email, IM, and the cell phone, using VoIP to add voice capabilities to the rich capabilities of web applications? The race is on.

It's easy to see how Web 2.0 will also remake the address book. A Web 2.0-style address book would treat the local address book on the PC or phone merely as a cache of the contacts you've explicitly asked the system to remember. Meanwhile, a web-based synchronization agent, Gmail-style, would remember every message sent or received, every email address and every phone number used, and build social networking heuristics to decide which ones to offer up as alternatives when an answer wasn't found in the local cache. Lacking an answer there, the system would query the broader social network.

A Web 2.0 word processor would support wiki-style collaborative editing, not just standalone documents. But it would also support the rich formatting we've come to expect in PC-based word processors. Writely is a good example of such an application, although it hasn't yet gained wide traction.

Nor will the Web 2.0 revolution be limited to PC applications. Salesforce.com demonstrates how the web can be used to deliver software as a service, in enterprise scale applications such as CRM.

The competitive opportunity for new entrants is to fully embrace the potential of Web 2.0. Companies that succeed will create applications that learn from their users, using an architecture of participation to build a commanding advantage not just in the software interface, but in the richness of the shared data.

Core Competencies of Web 2.0 Companies

In exploring the seven principles above, we've highlighted some of the principal features of Web 2.0. Each of the examples we've explored demonstrates one or more of those key principles, but may miss others. Let's close, therefore, by summarizing what we believe to be the core competencies of Web 2.0 companies:

Services, not packaged software, with cost-effective scalability
Control over unique, hard-to-recreate data sources that get richer as more people use them
Trusting users as co-developers
Harnessing collective intelligence
Leveraging the long tail through customer self-service
Software above the level of a single device
Lightweight user interfaces, development models, AND business models

The next time a company claims that it's "Web 2.0," test their features against the list above. The more points they score, the more they are worthy of the name. Remember, though, that excellence in one area may be more telling than some small steps in all seven.

Tim O'Reilly
O’Reilly Media, Inc., tim@oreilly.com
President and CEO

What Is Web 2.0? page4

2008-03-30T23:03:00.000-07:00

by Tim O'Reilly

4. End of the Software Release Cycle

As noted above in the discussion of Google vs. Netscape, one of the defining characteristics of internet era software is that it is delivered as a service, not as a product. This fact leads to a number of fundamental changes in the business model of such a company:

Operations must become a core competency. Google's or Yahoo!'s expertise in product development must be matched by an expertise in daily operations. So fundamental is the shift from software as artifact to software as service that the software will cease to perform unless it is maintained on a daily basis. Google must continuously crawl the web and update its indices, continuously filter out link spam and other attempts to influence its results, continuously and dynamically respond to hundreds of millions of asynchronous user queries, simultaneously matching them with context-appropriate advertisements.
It's no accident that Google's system administration, networking, and load balancing techniques are perhaps even more closely guarded secrets than their search algorithms. Google's success at automating these processes is a key part of their cost advantage over competitors.

It's also no accident that scripting languages such as Perl, Python, PHP, and now Ruby, play such a large role at web 2.0 companies. Perl was famously described by Hassan Schroeder, Sun's first webmaster, as "the duct tape of the internet." Dynamic languages (often called scripting languages and looked down on by the software engineers of the era of software artifacts) are the tool of choice for system and network administrators, as well as application developers building dynamic systems that require constant change.

Users must be treated as co-developers, in a reflection of open source development practices (even if the software in question is unlikely to be released under an open source license.) The open source dictum, "release early and release often" in fact has morphed into an even more radical position, "the perpetual beta," in which the product is developed in the open, with new features slipstreamed in on a monthly, weekly, or even daily basis. It's no accident that services such as Gmail, Google Maps, Flickr, del.icio.us, and the like may be expected to bear a "Beta" logo for years at a time.
Real time monitoring of user behavior to see just which new features are used, and how they are used, thus becomes another required core competency. A web developer at a major online service remarked: "We put up two or three new features on some part of the site every day, and if users don't adopt them, we take them down. If they like them, we roll them out to the entire site."

Cal Henderson, the lead developer of Flickr, recently revealed that they deploy new builds up to every half hour. This is clearly a radically different development model! While not all web applications are developed in as extreme a style as Flickr, almost all web applications have a development cycle that is radically unlike anything from the PC or client-server era. It is for this reason that a recent ZDnet editorial concluded that Microsoft won't be able to beat Google: "Microsoft's business model depends on everyone upgrading their computing environment every two to three years. Google's depends on everyone exploring what's new in their computing environment every day."

While Microsoft has demonstrated enormous ability to learn from and ultimately best its competition, there's no question that this time, the competition will require Microsoft (and by extension, every other existing software company) to become a deeply different kind of company. Native Web 2.0 companies enjoy a natural advantage, as they don't have old patterns (and corresponding business models and revenue sources) to shed.

A Web 2.0 Investment Thesis

Venture capitalist Paul Kedrosky writes: "The key is to find the actionable investments where you disagree with the consensus". It's interesting to see how each Web 2.0 facet involves disagreeing with the consensus: everyone was emphasizing keeping data private, Flickr/Napster/et al. make it public. It's not just disagreeing to be disagreeable (pet food! online!), it's disagreeing where you can build something out of the differences. Flickr builds communities, Napster built breadth of collection.

Another way to look at it is that the successful companies all give up something expensive but considered critical to get something valuable for free that was once expensive. For example, Wikipedia gives up central editorial control in return for speed and breadth. Napster gave up on the idea of "the catalog" (all the songs the vendor was selling) and got breadth. Amazon gave up on the idea of having a physical storefront but got to serve the entire world. Google gave up on the big customers (initially) and got the 80% whose needs weren't being met. There's something very aikido (using your opponent's force against them) in saying "you know, you're right--absolutely anyone in the whole world CAN update this article. And guess what, that's bad news for you."

--Nat Torkington

5. Lightweight Programming Models

Once the idea of web services became au courant, large companies jumped into the fray with a complex web services stack designed to create highly reliable programming environments for distributed applications.

But much as the web succeeded precisely because it overthrew much of hypertext theory, substituting a simple pragmatism for ideal design, RSS has become perhaps the single most widely deployed web service because of its simplicity, while the complex corporate web services stacks have yet to achieve wide deployment.

Similarly, Amazon.com's web services are provided in two forms: one adhering to the formalisms of the SOAP (Simple Object Access Protocol) web services stack, the other simply providing XML data over HTTP, in a lightweight approach sometimes referred to as REST (Representational State Transfer). While high value B2B connections (like those between Amazon and retail partners like ToysRUs) use the SOAP stack, Amazon reports that 95% of the usage is of the lightweight REST service.

This same quest for simplicity can be seen in other "organic" web services. Google's recent release of Google Maps is a case in point. Google Maps' simple AJAX (Javascript and XML) interface was quickly decrypted by hackers, who then proceeded to remix the data into new services.

Mapping-related web services had been available for some time from GIS vendors such as ESRI as well as from MapQuest and Microsoft MapPoint. But Google Maps set the world on fire because of its simplicity. While experimenting with any of the formal vendor-supported web services required a formal contract between the parties, the way Google Maps was implemented left the data for the taking, and hackers soon found ways to creatively re-use that data.

There are several significant lessons here:

Support lightweight programming models that allow for loosely coupled systems. The complexity of the corporate-sponsored web services stack is designed to enable tight coupling. While this is necessary in many cases, many of the most interesting applications can indeed remain loosely coupled, and even fragile. The Web 2.0 mindset is very different from the traditional IT mindset!
Think syndication, not coordination. Simple web services, like RSS and REST-based web services, are about syndicating data outwards, not controlling what happens when it gets to the other end of the connection. This idea is fundamental to the internet itself, a reflection of what is known as the end-to-end principle.
Design for "hackability" and remixability. Systems like the original web, RSS, and AJAX all have this in common: the barriers to re-use are extremely low. Much of the useful software is actually open source, but even when it isn't, there is little in the way of intellectual property protection. The web browser's "View Source" option made it possible for any user to copy any other user's web page; RSS was designed to empower the user to view the content he or she wants, when it's wanted, not at the behest of the information provider; the most successful web services are those that have been easiest to take in new directions unimagined by their creators. The phrase "some rights reserved," which was popularized by the Creative Commons to contrast with the more typical "all rights reserved," is a useful guidepost.

Innovation in Assembly

Lightweight business models are a natural concomitant of lightweight programming and lightweight connections. The Web 2.0 mindset is good at re-use. A new service like housingmaps.com was built simply by snapping together two existing services. Housingmaps.com doesn't have a business model (yet)--but for many small-scale services, Google AdSense (or perhaps Amazon associates fees, or both) provides the snap-in equivalent of a revenue model.

These examples provide an insight into another key web 2.0 principle, which we call "innovation in assembly." When commodity components are abundant, you can create value simply by assembling them in novel or effective ways. Much as the PC revolution provided many opportunities for innovation in assembly of commodity hardware, with companies like Dell making a science out of such assembly, thereby defeating companies whose business model required innovation in product development, we believe that Web 2.0 will provide opportunities for companies to beat the competition by getting better at harnessing and integrating services provided by others.

6. Software Above the Level of a Single Device

One other feature of Web 2.0 that deserves mention is the fact that it's no longer limited to the PC platform. In his parting advice to Microsoft, long time Microsoft developer Dave Stutz pointed out that "Useful software written above the level of the single device will command high margins for a long time to come."

Of course, any web application can be seen as software above the level of a single device. After all, even the simplest web application involves at least two computers: the one hosting the web server and the one hosting the browser. And as we've discussed, the development of the web as platform extends this idea to synthetic applications composed of services provided by multiple computers.

But as with many areas of Web 2.0, where the "2.0-ness" is not something new, but rather a fuller realization of the true potential of the web platform, this phrase gives us a key insight into how to design applications and services for the new platform.

To date, iTunes is the best exemplar of this principle. This application seamlessly reaches from the handheld device to a massive web back-end, with the PC acting as a local cache and control station. There have been many previous attempts to bring web content to portable devices, but the iPod/iTunes combination is one of the first such applications designed from the ground up to span multiple devices. TiVo is another good example.

iTunes and TiVo also demonstrate many of the other core principles of Web 2.0. They are not web applications per se, but they leverage the power of the web platform, making it a seamless, almost invisible part of their infrastructure. Data management is most clearly the heart of their offering. They are services, not packaged applications (although in the case of iTunes, it can be used as a packaged application, managing only the user's local data.) What's more, both TiVo and iTunes show some budding use of collective intelligence, although in each case, their experiments are at war with the IP lobby's. There's only a limited architecture of participation in iTunes, though the recent addition of podcasting changes that equation substantially.

This is one of the areas of Web 2.0 where we expect to see some of the greatest change, as more and more devices are connected to the new platform. What applications become possible when our phones and our cars are not consuming data but reporting it? Real time traffic monitoring, flash mobs, and citizen journalism are only a few of the early warning signs of the capabilities of the new platform.

What Is Web 2.0? page3

2008-03-30T22:54:00.000-07:00

by Tim O'Reilly

Blogging and the Wisdom of Crowds

One of the most highly touted features of the Web 2.0 era is the rise of blogging. Personal home pages have been around since the early days of the web, and the personal diary and daily opinion column around much longer than that, so just what is the fuss all about?

At its most basic, a blog is just a personal home page in diary format. But as Rich Skrenta notes, the chronological organization of a blog "seems like a trivial difference, but it drives an entirely different delivery, advertising and value chain."

One of the things that has made a difference is a technology called RSS. RSS is the most significant advance in the fundamental architecture of the web since early hackers realized that CGI could be used to create database-backed websites. RSS allows someone to link not just to a page, but to subscribe to it, with notification every time that page changes. Skrenta calls this "the incremental web." Others call it the "live web".

Now, of course, "dynamic websites" (i.e., database-backed sites with dynamically generated content) replaced static web pages well over ten years ago. What's dynamic about the live web are not just the pages, but the links. A link to a weblog is expected to point to a perennially changing page, with "permalinks" for any individual entry, and notification for each change. An RSS feed is thus a much stronger link than, say a bookmark or a link to a single page.

The Architecture of Participation

Some systems are designed to encourage participation. In his paper, The Cornucopia of the Commons, Dan Bricklin noted that there are three ways to build a large database. The first, demonstrated by Yahoo!, is to pay people to do it. The second, inspired by lessons from the open source community, is to get volunteers to perform the same task. The Open Directory Project, an open source Yahoo competitor, is the result. But Napster demonstrated a third way. Because Napster set its defaults to automatically serve any music that was downloaded, every user automatically helped to build the value of the shared database. This same approach has been followed by all other P2P file sharing services.

One of the key lessons of the Web 2.0 era is this: Users add value. But only a small percentage of users will go to the trouble of adding value to your application via explicit means. Therefore, Web 2.0 companies set inclusive defaults for aggregating user data and building value as a side-effect of ordinary use of the application. As noted above, they build systems that get better the more people use them.

Mitch Kapor once noted that "architecture is politics." Participation is intrinsic to Napster, part of its fundamental architecture.

This architectural insight may also be more central to the success of open source software than the more frequently cited appeal to volunteerism. The architecture of the internet, and the World Wide Web, as well as of open source software projects like Linux, Apache, and Perl, is such that users pursuing their own "selfish" interests build collective value as an automatic byproduct. Each of these projects has a small core, well-defined extension mechanisms, and an approach that lets any well-behaved component be added by anyone, growing the outer layers of what Larry Wall, the creator of Perl, refers to as "the onion." In other words, these technologies demonstrate network effects, simply through the way that they have been designed.

These projects can be seen to have a natural architecture of participation. But as Amazon demonstrates, by consistent effort (as well as economic incentives such as the Associates program), it is possible to overlay such an architecture on a system that would not normally seem to possess it.

RSS also means that the web browser is not the only means of viewing a web page. While some RSS aggregators, such as Bloglines, are web-based, others are desktop clients, and still others allow users of portable devices to subscribe to constantly updated content.

RSS is now being used to push not just notices of new blog entries, but also all kinds of data updates, including stock quotes, weather data, and photo availability. This use is actually a return to one of its roots: RSS was born in 1997 out of the confluence of Dave Winer's "Really Simple Syndication" technology, used to push out blog updates, and Netscape's "Rich Site Summary", which allowed users to create custom Netscape home pages with regularly updated data flows. Netscape lost interest, and the technology was carried forward by blogging pioneer Userland, Winer's company. In the current crop of applications, we see, though, the heritage of both parents.

But RSS is only part of what makes a weblog different from an ordinary web page. Tom Coates remarks on the significance of the permalink:

It may seem like a trivial piece of functionality now, but it was effectively the device that turned weblogs from an ease-of-publishing phenomenon into a conversational mess of overlapping communities. For the first time it became relatively easy to gesture directly at a highly specific post on someone else's site and talk about it. Discussion emerged. Chat emerged. And - as a result - friendships emerged or became more entrenched. The permalink was the first - and most successful - attempt to build bridges between weblogs.

In many ways, the combination of RSS and permalinks adds many of the features of NNTP, the Network News Protocol of the Usenet, onto HTTP, the web protocol. The "blogosphere" can be thought of as a new, peer-to-peer equivalent to Usenet and bulletin-boards, the conversational watering holes of the early internet. Not only can people subscribe to each others' sites, and easily link to individual comments on a page, but also, via a mechanism known as trackbacks, they can see when anyone else links to their pages, and can respond, either with reciprocal links, or by adding comments.

Interestingly, two-way links were the goal of early hypertext systems like Xanadu. Hypertext purists have celebrated trackbacks as a step towards two way links. But note that trackbacks are not properly two-way--rather, they are really (potentially) symmetrical one-way links that create the effect of two way links. The difference may seem subtle, but in practice it is enormous. Social networking systems like Friendster, Orkut, and LinkedIn, which require acknowledgment by the recipient in order to establish a connection, lack the same scalability as the web. As noted by Caterina Fake, co-founder of the Flickr photo sharing service, attention is only coincidentally reciprocal. (Flickr thus allows users to set watch lists--any user can subscribe to any other user's photostream via RSS. The object of attention is notified, but does not have to approve the connection.)

If an essential part of Web 2.0 is harnessing collective intelligence, turning the web into a kind of global brain, the blogosphere is the equivalent of constant mental chatter in the forebrain, the voice we hear in all of our heads. It may not reflect the deep structure of the brain, which is often unconscious, but is instead the equivalent of conscious thought. And as a reflection of conscious thought and attention, the blogosphere has begun to have a powerful effect.

First, because search engines use link structure to help predict useful pages, bloggers, as the most prolific and timely linkers, have a disproportionate role in shaping search engine results. Second, because the blogging community is so highly self-referential, bloggers paying attention to other bloggers magnifies their visibility and power. The "echo chamber" that critics decry is also an amplifier.

If it were merely an amplifier, blogging would be uninteresting. But like Wikipedia, blogging harnesses collective intelligence as a kind of filter. What James Suriowecki calls "the wisdom of crowds" comes into play, and much as PageRank produces better results than analysis of any individual document, the collective attention of the blogosphere selects for value.

While mainstream media may see individual blogs as competitors, what is really unnerving is that the competition is with the blogosphere as a whole. This is not just a competition between sites, but a competition between business models. The world of Web 2.0 is also the world of what Dan Gillmor calls "we, the media," a world in which "the former audience", not a few people in a back room, decides what's important.

3. Data is the Next Intel Inside

Every significant internet application to date has been backed by a specialized database: Google's web crawl, Yahoo!'s directory (and web crawl), Amazon's database of products, eBay's database of products and sellers, MapQuest's map databases, Napster's distributed song database. As Hal Varian remarked in a personal conversation last year, "SQL is the new HTML." Database management is a core competency of Web 2.0 companies, so much so that we have sometimes referred to these applications as "infoware" rather than merely software.

This fact leads to a key question: Who owns the data?

In the internet era, one can already see a number of cases where control over the database has led to market control and outsized financial returns. The monopoly on domain name registry initially granted by government fiat to Network Solutions (later purchased by Verisign) was one of the first great moneymakers of the internet. While we've argued that business advantage via controlling software APIs is much more difficult in the age of the internet, control of key data sources is not, especially if those data sources are expensive to create or amenable to increasing returns via network effects.

Look at the copyright notices at the base of every map served by MapQuest, maps.yahoo.com, maps.msn.com, or maps.google.com, and you'll see the line "Maps copyright NavTeq, TeleAtlas," or with the new satellite imagery services, "Images copyright Digital Globe." These companies made substantial investments in their databases (NavTeq alone reportedly invested $750 million to build their database of street addresses and directions. Digital Globe spent $500 million to launch their own satellite to improve on government-supplied imagery.) NavTeq has gone so far as to imitate Intel's familiar Intel Inside logo: Cars with navigation systems bear the imprint, "NavTeq Onboard." Data is indeed the Intel Inside of these applications, a sole source component in systems whose software infrastructure is largely open source or otherwise commodified.

The now hotly contested web mapping arena demonstrates how a failure to understand the importance of owning an application's core data will eventually undercut its competitive position. MapQuest pioneered the web mapping category in 1995, yet when Yahoo!, and then Microsoft, and most recently Google, decided to enter the market, they were easily able to offer a competing application simply by licensing the same data.

Contrast, however, the position of Amazon.com. Like competitors such as Barnesandnoble.com, its original database came from ISBN registry provider R.R. Bowker. But unlike MapQuest, Amazon relentlessly enhanced the data, adding publisher-supplied data such as cover images, table of contents, index, and sample material. Even more importantly, they harnessed their users to annotate the data, such that after ten years, Amazon, not Bowker, is the primary source for bibliographic data on books, a reference source for scholars and librarians as well as consumers. Amazon also introduced their own proprietary identifier, the ASIN, which corresponds to the ISBN where one is present, and creates an equivalent namespace for products without one. Effectively, Amazon "embraced and extended" their data suppliers.

Imagine if MapQuest had done the same thing, harnessing their users to annotate maps and directions, adding layers of value. It would have been much more difficult for competitors to enter the market just by licensing the base data.

The recent introduction of Google Maps provides a living laboratory for the competition between application vendors and their data suppliers. Google's lightweight programming model has led to the creation of numerous value-added services in the form of mashups that link Google Maps with other internet-accessible data sources. Paul Rademacher's housingmaps.com, which combines Google Maps with Craigslist apartment rental and home purchase data to create an interactive housing search tool, is the pre-eminent example of such a mashup.

At present, these mashups are mostly innovative experiments, done by hackers. But entrepreneurial activity follows close behind. And already, one can see that for at least one class of developer, Google has taken the role of data source away from Navteq and inserted themselves as a favored intermediary. We expect to see battles between data suppliers and application vendors in the next few years, as both realize just how important certain classes of data will become as building blocks for Web 2.0 applications.

The race is on to own certain classes of core data: location, identity, calendaring of public events, product identifiers and namespaces. In many cases, where there is significant cost to create the data, there may be an opportunity for an Intel Inside style play, with a single source for the data. In others, the winner will be the company that first reaches critical mass via user aggregation, and turns that aggregated data into a system service.

For example, in the area of identity, PayPal, Amazon's 1-click, and the millions of users of communications systems, may all be legitimate contenders to build a network-wide identity database. (In this regard, Google's recent attempt to use cell phone numbers as an identifier for Gmail accounts may be a step towards embracing and extending the phone system.) Meanwhile, startups like Sxip are exploring the potential of federated identity, in quest of a kind of "distributed 1-click" that will provide a seamless Web 2.0 identity subsystem. In the area of calendaring, EVDB is an attempt to build the world's largest shared calendar via a wiki-style architecture of participation. While the jury's still out on the success of any particular startup or approach, it's clear that standards and solutions in these areas, effectively turning certain classes of data into reliable subsystems of the "internet operating system", will enable the next generation of applications.

A further point must be noted with regard to data, and that is user concerns about privacy and their rights to their own data. In many of the early web applications, copyright is only loosely enforced. For example, Amazon lays claim to any reviews submitted to the site, but in the absence of enforcement, people may repost the same review elsewhere. However, as companies begin to realize that control over data may be their chief source of competitive advantage, we may see heightened attempts at control.

Much as the rise of proprietary software led to the Free Software movement, we expect the rise of proprietary databases to result in a Free Data movement within the next decade. One can see early signs of this countervailing trend in open data projects such as Wikipedia, the Creative Commons, and in software projects like Greasemonkey, which allow users to take control of how data is displayed on their computer.

What Is Web 2.0? page2

2008-03-30T20:46:00.000-07:00

by Tim O'Reilly

DoubleClick vs. Overture and AdSense

Like Google, DoubleClick is a true child of the internet era. It harnesses software as a service, has a core competency in data management, and, as noted above, was a pioneer in web services long before web services even had a name. However, DoubleClick was ultimately limited by its business model. It bought into the '90s notion that the web was about publishing, not participation; that advertisers, not consumers, ought to call the shots; that size mattered, and that the internet was increasingly being dominated by the top websites as measured by MediaMetrix and other web ad scoring companies.

As a result, DoubleClick proudly cites on its website "over 2000 successful implementations" of its software. Yahoo! Search Marketing (formerly Overture) and Google AdSense, by contrast, already serve hundreds of thousands of advertisers apiece.

Overture and Google's success came from an understanding of what Chris Anderson refers to as "the long tail," the collective power of the small sites that make up the bulk of the web's content. DoubleClick's offerings require a formal sales contract, limiting their market to the few thousand largest websites. Overture and Google figured out how to enable ad placement on virtually any web page. What's more, they eschewed publisher/ad-agency friendly advertising formats such as banner ads and popups in favor of minimally intrusive, context-sensitive, consumer-friendly text advertising.

The Web 2.0 lesson: leverage customer-self service and algorithmic data management to reach out to the entire web, to the edges and not just the center, to the long tail and not just the head.

A Platform Beats an Application Every Time

In each of its past confrontations with rivals, Microsoft has successfully played the platform card, trumping even the most dominant applications. Windows allowed Microsoft to displace Lotus 1-2-3 with Excel, WordPerfect with Word, and Netscape Navigator with Internet Explorer.

This time, though, the clash isn't between a platform and an application, but between two platforms, each with a radically different business model: On the one side, a single software provider, whose massive installed base and tightly integrated operating system and APIs give control over the programming paradigm; on the other, a system without an owner, tied together by a set of protocols, open standards and agreements for cooperation.

Windows represents the pinnacle of proprietary control via software APIs. Netscape tried to wrest control from Microsoft using the same techniques that Microsoft itself had used against other rivals, and failed. But Apache, which held to the open standards of the web, has prospered. The battle is no longer unequal, a platform versus a single application, but platform versus platform, with the question being which platform, and more profoundly, which architecture, and which business model, is better suited to the opportunity ahead.

Windows was a brilliant solution to the problems of the early PC era. It leveled the playing field for application developers, solving a host of problems that had previously bedeviled the industry. But a single monolithic approach, controlled by a single vendor, is no longer a solution, it's a problem. Communications-oriented systems, as the internet-as-platform most certainly is, require interoperability. Unless a vendor can control both ends of every interaction, the possibilities of user lock-in via software APIs are limited.

Any Web 2.0 vendor that seeks to lock in its application gains by controlling the platform will, by definition, no longer be playing to the strengths of the platform.

This is not to say that there are not opportunities for lock-in and competitive advantage, but we believe they are not to be found via control over software APIs and protocols. There is a new game afoot. The companies that succeed in the Web 2.0 era will be those that understand the rules of that game, rather than trying to go back to the rules of the PC software era.

Not surprisingly, other web 2.0 success stories demonstrate this same behavior. eBay enables occasional transactions of only a few dollars between single individuals, acting as an automated intermediary. Napster (though shut down for legal reasons) built its network not by building a centralized song database, but by architecting a system in such a way that every downloader also became a server, and thus grew the network.

Akamai vs. BitTorrent

Like DoubleClick, Akamai is optimized to do business with the head, not the tail, with the center, not the edges. While it serves the benefit of the individuals at the edge of the web by smoothing their access to the high-demand sites at the center, it collects its revenue from those central sites.

BitTorrent, like other pioneers in the P2P movement, takes a radical approach to internet decentralization. Every client is also a server; files are broken up into fragments that can be served from multiple locations, transparently harnessing the network of downloaders to provide both bandwidth and data to other users. The more popular the file, in fact, the faster it can be served, as there are more users providing bandwidth and fragments of the complete file.

BitTorrent thus demonstrates a key Web 2.0 principle: the service automatically gets better the more people use it. While Akamai must add servers to improve service, every BitTorrent consumer brings his own resources to the party. There's an implicit "architecture of participation", a built-in ethic of cooperation, in which the service acts primarily as an intelligent broker, connecting the edges to each other and harnessing the power of the users themselves.

2. Harnessing Collective Intelligence

The central principle behind the success of the giants born in the Web 1.0 era who have survived to lead the Web 2.0 era appears to be this, that they have embraced the power of the web to harness collective intelligence:

Hyperlinking is the foundation of the web. As users add new content, and new sites, it is bound in to the structure of the web by other users discovering the content and linking to it. Much as synapses form in the brain, with associations becoming stronger through repetition or intensity, the web of connections grows organically as an output of the collective activity of all web users.
Yahoo!, the first great internet success story, was born as a catalog, or directory of links, an aggregation of the best work of thousands, then millions of web users. While Yahoo! has since moved into the business of creating many types of content, its role as a portal to the collective work of the net's users remains the core of its value.
Google's breakthrough in search, which quickly made it the undisputed search market leader, was PageRank, a method of using the link structure of the web rather than just the characteristics of documents to provide better search results.
eBay's product is the collective activity of all its users; like the web itself, eBay grows organically in response to user activity, and the company's role is as an enabler of a context in which that user activity can happen. What's more, eBay's competitive advantage comes almost entirely from the critical mass of buyers and sellers, which makes any new entrant offering similar services significantly less attractive.
Amazon sells the same products as competitors such as Barnesandnoble.com, and they receive the same product descriptions, cover images, and editorial content from their vendors. But Amazon has made a science of user engagement. They have an order of magnitude more user reviews, invitations to participate in varied ways on virtually every page--and even more importantly, they use user activity to produce better search results. While a Barnesandnoble.com search is likely to lead with the company's own products, or sponsored results, Amazon always leads with "most popular", a real-time computation based not only on sales but other factors that Amazon insiders call the "flow" around products. With an order of magnitude more user participation, it's no surprise that Amazon's sales also outpace competitors.

Now, innovative companies that pick up on this insight and perhaps extend it even further, are making their mark on the web:

Wikipedia, an online encyclopedia based on the unlikely notion that an entry can be added by any web user, and edited by any other, is a radical experiment in trust, applying Eric Raymond's dictum (originally coined in the context of open source software) that "with enough eyeballs, all bugs are shallow," to content creation. Wikipedia is already in the top 100 websites, and many think it will be in the top ten before long. This is a profound change in the dynamics of content creation!
Sites like del.icio.us and Flickr, two companies that have received a great deal of attention of late, have pioneered a concept that some people call "folksonomy" (in contrast to taxonomy), a style of collaborative categorization of sites using freely chosen keywords, often referred to as tags. Tagging allows for the kind of multiple, overlapping associations that the brain itself uses, rather than rigid categories. In the canonical example, a Flickr photo of a puppy might be tagged both "puppy" and "cute"--allowing for retrieval along natural axes generated user activity.
Collaborative spam filtering products like Cloudmark aggregate the individual decisions of email users about what is and is not spam, outperforming systems that rely on analysis of the messages themselves.
It is a truism that the greatest internet success stories don't advertise their products. Their adoption is driven by "viral marketing"--that is, recommendations propagating directly from one user to another. You can almost make the case that if a site or product relies on advertising to get the word out, it isn't Web 2.0.
Even much of the infrastructure of the web--including the Linux, Apache, MySQL, and Perl, PHP, or Python code involved in most web servers--relies on the peer-production methods of open source, in themselves an instance of collective, net-enabled intelligence. There are more than 100,000 open source software projects listed on SourceForge.net. Anyone can add a project, anyone can download and use the code, and new projects migrate from the edges to the center as a result of users putting them to work, an organic software adoption process relying almost entirely on viral marketing.

The lesson: Network effects from user contributions are the key to market dominance in the Web 2.0 era.

What Is Web 2.0? page1

2008-03-30T20:21:00.000-07:00

by Tim O'Reilly

Design Patterns and Business Models for the Next Generation of Software

The bursting of the dot-com bubble in the fall of 2001 marked a turning point for the web. Many people concluded that the web was overhyped, when in fact bubbles and consequent shakeouts appear to be a common feature of all technological revolutions. Shakeouts typically mark the point at which an ascendant technology is ready to take its place at center stage. The pretenders are given the bum's rush, the real success stories show their strength, and there begins to be an understanding of what separates one from the other.

The concept of "Web 2.0" began with a conference brainstorming session between O'Reilly and MediaLive International. Dale Dougherty, web pioneer and O'Reilly VP, noted that far from having "crashed", the web was more important than ever, with exciting new applications and sites popping up with surprising regularity. What's more, the companies that had survived the collapse seemed to have some things in common. Could it be that the dot-com collapse marked some kind of turning point for the web, such that a call to action such as "Web 2.0" might make sense? We agreed that it did, and so the Web 2.0 Conference was born.

In the year and a half since, the term "Web 2.0" has clearly taken hold, with more than 9.5 million citations in Google. But there's still a huge amount of disagreement about just what Web 2.0 means, with some people decrying it as a meaningless marketing buzzword, and others accepting it as the new conventional wisdom.

This article is an attempt to clarify just what we mean by Web 2.0.

In our initial brainstorming, we formulated our sense of Web 2.0 by example:

Web 1.0		Web 2.0
DoubleClick	-->	Google AdSense
Ofoto	-->	Flickr
Akamai	-->	BitTorrent
mp3.com	-->	Napster
Britannica Online	-->	Wikipedia
personal websites	-->	blogging
evite	-->	upcoming.org and EVDB
domain name speculation	-->	search engine optimization
page views	-->	cost per click
screen scraping	-->	web services
publishing	-->	participation
content management systems	-->	wikis
directories (taxonomy)	-->	tagging ("folksonomy")
stickiness	-->	syndication

The list went on and on. But what was it that made us identify one application or approach as "Web 1.0" and another as "Web 2.0"? (The question is particularly urgent because the Web 2.0 meme has become so widespread that companies are now pasting it on as a marketing buzzword, with no real understanding of just what it means. The question is particularly difficult because many of those buzzword-addicted startups are definitely not Web 2.0, while some of the applications we identified as Web 2.0, like Napster and BitTorrent, are not even properly web applications!) We began trying to tease out the principles that are demonstrated in one way or another by the success stories of web 1.0 and by the most interesting of the new applications.

1. The Web As Platform

Like many important concepts, Web 2.0 doesn't have a hard boundary, but rather, a gravitational core. You can visualize Web 2.0 as a set of principles and practices that tie together a veritable solar system of sites that demonstrate some or all of those principles, at a varying distance from that core.

Figure 1 shows a "meme map" of Web 2.0 that was developed at a brainstorming session during FOO Camp, a conference at O'Reilly Media. It's very much a work in progress, but shows the many ideas that radiate out from the Web 2.0 core.

For example, at the first Web 2.0 conference, in October 2004, John Battelle and I listed a preliminary set of principles in our opening talk. The first of those principles was "The web as platform." Yet that was also a rallying cry of Web 1.0 darling Netscape, which went down in flames after a heated battle with Microsoft. What's more, two of our initial Web 1.0 exemplars, DoubleClick and Akamai, were both pioneers in treating the web as a platform. People don't often think of it as "web services", but in fact, ad serving was the first widely deployed web service, and the first widely deployed "mashup" (to use another term that has gained currency of late). Every banner ad is served as a seamless cooperation between two websites, delivering an integrated page to a reader on yet another computer. Akamai also treats the network as the platform, and at a deeper level of the stack, building a transparent caching and content delivery network that eases bandwidth congestion.

Nonetheless, these pioneers provided useful contrasts because later entrants have taken their solution to the same problem even further, understanding something deeper about the nature of the new platform. Both DoubleClick and Akamai were Web 2.0 pioneers, yet we can also see how it's possible to realize more of the possibilities by embracing additional Web 2.0 design patterns.

Let's drill down for a moment into each of these three cases, teasing out some of the essential elements of difference.

Netscape vs. Google

If Netscape was the standard bearer for Web 1.0, Google is most certainly the standard bearer for Web 2.0, if only because their respective IPOs were defining events for each era. So let's start with a comparison of these two companies and their positioning.

Netscape framed "the web as platform" in terms of the old software paradigm: their flagship product was the web browser, a desktop application, and their strategy was to use their dominance in the browser market to establish a market for high-priced server products. Control over standards for displaying content and applications in the browser would, in theory, give Netscape the kind of market power enjoyed by Microsoft in the PC market. Much like the "horseless carriage" framed the automobile as an extension of the familiar, Netscape promoted a "webtop" to replace the desktop, and planned to populate that webtop with information updates and applets pushed to the webtop by information providers who would purchase Netscape servers.

In the end, both web browsers and web servers turned out to be commodities, and value moved "up the stack" to services delivered over the web platform.

Google, by contrast, began its life as a native web application, never sold or packaged, but delivered as a service, with customers paying, directly or indirectly, for the use of that service. None of the trappings of the old software industry are present. No scheduled software releases, just continuous improvement. No licensing or sale, just usage. No porting to different platforms so that customers can run the software on their own equipment, just a massively scalable collection of commodity PCs running open source operating systems plus homegrown applications and utilities that no one outside the company ever gets to see.

At bottom, Google requires a competency that Netscape never needed: database management. Google isn't just a collection of software tools, it's a specialized database. Without the data, the tools are useless; without the software, the data is unmanageable. Software licensing and control over APIs--the lever of power in the previous era--is irrelevant because the software never need be distributed but only performed, and also because without the ability to collect and manage the data, the software is of little use. In fact, the value of the software is proportional to the scale and dynamism of the data it helps to manage.

Google's service is not a server--though it is delivered by a massive collection of internet servers--nor a browser--though it is experienced by the user within the browser. Nor does its flagship search service even host the content that it enables users to find. Much like a phone call, which happens not just on the phones at either end of the call, but on the network in between, Google happens in the space between browser and search engine and destination content server, as an enabler or middleman between the user and his or her online experience.

While both Netscape and Google could be described as software companies, it's clear that Netscape belonged to the same software world as Lotus, Microsoft, Oracle, SAP, and other companies that got their start in the 1980's software revolution, while Google's fellows are other internet applications like eBay, Amazon, Napster, and yes, DoubleClick and Akamai.

Hide/Show Console window in .NET 2.0 and higher (black window)

2008-03-26T20:13:00.000-07:00

When working with .Net Console application, one issue may occurred is how to hide the console screen ( the black window ). In my case, my console application call to show an Window Form and the console need to be hide for convenient handling. And when needed, we also unhide the console.

See runnable example below :


using System;
using System.Collections.Generic;
using System.Windows.Forms;

namespace MyNamespace
{
    class Program
    {
        [DllImport("user32.dll")]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
        [DllImport("user32.dll")]
        static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

        [STAThread]
        static void Main(string[] args)
        {
            // My example context is when app run with no parameters
            // application launch an UI to waiting command from it.           
            if (arrArgs.Count == 0)
            {
                // Display manage UI and hide console
                HideConsole();
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new mainForm());
            }
            else
            {
                // Handle parameters ...
            }
        }  
      
        static void HideConsole()
        {
            IntPtr hWnd = FindWindow(null, Console.Title);
            if(hWnd != IntPtr.Zero)
            {
                ShowWindow(hWnd, 0); // 0 = SW_HIDE
            }
        }
        static void ShowConsole()
        {
            IntPtr hWnd = FindWindow(null, Console.Title);
            if (hWnd != IntPtr.Zero)
            {
                ShowWindow(hWnd, 1); //1 = SW_SHOWNORMA
            }
        }
    }
}

Hope this useful for you.
Happy harvest exp.
Moongy.

How to get the Current windows username?

2008-03-20T21:14:00.000-07:00

From Dotnetspider

I am trying to integrate single - sign - on Facility for one application in .NET.
I would like get the cuurent windows user name so that i will compare that name with the name in DB. If succeeds application should allow user further. Please help

Answers .............

20 Sep 06 03:28 AM : Padma : MNC
Dim strLogonUser as string strLogonUser = Request.ServerVariables("REMOTE_USER")
20 Sep 06 03:34 AM : chandan nagaraj :
Dim temp As String = System.Web.HttpContext.Current.User.Identity.Name dim Username as string Username = Mid(temp, InStr(temp, "\") + 1)
20 Sep 06 03:54 AM : Gaurav Sharma : MCAD/MCP http://www.dotnetlearner.blogspot.com
to access Current window User name u need to read it from Registry thanks
20 Sep 06 04:56 AM : kumar : WC2
Hi, you can write like below HttpContext.Current.User.Identity.Name thanks and regards, kumar
20 Sep 06 05:03 AM : chandan nagaraj :
using three ways we can get the User Name using C# 1) System.Security.Principal.WindowsPrincipal p = System.Threading.Thread.CurrentPrincipal as System.Security.Principal.WindowsPrincipal; string strName = p.Identity.Name; [ OR ] 2) string strName = HttpContext.Current.User.Identity.Name.ToString(); [ OR ] 3) string strName = Request.ServerVariables["AUTH_USER"]; //Finding with name string strName = Request.ServerVariables[5]; //Finding with index In Above 3 Cases returnin string contains DomainName\WinNTLoggedUserName Using string operations seperate the DomainName and UserName. Source:-Code Project
25 Apr 07 04:50 AM : vivek singh bhadauriya : ANPL http://www.agroecommerce.net.in
In window application (VB.Net)use this on login form... SaveSetting("AnyName", "Properties", "UserID",txtName.text) Now on any form u can get that value by.... Dim UserId As string = GetSetting("AnyName", "Properties", "UserID")

----------------------------------------------------------

From TheScript

To get the current user, better switch to .NET:
Environment.UserName
or
System.Windows.Forms.SystemInformation.UserName
--
Thomas Scheidegger - MVP .NET - 'NETMaster'
http://www.cetus-links.org/oo_dotnet.html - http://dnetmaster.net/

-------------------------------------------------
Hi,
You can use :
WindowsIdentity.GetCurrent().Name
It return the user logged on the system.
Hope this help,
--
Ignacio Machin,
ignacio.machin AT dot.state.fl.us
Florida Department Of Transportation

Regular Expression references

2008-03-16T22:31:00.000-07:00

Regular expressions provide a concise and flexible means for identifying strings of text of interest, such as particular characters, words, or patterns of characters. Regular expressions (abbreviated as regex or regexp, with plural forms regexes, regexps, or regexen) are written in a formal language that can be interpreted by a regular expression processor, a program that either serves as a parser generator or examines text and identifies parts that match the provided specification.

This article indexed some useful internet resources about Regular Expressions (syntax, explanation and examples).

How to match a pattern by using regular expressions and Visual C#

Link

Regular Expression Syntax

Link

Introduction to Regular Expressions (JScript .NET)

Link

Introduction to Regular Expressions (Visual Basic Scripting Edition)

Link

Regular Expressions Language Elements (Microsoft .NET Framework General Reference)

Link

Regular Expression (RegExp) Object (Microsoft .NET Framework Class Library)

Link

C# Regular Expressions by Brad Merrill

Regular expressions have been used in various programming languages and tools for many years. The .NET Base Class Libraries include a namespace and a set of classes for utilizing the power of regular expressions. They are designed to be compatible with Perl 5 regular expressions whenever possible.

In addition, the regexp classes implement some additional functionality, such as named capture groups, right- to-left pattern matching, and expression compilation.

In this article, I'll provide a quick overview of the classes and methods of the System.Text.RegularExpression assembly, some examples of matching and replacing strings, a more detailed walk-through of a grouping structure, and finally, a set of cookbook expressions for use in your own applications. Read more

C# Regular Expressions, Revisited by Brad Merrill, coauthor of C# Essentials, 2nd Edition.

The following is a brief list of the major changes to the RegEx class library since Beta1:

* The RegularExpression Assembly is now merged with the main Frameworks class library. This means you will no longer need to reference the assembly seperately. You will still need to specify the namespace via the using statement, in order to use the classes by name.

* When matching groups, the Group method was used to retrieve appropriately indexed group. Now we can retrieve the Groups property, which is a GroupCollection, which can be indexed directly.

* In Beta1, the RegEx modifiers were specified as character code. Now, there is an Enum called RegexOptions which provides access to the modifier functionality. Read more

Beginning Regular Expressions in C#, Java, and Perl by Larry Mak

A regular expression is a pattern of text in regular language. It describes what to match in a regular string. It serves as a filter to find what you're looking for.

Regular expressions are somewhat standardized - they're consistent with the different languages, despite the different syntax to call them.

The two main function of using regular expression is to match and to replace. The former determines if the pattern is in the string, and if so, find it. Replace changes the string according to the pattern to another pattern. Read more

Regular Expressions and C#, .NET ( Syntax and explanation )

Link

An articles contains syntax table and explanation quite cool. Just have a visit.

Learn Regular Expression (Regex) syntax with C# and .NET

Link

C# Regular Expression (Regex) Examples in .NET

Link

C# Demo Application Illustrating the Use of Regular Expressions with The .NET Framework

Link

Regular Expressions Usage in C# By Prasad

Link

The source code shows how to use Regular Expressions in C#. The code Functions written for Validation Alphabet, AlphaNumeric, Integer, Postive Integer, Floating point numbers. You just cut copy these functions and use in any program.

Take a preview of C# Essentials, 2nd Edition at

Link

Get computer name, get IP Address, translate among them technique articles

2008-03-06T19:38:00.000-08:00

This is the list articles about how to get IP address from computer name, how to get ip address from network computer name, how to get MAC address, and vice versa, how to get name info by socket address. Almost are technique specification using C++, VC++ and one by PHP.

SystemInformation, ComputerName Property

http://msdn2.microsoft.com/en-us/library/system.windows.forms.systeminformation.computername.aspx

How to get IP address of computer given its name

http://www.thescripts.com/forum/thread280096.html

Get MAC address tool

http://www.youngzsoft.net/cc-get-mac-address/

Get the local computer name using C++

http://www.techbytes.ca/techbyte97.html

Listing all the IP addresses of an URL or Computer Name (using XAPI)

http://www.codeproject.com/KB/IP/ipaddresslist.aspx

PHP code get host by address, Get the Internet host name corresponding to a given IP address

http://de3.php.net/manual/en/function.gethostbyaddr.php

C++ Get address by computer name

http://www.opengroup.org/onlinepubs/009695399/functions/getaddrinfo.html

C++ Get computer name by socket address

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/system_information.asp
http://www.opengroup.org/onlinepubs/009695399/functions/getnameinfo.html

C++ Translate computer address to computer name

http://msdn2.microsoft.com/en-us/library/ms738532(VS.85).aspx
http://homepages.cwi.nl/~aeb/linux/man2html/man3/getnameinfo.3.html

HTML transparent image, PNG transparent issue

2008-03-04T19:09:00.000-08:00

Recently, i just designed my new blogspot blog and my problem was how to add a transparent image to my blog. As we known, transparent can be applied as background image. I fount a lot of ways to do background transparent via CSS. But i need work to be done with a png transparent image inside the tag <img>.

Everything is ok with Mozilla Firefox, but with IE the problem occured. In IE, the image also transpanent as the bare it is but it's background didn't match your outter background.

The answer is IE does not support transparent for PNG images. It's ok with the original GIF transparent images. You can also convert your images to GIF format or just match your background with it. If you need to digg more, hope list of articles below useful for you.

Try how cool it is when design your web with transparent images. >>click here

Start, stop thread, how implement multithread C#

2008-02-26T00:27:00.000-08:00

You're writing a application do something hard, your app UI was not responding when it's running... and you try multithreading...

So, how to implement it? and how to stop it? and... ;) how do i know it's stopped? the snippet below may help you to get the answer.

Below is a small help to implement multithread in C# - does not lock UI and synchronize to avoid recall thread that not complete yet ( ex.. when button clicked, thread run, the button disabled, till the thread complete then resume the button.)


      using System.Threading;          

      class MyClass{
      bool _isStop=false;     
      bool _isStopSuccess = false;
      private void Button1_Click(){
          try
          {
              if (_isStop == true)
              {          
                  Button1.Text = "Stop";       
                  ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork));             
              }
              else
              {
                  _isStop = true;
                  while (!_isStopSuccess)
                      Thread.Sleep(1000);   
                  Button1.Text = "Start";          
              }

          }
          catch (Exception ex)
          {             
              _isStop = true;
              Button1.Text = "Start";
          } 
      }


      private void DoWork(object state)
      {
           // In this sample, our function must has a loop
           // cuz we need to check the _isStop status every time the loop loops
           // otherwise, we had to Abort the thread if we want to stop it.
           for(int i=0;i<1000;i++)
           {
               if (_isStop)
               {
                   _isStopSuccess = true;
                   return;
               }

               // your work here
               // ..............
           }
      }
      }// end class

You should do check variable "_isStop" often, so that the thread could return as soon as possible.
The idea "_isStopSuccess" to show our whether thread is stopped successful and we can do something to get a better app ;) ( may be change label of a button between "Do work" and "Working...", set enable some control ... )

In the case your thread function does not in a loop, so how to stop it? With .Net 2.0 and higher, we should use BackGroundWorker class to implement multithreading. It's also provided ways to stop thread easily. In this case, with .Net 1.1, we must call Abort from our Thread instance to abort it. And also remember to try catch it, cuz the ThreadAbortException will occurred when thread was aborted.

Hope this useful for you.
Happy harvest exp.

make cool photo with Graphita

2008-02-26T00:03:00.001-08:00

Why dont you stop coding and try some funny thing ;)
Fortuitous, i found this site, just up load a pic and try many cool stuff there...
Take a stopping on ...why not? :D

http://www.graphita.com/

and before save your complete cool pic, push the print screen to cache it and paste to any picture editor; save process quite slow and your pic may be crashed. ;).
Happy harvest exp.

Remind Javascript operators

2008-02-25T23:50:00.000-08:00

The operator = is used to assign values.

The operator + is used to add values.

The assignment operator = is used to assign values to JavaScript variables.

The arithmetic operator + is used to add values together.

y=5;
z=2;
x=y+z;

The value of x, after the execution of the statements above is 7.

JavaScript Arithmetic Operators

Arithmetic operators are used to perform arithmetic between variables and/or values.

Given that y=5, the table below explains the arithmetic operators:

Operator	Description	Example	Result
+	Addition	x=y+2	x=7
-	Subtraction	x=y-2	x=3
*	Multiplication	x=y*2	x=10
/	Division	x=y/2	x=2.5
%	Modulus (division remainder)	x=y%2	x=1
++	Increment	x=++y	x=6
--	Decrement	x=--y	x=4

JavaScript Assignment Operators

Assignment operators are used to assign values to JavaScript variables.

Given that x=10 and y=5, the table below explains the assignment operators:

Operator	Example	Same As	Result
=	x=y		x=5
+=	x+=y	x=x+y	x=15
-=	x-=y	x=x-y	x=5
*=	x*=y	x=x*y	x=50
/=	x/=y	x=x/y	x=2
%=	x%=y	x=x%y	x=0

The + Operator Used on Strings

The + operator can also be used to add string variables or text values together.

To add two or more string variables together, use the + operator.

txt1="What a very";
txt2="nice day";
txt3=txt1+txt2;

After the execution of the statements above, the variable txt3 contains "What a verynice day".

To add a space between the two strings, insert a space into one of the strings:

txt1="What a very ";
txt2="nice day";
txt3=txt1+txt2;

or insert a space into the expression:

txt1="What a very";
txt2="nice day";
txt3=txt1+" "+txt2;

After the execution of the statements above, the variable txt3 contains:

"What a very nice day"

Adding Strings and Numbers

Look at these examples:

x=5+5;
document.write(x);

x="5"+"5";
document.write(x);

x=5+"5";
document.write(x);

x="5"+5;
document.write(x);

http://www.w3schools.com

Coding experience sharing...

Development Web Service Internal with standards

I found an interested guide with suggests as 'Standard' for Web Service development, it's really worthy to take reading.

Coding Standards (HTML/ASP/JavaScript)

File and folder names

Examples

Standard Folder Names

Variable Names (JavaScript, ASP)

HTML/ASP formatting

Cascading Style Sheets

JavaScript

SQL Formatting

SQL Tables and Fields

ORACLE Architecture and Terminology

Figure 1. ORACLE Architecture

Figure 2. Data Files and Tablespaces

Figure 3. The Relationship Among Segments, Extents and Data Blocks

Figure 4. Data Block Format

Figure 5. Maintaining the Free Space of Data Blocks with PCTFREE and PCTUSED

Response buffer limit exceeded : Error message when a Web browser sends a request for an active server page to a Web server that is running IIS 6.0

SYMPTOMS

CAUSE

RESOLUTION

Method 1: Decrease the response size

Method 2: Use the Response.Flush method

Method 3: Disable buffering

Method 4: Increase the buffer limit

Blogger JSON feed and a JSON recent posts widget

What is a JSON-Feed?

Getting the JSON-feed

Examining the feed

How to parse a JSON-feed

A basic Recent Posts Widget

Forms Authentication - Redirect Page and http to https problem

ASP.NET authentication with SSL and http to https, https to http problems

Efficient debug in Visual Studio 2005

Pass parameters to Install Shield ( MSI ) setup project

Detecting Session Timeout in ASP.NET 2.0 Web Application

Build an ASP.NET Session Timeout Redirect Control

Hướng dẫn config và sử dụng ASP.NET Session State

How ASP.NET Sessions Are Implemented

How Sessions Are Implemented

Example User Session

Conclusion

About Html encoding, remind character entity references

ASCII Characters

ISO Latin 1Characters

Javascript get mouse position ( compatible IE and Firefox )

Microsoft standard Numeric Format Strings

About ASP.NET Session State

ASP.NET Session State

Using ASP.NET Session State

Web.config

Session configuration

In-process Mode

Performance and Reliability Considerations

Microsoft Custom Numeric Format Strings

Javascript format numbers with custom string

Javascript Trim string

Understand ASP.NET Response.Redirect & Server.Transfer

Interact window service with command line

User objects and resources

Basic Introduction to SQLPLUS

Some elementary Commands

Schema

SQL with Oracle

Command Endings

SELECT

.NET assembly and COM interoperation

Debug javascript

HttpWebRequest : Expect: 100-continue Header Problem

Hide/Show Console window in .Net 1.1 Console application

NTLDR is Missing

Cause:

Computer is booting from a non-bootable source

Computer hard disk drive is not properly setup in BIOS

Corrupt NTLDR and/or NTDETECT.COM file

Misconfiguration with the boot.ini file

Attempting to upgrade from a Windows 95, 98, or ME computer that is using FAT32

New hard disk drive being added