Exam Details

Candidates for this exam work on a team in a medium or large development environment that uses Microsoft Visual Studio .NET 2003 Enterprise Developer or Visual Studio 2005. Candidates should have a working knowledge of Visual Studio 2005 and a sound knowledge of the new features of ASP.NET 2.0. Candidates should have at least two years of experience developing applications by using the Microsoft .NET Framework.

Candidates should have at least three to four years of on-the-job experience dedicated to Web application development. In most cases, candidates will be full-time developers who develop server-side ASP.NET code that creates the browser-based, client-side interface to an application.

This certification exam measures your ability to build interactive, data-driven Web-based applications with Web forms, ASP.NET, and the .NET Framework for both intranet and Internet uses.

Exam Code	70-551
Minutes To Complete	? minutes
Number of Questions	90 in beta
Passing Score	?
Adaptive	No

Official Microsoft Stuff

• http://www.microsoft.com/learning/exams/70-551.asp
• Breaking changes in .NET Framework 2.0 - http://msdn.microsoft.com/netframework/programming/breakingchanges/default.aspx
• What's New in .NET 2.0 - http://blogs.msdn.com/junfeng/archive/2004/08/01/203813.aspx
• What's New in ASP.NET 2.0 - http://msdn2.microsoft.com/en-us/library/fa1h9d0d.aspx

Links to Other Sites

• What Did You Learn Today? Blog - http://blog.denoncourtassociates.com/CategoryView,category,Certifications.aspx

MSDN for Official Objectives

Section 1 - .NET Framework Fundamentals (30 Questions)

Although this section does not have a name, I have decided to call in .NET Framework Fundamentals. That is because it has to do with understanding some of the new classes and components of the .NET 2.0 Framework. I have tried to highlight the NEW classes.

In all of the new upgrade exams, Section 1 is identical.

Good review of section 1 is also here - http://blog.denoncourtassociates.com/CategoryView,category,Certifications.aspx

Developing applications that use system types and collections

• Manage data in a .NET Framework application by using .NET Framework 2.0 system types. (Refer System namespace at http://msdn2.microsoft.com/en-us/library/system(VS.80).aspx )
• New in 2.0, TypeForwardedTo attribute. From here: http://www.heege.net/blog/PermaLink,guid,8d076332-4fb0-44b5-a829-4c4d653de2d6.aspx
• Allows you to move a type from one library to another without breaking existing code
• One library (lib1.dll) can contain a reference to another (lib2.dll) and client code can still call the first.
• Use:

 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(TheType))]

• Manage a group of associated data in a .NET Framework application by using collections. (Refer System.Collections namespace at http://msdn2.microsoft.com/en-us/library/system.collections(VS.80).aspx )
• New in 2.0, the C# "yield return" statement allows functions which implement the IEnumerator interface to return an array one piece at a time
• See http://robgarrett.com/Blogs/software/archive/2005/09/13/1588.aspx
• NEW Improve type safety and application performance in a .NET Framework application by using generic collections. (Refer System.Collections.Generic namespace at http://msdn2.microsoft.com/en-us/library/system.collections.generic(VS.80).aspx )
• Implement .NET Framework interfaces to cause components to comply with standard contracts. (Refer System namespace at http://msdn2.microsoft.com/en-us/library/system(VS.80).aspx )

Embedding configuration, diagnostic, management, and installation features into a .NET Framework application

• Embed configuration management functionality into a .NET Framework application. (Refer System.Configuration namespace at http://msdn2.microsoft.com/en-us/library/system.configuration(VS.80).aspx and http://blogs.conchango.com/pauloreichert/archive/2005/05/31/1514.aspx )
• Access to configuartion setting has been overhauled in 2.0
• ConfigurationManager class used to access web.config and program.config
• ConnectionStrings and AppSettings sections of config file

 <connectionStrings>
   <add name="pubs" 
       connectionString="localhost;integrated 
       security=true;database=pubs;" />
 </connectionStrings> 

and

 <%@ Import Namespace="System.Configuration" %>
 <%@ Import Namespace="System.Web.Configuration" %>


 <script runat="server" language="C#" >
  public void Page_Load(object source, EventArgs e)
  {
   Response.Write("Connection String:" + 
      ConfigurationManager.ConnectionStrings["pubs"].ConnectionString);
  }
 </script>

• So you can store multiple connection strings in one web.config
• And access them (production, dev, testing, etc.) programmatically
• Connection strings can be encrypted using the ProtectSection and UnProtectSection methods
• The connection string section unencrypted looks like this:

 <connectionStrings>
   <add name="pubs" 
      connectionString="localhost;integrated 
      security=true;database=pubs;" />
 </connectionStrings> 

• The connection string section encrypted looks like this:

 <protectedData>
   <protectedDataSections>
    <add name="connectionStrings" 
      provider="DataProtectionConfigurationProvider"
      inheritedByChildren="False"/>
   </protectedDataSections>
 </protectedData>


 <connectionStrings>
    <EncryptedData>
      <CipherData>
        <CipherValue>AQA------------
           FnvpHa1iy4Oww=</CipherValue>
      </CipherData>
    </EncryptedData>
 </connectionStrings> 

• So connection strings no longer need to be kept in plain-text on the web server

• Debug and trace a .NET Framework application by using the System.Diagnostics namespace (see http://msdn2.microsoft.com/en-us/library/system.diagnostics(VS.80).aspx )
• Three new trace sources with 2.0: ConsoleTraceListener, DelimitedListTraceListener and XmlWriterTraceListener.

Implementing serialization and input/output functionality in a .NET Framework application

• Serialize or deserialize an object or an object graph by using runtime serialization techniques. (Refer System.Runtime.Serialization namespace at http://msdn2.microsoft.com/en-us/library/system.runtime.serialization(VS.80).aspx )
• Almost the same as 1.1
• Control the serialization of an object into XML format by using the System.Xml.Serialization namespace (see http://msdn2.microsoft.com/en-us/library/system.xml.serialization(VS.80).aspx )
• New tool SGen.exe to create XML serializer assemblies
• Pre-serializes objects as XML, for a big performance improvement
• Access files and folders by using the File System classes. (Refer System.IO namespace at http://msdn2.microsoft.com/en-us/library/system.io(VS.80).aspx )
• File object has several new methods, ie: Encrypt, Decrypt, ReadAllLines, ReadAllBytes, ReadAllText, WriteAllBytes, WriteAllLines and WriteAllText
• GetAccessControl and SetAccessControl methods on File and Directory classes
• DriveInfo to get info on the drives
• DriveType to tell between hard disk, CDRom, etc.
• NEW Compress or decompress stream information in a .NET Framework application (refer System.IO.Compression namespace at http://msdn2.microsoft.com/en-us/library/system.io.compression(VS.80).aspx and http://dotnetcoalface.blogspot.com/2006/01/gzipstream-and-deflate-compression.html ), and improve the security of application data by using isolated storage. (Refer IsolatedStorage namespace at http://msdn2.microsoft.com/en-us/library/system.io.isolatedstorage(VS.80).aspx and http://blogs.msdn.com/shawnfa/archive/2006/01/18/514407.aspx )
• Isolated Storage, as it's name implies, is a safe and isolated piece of disk storage that application developers can use (read/write) without needing full access to the entire disk drive. It is a sandbox.
• Stored in the ApplicationData directory of the user under Documents and Settings. Each app is given a random unique name as a folder for storage.
• Application has to decalre which scope for the storage: user and assembly; or user, domain and assembly
• Addition of domain means that only the application that wrote the data can read it
• Compression classes are new and can only handle files less than 4GB

Improving the security of .NET Framework applications by using the .NET Framework 2.0 security features

• NEW Implement access control by using the AccessControl classes (see http://msdn2.microsoft.com/en-us/library/system.security.accesscontrol(VS.80).aspx and http://wgao.blogspot.com/2005/03/some-basic-facts-about-access-control.html and http://west-wind.com/weblog/posts/4072.aspx )
• Allows applications to grant users access to files, directories, registry keys, objects, mutexes, and semaphores.
• An Access Control List (ACL) is a top-to-bottom list of who is granted or denied access. As soon as a rule is met, the rest of the file is skipped. So if the first line grants everyone full access, then there is no point reading the rest.
• NEW Implement a custom authentication scheme by using the System.Security.Authentication classes. (Refer System.Security.Authentication namespace at http://msdn2.microsoft.com/en-us/library/system.security.authentication(VS.80).aspx and http://pluralsight.com/wiki/default.aspx/Keith.GuideBook/HowToAddCIAToASocketBasedApp.html )
• The key is the AuthenticatedStream class
• You can open a socket to a server, NegotiateStream to authenticate and start encryption. .NET 2.0 will take care of it for you. You can use SSL or some other protocol.
• Encrypt, decrypt, and hash data by using the System.Security.Cryptography classes. (Refer System.Security.Cryptography namespace at http://msdn2.microsoft.com/en-us/library/system.security.cryptography(VS.80).aspx )
• Supports TripleDES, RC2, MD5, DES, SHA1, RSA, AES...
• New classes include ProtectedDate and ProtectedMemory. ProtectedData is only good until reboot, and ProtectedData can only be decrypted on the same machine.
• Control permissions for resources by using the System.Security.Permission classes. (Refer System.Security.Permissions namespace at http://msdn2.microsoft.com/en-us/library/system.security.permissions(VS.80).aspx and http://msdn.microsoft.com/msdnmag/issues/05/11/CodeAccessSecurity/default.aspx )
• Set the principal policy to WindowsPrincipal before demanding permissions
• Demanding permissions while the policy is set to UnauthenticatedPrincipal results in an error
• The Evidence class holds the clues as to what Windows uses to make decisions on the security level of code. Look here to see why security is failing.
• Control code privileges by using System.Security.Policy classes. (Refer System.Security.Policy namespace at http://msdn2.microsoft.com/en-us/library/system.security.policy(VS.80).aspx )
• CodeGroups wrap an assembly
• You assign permissions to a code group, every assembly that is part of that group gets those permissions
• Code Access Security runs on top of Win32 security, so you still need to give the user proper windows permissions to do stuff
• Access and modify identity information by using the System.Security.Principal classes. (Refer System.Security.Principal namespace at http://msdn2.microsoft.com/en-us/library/system.security.principal(VS.80).aspx and http://www.dotnetbips.com/articles/displayarticle.aspx?id=196 )
• Can use User.IsInRole("Administrators") to check role
• A Principal = an Identity plus one or more Roles

Implementing interoperability, reflection, and mailing functionality in a .NET Framework application

• NEW Send electronic mail to a Simple Mail Transfer Protocol (SMTP) server for delivery from a .NET Framework application. (Refer System.Net.Mail namespace at http://msdn2.microsoft.com/en-us/library/system.net.mail(VS.80).aspx and http://www.eggheadcafe.com/articles/20050505.asp )
• Not dependent on CDO
• Can send both text and HTML versions of an email together
• Can work over SSL
• Can capture exceptions when one or more sender email addresses is not valid
• LinkedResource to include embedded images

Implementing globalization, drawing, and text manipulation functionality in a .NET Framework application

• Enhance the user interface of a .NET Framework application by using the System.Drawing namespace. (see http://msdn2.microsoft.com/en-us/library/system.drawing(VS.80).aspx and http://www.ondotnet.com/pub/a/dotnet/2002/05/20/drawing.html?page=1 ).
• Pens are used to draw lines and shapes, Brushes are used to fill surfaces, Fonts are used to render text, and Colors are... colors
• Brushes available: SolidBrush, TextureBrush, HatchBrush, LinearGradientBrush, and PathGradientBrush.

Section 2 - Core Web Application Development (30 Questions)

Although this section does not have a name, I have decided to call in Core Web Application Development. That is because it deals with all of the fundamental topics of web development. Existing MCAD's who have experience in web development should already know most of these topics. I have tried to highlight the NEW features of .NET 2.0 when they are mentioned.

Creating and Programming a Web Application

• Add and configure Web server controls (see what's changed here http://www.mikepope.com/blog/DisplayBlog.aspx?permalink=1039&count=no )
• The Button control has an OnClientClick event that you can use to add JavaScript code
• Also UseSubmitBehavior which makes the button act like an HTML Submit button
• Also a PostBackUrl property which says which page should be loaded to handle a postback
• Changes to the calendar control
• New FileUpload control, identical to the HtmlInputFile control
• New ImageMap control, allows you to do postbacks on areas on an image
• Skinning
• Data binding can now be appended, so you can have one or two manual items and then the stuff from the database (cool)
• Textbox controls have support for AutoComplete
• Configure settings for a Web application
• Web config can be modified using new Configuration classes (see Section 1 above)
• The web config can be edited using a wizard interface called the Web Site Administration Tool. You can define security, application or provider settings.
• Program a Web application
• Response.Redirect
• Server.Transfer vs. PostBackUrl
• Page Two can access the page that sent it using PreviousPage object

Integrating Data in a Web Application by Using ADO.NET, XML, and Data-Bound Controls

• Implement data-bound controls
• All controls can be data bound. New Menu and SiteMap controls as well.
• Manage connections and transactions of databases
• New class, System.Transaction
• Transactions without using serviced components
• Implicit and explicit transactions
• An implicit transaction simply encloses sql calls inside a using code block

 void btnImplicitLocal_Click(object sender, EventArgs e)
 {
    // Create the TransactionScope
    using (TransactionScope oTranScope = new TransactionScope())
    {
        using (SqlConnection oCn1 = new SqlConnection(this.sCn1))
        {
            SqlCommand oCmd = new SqlCommand(this.sSQL, oCn1);
            oCn1.Open();
            oCmd.ExecuteNonQuery();
            oCn1.Close();
        }


        // Tell the transaction scope that the transaction is in a
        // consistent state and can be committed
        oTranScope.Consistent = true; // oTranScope.Complete() in beta 2


        // The following bracket completes, commits, and disposes 
        // the transaction
    }
 }

• Remember these?
• Required - If within a currently active transaction scope, this transaction scope will join it. Otherwise it will create its own transaction scope.
• RequiresNew - This transaction will create its own transaction scope.
• Supports - If within a currently active transaction scope, this transaction scope will join it. Otherwise no transaction scope will be created.
• NotSupported - No transaction scope will be created.
• SQL Server 2005 transactions are supported locally
• As soon as any other database is involved, is it a distributed transaction
• So a SQL statement executed again SQL 2005 and Oracle are in one transaction, where failure of one causes rollback in the other
• Create, delete, and edit data in a connected environment
• Now supports Async methods: BeginExecuteNonQuery, BeginExecuteDataReader and BeginExecuteXmlReader
• Managed support for bulk copies with the SqlBulkCopy class
• Blobs now supported inline, no seperate GetChunk code

Creating Custom Web Controls

• Create a composite Web application control
• New Item -> Web User Control
• An existing web page can be converted to a control, cool
• LoadControl and add to Controls collection to programmatically load a control

Tracing, Configuring, and Deploying Applications

Note, a good overview of this section here ( http://msdn2.microsoft.com/en-us/library/baf8bxh4(VS.80).aspx )

• NEW Copy a Web application to a target server by using the Copy Web tool (see http://msdn2.microsoft.com/en-us/library/1cc82atw.aspx )
• 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.
• NEW Precompile a Web application by using the Publish Web tool (see http://msdn2.microsoft.com/en-us/library/1y1404zt.aspx and http://msdn2.microsoft.com/en-us/library/377y0s6t(VS.80).aspx )
• 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.
• Optimize and troubleshoot a Web application

Customizing and Personalizing a Web Application

Note, the ASP.NET videos cover this nicely. http://weblogs.asp.net/scottgu/archive/2006/02/26/439088.aspx

• NEW Implement a consistent page design by using master pages (see http://msdn2.microsoft.com/en-us/library/wtxbf3hh(VS.80).aspx )
• NEW Customize a Web page by using themes and user profiles (see http://msdn2.microsoft.com/en-us/library/ykzx33wh(VS.80).aspx )
• NEW Implement Web Parts in a Web application (see http://msdn2.microsoft.com/en-us/library/hhy9ewf1(VS.80).aspx )

Implementing Authentication and Authorization

Note, the ASP.NET videos cover this nicely. http://weblogs.asp.net/scottgu/archive/2006/02/26/439088.aspx

• Establish a user's identity by using forms authentication
• Use authorization to establish the rights of an authenticated user
• Use login controls to control access to a Web application

Creating ASP.NET Mobile Web Applications

• Create a mobile Web application project (see http://msdn2.microsoft.com/en-us/library/ms178619(VS.80).aspx )
• Use device-specific rendering to display controls on a variety of devices
• Use adaptive rendering to modify the appearance of Web server controls
• Use the mobile Web controls to display content on a device

Section 3 - Application Development Advanced Topics (30 Questions)

Although this section does not have a name, I have decided to call in Application Development Advanced Topics. That is because it deals with (d'oh) advanced topics of development. This is a strange section. Some of it is hard to really test (ie: perform a code review) and others are sort of fundamental to being a developer (ie: evaluate the design of a database).

There is probably not much you can do to study for this section. If you are a professional developer, and have been so for many years, you will likely pass this part easily.

Envisioning and Designing an Application

• Evaluate the technical feasibility of an application design concept
• Evaluate the technical specifications for an application to ensure that the business requirements are met
• Evaluate the design of a database
• Evaluate the logical design of an application
• 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.

Designing and Developing a User Interface

• Choose an appropriate layout for the visual interface
• Evaluate a strategy for implementing a common layout throughout the UI.
• Choose an appropriate control based on design specifications.
• Choose an appropriate data validation method at the UI layer.
• Choose appropriate user assistance and application status feedback techniques.

Designing and Developing a Component

• Establish the required characteristics of a component.
• Create the high-level design of a component.
• Develop the public API of a component.
• Develop the features of a component.
• Develop an exception handling mechanism.
• Develop the data access and data handling features of a component.

Designing and Developing an Application Framework

• Consume a reusable software component.
• Choose an appropriate exception handling mechanism.
• Choose an appropriate implementation approach for the application design logic.
• Choose an appropriate event logging method for the application.
• Evaluate the application configuration architecture.

Testing and Stabilizing an Application

• Perform a code review.
• Evaluate the testing strategy.
• Design a unit test.
• Perform integration testing.
• Resolve a bug.

Deploying and Supporting an Application

• Evaluate the performance of an application based on the performance analysis strategy.
• Analyze the data received when monitoring an application.
• Evaluate the deployment plan.
• Validate the production configuration environment. Considerations include load balancing, Web farms, and Web gardens.

User Reviews

From http://blogs.clearscreen.com/migs/archive/2006/02/24/2849.aspx :

 I just took this exam today and it seemed to have a pretty good level. 
 The exam was divided in three section of 30 questions each. Once you  
 finish a section you can't go back and change your answers, but you can 
 go back to add comments to them.


 The first section was specific to web applications and it has a bunch of 
 question with mobile pages, mobile devices, web forms and web controls as 
 the main topics. The second part of the exam looked the hardest one, it 
 was related to framework and types with security attributes, xml 
 serialization attributes, class design and generics in its topics. The third 
 part, the one I was really scared of, was the architecture one and it was 
 really easy to pass, lot of logical questions about designing solutions 
 and best practices.


 There is one thing I still have in mind, that really impressed me 
 positively. I got some questions talking about unit testing, code 
 coverage and integration tests ... :-D


 As with all the beta exams, I'll have to wait to get my results a 
 couple of weeks. While I wait, I'll take more exams.... Next stop: 
 71-552 Upgrade from MCAD to MCPD Windows Developer; next Monday morning.
Click to read this topic
6/10/2008 4:48:48 PM - -66.207.195.3
add a one or paragraph summary or description of what's discussed here;  put yours after 'Summary:'
4/3/2006 8:54:49 AM - mike SMITH-64.27.6.178
Click to read this topic
6/10/2008 4:48:12 PM - -66.207.195.3
Click to read this topic
6/10/2008 4:48:59 PM - -66.207.195.3
Click to read this topic
6/10/2008 4:48:59 PM - -66.207.195.3