Opera for Windows 7.54 serial key or number

• 15 minutes to read

New information has been added to this article since publication.
Refer to the Editor's Update below.

The ASP Column

Determining Browser Capabilities in ASP.NET

George Shepherd

Contents

HTTP Headers and the User Agent
Determining Browser Capabilities
Mapping Headers to Browser Capabilities
Up-Level Versus Down-Level Browsers
Defining a New Browser
Testing
Creating Your Own Target
HtmlTextWriter and Html32TextWriter
Mobile Browser Capabilities
Conclusion

Web applications are different from applications that run in homogenous environments because they send their output to all kinds of platforms and Web browsers. Some browsers support client-side scripting, some support XHTML, and still others have limited screen real estate. So how will your Web app deliver content to browsers with limited capabilities or special requirements?

[ Editor's Update - 12/14/2004: The sidebar has been updated.]

HTTP Headers and the User Agent

The first step in determining the capabilities of the browser making a request to your Web site is to find out what kind of browser it is. Inside the payload sent in the HTTP Headers is the User Agent string, which describes the browser making the request. While you don't normally see the headers sent by your client browser to a remote Web site, you can view them using TCP tracing applications. I use TCPTrace (an application written by Simon Fell and Matt Humphrey) to examine headers. Figure 1 shows the header dump for one such Web request.

Figure 1 HTTP Request/Response Payloads in TCP Trace

Here's the text from the upper-right pane of the bitmap:

Here's the text from the lower-right pane:

Notice the User Agent strings in Figure 2. In your ASP.NET application, you can easily fetch the string from the header collection programmatically. You can also look at the User Agent string when you turn tracing on in your application, as shown in Figure 3.

Figure 2 Common User Agent Strings

Figure 3** The HTTP_USER_AGENT String as It Appears **

That's great, but what do you do with that information? It's only useful if you know what capabilities are attached to each browser version. In both classic ASP and ASP.NET, the capabilities of various browsers are captured in secondary files.

Determining Browser Capabilities

In classic ASP the DLL %windir%\System32\inetsrv\browscap.dll includes a class that determines browser capabilities based on the incoming User Agent string. The browser capabilities object examines %windir%\System32\inetsrv\browscap.ini to match the User Agent string to a specific section in the .ini file, which describes the well-known capabilities of that browser. (ATL Server, which is a C++ template library for creating ISAPI DLLs, also uses browscap.ini to determine browser capabilities. For more information on ATL Server, take a look at The ASP Column in the November 2003 issue of MSDN®Magazine.)

Figure 4 shows a section from the browscap.ini file reporting the capabilities of a browser identifying itself as Microsoft® Internet Explorer 2.0. This section of the .ini file indicates that Internet Explorer does not support client-side scripting, nor does it support Java applets.

Figure 4 Browscap.ini Section

To use this information in a classic ASP application, you'd create the BrowserType object in a script block (it's a COM object with the ProgID of "MSWC.BrowserType") and query its properties for information such as browser name, version, and whether cookies are supported. With that information, you can deliver your content appropriately.

ASP.NET includes the HttpBrowserCapabilities class for interrogating the browser's capabilities. The HttpRequest class includes a reference to an instance of the HttpBrowserCapabilties class, so it's always available throughout your application. You can fetch it from the current Page instance or from the current instance of the HttpContext class. HttpBrowserCapabilities includes a number of properties and their significance, as you can see in Figure 5.

Figure 5 Browser Capabilities Represented

The significance of most of the browser capabilities is obvious, and you can use the information provided to tailor your output. For example, if you have a script, you should send it to the client only if the browser on the other end understands it, which I demonstrate in the code in Figure 6.

Figure 6 Script Test

Mapping Headers to Browser Capabilities

In the September 2004 installment of this column, I looked at ASP.NET configuration and how ASP.NET has specific handlers for interpreting individual sections within a configuration file. Let's now take a look at parts of the Machine.config file, which is the starting point for configuration in ASP.NET. Near the top of the file you'll see a node providing the name of the component that interprets a User Agent string to determine a browser's capabilities:

As you can see, the type named "HttpCapabilitiesSectionHandler" is used to parse the <browserCaps> section of the configuration file. After the browser configuration settings have been parsed, for each request it looks at the HTTP headers and uses them to determine the client browser capabilities. The <browserCaps> element within Machine.config contains mappings between HTTP headers and specific browser capabilities. This information is used to populate the HttpBrowserCapabilities class for each request. Note that the browser capabilities feature matches more than just the User Agent string. Any inbound header can be matched and utilized as part of the values set for that HttpBrowserCapabilities object. Figure 7 shows some code from the <browserCaps> section of Machine.config.

Figure 7 <browserCaps>

The <browserCaps> section defines a set of key-value pairs representing capabilities. Further down in the Machine.config file, you'll see mappings of these variables to specific regular expressions in various User Agent strings. For example, between the <browserCaps> tags, you'll see regular expressions indicating the client version. If the HttpBrowserCapabilitiesHandler matches the platform strings in the User Agent string, HttpBrowserCapabilitiesHandler sets the platform property appropriately:

Up-Level Versus Down-Level Browsers

Browsers as defined in Machine.config can be categorized into two main types: up-level and down-level. Up-level browsers support HTML 4.0, cascading style sheets, ECMAScript version 1.2 (JScript® and JavaScript), and a W3C-compatible Document Object Model. Down-level browsers and client devices support only HTML 3.2. The distinction between browsers is useful for evaluating how the appearance of your Web site will change when accessed in the most common use cases.

Most modern browsers are mentioned within Machine.config. If a browser is not defined there, you can easily add a definition for one to the Machine.config or to your application's Web.config.

Defining a New Browser

[ Editor's Update - 12/14/2004: At any given node, only one child browser element can match, or the runtime will stop the tree traversal at that point. Multiple gateway matches are permitted.] This restriction eliminates some of the previous ambiguity found when working to update the browserCaps section. The regular expressions must provide unique matches so that a definitive path through the tree can be found. A request does not necessarily need to match all the way to a leaf node. The resulting HttpBrowserCapabilities object is the result of the default settings specified in the root node and the cumulative effect of all the additional properties and overridden settings that are applied as the tree is traversed.

A browser element can either create a new node in the tree by specifying a parent browser node, or it can modify the settings for an existing node by referencing it. If a browser element is not modifying an existing node, it will include an identification section to indicate what capabilities or header values must exist for a browser match to be true. In addition to identifying a browser, the node can also contain a set of elements that capture data from the headers of the request. This information can then be used in the capabilities section to set properties of the HttpBrowserCapabilities object.

Another change to the browser capabilities system is the support for specifying control adapters. ASP.NET 2.0 features a pluggable control adapter architecture that allows you to take over or participate in many of the lifecycle behaviors of the controls in a page. The need to adapt a control's behavior or output is typically a function of the browser that is being targeted, so it makes sense to include the controlAdapters element in the browser definition as well.

A final key feature of the new browser capabilities system is how it works to provide support for browser-specific page customization. In version 2.0 of ASP.NET, you can customize property values declaratively based on the requesting browser. Simply prefix a control attribute with the ID of a browser. The most specific match from the tree traversal will be used as the final value of the property. For example, a label can declaratively set different text to be used based on what browser has made the request, as shown here:

This makes it easy to tailor applications for the unique capabilities of the various browsers.

The enhancements to the browser capabilities feature in ASP.NET 2.0 should make it easier for you to keep up with the changing features of new browsers as they emerge to customize applications for varying browsers, and even to modify control behaviors through the use of adapters.

Figure 8 Web.Config

This tells ASP.NET about a new kind of browser named the "LameBrowser". Given the definition in the <browserCaps> section, this is a down-level browser that supports background sounds. If the User Agent includes the string "LameBrowser", ASP.NET will fill the current HttpBrowserCapabilities object with the values mentioned in Web.config. Note, though, that the matching of the regular expressions is additive, so a subsequent match further down in the application hierarchy could override these settings.

Testing

If you have copies of your target browsers in your test environment, it's pretty easy to see how your Web site will respond. If not, ASP.NET supports an aliasing technique that lets you force your application into thinking a certain browser made a request.

In Machine.config, you'll find a <clientTarget> section that defines aliases for Internet Explorer 4.0 and 5.0, up-level browsers, and down-level browsers:

As you can see, the <clientTarget> section maps short names to specific User Agent strings. If you set your page's ClientTarget property to any of the aliases listed, the ClientTargetSectionHandler class will intercept the alias and use the specific User Agent string to determine the browser's capabilities. Here's an example of setting ClientTarget within the page directive (you can also set this property in the Visual Studio designer):

This allows you to render your page render in different browsers.

Creating Your Own Target

While ASP.NET gives you four built-in target aliases, you probably could benefit from more. For example, imagine you wanted to test your site against the Firefox browser or the LameBrowser mentioned previously. The following bit of XML placed in your Web.config file will do the trick (provided you have <browserCaps> sections set up for each of them):

HtmlTextWriter and Html32TextWriter

In addition to the properties shown in Figure 5, HttpBrowserCapabilities exposes another read-only property named TagWriter. The TagWriter property exposes the Type of the class to use to render tags from a control. If you've ever written a custom server-side control, you've undoubtedly seen the HtmlTextWriter class passed into the Render method.

You might think calling output.Write from within a server-side control is the same as calling Response.Write, but it's actually more flexible than that. The HtmlTextWriter contains methods for rendering specific HTML elements.

While it's often good enough to contain other ASP.NET server-side controls when writing a custom control, you sometimes need to work with tags manually. The HtmlTextWriter class includes methods to support stack-based rendering of tags and attributes.

In addition to helping you keep beginning and ending tags straight, the HtmlTextWriter helps you emit the right version of HTML. When ASP.NET gets a request, it examines the TagWriter property of the HttpBrowserCapabilities class and uses either HtmlTextWriter or Html32TextWriter (Html32TextWriter derives from HtmlTextWriter). For example, tables render slightly differently in HTML 3.2 than they do in HTML 4.0. The code snippet in Figure 9 (showing the Render method overridden in a server-side control) renders a simple table with one row and one column. HtmlTextWriter includes methods to render the attributes and tags based on the HTML version understood by the browser.

Figure 9 Rendering a Control

Here's how the Html32TextWriter renders the table

while the HtmlTextWriter class renders the table like this:

Remember, Page derives from the Control class and you may override the Render method to access the HtmlTextWriter from a Page. The ASP.NET standard server-side controls are built to render based upon the capabilities of the browser making the request.

Mobile Browser Capabilities

So far, I've looked only at the basic set of browser capabilities. A whole new set of mobile browsers are supported as of ASP.NET 1.1. A tour through the Machine.config file of an ASP.NET 1.1 installation reveals settings for devices and systems such as Windows® CE, Nokia, Ericsson, and AvantGo. These are the browsers you'll find built into modern cell phones and PDAs.

ASP.NET determines these capabilities in exactly the same way it does for normal browsers. However, as you look through the various devices, you'll see that determining browser capabilities for these devices is a bit more involved because there are just a lot more capabilities to figure out.

Determining the mobile capabilities of a device is a mere type cast away from the normal device capabilities. That is, just cast the Request.Browser field to the MobileCapabilities class and you can examine the device capabilities (MobileCapabilities derives from HttpBrowserCapabilities). The code in Figure 10 determines the nature of the markup language of the browser/device (WML versus HTML), the size of the user's screen (in characters), and whether or not the device can deal with e-mail.

Figure 10 Determining Mobile Browser Capabilities

When you look at Machine.config you'll see more than 75 mobile device capabilities (in addition to the standard browser capabilities). The mobile capabilities of a device are determined by the MobileDeviceCapabilitiesSectionHandler configuration handler.

Conclusion

ASP.NET provides a number of features for determining the capabilities of the client making any given request. This provides you with a means of controlling your site's output by aliasing client targets to specific User Agent strings within your application.

Send your questions and comments to  asp-net@microsoft.com.

George Shepherd specializes in software development for the .NET Framework. He is the author of Programming with Microsoft Visual C++.NET (Microsoft Press, 2002), and coauthor of Applied .NET (Addison-Wesley, 2001). He is a contributing architect for Syncfusion's Windows Forms and ASP.NET tools.

Cégünk 1995-ben alakult. Célunk, hogy a kor követelményeihez igazodva magas színvonalú akusztikai tervezési és kivitelezési szolgáltatásokat nyújtsunk középületek, irodaházak, stúdiók, színházak, koncerttermek, sportlétesítmények, lakóépületek beruházásánál, építésénél. Az elmúlt évek alatt számos speciális akusztikai feladatot oldottunk meg. Tovább >> Color Front - Mozi együttes Épületakusztikai és teremakusztikai tervezés (2006-2007) Liszt Ferenc Zeneakadémia – Rekonstrukció Teremakusztikai tervezés (2007-) További referenciák >>

learnwords 3.2 serial

left right left serial

leica lens number serial

leng serial

les paul serial numbers

les paul special serial numbers

lespaul serial numbers

letour serial

libvirt serial

licence serial

lifejournal 2 serial

like serial experiments lain

lineform 1.3 serial

lingvosoft 2007 serial

linplug albino serial

linux opera 7.54 serial

linux programming serial port sample

linux serial port c ioperm

linux serial port communication example

linux serial port mounting

lippia javanica by serial

lippia javanica by serial dilution

lippia javanica by serial dilution method

list of serial kilers

list of serial title word abbreviations cieps

list of serial title word abbreviations cieps isds

listgrabber 3.0 serial

mirc 6.32 serial number

mirc serial code

misu serial

mithology serial

mixman studio pro 4.0 serial

mixstation 2 serial number

mizuno golf club serial

mk1234gsx 120gb 5400 rpm serial

mk1234gsx 120gb 5400 rpm serial ata150

mks virus 2005 serial key

mnotes 4.3 10 serial

mnotes5 serial

mobile 8.65 serial

mobiledit serial no

mobiledit serial ou crack

mobilesync browser serial

mobimb serial

mobtime 5.1 serial

mobtime serial no

mobyexplorer serial

modbus serial

modem serial cable db9f

moneytoday serial

monkey 2.5 2 serial

monkey 2.5 2.951 serial

moonlight mpeg 2 decoder pack serial

moonlight xmuxer serial

morozov serial

morphgear 2.3 0.2 serial

mortus serial number

moschip pci serial card

mosrite guitar serial

most nortorious serial

most nortorious serial killers

most notourious serial

most notrious serial

most profilic serial

most profilic serial killer

most serial killers

motherboad serial

mount and blade serial

movavi enhancemovie 3 serial

mp3 cd converter crack serial

mp3 joiner serial

mp3 splitter and joiner 2.88 serial

mp3 splitter and joiner serial number

mp3 splitter and serial

mpr 1.0 9 serial

ms office 2007 serial

ms project 2007 serial

ms serial number

ms9540 serial

msgbox serial number missing

msipvs serial code

mugdha chaphekar new serial

muktha muktha serial

multi raid for ata133 serial ata

multiedit 9.10 serial

multimedia builder 4 serial

multimedia builder 4.9 5 serial number

multimedia builder 4962 serial

multiphysics 3.3 serial

multitranse 3.2 1 serial

muncher serial

mx300 serial number

my crysis serial

my files 3.98 5134 serial

my serial number for adobe photoshop

my serial number for dreamweaver

my serial number for sims 2

my sims2 serial

mydvd serial

myinvoices estimates deluxe serial

myjal serial connection

mymathlab serial

myslideshow 2.3 4 serial

mysporttraining food serial

mytheatre 3.36 serial

n track studio 4.04 serial

n7x0c palmos pda serial

naagin hindi serial

naagin serial on

naanayam serial

naggin serial

namewiz 4 serial

narges serial zohreh

nas 500 gb serial ata 300

nassi 4.4 serial

ndrive serial

neat image serial

neato mediaface 4 serial number

nee enaku serial

need a serial number for adobe photoshop

need for speed 2 underground serial

need for speed undergrond 2 serial

need serial number for adobe photoshop

neeram illai serial

neodownloader 2.3 c serial

nero 6606 serial key

net detective 7 serial

net detective serial key

net serial number

netadjust serial

netadvantage 2006 serial number

netasyst serial

netcaptor 7.5 3 serial

netcaptor pro serial

netfootle serial

netlimiter 2.0 7.1 pro serial

netlimiter serial

netmedia resource serial

netremote ir serial

netscream serial