I'm going to be taking this next week, so I thought I'd post my study notes as I assemble them.

• May include but is not limited to: using the ConnectionStringBuilder; leveraging the ConfigurationManager; protecting the connection string; using Security Support Provider Interface (SSPI) or SQL Server authentication; correctly addressing the SQL Server instance; managing “User Instance” and AttachDBfilename

The ConnectionStringBuilder objects allow for an abstract way of building a connection string for ADO.NET.  There is a good writeup on the data access blog showing basic usage.  There is a SqlConnectionStringBuilder, OleDbConnectionStringBuilder, OdbcConnectionStringBuilder, and an OracleConnectionStringBuilder.

The ConfigurationManager has a specific section for storing connection strings and the ConnectionStrings property to manipulate them.  See this article on MSDN for more information.  An area that doesn't get much attention is that the Connection string configuration can be stored in a separate config file.  See the section titled "Using external configuration files" to see how to use the configSource property.

MSDN has an article on securing configuration strings.  An important part to pay attention to is encrypting connection string information stored in config files.  Scott Forsyth has a post on using aspnet_regiis to protect web.config files.  Daruish Tasdighi has an article at codeproject about protecting the contents using the ConfigurationSection.ProtectSection / UnprotectSection methods.

• Manage connection objects.
  May include but is not limited to: managing connection state, managing connection pool; implementing persistent data connections; implementing Multiple Active Result Sets (MARS); encrypting and decrypting data

Managing connection state.  I think that is knowing that there are methods on the connection object to open and close the connection.  The connection will be closed when the connection object is disposed.

There is a great post by Sijin Joseph about connection pooling with all the different connection objects.  I wasn't aware that there is no connection pooling with ODBC using the managed providers.  Also interesting was that connection pooling for SQL Server was disabled while debugging in Visual Studio.  Another thing to be aware of is that when using Integrated Security for SQL Server, the domain/user is added to the list of things that need to match for a connection to be reused.

To have a persistent data connection, you disable connection pooling and keep the instance of the connection object around.  The connection will remain open until the connection object is disposed or the close method is used.

Eric Moreau has a post on using MARS.  It is only supported in the SQL Server and Oracle managed providers. 

You can encrypt/decrypt the data passed from the client back and to the database server by adding the Encrypt keyword to the connection string for SQL Server or using the Encrypt property on the SqlConnectionStringBuilder.

• Work with data providers.
  May include but is not limited to: limitations, behaviors, performance, installation issues, deployment issues; ODBC, Microsoft OLE DB, SqlClient, managed providers, third-party providers, native providers

I guess this is a nice way of saying, "Know everything about ADO.NET".  Some of the things I'm aware of are the just because you have a managed provider available, you still need the native dll libraries.  Oracle, for example.  The client needs the oracle client libraries in order to connect to Oracle.  I mentioned some of the shortcomings of ODBC above in regards to pooling.  A great source for third party data providers can be found at the mono project (Firebird, MySql, SQLLite, PostgresSQL, Mimer, Sybase..)

• Connect to a data source by using a generic data access interface.
  May include but is not limited to: System.Data.Common namespace classes

The common namespace is the abstract definition for all data providers.  You would use this when you aren't sure which data provider your application will ultimately use.  Using the DbProviderFactory you can instantiate objects for a specific data provider.   Suman Chakrabarti has a post showing how to use the DbProviderFactory class.

• Handle and diagnose database connection exceptions.
  May include but is not limited to: implementing try/catch handlers

Joydip Kanjilal has a post on handling exceptions in ADO.NET.  If you catch a SqlException, you would examine the number property to determine the root cause of the problem.

Next -> Section II Selecting and Querying Data

UPGRADE: MCSD Microsoft .NET Skills to MCPD Enterprise Application Developer by Using the Microsoft .NET Framework: Part 2

Create a client application to access a remote object.

• Create a remote object.
• Configure a client application programmatically.
• Configure a client application manually by using configuration files.
• Access the remoting service by calling a remote method.
• Call a remote method synchronously in a client application.

To create a remote object, configure the client application to use remoting.  This can be done using a config file, or programatically.  MSDN has information on setting up a client application.

You can see how to progmatically setup a client on Jibin Pan's article at c-sharpcorner. 

MSDN has information on how to setup a client using configuration files.

To call a remote method, create the object as usual (if you have remoting configured for the type) or use Activator.GetObject.

By default remoting calls are synchronous.  So I think they meant to say "Call a remote method asynchronously in a client application".  MSDN has information on how to do invoke a method asynchronously.

Create and configure a server application.

• Create a server application domain.
• Configure a server application programmatically.
• Configure a server application by using configuration files.
• Compile and build a server application.

In general, it's good to look at the Remoting FAQ at thinktecture.

To create a server app domain, look at these instructions on MSDN.  Use a configuration file, and use RemotingConfiguration.Configure to read it in.  The objects are available at that point.

To do it programically, look at this article at Express Computer. 

The MSDN article has instructions on how to configure the server application.

I don't see why building a server application is any different that other types of applications.  You just compile to get an executable.  Make sure that the configuration file (if you're using a config file) gets named to <app>.exe.config and is deployed with the executable.

UPGRADE: MCSD Microsoft .NET Skills to MCPD Enterprise Application Developer by Using the Microsoft .NET Framework: Part 2

Configure SOAP messages.

• Configure the formatting of SOAP messages for a Web service method.
• Specify the basic information for a Web service application.
• Specify the bindings of a Web service application by using the WebServiceBindingAttribute attribute.
• Configure a Web service application by using a Machine.config file.
• Configure a Web service application by using a Web.config file.

MSDN has a section on formatting SOAP messages.  Know about the SoapDocumentMethod attribute and SoapDocumentService attribute.  Know that you can control the formatting using XML Serialization attributes.

I guess the basic information for a web service application would be specified using the WebService attribute.  You can control the name of the web service, and the namespace.

Binding defines a concrete set of operations.  It is implemented by the WebServiceBinding attribute.  You can specify what WSI spec your service conforms to (as of now, Basic Profile 1.1 or none), whether or not the service emits conformance claims, the location of the binding (defaults to your web service), and the namespace associated with the binding.  Christian Weyer has some thoughts about the attribute on his blog.

The XML Web Services repository has a good FAQ.  In in, some of the things controlled by the web/machine.config are pointed out.  Here's how to enable/disable WSDL generation.  Also you can control the location of a dynamic reference to a web service in the config file.

PRO: Designing and Optimizing Data Access by Using Microsoft SQL Server 2005

Design client libraries to write applications that administer a SQL Server service.

• Design server management objects (SMO) applications.
• Design replication management objects (RMO) applications.
• Design automation management objects (AMO) applications.
• Design SQL Server Networking Interface (SNI) for asynchronous queries.

Here's MSDN's section on SMO.  Darshan Singh has an overview of SMO at YukonXML.com.  David Hayden has an example of how to create a table using SMO.

MSDN's section on RMO.  There is not a lot of community activity in respects to RMO.  Here's my take.  Probably good to know how to create a publication (EnabledTransPublishing on ReplicationDatabase, Create a TransPublication object), create a subscription (TransPullSubscription, or TransSubscription), how to cause a syncronization (TransSynchronizationAgent).  Keep in mind I've never use these objects, these are the ones that strike me as important.

It appears that AMO really means Analysis Management Objects.  There appears to be no reference anywhere to "automation management objects" anywhere.  Here's MSDN's section on AMO.  Liu Tang and Paul Bradley wrote a overview for MSDN magazine.

SNI For Async?  It looks like SNI is used for tracing.  Here's an article at MSDN that mentions SNI.

Next up-> MARS

PRO: Designing and Optimizing Data Access by Using Microsoft SQL Server 2005

Design caching strategies.

• Select ADO.NET caching.
• Design custom caching functionality.
• Design a refresh strategy for cached data.

ADO.NET doesn't have a cache.  ASP.NET does.  ADO.NET retrieves results into objects like DataSets that can be cached in the ASP.NET cache or your own Cache app.

Designing your caching functionality seems like a lot of work.  You have to manage the size of the cache, object expiration, object invalidation.  I use the Enterprise library and that provides a lot of the plumbing.

Refreshing cached data is done using Query Notifications via the SqlDependency or SqlNotificationRequest objects.  There is a good article on MSDN outlining how to set this up.  Steve Smith mentions the changes that have occured since Beta 2 on his blog.

Next up->Client Libraries

PRO: Designing and Optimizing Data Access by Using Microsoft SQL Server 2005

Design appropriate data access technologies.

Design an appropriate data access object model.

Design a cursor strategy for a data access component.

• Decide when to use cursors.
• Decide how to maximize cursor performance.
• Detect which applications are using cursors and evaluate whether to remove them.

I just looked at my testing schedule and realized I'm taking this test in two days.  Time to get cramming...

The first two items are kind of vague.  I don't think there's much to be said there.

My cursor strategy is... don't use them.  However it appears there are times when it is faster.  Andy Machanic has found that they solve the running sum problem much faster than traditional relational methods.  However he found using CLR worked much better.

Maximizing performance would be centered around opening it as FAST_FORWARD.

There's a couple of ways that I can think of to detect whether or not an "app" is using cursors.  You can scan through the system tables(sys.procedure) looking for the word OPEN CURSOR.  That won't work if a) the stored procs are encrypted, b) the stored procs utilize CLR, or c) the app uses dynamic SQL. The best option would be to profile the database, looking for cursor events.

UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework

Copy a Web application to a target server by using the Copy Web tool.

Precompile a Web application by using the Publish Web tool.

Optimize and troubleshoot a Web application.

• Customize event-level analysis by using the ASP.NET health-monitoring API.
• Use performance counters to track the execution of an application.
• Troubleshoot a Web application by using ASP.NET tracing.
• Optimize performance by using the ASP.NET Cache object.

The Copy Web Tool allows you to copy your website from your machine to another machine.  It can connect to a remote machine through http (using Frontpage extensions), FTP.  It can also deploy to your local IIS machine, or your file system.  It does a bi directional sync, meaning changes from your machine are uploaded to the server and changes from the server are downloaded to your machine.

The Publish web tool allows you to precompile your website.  You can then deploy the website without the accompanying source code.  You publish to either a local file path, ftp or http.  If you select the "Allow this precompiled site to be updateable" option, the HTML is not compiled into the assembly.  If you select the "Use fixed naming and single page assemblies" option, you will get an assembly for each page.  Skins and Themes are still compiled into a single assembly.  The last option available to you is whether or not you want to strongly name the assemblies.

In the last section of this MSDN article, Jeff Prosise describes the health monitoring API.  There is also a Patterns and Practices article describing best uses of the feature.

There are quite a few performance counters.  Look (in perfmon) under ASP .NET Apps v2.0.50727 .  Counters that look interesting to watch are Anonymous Requests / Sec, Error Events Raised / Sec, Request Execution Time, Request Wait Time, Requests Executing,  Requests / Sec, Sessions Total.

To get tracing information from an ASP.NET application, you still have to enable tracing in the web.config file.  You request http://localhost/myapp/trace.axd to view the trace logs.  There is an article at ExtremeExperts.com on the new tracing features.

Thiru Thangarathinam has a overview of the new caching features at 15seconds.com.  Important changes appear to be the SqlCacheDependency.

Next up->Master Pages

UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework

Create a composite Web application control.

• Create a user control.
• Convert a Web Forms page to a user control.
• Include a user control in a Web Forms page.
• Manipulate user control properties.
• Handle user control events within the user control code-declaration block or code-behind file.
• Create instances of user controls programmatically.
• Develop user controls in a code-behind file.
• Create a templated user control.

Add New Item->Web User Control.

There is an article on MSDN on how to convert a page to a user control.  It's a little easier than in 1.1 if you are using single-file pages.  Rename to .ascx, change @Page to @Control. Remove HTML, Body and Form tags from the HTML Code.

There is also an article on MSDN on how to include user controls in a page.  Add a Register directive to the top of the page, specifying a prefix, tagname and a relative URL to the user control.  You can also now drag the user control from your project onto the page and it will wire it up.

You manipulate a user control as you would any other control, through a member variable of the page.

To handle a user control event within the user control code declaration block, you add it the event as an attribute to the tag.  Here is an example of a usercontrol that has an event named TextStringChanged.

<uc1:MyUserControl ID="MyUserControl1" runat="server" TextString="Phil was here" OnTextStringChanged="TextStringChanged"/>

To handle it in the code-behind file, you treat it like a event on any other type of control.  Add a event handler delegate to the event.

To programatically create a usercontrol, use the LoadControl method of the Page.  That returns a reference to a new instance of the user control.  Then you must add it to a controls collection in order for it to appear on a page.

Creating templated usercontrols sounds tricky, but it's not that bad.  Try the walkthough on MSDN .

Next up->Copy / Publish Web tool

UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework

Create, delete, and edit data in a connected environment.

• Retrieve data by using a DataReader object.
• Build SQL commands visually in Server Explorer.
• Build SQL commands in code.
• Create parameters for a command object.
• Perform database operations by using a command object.
• Retrieve data from a database by using a command object.
• Perform asynchronous operations by using a command object.
• Perform bulk copy operations to copy data to a SQL Server computer.
• Store and retrieve binary large object (BLOB) data types in a database.

To use a DataReader, you create a command object, open the associated connection, and call the ExecuteDataReader method.

To build SQL Commands visually in Server Explorer, right click on the Database in the Server Explorer and select "New Query".

To build SQL Commands in code, you create a SQLCommand instance, set the commandtext property with the SQL Statement, add parameter objects to the parameters collection, and associate a connection to the command object.

Creating parameters is done by creating SqlParameter objects, setting the name, dbtype and value, and append to the command's parameters collection.

To perform database operations using a command object, invoke the ExecuteNonQuery method.  It executes the SQL statement of the command object and returns the number of rows affected.

To retrieve data using a command object, you can call the ExecuteDataReader, ExecuteScalar, or ExecuteXMLReader methods.

The command object now supports async operations.  There are BeginExecuteNonQuery, BeginExecuteDataReader, or BeginExecuteXmlReader methods.  Vishnu Prasad has a writeup on this at DevX.

They've added managed support for SQL Bulk Copies in the SqlBulkCopy class.  David Hayden has an example of how to use this class.

Working with Blobs isn't as hard as it used to be.  You just set the parameter's dbtype to SqlString and assign the large string to the parameter's value property.  No AppendChuck, GetChunk.  There is another method that I found interesting from Vadivel's blog.  I don't think that will be on the test.

Next up-> Composite Web Controls

UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework

Manage connections and transactions of databases.

• Configure a connection to a database graphically by using the Connection Wizard.
• Configure a connection by using Server Explorer.
• Configure a connection to a database by using the connection class.
• Connect to a database by using specific database connection objects.
• Enumerate through instances of Microsoft SQL Server by using the DbProviderFactories.GetFactoryClasses method.
• Open a connection by using the Open method of a connection object.
• Close a connection by using the connection object.
• Secure a connection to protect access to your data source.
• Create a connection designed for reuse in a connection pool.
• Control connection pooling by configuring ConnectionString values based on database type.
• Use connection events to detect database information.
• Handle connection exceptions when connecting to a database.
• Perform transactions by using the ADO.NET Transaction object.

Again, I still haven't found a "Connection Wizard".  Referring to my earlier post, There is a Data Source Configuration Wizard. 

To configure a connection in the server explorer, right click on Data Connections node, and select Add New Connection.

Also, there is no Connection class.  There are a few objects that have a Connection property.  There are classes that implement IDbConnection, but strictly speaking, (unless we talking about sharepoint) there is no Connection class.  However, if you have a class that implements IDbConnection (SqlConnection, OleDbConnection...), you configure it using the ConnectionString property.

To connect to a SQL Server database, use the SqlConnection object.  Call the Open method after setting the connection string.

Alex Homer has an example of how to use DbProviderFactories.GetFactoryClasses at Devx.com.  It returns a datatable of all the classes that registered as DbProviderFactories in the machine.config.

To close the connection, invoke the close method on the connection object.  Obviously, an exception will be thrown if the connection is no longer open.  You can inspect the state property to see if the connection is still active.

To protect Datasource information, you're supposed to put the ConnectionStrings in the ConnectionStrings section of the web.config.  Then you encrypt the contents using the method outlined by David Hayden's site.

To create a connection that will stay in a pool, make sure your connections are connecting to the database with the same login.  Reportedly having minor differences in the connection string will cause it not to pool. 

There is information about controlling connection pooling at MSDN via ConnectionString values.

There are two events worth listening to on a SqlConnection.  InfoMessage (fired when warnings or informational messages are returned by SQL Server), and StateChanged (fired when the state of the connection has changed).

To handle exceptions when connecting to a database, catch SqlException (if SQL rejected the connection), or InvalidOperationException (The connection was already opened, or you haven't given the connection object enough info.)

To Begin a transaction on an open connection, call the BeginTransaction method on the SqlConnection object.  That returns a transaction object that you control the Commit or Rollback with.  There is a new locking level, snapshot isolation which bears understanding.

There is also a new Systems.Transaction namespace.  This is used for distributed transactions.  John Papa has a writeup on MSDN covering the feature.

Next up-> Data objects

UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework

Implement data-bound controls.

• Use tabular data source controls to return tabular data.
• Use hierarchical data source controls to display hierarchical data.
• Display data by using simple data-bound controls.
• Display data by using composite data-bound controls.
• Display data by using hierarchical data-bound controls.
• Use the FormView control to display the values of a single table record from a data source.

Tabular data source controls would be the SqlDataSource, AccessDataSource, and ObjectDataSource.  SqlDataReader and AccessDataSources should be self explanatory.  The ObjectDatasource allows the binding of custom business objects, including datasets.  GridViewGuy has a walkthrough on using the component on his site.

There are two hierarchical data source controls.  SiteMapDataSource, and the XmlDataSource.  The SiteMapDataSource reads SiteMap info from the SiteMapProvider for the website.  It keeps current as the user navigates the website.  The XmlDataSource allows you to bind XML.  Keyvan Nayyeri has a tutorial on the XMLDataSource at CodeProject.

Most web controls can be bound.  You should know the difference between Eval (Readonly data) and Bind(Two way binding; data might be changed).  There is an article at MSDN on this.

Composite Databound controls are the Gridview, DataList,  DetailsView and the Repeater.  Dino Esposito has an article at MSDN on the GridView.  It's old, but it still applies.  Wei Meng Lee has an article on the Datalist.  The data reader doesn't seem to have changed.   GridViewGuy has an article on the DetailsView.

To display hierarchical data, you can use the new TreeView.  Technically, you could also use the SiteMapPath or the Menu.  Thiru Thangarathinam has a very comprehensive article on binding with this control at 15seconds.

The FormView is a templated control that works on a record by record basis.  You provide a readonly layout in the ItemTemplate, and a layout for edits in the EditItemTemplate. There is an overview at ASP.NET.

Next up -> Database Connections

UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework

Program a Web application.

• Redirect users to another Web page by using a server-side method.
• Detect browser types in Web Forms.
• Ascertain the cause of an unhandled exception at the page level.
• Programmatically access the header of a Web page.
• Implement cross-page postbacks.
• Assign focus to a control on a page when the page is displayed.
• Avoid performing unnecessary processing on a round trip by using a page's IsPostBack property.
• Access encapsulated page and application context.
• Avoid unnecessary client-side redirection by using the HttpServerUtility.Transfer method.
• Avoid round trips by using client-side scripts.
• Use a page's Async attribute to create a page that has built-in asynchronous capabilities.
• Convert HTML server controls to HTML elements.

There are two ways to redirect users to another web page.  Response.Redirect, which aborts processing the current page and tells the user's browser to go somewhere else, Server.Transfer and Server.Execute.  There is the PostBackURL property for button controls, but I consider that client side functionality.  Mike Pope has a writeup about the advantages of Server.Transfer vs. PostBackURL. 

To detect the browser type, use the Browser property on the response object.  There are plenty of new properties in the HttpBrowserCapabilities object. Mostly to support mobile device features.

Unhandled exceptions at the Page level are supposed to be handled in the Error event of the page.  Victor Garcia Aprea has an post on the exceptions to this rule.

To access the header, use the methods on the Response property, AppendHeader (AddHeader is obsolete) and ClearHeaders methods; Headers property.

Cross page postbacks are a new feature.  To make use of the them, set the PostBackURL property to a different page.  There are a few good writeups on this feature.  Scott Allen at OdeToCode, Naveedullah Khan at DotNetPakistan, Ting-hao Yang at MSDN.

To assign focus to a control, set the DefaultFocus attribute of the Form element to the HTML id of the control to get focus.  Scott Guthrie has a post on this feature.  There is also a Focus method on controls.

The IsPostBack feature hasn't changed.  Understand that when you use Server.Transfer, IsPostBack in the transferred page is set to the value of the initial page.

The Page and Application objects still exist.  The Page has its own Cache for Page specific information,  Application has it's own cache for the entire website.

To avoid round trips using client side script, you can either use the Validation controls, or write your own script, registering it by calling RegisterClientSideScript, RegisterStartupScript, or RegisterOnSubmitStatement.

The Async feature allows you to send requests to get data.  When the data is returned, you then resume building the page.  Fritz Onion has a writeup on the feature.  Bipin Joshi also has a good article.

To convert an HTML Server control back to a plain old HTML element, just remove the RunAt=Server attribute.  Obviously this won't work with Web Controls.

Next up-> Data Bound Controls

• Configure system-wide settings in the Machine.config file.
• Configure settings for a Web application in the Web.config file.
• Manage a Web application's configuration by using the Web Site Administration Tool.

You can change the system wide settings by manually editing the machine.config file in the config subdirectory of the framework or you can change it programatically by using the Configuration classes.  Same with web.config

There two articles at ExtremeExperts.com that cover configuration.  Part 1 and Part 2

The Web Site Administration Tool  Ludmal has a quick article outlining the feature set

Next up->Web Applications

UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework

Add and configure Web server controls.

• Add Web server controls to a Web Form.
• Configure the properties of Web server controls programmatically.
• Configure Web server control properties by using the Microsoft Visual Studio Property Editor.
• Specify whether events of a control cause a Web Form to post to the server.
• Configure a control to receive postback events.
• Access controls in Web Forms pages when working with naming containers and child controls.
• Create HTML server controls in the designer.
• Set HTML server control properties programmatically.
• Use HTML server controls to programmatically access HTML tags.
• Create HTML controls as elements in an HTML document.
• Use the AdRotator Web server control to manage banners and pop-up windows.
• Use the Button Web server control to send a command to the server when a button is clicked.
• Display a calendar on a Web page by using the Calendar Web server control.
• Implement the CheckBox Web server control.
• Implement the FileUpload Web server control.
• Create and manipulate links on a Web Form by using the HyperLink Web server control.
• Display an image on a Web Form by using the Image Web server control.
• Implement a button on a Web Form by using the ImageButton Web server control.
• Define hotspot regions within an image by using the ImageMap Web server control.
• Use the Label Web server control to display customized text on a Web page.
• Display a hyperlink style button on a Web Form by using the LinkButton Web server control.
• Display lists of information by using controls that derive from the ListControl class.
• Create a Web Form with static text by using the Literal Web server control.
• Implement pagination for controls on a page by using the Pager Web server control.
• Use the Panel Web server control to arrange controls in groups on a page.
• Create a container for a group of View controls by using the MultiView Web server control.
• Use the View Web server control to create a Web application.
• Create a mutually exclusive set of choices by using the RadioButton Web server control.
• Construct a table by using the Table, TableRow, and TableCell Web server controls.
• Enable users to type information into a Web Form by using the TextBox Web server control.
• Create a wizard by using the Wizard Web server control to collect data through multiple steps of a process.
• Use the XML Web server control to create XML data at the location of the control.
• Customize the appearance of Web server controls by using Web control templates.
• Programmatically edit settings in a Web site's configuration file.
• Dynamically add Web server controls to a Web Forms page.

The first three bullets shouldn't be problematic.  The next two are about setting the AutoPostback property of web controls. 

To access controls within a naming container, use the FindControl method.  Remember that FindControl only finds controls within its own Naming Container.

"Create HTML server controls in the designer." and "Set HTML server control properties programmatically" shouldn't present new challenges.

To create HTML controls as elements in the HTML document, you can add the RunAt=Server attribute to existing HTML elements, or you can add elements at runtime by creating an HtmlGenericControl and adding it to the controls collection.

The AdRotator component hasn't changed much.  It is now bindable to a database.  As I recall, you used to have to create an XML file for it to use.  Doug Seven has a article on the AdRotator component (based on an older version of the framework)

The Button control has a few minor changes.  It has an OnClientClick property.  You put in javascript code that will execute when the user clicks the button.  There is also a UseSubmitBehavior, which if set, turns the button into an HTML submit button.  In addition, there is a PostBackUrl property which states which page should be loaded when a button causes a postback.  Dino Esposito has a writeup on some of the complications in using this property.  Buttons also govern a new feature called ValidationGroups implemented using the ValidationGroup property.  Peter Blum has a writeup explaining the new feature.

Mike Pope found what was new with the Calendar control (And most others as well).

No changes on the CheckBox control except it can be a part of a ValidationGroup. 

The FileUpload control is new, but it is functionally identical to the HtmlInputFile control.  Anand Narayanaswany has a quick tutorial on using the control.

The Hyperlink control hasn't changed.

The image control also hasn't changed significantly except the property that Mike points out, GenerateEmptyAlternativeText.

The ImageButton has the same changes as the button control.

ImageMap control is brand new.  You define hotspots over a image in different shapes (Circle, Rectange, Polygon).  With each hotspot, you specify a PostBackValue.  That is the value that is sent back to the page if you said that postbacks should occur.  The other option is to have it navigate to a specific URL when the hotspot is clicked.

The label control hasn't changed much.  Support for skinning is about it.

LinkButton also has the same new properties as the button control.

There are four controls that derive from ListControl: CheckBoxList, DropDownList, ListBox, and RadioButtonList.  They all support the new data binding model.  There is a property call AppendDataBoundItems that allows you to add bound items below items that you've added manually.  That seems to be about it.

The Literal control has a mode property, allowing you to state how to treat the literal: Encode (The contents are HTML-Encoded), PassThrough (The contents are not touched), or Transform (Remove unsupported elements for WML or cHTML renderings)

The Pager control was dropped from the final release.

The Panel control has some improvements.  There is a ScrollBars property that allows you to specify whether or not content is scrolled within the panel.  There is a DefaultButton property that specifies which button is depressed when <Enter> is pressed within the panel.  There is a GroupingText property which is displayed as a title in the panel.

The MultiView control is a nice new control.  It's purpose is control a collection of View controls, of which only one can be visible at a time.  Jason N. Gaylord has a tutorial on ASP Alliance.

Remember that Views can only be used within a MultiView control.

The Radiobutton control hasn't changed.  Join a Radiobutton to a group using the GroupName property.  It supports validation groups.

The Table, TableRow, and TableCell controls don't appear to have changed.

The Textbox has support for Autocomplete, that appears to be all I see as changed.

The wizard is a templated control that allows you to create a wizard without having to worry about the plumbing of the previous/next/finished buttons.  Dino Esposito has a writeup at MSDN on the control.

The XML Control hasn't changed.  It's used to bring XML back to the client which can then be transformed into presentable data.

Web control templates?  Maybe they mean skinning.  Thiru Thangarathinam has a writeup at 15seconds.com about skinning.  To me it seems they took CSS to the next level.

You would modify the web.config file using the ASP.NET Configuration API.  Note that the account must have write access to successfully update the config.

To programmatically add controls to a webpage, just create a new object, add it to the page's controls collection.  Scott Mitchell has a quick overview of how to do this.

Next up->Web Application Settings

Evaluate the technical feasibility of an application design concept.

• Evaluate the proof of concept.
• Recommend the best technologies for the features and goals of the application.
• Weigh implementation considerations.
• Investigate existing solutions for similar business problems.

Create a proof-of-concept prototype.

• Evaluate the risks associated with the proposed technology or implementation.
• Validate that the proposed technology can be used in the application.
• Demonstrate to stakeholders that the proposed solution will address their needs.

Evaluate the technical specifications for an application to ensure that the business requirements are met.

• Translate the functional specification into developer terminology, such as pseudo code and UML diagrams.
• Suggest component type and layer.

Evaluate the logical design of an application.

• Evaluate the logical design for performance.
• Evaluate the logical design for maintainability.
• Evaluate the logical design for extensibility.
• Evaluate the logical design for scalability.
• Evaluate the logical design for security.
• Evaluate the logical design against use cases.
• Evaluate the logical design for recoverability.
• Evaluate the logical design for data integrity.

Evaluate the physical design of an application. Considerations include the design of the project structure, the number of files, the number of assemblies, and the location of these resources on the server.

• Evaluate the physical design for performance.
• Evaluate the physical design for maintainability.
• Evaluate how the physical location of files affects the extensibility of the application.
• Evaluate the physical design for scalability.
• Evaluate the physical design for security.
• Evaluate the physical design for recoverability.
• Evaluate the physical design for data integrity.

Choose an appropriate layout for the visual interface.

• Decide the content flow within the application.
• Evaluate user navigation needs.
• Identify the goal of the UI.
• Ensure the congruency and consistency of the user experience throughout the application.
• Choose techniques to control the layout.

Evaluate a strategy for implementing a common layout throughout the UI.

• Suggest an applicable UI standard based on the application specification. Considerations include MDI, SDI, control grouping, and so on.

Choose an appropriate control based on design specifications.

• Evaluate the type of data that must be captured or displayed.
• Evaluate available controls. Considerations include standard .NET Framework controls and custom, internally developed, and third-party controls.
• Evaluate the manner in which available controls are implemented in previous and ongoing projects or applications.
• Evaluate the user demographic.
• Evaluate the user environment.

Choose an appropriate data validation method at the UI layer.

• Choose a validation method based on the data type provided.
• Decide how to report the feedback. Considerations include callbacks, exceptions, and writing to an event log.
• Identify the source of invalid data.
• Identify the cause of an invalid entry.
• Evaluate whether invalid data can be prevented.
• Evaluate whether an exception must be thrown.
• Evaluate whether an exception must be logged.
• Evaluate whether visual feedback, such as a message box or color, is required.

Choose appropriate user assistance and application status feedback techniques.

• Design a user assistance mechanism.
• Choose an appropriate application status feedback technique based on available control types.
• Choose an appropriate application status feedback technique to support accessibility.
• Design an application status feedback mechanism.

Establish the required characteristics of a component.

• Decide when to create a single component or multiple components.
• Decide in which tier of the application a component should be located.
• Decide which type of object to build.

Create the high-level design of a component.

• Establish the life cycle of a component.
• Decide whether to use established design patterns for the component.
• Decide whether to create a prototype for the component.
• Document the design of a component by using pseudo code, class diagrams, sequence diagrams, activity diagrams, and state diagrams.
• Evaluate tradeoff decisions. Considerations include security vs. performance, performance vs. maintainability, and so on.

Develop the public API of a component.

• Decide the types of clients that can consume a component.
• Establish the required component interfaces.
• Decide whether to require constructor input.

Develop the features of a component.