by Danijel Arsenovski

In this article, you will begin to learn a preliminary VB refactoring, enforcing variable declaration. I call it preliminary because you can execute it even without deeper knowledge of the problem domain the code is meant to resolve. It is performed on the syntactic level and deals with problems that have their origin in VB backward compatibility or are related to good programming practices that I call "basic programming hygiene."

Almost all high-level programming languages implement the concept of types. By classifying values and expressions into types, you achieve a number of benefits: safety, optimization, abstraction, and modularity.

Most modern programming languages can be placed into one of two categories: statically typed or dynamically typed.

• In statically typed languages, type resolution is performed at compile time, and type information is provided explicitly in the code by the programmer himself in the form of a variable declaration.
• In dynamically typed languages, data types are not declared, and type information is not available until execution.

Visual Basic can be statically or dynamically typed. This behavior of VB's compiler is controlled by the Option Explicit statement.

Languages are also differentiated by the level of type safety they provide. Strongly typed languages disallow operations on arguments that have a wrong type. Other type languages permit these operations by implicitly casting the types of arguments so that the operations in question can be performed, guided by rules that take both operands into account. The disallowing or allowing of implicit conversions in VB code is controlled by VB's Option Strict statement.

by Arul Kumaravel

Windows PowerShell provides an extensible architecture that allows new functionality to be added to the shell. This new functionality can be in the form of cmdlets, providers, type extensions, format metadata, and so on. A Windows PowerShell snap-in is a .NET assembly that contains cmdlets, providers, and so on. Windows PowerShell comes with a set of basic snap-ins that offer all the basic cmdlets and providers built into the shell. You write a snap-in when you want your cmdlets or providers to be part of the default Windows PowerShell. When a snap-in is loaded in Windows PowerShell, all cmdlets and providers in the snap-in are made available to the user. This model allows administrators to customize the shell by adding or removing snap-ins to achieve precise sets of providers and cmdlets. (Note, however, that PowerShell built-in snap-ins, such as Microsoft.PowerShell.Host, cannot be removed.)

This article shows you step by step, how to author, register, and use both types of snap-ins. To make it more meaningful, the code examples also show the minimum coding needed for authoring cmdlets.

Note that all code examples in this article are written in C#. The code examples for this article are available from the code download page for the book, Professional Windows PowerShell Programming: Snapins, Cmdlets, Hosts and Providers (Wrox, 2008, ISBN: 978-0-470-17393-0).

by Scott Hanselman

If you start up Visual Studio 2008 and open the Books.xml, which is listing 10-1 from the code download for the book Professional ASP.NET 3.5: in C# and VB (Wrox, 2008, ISBN: 978-0-470-18757-9) file into the editor, you notice immediately that the Visual Studio editor provides syntax highlighting and formats the XML document as a nicely indented tree. If you start writing a new XML element anywhere, you don't have access to IntelliSense. Even though the http://example.books.com namespace is the default namespace, Visual Studio 2008 has no way to find the Books.xsd file (listing 10-3 from the code download for the book Professional ASP.NET 3.5: in C# and VB); it could be located anywhere. Remember that the namespace is not a URL. It's a URI — an identifier. Even if it were a URL it wouldn't be appropriate for the editor, or any program you write, to go out on the Web looking for a schema. You have to be explicit when associating XML Schema with instance documents.

Classes and methods are used to validate XML documents when you are working programmatically, but the Visual Studio editor needs a hint to find the Book.xsd schema. Assuming the Books.xsd file is in the same directory as Books.xml, you have three ways to inform the editor:

• Open the Books.xsd schema in Visual Studio in another window while the Books.xml file is also open.
• Include a schemaLocation attribute in the Books.xml file.
• If you open at least one XML file with the schemaLocation attribute set, Visual Studio uses that schema for any other open XML files that don't include the attribute.
• Add the Books.xsd schema to the list of schemas that Visual Studio knows about internally by adding it to the Schemas property in the document properties window of the Books.xml file. When schemas are added in this way, Visual Studio checks the document's namespace and determines if it already knows of a schema that matches.

by Rod Stephens

WPF applications are similar in concept to Windows Forms applications in many respects. Both display a form or window that contains controls. Controls in both systems provide properties, methods, and events that determine the control's appearance and behavior.

Windows Forms applications use a set of controls provided by the System.Windows.Forms namespace. WPF applications use a different set of controls in the System.Windows.Controls namespace. Many of these controls serve similar functions to those used by Windows Forms applications, but they provide a different set of capabilities. For example, both namespaces have buttons, labels, combo boxes, and check boxes, but their appearances and abilities are different.

WPF uses these similar, but different, controls for two main reasons. First, the new controls take better advantage of the graphics capabilities of modern computer hardware and software. They can more easily provide graphical effects such as transparent or translucent backgrounds, gradient shading, rotation, two- and three-dimensional appearance, multimedia, and other effects.

The second main goal of WPF is to provide a greater separation between the user interface and the code behind it. The following sections describe this idea and some of the other key WPF concepts in greater detail.

Separation of User Interface and Code

The idea of separating the user interface from the code isn't new. Visual Basic developers have been building thin user interface applications for years. Here, the user interface contains as little code as possible, and calls routines written in libraries to do most of the work.

Unfortunately, the code that calls those libraries sits inside the same file that defines the user interface, at least in Visual Studio 2008 Windows Forms applications. That means you cannot completely separate the code from the user interface. For example, if one developer wants to modify the user interface, another developer cannot simultaneously modify the code behind it.

WPF separates the user interface from the code more completely. The program stores the user interface definition in a text file that uses a language called XAML (pronounced zammel). XAML is a special form of Extensible Markup Language (XML) that defines user interface elements such as buttons, labels, container controls, backgrounds, colors, fonts, styles, and other control attributes.

by Imar Spaanjaars

Although you could theoretically write ASP.NET 3.5 Web applications with Notepad or another text editor alone, you really want to install a copy of Microsoft Visual Web Developer. VWD is developed specifically for building ASP.NET Web sites, and as such, hosts an enormous amount of tools that will help you in rapidly creating complex ASP.NET Web applications.

Visual Web Developer comes in two flavors: as a standalone and free version called Microsoft Visual Web Developer 2008 Express Edition, and as part of the larger development suite called Visual Studio 2008 which is also available in different editions, each with its own price tag. Although the Express Edition of VWD is free, it contains all the features and tools you need to create complex and feature-rich Web applications. Getting VWD is easy. You can just download it from the Microsoft site as discussed next.

Getting Visual Web Developer

You can get the free version of VWD from Microsoft's site at http://msdn.microsoft.com/vstudio/express/. On the Express home page, follow the Download link until you reach the page that offers the downloads for the Express products, including Visual Web Developer 2008 Express Edition. (You may need to choose the Web Development category first.) Read the system requirements to make sure VWD will run on your system and then download VWD 2008 Express Edition. Make sure you choose Visual Web Developer from the page, and not one of the other free Express products.

Don't be fooled by the file size of the download, which is a little under 3MB. The file you downloaded is just the installer that downloads the required files over the Internet. The total download is around 1.3GB.

Installing Visual Web Developer Express Edition

Installing Visual Web Developer is a straightforward, although somewhat lengthy process. Depending on your installation method, your computer and your Internet connection speed, installing VWD may take up to several hours.

by Bill Evjen

Prior to Visual Studio 2008, the ASP.NET AJAX product used to be a separate installation that you were required to install on your machine and the Web server that you were working with. This release gained in popularity quite rapidly and is now a part of the Visual Studio 2008 offering. Not only is it a part of the Visual Studio 2008 IDE, the ASP.NET AJAX product is also baked into the .NET Framework 3.5. This means that to use ASP.NET AJAX, you don't need to install anything if you are working with ASP.NET 3.5.

ASP.NET AJAX is now just part of the ASP.NET framework. When you create a new Web application, you do not have to create a separate type of ASP.NET application. Instead, all ASP.NET applications that you create are now AJAX-enabled.

If you have already worked with ASP.NET AJAX prior to this 3.5 release, you will find that there is really nothing new to learn. The entire technology is seamlessly integrated into the overall development experience.

Overall, Microsoft has fully integrated the entire ASP.NET AJAX experience so you can easily use Visual Studio and its visual designers to work with your AJAX-enabled pages and even have the full debugging story that you would want to have with your applications. Using Visual Studio 2008, you are now able to debug the JavaScript that you are using in the pages.

In addition, it is important to note that Microsoft focused a lot of attention on cross-platform compatibility with ASP.NET AJAX. You will find that the AJAX-enabled applications that you build upon the .NET Framework 3.5 can work within all the major up-level browsers out there (e.g., Firefox and Opera).

Developing with ASP.NET AJAX

There are a couple of types of Web developers out there. There are the Web developers who are used to working with ASP.NET and who have experience working with server-side controls and manipulating these controls on the server-side. Then there are developers who concentrate on the client-side and work with DHTML and JavaScript to manipulate and control the page and its behaviors.

With that said, it is important to realize that ASP.NET AJAX was designed for both types of developers. If you want to work more on the server-side of ASP.NET AJAX, you can use the new ScriptManager control and the new UpdatePanel control to AJAX-enable your current ASP.NET applications with little work on your part. All this work can be done using the same programming models that you are quite familiar with in ASP.NET.

In turn, you can also use the Client Script Library directly and gain greater control over what is happening on the client's machine. Next, this article looks at building a simple Web application that makes use of AJAX.

by Rod Stephens

Many of the newest features in Visual Studio 2008 were added to support LINQ (Language Integrated Query). Extension methods, lambda functions, anonymous types, and many of the other features new to Visual Studio were added to make building LINQ easier.

Visual Basic doesn't really execute LINQ queries. Instead it converts them into a series of function calls that perform the query. While the LINQ query syntax is generally easier to use, it is sometimes helpful to understand what those function calls look like.

The following sections explain the general form of these function calls. They explain how the function calls are built, how you can use these functions directly in your code, and how you can extend LINQ to add your own LINQ query methods.

by Bill Evjen

This article looks at Windows-based ASP.NET authentication, one of several different types of authentication measures ASP.NET 3.5 provides to use within your applications. ASP.NET has several ways of performing Windows-based authentication and we'll look at all of them: Integrated Windows authentication, Basic authentication, and Digest authentication. You'll also see in this article that if you are running your ASP.NET 3.5 pages on IIS 7 and Windows Vista, some of the authentication options will be configured with slightly different steps than in IIS 5.0 and 6.0 on Windows Server 2003 or Windows XP.

In ASP.NET terms, authentication is the process that determines the identity of a user. After a user has been authenticated, a developer can determine if the identified user has authorization to proceed. It is impossible to give an entity authorization if no authentication process has been applied. You should never authorize access to resources you mean to be secure if you have not applied an authentication process to the requests for the resources.

Authorization is the process of determining whether an authenticated user is permitted access to any part of an application, access to specific points of an application, or access only to specified datasets that the application provides. Authenticating and authorizing users and groups enable you to customize a site based on user types or preferences.

The different authentication modes are established through settings that can be applied to the application's web.config file or in conjunction with the application server's Internet Information Services (IIS) instance.

ASP.NET is configured through a series of .config files on the application server. These are XML-based files that enable you to easily change how ASP.NET behaves. This is an ideal way to work with the configuration settings you require. ASP.NET configuration files are applied in a hierarchal manner. The .NET Framework provides a server-level configuration file called the machine.config file, which can be found at C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG. The folder contains the machine.config file. This file provides ASP.NET application settings at a server-level, meaning that the settings are applied to each and every ASP.NET application that resides on the particular server.

A web.config file is another XML-based configuration file that resides in the root of the Web application. The settings applied in the web.config file override the same settings applied in the higher-level machine.config file.

You can even nest the web.config files so that the main application web.config file is located in the root directory of your application, but additional web.config files reside in some of the application's subdirectories (see Figure 1). The web.config files contained in any of the subdirectories supersede the root directory's web.config file. Therefore, any settings applied through a subdirectory's web.config file change whatever was set in the application's main web.config file.

by Bill Evjen

Developers generally like to include some of their own custom JavaScript functions in their ASP.NET pages. You have a couple of ways to do this. The first is to apply JavaScript directly to the controls on your ASP.NET pages. For example, look at a simple Label server control, shown in Listing 1, which displays the current date and time.

Listing 1: Showing the current date and time

VB

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs)
   TextBox1.Text = DateTime.Now.ToString()
End Sub

C#

protected void Page_Load(object sender, EventArgs e) {
   TextBox1.Text = DateTime.Now.ToString();
}

This little bit of code displays the current date and time on the page of the end user. The problem is that the date and time displayed are correct for the Web server that generated the page. If someone sits in the Pacific time zone (PST), and the Web server is in the Eastern time zone (EST), the page won't be correct for that viewer. If you want the time to be correct for anyone visiting the site, regardless of where they reside in the world, you can employ JavaScript to work with the TextBox control, as illustrated in Listing 2.

by Bill Evjen

Regular expressions are part of those small technology areas that are incredibly useful in a wide range of programs, yet rarely used among developers. You can think of regular expressions as a mini-programming language with one specific purpose: to locate substrings within a large string expression. It is not a new technology; it originated in the Unix environment and is commonly used with the Perl programming language. Microsoft ported it onto Windows, where up until now it has been used mostly with scripting languages. Today, regular expressions are, however, supported by a number of .NET classes in the namespace System.Text.RegularExpressions. You can also find the use of regular expressions in various parts of the .NET Framework. For instance, you will find that they are used within the ASP.NET Validation server controls.

If you are not familiar with the regular expressions language, this section introduces both regular expressions and their related .NET classes. If you are already familiar with regular expressions, you will probably want to just skim through this section to pick out the references to the .NET base classes. You might like to know that the .NET regular expression engine is designed to be mostly compatible with Perl 5 regular expressions, although it has a few extra features.

by Dr. Shahram Khosravi

An ASP.NET AJAX client control is an ASP.NET AJAX client component that directly or indirectly derives from the Control base class. You can think of an ASP.NET AJAX client control as an ASP.NET AJAX representation of a specific DOM element on a page.

The ASP.NET AJAX client controls essentially emulate their corresponding ASP.NET server controls. Most basic ASP.NET server controls, such as Label and Image, are ASP.NET representations of DOM elements. These representations enable you to program against the underlying DOM elements using the ASP.NET/.NET Framework. In other words, these representations enable you to treat DOM elements as .NET objects.

The ASP.NET AJAX client controls play a similar role in the client-side programming. These controls are the ASP.NET AJAX representations of DOM elements, allowing you to program against these elements using the ASP.NET AJAX Framework. In other words, these representations enable you to treat DOM elements as ASP.NET AJAX objects.

Every ASP.NET AJAX client control emulates its corresponding ASP.NET server control as much as possible. As such, they expose similar methods and properties as their server counterparts.

The ASP.NET AJAX client-side framework includes with a Sys.Preview namespace defined as follows:

By Jason Beres

In pretty much every demo of the new Silverlight technology, the product demos show off a video integrated into a Web page. This was intentional. The goal of the initial release of Silverlight was to provide rich, multimedia experiences on Web pages, which in the case of Silverlight 1.0, means audio and video on Web pages. If you take a look at the top 100 trafficked Web sites on the Internet, almost all of them have video playing on the home page or have video prevalent throughout. If Microsoft was to take the next step of having a complete stack of capabilities for Web pages, having multimedia integration was essential. Adobe Flash is pretty much the dominant cross-platform vehicle for any media playing.

Working with XAML in This Article

To work with the XAML here, you should create a new Visual Studio 2005 Silverlight project. Follow the next few steps to create an application that will run, but is such that you can type in the XAML or JavaScript to test the code that you are learning about.

by Dan Rahmel

Ajax (which stands for Asynchronous JavaScript and XML) combines a powerful set of technologies for Web 2.0 sites. Using Ajax technology, you can make the user experience far more interactive than previous Web site implementations. In the past, changes to parameters or the selection of buttons on a Web page required the changes be sent back to the Web server for an update. The browser would have to wait for the entire modified page to be returned to display the revisions. Using that process, user interaction with a Web application was fairly clunky.

In a Web application designed with Ajax, near-immediate interaction is possible. User-interface requests such as changing the sort order of a table by clicking on the column headings can be handled on the client with little delay. If the interaction involves requesting additional information (such as help text on a line item), rather than requesting an update of the entire page, Ajax technology allows small amounts of data to be exchanged with the server. Updates can happen dynamically, so the entire Web page doesn't need to be reloaded.

Joomla has incorporated functionality that promotes Ajax technology. A Joomla site can support Ajax background information exchange for a more dynamic and responsive user experience.

By Scott Hanselman

Performance is a key requirement for any application or piece of code that you develop. The browser helps with client-side caching of text and images, whereas the server-side caching you choose to implement is vital for creating the best possible performance. Caching is the process of storing frequently used data on the server to fulfill subsequent requests. You will discover that grabbing objects from memory is much faster than re-creating the Web pages or items contained in them from scratch each time they are requested. Caching increases your application's performance, scalability, and availability. The more you fine-tune your application's caching approach, the better it performs.

This article focuses on the new SQL invalidation caching capabilities that ASP.NET 2.0 provides. When you are using SQL cache invalidation, if the result set from SQL Server changes, the output cache can be triggered to change. This ensures that the end user always sees the latest result set, and the data presented is never stale. This feature was frequently requested by developers using ASP.NET 1.0/1.1, so the ASP.NET team worked hard to bring it to ASP.NET 2.0.

To utilize the new SQL Server Cache Dependency feature in ASP.NET 2.0, you must perform a one-time setup of your SQL Server database. To set up your SQL Server, use the aspnet_regsql.exe tool found at C:\Windows\Microsoft.NET\Framework\v2.0xxxxx\. This tool makes the necessary modifications to SQL Server so that you can start working with the new SQL cache invalidation features.

Follow these steps when using the new SQL Server Cache Dependency features:

by Cristian Darie and Jaimie Sirovich

One of the perks of ASP.NET is that it abstracts away many low-level implementation details from the Web developer. It does such a great job, in fact, that one can typically build complex Web applications without understanding much at all about the protocol Web servers use to speak to the world, HTTP (HyperText Transport Protocol).

Though most of the time this ignorance is bliss, it is sometimes not so with regard to search engine optimization. Using the protocol improperly has the potential to wreak havoc for search engine rankings. On the other hand, knowing how to use it effectively can be of great help to the very same end.

HTTP status codes are a small but critical part of this protocol. They provide information regarding the state of an HTTP request. One may use them, for example, to indicate that the requested information should be retrieved from a different location henceforth. In modern search engines, doing so also may result in a transference of link equity to that new location. This example alone highlights the importance of knowing how to use these codes.

By Matt Ranlett

WSS v2 offered developers the ability to catch certain user actions in code and react programmatically. These user actions triggered a set of asynchronous events which happened after the user had completed the action. An example is the act of adding a document to a document library. A developer could catch the DocumentAdded event and perform some action. Unfortunately for v2 developers, all of the event handlers were "after the fact" handlers. You can't stop a user from performing an action with an event handler. Another limitation of v2 event handlers is that you can only catch events on document and forms libraries.

Fortunately for us, all of this has changed. Now, WSS v3 has a vastly increased number of events developers can take advantage of. These events include "before the fact" or synchronous events as well as "after the fact" or asynchronous events as illustrated in Figure 1. As a developer interested in catching SharePoint events, you are no longer limited to only document libraries and forms libraries. Now you have the ability to catch events on practically every list type that SharePoint offers, as well as at the site level, list or library level, and at the individual file level. Combine the increase in available functionality of event handlers with Workflow and you'll really have a flexible system.

Web Parts are the building blocks of pages in SharePoint sites. Users of SharePoint sites can make use of those building blocks to determine what should be displayed on a specific page in a particular SharePoint site.

When you install SharePoint, you can make use of some out-of-the-box Web Parts straight away. Depending on whether you have Windows SharePoint Services (WSS) or Microsoft Office SharePoint Server (MOSS) as your SharePoint installation, you'll have more or less. Additionally, every SharePoint list and document library will have a Web Part counterpart that can display the contents of the corresponding list or document library.

Of course, the out-of-the-box Web Parts are not the only ones that you can use! Developers can build their own Web Parts as well and deploy them to the SharePoint server. End users won't notice the difference between the custom Web Parts and the out-of-the-box Web Parts, so Web Parts are a great way to extend SharePoint.

This article takes you through the basic steps to create your own Web Parts in various ways.

by Rich Tretola

Creating components is one of the most important features of Flex because it allows for the reuse of code created either by you or by other developers. Once a component is created, it can be reused by simply including it within your application. This article shows you how to create simple and advanced components. You also learn how to scope and style your components.

To create a component, you simply create a new MXML file and add a visual component as the root tag. Ensure that you add the mx namespace to the root tag. If you are using Flex Builder, you can accomplish this by selecting File -> New -> MXML Component. Simply give it a unique name and choose a Based On tag and you should end up with something like this:

With the popularity of Ajax applications exploding in 2005, developers and companies began looking for ways to streamline the process. As with many common programming practices, Ajax involves a lot of repetitive procedures that can be identified and simplified for common use. It wasn't long before JavaScript developers started introducing libraries to ease the redundant and sometimes quirky behavior of Ajax communication techniques. These libraries sought to break outside of the hidden frame and XHR modalities of communication and introduce their own methods (which typically are just wrappers for already accepted forms of Ajax communication). Remember, the goals of such libraries are to free the developer from worrying about cross-browser Ajax issues by hiding the details.

Prototype

One JavaScript library that has gained considerable popularity with the emergence of Ajax is Prototype, available at http://prototype.conio.net. Prototype is not simply an Ajax library; it is actually a complete JavaScript framework designed to ease the development of all types of JavaScript solutions.

The Ajax.Request Object

Most of Prototype's low-level Ajax features are contained on the aptly named Ajax object. The Ajax object has several properties containing methods and constructors for useful objects. The simplest object, and the most similar to XHR, is the Ajax.Request object, which has the following constructor:

by Cristian Darie and Jaimie Sirovich

Data displayed by dynamic Web sites is usually stored in some sort of backend database. Typically, a numeric ID is associated with a data row of a database table, and all database operations with the table (such as selecting, inserting, deleting, or updating rows) are done by referencing that ID.

More often than not, the same ID used to identify an item in the database is also used in ASP.NET code to refer to that particular item-such as a product in an e-commerce Web site, or an article of a blog, and so on. In a dynamic URL, these IDs are passed via the query string to a script that presents differing content accordingly.

Figure 1 shows a page from http://www.cristiandarie.ro/BalloonShop/. This is a demo e-commerce site presented in one of Cristian's books, and employs dynamic URLs. As you can see, the page is composed using data from the database, and the ID that identifies the data item is taken from the dynamic URL.

This is probably the most common approach employed by dynamic Web sites at present, as you frequently meet URLs such as the following:

• http://www.example.com/Catalog.aspx?CatID=1
• http://www.example.com/Catalog.aspx?CatID=2&ProdID=3&RefID=4

This approach is certainly the easiest and most straightforward when developing a dynamic site. However, this is about the only benefit these URLs bring. Dynamic URLs come with three important potential drawbacks, however:

• They are frequently sub-optimal from a search engine spider's point of view.
• They don't provide relevant keywords or a call to action to a human viewing the URL, therefore reducing the CTR.
• They aren't easy to remember, or communicate to other parties in the offline world.

By Jacob J. Sanford

Creating one page (Default.aspx) that is aesthetically pleasing, easy to use by your visitors, takes various browsers into consideration, uses CSS, is one thing. Copying this code to every page in your site would be, to say the least, a maintenance nightmare. Can you imagine having to update thousands of pages because the client wants a fairly minor design tweak? What you really want is a way to create a reusable template that can be incorporated into every page of your site. This will allow for all pages to look the same throughout your project while allowing for easier maintenance as your projects mature. In a year or so when you want to redo the entire site, you would only need to change the template rather than the coding on every page of your application. With Master Pages, you can do exactly that.

A Master Page is simply a single page that holds the structure of your Web site. The files are designated with a .master file extension and are imported into content pages through the MasterPageFile property of the @Page directive of the content pages. They are meant to provide the template that all of your pages will use throughout the site. They are not really meant to hold the content of an individual page or, even, the stylistic definitions of the page. They are meant to provide a blueprint of what your site should look like and then connect that template to style rules set in detached CSS files (as appropriate).

Enough Talk; Time to Code

This article will go through the ins and outs of Master Pages. You should start a new project to practice these new concepts. So, with a new Web project open in Visual Studio 2005, click on Website and then choose "Add New Item" to get the screen depicted in Figure 1.

by Dan Wahlin

Microsoft's ASP.NET AJAX framework provides a solid foundation for building efficient and high performance Web-based applications that can enhance the overall end user experience. No matter how good a development platform is, however, bugs and other issues can be introduced by developers and triggered by end users. Knowing how to quickly debug ASP.NET AJAX applications can greatly increase your productivity as a developer and reduce the amount of frustration experienced while tracking down issues.

There are many tools available to you as an ASP.NET AJAX developer to efficiently debug and test your applications. For example there is debug functionality available in the ASP.NET AJAX script library that can be used to make assertions and perform tracing operations. There are several tools to intercept and view request and response messages, to more easily track down data issues and monitor AJAX request and response message sizes. This article looks at several ways to use Internet Explorer and Visual Studio to debug JavaScript. And there are also several different debugging techniques available in Firefox that can simplify the process of debugging ASP.NET AJAX applications.

Debugging JavaScript has proven to be somewhat of a challenge and has resulted in many developers resorting to "alert style" debugging to better understand how an application is working. Fortunately, Internet Explorer 6 or higher includes integrated debugging functionality that can be used to start a debug session and step through ASP.NET AJAX code with a debugging tool such as Visual Studio .NET 2005 or Microsoft's Script Debugger, as shown in the following sections. Learning how to leverage Internet Explorer debugging features can enhance your productivity and significantly minimize the amount of time you spend hunting down bugs and other issues.

The debug capabilities in Internet Explorer 6 or higher are disabled by default but can be turned on by going to Tools-->Internet Options-->Advanced. The Advanced tab defines two items that need to be unchecked (a check means you can't debug):

The latest release of the SharePoint platform, Microsoft Office SharePoint Server (MOSS) 2007, introduces new capabilities to the SharePoint platform: hosting content-centric Web sites on SharePoint and providing a robust publishing infrastructure. This publishing infrastructure enables site owners to delegate to certain individuals the creation and management of content on the site. Other users have rights to approve and publish content for readers to see. Interwoven in this process is a robust controlled publishing infrastructure founded on the Windows Workflow Foundation (WFF). Combined with significant performance enhancements and improvements to the underlying foundation of MOSS, Windows SharePoint Services (WSS) v3, SharePoint is now capable of hosting content-centric Internet sites! This component of MOSS 2007 is commonly referred to as Web Content Management (WCM), and sites utilizing the WCM features are called Publishing sites.

A major component to Publishing sites is the development story: the process behind constructing a content-centric site. Most development concepts surrounding Publishing sites are really SharePoint concepts, because a Publishing site is just another WSS site with some extra functionality. So, how are you supposed to develop a Publishing site? To date, only one approach has been the leader in the WCM community. This is the approach you will find in virtually all documentation, every whitepaper, every Webcast, every conference or trade show presentation, and every magazine article. However, this approach poses certain challenges in the real world when many organizations have a strict change control process.

An alternate development process is presented in this article. It addresses many of the pitfalls associated with the conventional approach. Though many of the concepts in this article are tailored to work specifically with Publishing sites, they will also work with little or no modifications in general WSS v3 sites. Before any concerns arise from the process outlined in this article, rest assured everything is 100 percent supported by Microsoft. In fact, this is the process Microsoft's out-of-the-box site templates (Collaboration Portal and Publishing Portal) utilize to create the site infrastructure and layout files to implement the default sites!

Another (and arguably better) option is to leverage the Feature and solution framework, a new addition in WSS v3.

by Randy Holloway

Microsoft's SharePoint technology architecture delivers a foundation of APIs and functionality that makes it easier for developers to build and deploy applications for a variety of scenarios. Workflow-enabled forms solutions, business intelligence and reporting aggregation tools, Excel-based publishing tools for Web reports, and records management tools are a few of the many functions that SharePoint supports out of the box with hooks for customization and extensibility built in. These products have been packaged into Microsoft Office SharePoint Server and are primarily delivered through SharePoint's Enterprise edition product.

One key set of functionality in Microsoft Office SharePoint Server 2007 is the support for delivery of reports, particularly Excel-based reports, through the Web browser. The Report Center in SharePoint 2007 is designed to provide a solution to integrate Excel-based reports, dashboards, Key Performance Indicators (KPI) lists based on SharePoint lists, and SQL Server Analysis Services and manually entered data to develop reporting and dashboard sites that can be deployed within SharePoint and managed like other SharePoint sites.

While the SharePoint platform has delivered integration with reporting tools in the past through Web Parts for Reporting Services and a variety of Web Parts published by other business intelligence tools vendors in previous versions, SharePoint Server 2007 builds the concept of business intelligence (BI) into the core of the product with a site template for the Reports Center, the introduction of Excel Services, and integrated support for KPI dashboards. To understand how the BI features in the Report Center work, the following presents an example of publishing reports and building a dashboard with Excel-based data with an integrated KPI dashboard.

by Christian Nagel

Windows Presentation Foundation (WPF) is one of the three major extensions of .NET Framework 3.0. WPF is a new library to create the UI for smart client applications. While the Windows Forms controls are based on native Windows controls that make use of Window handles that are based on screen pixels, WPF is based on DirectX. The application is no longer using Window handles, it is easy to resize the UI, and support for sound and video is included.

Windows Forms 2.0 data binding has a lot of improvements compared to 1.0. WPF data binding takes another huge step forward. This article gives you a good start in data binding with WPF and discusses these Simple Object Binding, Object Data Provider, and List Binding. In Chapter 31, "Windows Presentation Foundation," of the new book, Professional C# 2005 with .NET 3.0 (Wrox, 2007, ISBN: 978-0-470-12472-7), we also discuss Binding with XAML and Binding to XML.

Overview

With WPF data binding, the target can be any dependency property of a WPF element, and every property of a CLR object can be the source. Because a WPF element is implemented as a .NET class, every WPF element can also be the source. See Figure 1 for the connection between the source and the target. The Binding object defines the connection.

by Bill Sheldon

Windows Presentation Foundation (WPF) is Microsoft's next generation solution to graphical user-interface development. In terms of user interfaces, the transition to this new model will be similar in significance and paradigm shift to the shift from COM-based Visual Basic to Visual Basic .NET. In other words, the paradigms and syntax with which developers of Windows applications became familiar are all changing, and the changes are for the most part not backwards compatible. Currently there are no plans for an automated migration from any existing user-interface paradigm, forms, or web, to the new WPF format.

Yes, again you will need to transition existing application source code to a new technology paradigm. Perhaps not this year or next, but at some point the WPF paradigm will be used to update the look and feel of existing applications. So how will this transition compare to the last major .NET-related transition — the one from COM? Whereas Visual Studio includes a tool to attempt to migrate code from the COM-based world to .NET, there will not be a migration tool provided to transition existing user interfaces to WPF. You might consider this to be a good thing, considering the history of the current migration tools. However, Microsoft is providing libraries to allow user-interface developers to integrate these two interface models. In the long run this integration will probably go the way of COM-Interop. Which is to say it'll be available but will carry such a stigma that people will only use it when absolutely necessary.

In our new book, Professional VB 2005 with .NET 3.0 (Wrox, 2007, ISBN: 978-0-470-12470-3), Chapter 18, "Integrating WPF with Windows Forms," takes you through several key areas of WPF integration with Windows Forms including Forms integration — Crossbow, Using Windows Forms controls in WPF, Interop limitations, and the subject of this article - Using WPF controls in Windows Forms.

by Matt Gibbs

AJAX development centers on using more JavaScript. With increased use of JavaScript comes the need for better ways to manage, reference, localize (that is, provide different script versions for specific language and culture combinations), and transmit script code to the client browser. The ASP.NET ScriptManager is at the center of ASP.NET AJAX functionality. The ScriptManager is the key component that coordinates the use of JavaScript for the Microsoft AJAX Library. Custom controls also use it to take advantage of script compression and reliable loading, as well as for automatic access to localized versions of scripts.

The Ubiquitous ScriptManager

A ScriptManager is required on every page that wants to use the AJAX Library. When the ScriptManager is included in the page, the AJAX Library scripts are rendered to the browser. This enables support for partial page rendering and use of the ASP.NET AJAX Client Library. Listing 1 (Bare.aspx) is a page with a barebones ScriptManager that does nothing more than render the Microsoft AJAX Library files to the browser

by Shahar Prish

There are various technical details one needs to understand about Excel Services. Even though some of this information may not have an immediate impact on how you use, or even program against, Excel Services, it will help you understand what happens under the hood.

When programming Excel Services, it is incredibly important to understand exactly how sessions fit in.

All interaction with Excel Services revolves around workbooks that are loaded, queried, and manipulated. When a workbook is needed, it is loaded into a session. What happens internally is this:

1. The server brings up the file and copies it locally (more on that when I discuss workbook caches) if it has not already done so.
2. It loads the workbook into memory if it has not already done so. This loaded workbook will be used as a "template" or as an "initial state."
3. Finally, a session is opened, and the workbook "template" is assigned to the session where it will be used. The session will have its own private copy as needed, and it will not affect the globally loaded workbook. In that way, the changes users make to the workbooks they load are isolated. A user making a change to a workbook will not see changes made to that same workbook by a different user.

No interaction with workbooks can be achieved without a session, and no session can exist that does not refer to a specific workbook. When a session expires (for any reason), all the information it holds expires with it. That means that if you make changes to a workbook and the session you work against is closed, all your changes will be lost. Open sessions on the server have a unique ID (Session ID) associated with them. That ID is used to interact with the session throughout its lifetime.

by Darren Jefford

Although most systems today have some form of business rules implemented within them, they are typically implemented in code by developers and therefore require development resources and testing whenever changes are necessary. In contrast, BizTalk Server 2004 introduced the Business Rules Engine (BRE) as a core and stand-alone piece of the BizTalk architecture.

The BRE enables you to abstract these business rules from your solution and allow the owners of such business rules to control them. This abstraction is analogous to BizTalk orchestration, in which we abstract the process flow away from the code and into a business process.

In general, rules engines are highly efficient and can process many hundreds or even thousands of rules in a matter of milliseconds, making them highly desirable for BizTalk-style solutions, which typically process many messages a second.

The mechanics that underpin the BRE are incredibly complex and come across as being pretty inaccessible to almost everyone! So that you don't avoid BRE completely, perhaps to the detriment of a solution, this article covers the core BRE concepts that you need to understand before delving into practical examples.

by Scott Klein

A transaction is a collection or group of one or more units of operation executed as a whole. Another way to say it is that transactions provide a way to logically group single pieces of work and execute them as a single unit, or transaction.

For example, when you place an order online, a transaction occurs. Suppose you order a nice 21-inch wide-screen flat-panel monitor from your favorite online hardware source. Assume you were to pay for this monitor with a credit card. You enter the information required on the screen and click the "Place Order" button. At this point, two operations occur. The first operation takes place when your bank account is debited the amount of the monitor. The second operation occurs when the vendor is credited that amount. Each of those operations is a single unit of work.

Now imagine that one of those operations fails. For example, suppose that the money was removed from your bank account for the purchase of the monitor, but the payment to the vendor failed. First, you wouldn't receive your anxiously awaited monitor, and second, you would lose the amount of money for the cost of the monitor. I don't know about you, but I would be quite unhappy if this happened.

Conversely, a payment could be made to the vendor without debiting your account. In this case, the debit from your account failed but the payment to the vendor succeeded. You would likely receive the purchase item without having paid for it. Although this scenario is preferable to the former one, neither is acceptable in that in either case, someone is not receiving what is rightfully theirs.

The solution to this is to wrap both of these individual operations into a single unit of execution called a transaction. A transaction will make sure that both operations succeed or fail together. If either of the operations fails, the entire unit of work is cancelled and any and all changes are undone. At this point, each account is in the same state it was before you attempted your purchase. This undoing is known as "rolling back" the transaction.

by Göran Husman

Search engines are among the greatest time savers. Just look at how often you use MSN Search or Google, just to mention a couple of them. On the Internet, searching is absolutely critical, since you have no idea where information is stored, and there may be new sources one minute from now. That is why you search all the time. This is not really that different from the way you use your internal network. True, the volume of information is much smaller in your network, and you know where at least some of it is stored, since you created it. Still, it does not take much activity within an organization to create so much information that the average user loses track of where things are stored. So, users start looking around to find the file, document or whatever they are looking for. After some minutes, they find it. The question then becomes is this the latest version, or is there a newer version somewhere? Then when they get what they're looking for, they most likely want to be notified if that document gets updated later on. What you need is a solution that helps you:

• Find information regardless of where it is stored.
• Make sure that it is the latest version.
• Send a notification to you when this information is updated.

By John Holliday

The term "Document Management" has become a catch-all phrase for anything having to do with documents in an enterprise setting. It is an overly broad term that covers many different aspects of managing documents; from access control to version control to auditing, review and approval of content. To understand what document management means in the SharePoint environment, it helps to consider the evolution of document management systems over the last decade or so. It also helps to appreciate the value that SharePoint provides as a development platform for document management solutions.

Early document management systems were focused primarily on keeping track of revisions to documents that involved multiple authors, and operated in a manner similar to source code control systems. Individual authors checked out documents, thereby locking them so that other authors could not overwrite their changes. System administrators could specify who had permission to view or edit documents, and could generate reports of document activity. Other functions included the ability to automatically number each major or minor revision and revert at any time to a specific version of the document, generating the final content from information stored within the database.

The notion of metadata became a key characteristic of legacy document management systems. Metadata is information about a document, as opposed to the document content itself. For example, the current version number is an example of metadata, since it is information about the document. Other examples are the title, subject, comments and keywords associated with the document.

Most document management systems store document metadata in a central database. In fact, many of the early document management systems were written as database applications. This worked well at a time when the only business process being modeled was the generic document revision cycle. It starts to break down, however, when you want to model other business processes.

This is where SharePoint emerges as a superior platform for developing document management solutions. SharePoint refines the notion of document metadata to distinguish between system, class and instance metadata. System-level metadata is maintained internally by SharePoint for all documents. Class-level metadata is stored within the SharePoint database for a given document library or content type and can be customized easily to include domain-specific information. Instance-level metadata is stored within each document instance as a set of document properties, and moves along with the physical document. This is especially important for managing documents in disconnected environments.

by Amanda Murphy and Shane Perran

Most businesses have processes related to specific activities and, typically, the steps of these processes are documented in procedures in a predictable manner. Workflow involves the various tasks that employees must complete on a business activity, and these tasks often occur in a specific order. A workflow could be something completely non-technical, such as washing your car; however, it usually involves some level of interaction with technology mixed with human activity. Workflows in SharePoint generally focus on a specific document or list item. However, it is important to remember that the actual document may be representative of a much larger human-based process such as applying for a job or requesting vacation time.

In the 2003 release, SharePoint did not include an automated workflow engine. For many organizations, this meant purchasing third-party software solutions to get automated business process management. However, in 2007, SharePoint comes with support for automated workflow solutions built upon the Windows Workflow Foundation, which is Microsoft's platform for workflow development and tools. Because it is a development platform, it can be extended and customized to meet the needs of most organizations if the available solutions do not.

Because it parallels business processes and natural human activity, workflow is an important part of document management. When used correctly, it can meld automation and tasks that rely heavily on people, allowing your team to track a project's progress and keeping team members informed of their duties.

by Rod Stephens

There are many ways you can make a program extensible at run-time. One of the most flexible methods for extending an application at run-time is scripting. By allowing the program to execute new code at run-time, you can enable it to do just about anything that you could do had you written the code ahead of time, at least in theory.

This article explains how a program can execute SQL statements at run-time. Structured Query Language (SQL) is a relatively easy-to-learn language for interacting with databases. It includes commands for creating, reading, editing, and deleting data.

SQL also includes commands that manipulate the database itself. Its commands let you create and drop tables, add and remove indexes, and so forth.

Visual Studio provides objects that interact with databases by executing SQL statements, so providing scripting capabilities is fairly easy.

The first part of this article explains how a program can execute queries written by the user. Then I'll show how a program can provide a tool that makes building queries easier and safer. The final section dealing with SQL scripts shows how a program can execute more general SQL statements to modify and delete data, and to alter the database's structure.

by Craig Thomas

Excel Services UDFs represent another tier in the Excel Services capability to support custom solutions. UDFs provide a means to call custom-managed code functions from within a workbook. Without UDFs, a workbook is restricted to using only the intrinsic Excel functions. With UDFs, custom functions can be called from the workbook as well.

UDFs are very instrumental to custom server solutions because Excel Services does not support loading workbooks that contain code behind (VBA). Nor does Excel Services support the Excel client add-ins used by workbooks to extend functionality. With the right UDF-managed wrapper solution, you could leverage existing custom client solutions on the server, but that topic isn't discussed here.

This article describes how to author manage UDFs and deploy them to the server to make them available to workbooks that are loaded from the trusted file locations. An example solution is provided to demonstrate the authoring and building of a UDF assembly. Additional material is provided to explain how the workbook interacts with UDF methods, and how to pass and return arguments to the workbook.

by Zak Ruvalcaba

CSS integration is abundant in Expression Web and is arguably the single greatest integration asset within Expression Web apart from HTML. CSS has limitless possibilities and because of external style sheets, Expression Web has the power to set the appearance of elements on your Web pages globally.

Many beginning Web designers ignore this fact because they simply want to build pages without carefully considering the long-term management perspective. When you're working with CSS in Expression Web, should styles be created inline automatically for you? Should you have document-wide styles created automatically for you instead? After all, document-wide styles would give you the ability to change properties for the entire page easily. Or, does it benefit you down the road, as your site grows, to create one external style sheet file, add your style rules to the style sheet file, and then apply them manually to elements within your Web pages, essentially preventing Expression Web from doing anything automatically for you?

These are questions you'll want to answer before you begin adding styles to your Web pages. Choosing the inline or document-wide route would allow you to create Web pages faster because Expression Web does most of the work for you automatically. Choosing the external route means that properties must be created manually for every element within your Web page. While the upside to this approach is easier management down the road as your site grows, the downside is careful planning initially, which results in slower development of pages at first.

by Todd Kitta

Workflow-to-host communication and host-to-workflow communication are vital components of Windows Workflow Foundation. Without the necessary hooks to send data back and forth, workflows would not be nearly as useful. Host applications are the most common locations where workflows receive information from the outside world.

For example, in a scenario where a user interacts with a Windows Forms application that is hosting a helpdesk ticket workflow, the Windows application needs to inform the workflow when the user starts a new ticket or updates an existing one. In addition, the workflow might need to tell the host application when an action of interest occurs, such as a request for further information from the user.

There are two main methods of workflow communication. The first, and the simpler of the two, uses parameters to pass data to a workflow when it is created. The second and richer form of communication is called local communication services. This technique uses method and events to facilitate communication. Both of these methods are covered in the following sections.

by Nicholas C. Zakas

Because the core of Ajax relies on requests going to servers (and responses being received from them), it makes sense that debugging Ajax applications relies heavily on understanding what is being sent to and received from the server. FireBug for Firefox inspects the requests and responses sent through XHR objects, but this is only a very small percentage compared to all of the requests and responses used during a typical user session. And, many requests may be sent without using XHR at all. The way to solve these problems is to use an HTTP proxy.

An HTTP proxy is a small program running on the client computer that intercepts all HTTP requests and responses. In normal HTTP communication, the browser initiates and sends a request over the Internet to a server. The server then sends a response back to the browser, which then acts upon the data it received. When an HTTP proxy is used, all requests are first sent through the proxy; it's the proxy's job to send that request to the server. The response is sent back to the proxy as well, and the proxy then forwards it to the browser (see Figure 1).

by Chris Ullman

Ajax is the catchy term coined by Jesse James Garrett in his 2005 article for "Adaptive Path" called "Ajax: A New Approach to Web Applications," which can still be found at http://adaptivepath.com/publications/essays/archives/000385.php. You should read this article if you haven't already! Ajax is also an acronym, but for the same reasons, let's defer explaining just what it stands for right now. Ajax didn't exist before this article, but the features the article described certainly did.

In short, Ajax is a set of programming techniques or a particular approach to Web programming. These programming techniques involve being able to seamlessly update a Web page or a section of a Web application with input from the server, but without the need for an immediate page refresh. This doesn't mean that the browser doesn't make a connection to the Web server. Indeed, the original article paints a slightly incomplete picture in that it fails to mention that server-side technologies are often still needed. It is very likely that your page, or data from which the page is drawn, must still be updated at some point by a rendezvous with the server. What differs in the Ajax model is that the position at which the page is updated is moved. We'll look at the two models in more detail shortly.

by Charles Freedman

The goal of this article is for you to build a Flex 2 mashup using the ActionScript-Flash (AS-Flash) API. The article will make us of methods and classes of the AS-Flash API, as they are used with Flex 2 and the local connection method. This article will guide you through building a mashup with a data source and the map API. This article is part 1 in a series of articles that will complete this project.

by Francis Shanahan

Amazon's Simple Storage Service (S3) is a storage service that allows anyone to purchase industrial-quality storage space on an as-needed basis. You pay only for what you use. This has major repercussions in terms of the business plans that it enables. A student working out of a dorm room can build a professional-quality photo storage site without requiring millions of dollars from venture capitalists up front. Budding media entrepreneurs can share content without a highly available redundant disaster-recovery site. The possibilities are endless.

This article uses the Amazon S3 to store files on the Internet. You don't really know where or how these files are stored, only that they are stored securely and without fear of being lost.

Understanding the Architecture

The sample application uses SOAP over HTTP to communicate with the S3 service. The architecture of the sample application is depicted in Figure 1.

by David A. Wilkinson

Flickr contains tens of millions of photographs taken by members all over the world, which must by now cover practically every subject imaginable. So — in theory at least — for pretty much any subject you find discussed on the web, you ought to be able to find photos from Flickr that could be used to illustrate it. In this mashup, you will try to do exactly that — take news feeds from some of the major news sites, such as the BBC and CNN and then automatically illustrate the news stories contained in those feeds with photos taken from Flickr.

by Brett O'Connor

del.icio.us seems so very simple at its core that it might be hard to realize the immense potential for mashups that exists within. Rest assured, there's a lot you can do with the massive database of the world's most trusted and favorite web links that del.icio.us provides, even without touching the del.icio.us API (Application Programming Interface). del.icio.us' RSS feeds alone provide a staggering amount of information about the web and what's interesting, hot, and new, and all in real-time.

by Alessandro Vernet

There isn't a test that can be run on a page to check if it is clean and simple. You can check whether a page is valid with a number of tools. But you won't find a tool that tells you whether a page is clean and simple. Creating pages that are clean and simple is a design principle; it is a goal to keep in mind when you write the HTML, CSS, and JavaScript code that make up a page. This article shows you some methods that will help you achieve this goal.

by Thiru Thangarathinam

One of the advanced features of ADO.NET 2.0 you can utilize from an ASP.NET page is creating and working with strongly typed DataSets. Using the DataSet class provided by the System.Data namespace, in a typical DataSet, you might access the name of a category like this:

By W. Clay Richardson

This article addresses some of the advanced data management concepts starting with a new annotations capability added to the JDBC 4.0 specification.

Annotations

Annotations were introduced into the language with JDK 1.5, and now they are making an impact with JDBC 4.0. An annotation is a declarative programming model where comments, associated with a code element, are used to inject code at runtime.