Microsoft Developer Tools Roadmap

In February 2002, software developers and architects worldwide were introduced to Visual Studio .NET and the Microsoft .NET Framework. This landmark release, four years in the making, offered a unified development environment and programming model for constructing a range of software solutions. With the recent launch of Visual Studio .NET 2003, customers gained the benefits of enhanced tool and framework functionality, as well as increased performance, security and scalability for building enterprise-critical software.

As the needs of businesses continue to evolve, Microsoft remains committed to ensuring the success of its customers by providing innovative developer tools that meet these ever-changing requirements. To help organizations plan future software development efforts, Microsoft is providing a roadmap to the following planned releases of its developer tools:

• Visual Studio 2005 (formerly referred to as "Visual Studio codename Whidbey").. This release of Visual Studio and the .NET Framework will offer innovations and enhancements to the class libraries, common language runtime (CLR), programming languages, and the integrated development environment (IDE). In addition, this product will provide deep support for SQL Server 2005 (formerly referred to as "SQL Server codename Yukon") by enabling developers to write stored procedures .
• Visual Studio code name "Orcas". This version of Visual Studio and the .NET Framework will provide tools support for the Windows operating system, code name "Longhorn."

Figure 1. Developer Tools Roadmap

Microsoft developer tools have always been built to enable developers to take advantage of the latest advances in the Windows platform. As shown in Figure 1, Microsoft will continue this tradition by providing tools that support upcoming versions of SQL Server and the Windows operating system.

Top of Page

Visual Studio 2005

The release of Visual Studio 2005 and the .NET Framework 2.0 will make strides in all dimensions of application development. First, Visual Studio 2005 will set a new bar for developer productivity by tailoring the software development experience to the needs of the individual developer. This "personalized productivity" will deliver features across the development environment and .NET Framework class libraries to help developers overcome their most pressing challenges in minimal time. Second, Visual Studio 2005 will enable developers to apply existing skills across a broader range of application development scenarios through improved integration with the Microsoft Office System and SQL Server 2005. Finally, Visual Studio 2005 will deliver a new set of tools and functionality that will help satisfy the application development needs of today's large-scale enterprises.

Key focus areas for Visual Studio 2005 include:

• Language and IDE Productivity. Microsoft will build on the distinctive characteristics of each of the four languages delivered as part of Visual Studio (Visual Basic, Visual C++, Visual C#, and Visual J#). This language innovation will enrich the programming experience for each of the respective developer communities without sacrificing existing language functionality and interoperability. Features surfaced through language innovation will be manifested throughout the IDE, delivering personalized productivity for all developer communities.
• The Microsoft .NET Framework. The .NET Framework 2.0 will introduce enhancements across the .NET Framework class libraries. Windows client application development will be simplified through new controls and designer features, while the introduction of "ClickOnce" technology will dramatically ease Windows client application deployment. ASP.NET 2.0 will introduce a collection of new features that refine Web application development and radically reduce coding effort. Other enhancements include more productive ADO.NET data access, support for the latest Web services standards, and expanded functionality for device-based development.
• Microsoft Office Solution Development. The release of Visual Studio 2005 Tools for the Microsoft Office System will bring significant enhancements to the development of business solutions based on Microsoft Office Excel 2003 and Microsoft Office Word 2003. Developers building Office solutions will benefit from improved integration between Visual Studio and Office, a familiar coding experience, and improved security and deployment.
• SQL Server 2005 Solution Development. SQL Server 2005 integrates the development and debugging of database objects into the Visual Studio 2005 development environment, enabling developers to use the same tools for building and deploying database objects that they use to write managed components and applications today.
• Enterprise Development and Life-Cycle Support. Microsoft plans to deliver improved support for architects and enterprise developers in the 2005 release. New tools will deliver enhanced project analysis and design, software configuration management, and deployment, as well as a scalable new build engine to ensure that Microsoft developer tools span the application life cycle.

Language and IDE Productivity

Microsoft offers four programming languages for building software with Visual Studio. In Visual Studio 2005, Microsoft will expand upon the unique strengths of Visual Basic, Visual C++, Visual C#, and Visual J# to deliver a rich language offering for developing a range of software. These language innovations, surfaced through the IDE, will work in concert with enhanced IDE profiles and an intuitive Help system to deliver productive, customized development experiences based on the needs of the developer community (figure 2).

Figure 2. Customized Help and improved IDE profiles will enable developers to use the Visual Studio 2005 development environment to access information more effectively.

Top of Page

Visual Basic

The 2005 release of Visual Basic will radically improve developer productivity while continuing to provide full access to the .NET Framework. Key design goals for Visual Basic 2005 include: reducing the amount of code required to accomplish common tasks; dramatically reducing programming errors at design time; simplifying data access; improving the RAD debugging experience; and delivering high-end features for advanced Visual Basic developers.

Visual Basic 2005 will reduce the coding associated with many common programming tasks by over 50 percent. New objects and methods will provide efficient access to the most frequently used functionality within the .NET Framework, including project-related resources, such as forms, data sources, and Web services, as well as machine-level components, such as printers, the file system, and the registry. The code in figure 3 shows one example of how these Visual Basic language extensions will dramatically simplify the code required for common operations.

In addition, the Visual Basic code editor will provide pre-built code templates that enable developers to "fill in the blanks" and focus on solving the problem at hand rather than on language syntax (figure 4). Developers will also be able to easily create and distribute their own customized code snippets.

Figure 4. Code snippets automatically author common programming tasks.

New features in the Visual Basic code editor will dramatically reduce programming errors for both beginning and advanced developers at design time. Providing similar functionality to the Microsoft Word spelling and grammar check, Visual Basic 2005 will suggest corrections for common syntax errors.

Figure 5 shows a smart tag offering corrections for a misnamed type. Examples of errors that will be trapped include: forgetting to reference a required assembly, attempting to override a method with an incorrect signature, and misspelling a class name. In addition, the compiler will warn developers of semantically incorrect code that would otherwise cause runtime errors, such as attempting to access code elements prior to initialization.

Figure 5. Smart tags provide automatic syntax correction mechanism for Visual Basic code.

Visual Basic 2005 will also radically enhance the experience of manipulating and retrieving data. Simplified data source design from within the development environment will be available for local and remote data, business objects, and Web services. Visual Basic 2005 will also reintroduce the ability to create data-bound forms without code. Ideal for many common data access scenarios, yet robust and scaleable enough for the most demanding distributed applications, this feature will enable developers to automatically generate customizable, data-bound UI when a table or columns are dragged and dropped onto a form.

Visual Basic 2005 will deliver a debugging experience that is both powerful and familiar to the Visual Basic developer. With the reintroduction of Edit and Continue, developers will be able to modify and test source code without stopping and restarting the debugging session. Debugger advances will allow developers to intercept exceptions, get additional information about the exception, and continue if appropriate (figure 6). This iterative development and debug cycle, combined with advanced error correction and code analysis in break mode, will provide developers using Visual Basic with a debugging experience that is both powerful and flexible.

Figure 6. Exception Helpers enable developers to more effectively diagnose runtime errors.

Following development, Visual Basic 2005 will simplify the task of deploying a completed Windows client application to a user's machine with the introduction of "ClickOnce" deployment. Using this technology, developers will be able to create an application package that can be distributed through a Web page, file share, or other medium. Application users will simply click on the distribution package to install the application and all of its prerequisites. Further information on ClickOnce deployment and other deployment advances in Visual Basic 2005 are covered later in this document.

For developers who have existing investments in Visual Basic 6.0 code, Visual Basic 2005 will include several key improvements to the Visual Basic Upgrade Wizard. While the current version of the upgrade wizard available with Visual Basic .NET 2003 will successfully upgrade up to 95 percent of an application, advances in Visual Basic 2005 will improve upon this rate with support for upgrading COM+ projects, additional Visual Basic 6.0 controls, including the TreeView, ListView and MaskedEdit controls, and enhanced support for upgrading code that involves programmatic printing. The Upgrade Wizard will also take advantage of many of the new language features being introduced in Visual Basic 2005 to produce even cleaner and more maintainable upgraded code.

For the more advanced Visual Basic developer, language enhancements include support for operator overloading, unsigned data types, and partial types. In addition, developers using Visual Basic will have access to the CLR implementation of generics that promote code reuse across a variety of data types. Visual Basic 2005 will introduce inline XML-documentation comments that will assist developers in creating well documented applications ready for deployment inside or outside the enterprise. Finally, Visual Basic 2005 developers will continue to have full and direct access to all of the classes and functionality within the .NET Framework.

Like its predecessors, Visual Basic 2005 will focus on enabling developers to rapidly build applications that span all tiers. Planned enhancements across the visual designers, code editor, language, and debugger will greatly enhance productivity, enabling developers to create robust, elegant applications faster and deploy them across the Web, a business group, or an enterprise.

Top of Page

Visual C++

Visual C++ 2005 will offer even more power and fine-grained control than its predecessors for systems and application developers targeting both Windows and the .NET Framework. Key improvements are planned across all areas of the product, including the language, compiler, and core libraries. These enhancements will enable C++ developers to more effectively target the CLR, optimize their code for performance, target 64-bit Windows, and improve application security. Moreover, Visual C++ 2005 will enable developers to build native C++ applications for mobile devices directly within the Visual Studio 2005 IDE. (More information about embedded C++ development can be found in the Device-Based Development section).

With Visual C++ .NET versions 2002 and 2003, Managed Extensions enable developers to explicitly take advantage of the CLR and the .NET Framework. In Visual C++ 2005, the existing Managed Extensions syntax will continue to be fully supported. In addition, Visual C++ will offer expanded support for the CLR and the .NET Framework with powerful new features and a more elegant syntax for writing managed code. This syntax is now undergoing ECMA standardization as a C++ binding to the ECMA-standardized Common Language Infrastructure (CLI). The new syntax will be called C++/CLI.

The C++/CLI subset of the C++ language will be largely implemented in Visual C++ 2005, and will offer Visual C++ developers a number of new capabilities. For the first time, C++ developers will be able to write .NET-connected applications using true C++ programming paradigms. For example, C++ templates and C++-style deterministic finalization will be enabled for code and data managed by the CLR and the garbage collector. Additionally, C++/CLI brings many CLR programming paradigms to C++, including the CLR implementation of generics.

C++/CLI also streamlines the manner in which managed data types are defined and consumed. The new standard introduces keywords that are more intuitive to C++ developers than the underbar-underbar keywords of current Managed Extensions. In C++/CLI, the ref keyword is used in a manner similar to the Managed Extensions __gc keyword to define a garbage-collected class:

   ref class MyRefClass { /* ... */ };

In addition, C++/CLI introduces a new category of type, the handle, which is used to signify the use of automatic garbage collection. Handles borrow the syntax of pointers, but use the carat (^) in place of the asterisk (*). The keyword gcnew is used to create these garbage collected objects, and returns a handle:

   MyRefClass ^ c = gcnew MyRefClass();

With C++/CLI, developers will also be able to incorporate traditional C++-style deterministic finalization for handle types. This means that a reference type may be optionally instantiated as an object using normal C++ stack-allocation syntax. In doing so, the object will automatically have its destructor called when it falls out of scope. This feature enables a style of programming not available in other languages targeting the CLR.

In addition to C++/CLI support, the Visual C++ compiler will offer several code-generation enhancements for CLR-targeting code. These enhancements include the ability to specify a "pure" image that includes no native-x86 instructions and a "safe" image that passes the CLR verification process. Furthermore, the Visual C++ 2005 compiler will be able to optimize MSIL beyond what is possible with other managed languages.

One of many enhancements planned for the C++ compiler in Visual C++ 2005 is Profile Guided Optimizations (POGO). POGO technology enables the compiler to instrument an application and collect information on how the application is used at runtime. This information enables Visual C++ to further optimize generated code based on real-world application usage patterns. Pre-release versions of 64-bit POGO technology currently ship in the freely downloadable Platform SDK (PSDK). In Visual C++ 2005, this technology will be extended to the core 32-bit compiler, and support will be integrated into the IDE (figure 7).

Figure 7. POGO support in Visual C++ 2005 will optimize applications through instrumentation and runtime analysis.

This release will also include the 64-bit C++ compilers that are currently only available in pre-release form within the PSDK. These compilers enable Visual C++ developers to write unmanaged code that target the 64-bit versions of Windows running on both Intel and AMD hardware. Support for targeting 64-bit Windows will be fully integrated into the IDE (figure 8).

Figure 8. Platform support in Visual C++ 2005 is extended to include 64-bit Windows, as well as various mobile devices.

In addition to language and compiler enhancements, Visual C++ 2005 will deliver improvements and additions to core C++ libraries, such as the Microsoft Foundation Classes (MFC), the Standard Template Library (STL), and the C-runtime library (CRT). These additions will enable C++ developers to better support the .NET Framework and deliver built-in application security.

First, a new version of the Standard Template Library (STL) will be introduced. This version of STL will be tuned for interacting with managed code and data. Programmers who are comfortable using STL for writing traditional C++ applications will find they will be able to apply the same coding techniques to writing CLR-based applications. Second, a new version of the C-runtime library (CRT) with enhanced security features will be released with Visual C++ 2005. As part of Microsoft's ongoing commitment to the Trustworthy Computing initiative, this release of the CRT will help increase the collective security of applications that integrate the CRT.

With Visual C++ 2005, developers will continue to choose Visual C++ to build their most demanding applications and components. With Visual C++ 2005 expands on the core set of capabilities delivered in the 2003 release of Visual C++ .NET with an exciting offering of new and refined features for the control and performance-conscious C++ developer.

Top of Page

Visual C#

In Visual C# 2005, Microsoft plans to infuse C# with a variety of language and code editor features that will provide C# developers with "code-focused RAD," delivering productivity for creating business frameworks and reusable object-oriented components. Included among these features are generics, iterators, anonymous methods, partial types, and refactoring.

As projects increase in sophistication, programmers often need a means to better reuse and customize existing component-based software. To achieve such a high level of code reuse, programmers typically employ a feature called generics. In Visual C++ 2005, the CLR will include a type-safe, high-performance, compile time-verified version of generics that differs slightly in syntax and greatly in implementation from the templates as found in C++ and the generics as proposed for the Java language. Generics allow developers to author, test, and deploy code once and reuse that code for a variety of different data types with negligible performance impact. The CLR implementation of generics will also reduce code bloat when compared to other strongly-typed implementations, leading to more readable and maintainable source.

In the example below, a generic Stack class is created that will accept the type for which they are created and store data of that type natively, rather than forcing conversions to and from the base class type:

   public class Stack<ItemType>
   {
      private ItemType[] items;

      public void Push(ItemType data)
      {
         ...
      }

      public ItemType Pop()
      {
         ...
      }
   }


The type used by the generic Stack class is only specified upon instantiation. In this example, the Stack class is instructed to use a primitive integer type by specifying it as a parameter using the angle notation in the instantiation statement:

   Stack<int> stack = new Stack<int>;
   stack.Push(3);
   int x = stack.Pop();

In addition to improving code reuse through generics, Visual C# will provide support for iterators to eliminate the often repetitive chores associated with implementing enumerator patterns. Based on similar features in research languages, such as CLU, Sather, and Icon, iterators make it easy for types to declare how the foreach statement will iterate over their elements. Rather than having to create the classes and build the state machine for manually implementing the enumerator pattern, the C# compiler will translate iterator code into the appropriate classes automatically.

Anonymous methods are practical language constructs that will enable programmers using Visual C# 2005 to create code blocks that can be encapsulated in a delegate and executed at a later time. They are based on a language concept called a lambda function and are similar to those found in Lisp and Python. Anonymous methods are defined dynamically at the point at which they are used, rather then being pre-defined as a named method of a specific class. Anonymous methods make some types of operations more convenient, particularly when the method signature or body needs to be changed at runtime.

In this example, an anonymous method is used to directly modify a ListBox on a form, foregoing the creation of an entirely new method for the class and instead directly referencing the executable steps contained therein. The code used to modify the list box is stored within the scope of execution immediately following the delegate creation statement:

   public class MyForm
   {
      ListBox listBox;
      TextBox textBox;
      Button button;

      public MyForm()
      {
      listBox = new ListBox(...);
      textBox = new TextBox(...);
      button = new Button(...);
      button.Click += new EventHandler(sender, e)
      {
         listBox.Items.Add(textBox.Text);
      };
     }
   }

Visual C# 2005 will also enable C# developers to split types consisting of a large amount of source code into several different source files using partial types. Providing easier development and code maintenance, partial types enable developers to separate machine-generated and user-written parts of a type in order to more effectively supplement or modify code generated by a tool.

In addition to extending the C# language, Visual C# 2005 will introduce C# developers to a number of code editor enhancements. Among these is code refactoring—the process of restructuring code in a disciplined way (figure 9). With refactoring, C# developers can improve the design and efficiency of code after it has been written. Visual C# 2005 will include the following Refactoring types: Rename, Encapsulate Field, Change Method Signature, Extract Method, and Extract Interface.

Figure 9. Refactoring enables developers to effectively manage code that is poorly organized.

Other C# code editor enhancements include "fill-in-the-blank" code expansions for common coding constructs, such as for loops and try/catch blocks (figure 10), improved IntelliSense support for attributes and generics, and a rich set of options for customizing how the IDE formats C# code.

Figure 10. Code expansions provide templates for common coding constructs.

With its focus on language innovation, C# will remain the language of choice for many framework designers and software architects. By supplementing its modern syntax with component-oriented features, modern language constructs, and code editor enhancements, C# will continue to deliver on the promise of code-focused RAD.

Top of Page

Visual J#

The 2005 release of Visual J# will introduce several features planned to enhance the Java-language development experience. First, Visual J# 2005 will include a number of enhancements to the language syntax to improve code migration and interoperability scenarios. Second, the 2005 release of Visual J# will be a full CLS Extender, enabling better interoperability with other CLS-compliant languages. Third, Visual J# will integrate J# Browser Controls (currently available as an add-on) to facilitate the migration of Java applets to run within the context of the .NET Framework.

In order to improve cross-language interoperability and support future Windows operating system features, Visual J# 2005 will include several language additions and enhancements. These language enhancements enable developers using Visual J# to write code that is more efficient, secure, and expressive. First, Visual J# will introduce support for the volatile keyword to improve code flexibility in optimized code scenarios. Second, Visual J# 2005 will enable support for .NET-style serialization, providing greater interoperability when exchanging data. Third, the APTC attribute (Allow Partially Trusted Callers) will be enabled for the J# Redistributable, meaning that developers can deploy applications that run with partial trust, given the appropriate code access security settings. Finally, Visual J# will provide support for consuming generics to ensure cross-language consistency in future releases of the .NET Framework:

   Queue<String> q;   // System.Collections.Generic.Queue
   Stack<Integer> s;  // System.Collections.Generic.Stack
   KeyValuePair<String, String> k;

In addition to syntax enhancements, Visual J# 2005 will become a full CLS Extender by adhering to the Common Language Specification rules for language interoperability. Visual J# .NET 2003 is a full CLS Consumer, but a limited CLS Extender, meaning that Visual J# applications can fully access and utilize CLS-compliant frameworks, but cannot always create them due to some limitations in the language. Visual J# 2005 will overcome these limitations by adding support for authoring value types and typesafe enums.

Value types are often thought of as lightweight classes. The primary difference between a value type and a class is that a value type does not require heap allocations and contains the data of the type, whereas a variable of a class type contains a reference to the data. Also referred to as user-defined value types, value types enable scenarios in which objects are used in a similar fashion to primitive types—without the overhead associated with garbage collection. The syntax for creating a value type in Visual J# is similar to creating a class type, with the exception that the value type extends from System.ValueType:

   public final class Point extends System.ValueType
   {
      public int x;
      public int y;
   }

An enum (or typesafe enumeration) type is a kind of value type. Each enum type has a corresponding integral type called the underlying type. This underlying type must be able to represent all of the enumerator values defined within the enumeration. Enums are typesafe, they improve code readability, and they can be used as the control type in a switch statement. An enum type is similar to a value type, except that it extends from System.Enum:

   public final class Color extends System.Enum
   {
      public static final int Red = 1;
      public static final int Green = 2;
      public static final int Blue = 3;
   }

The enum type above can then be instantiated as follows:

   Color c = new Color();

   int i = (int) c.Red; //i = 1


As a full CLS Extender, Visual J# 2005 will also support the CLSCompliant attribute that developers can apply to their assemblies to indicate whether or not a given component uses only CLS compliant features in the APIs that it exposes.

Since the inception of Visual J# in 2002, members of the Java community have requested the ability to migrate Java applets to managed code so that they run within the context of the .NET Framework. In addition to providing greater functionality and security than applets, such a technology would alleviate concerns over the planned end of life for the Microsoft Java Virtual Machine. In response to these customer requests, Microsoft has developed a technology known as J# Browser Controls. J# Browser Controls enable developers to migrate existing applet source code to run on the .NET Framework simply by opening their source code and recompiling with minimal or no code changes. Once this conversion is complete, developers can embed the J# Browser Control within a Web page in a way similar to embedding applets today. Additionally, J# Browser Controls have full access to the .NET Framework and will include support for consuming Web services. J# Browser Controls will be provided as part of the J# 2005 Redistributable and are available today as an add-on to the .NET Framework 1.1. See J# Browser Controls.

With its familiar syntax and object-oriented functionality, Visual J# continues to offer the most productive way for Java-language developers to start building applications with the .NET Framework. Enhancements in Visual J# 2005 will broaden the spectrum of capabilities available to students, teachers, and professors, as well as developers using the Java language and Visual J++.

Top of Page

The Microsoft .NET Framework

Developed in concert with Visual Studio .NET, the Microsoft .NET Framework provides a dependable foundation for constructing Windows, Web, and mobile device-based applications that integrate by design, and deploy efficiently across the enterprise. In version 2.0, the .NET Framework will further extend the capabilities of developers by introducing significant enhancements across each of its functional areas. New classes will give developers more efficient access to frequently used components, such as printers, the file system, and the registry. Advances to Windows Forms and ASP.NET classes will reduce code in common scenarios by up to 70 percent. Reliability and scalability will also be significantly improved through support for 64-bit processors from Intel and AMD, improved ASP.NET caching and page processing, and overall improved working set and application startup time.

Windows Client Application Development (Windows Forms)

Windows Forms empowers developers with the full power of the Windows client PC. In the .NET Framework 2.0, the Windows Forms classes will be enhanced to include an improved application deployment model, increased developer productivity, and simplified data access. The .NET Framework 2.0 will also include notable enhancements to Windows client application performance and security.

The .NET Framework 2.0 No-Touch Deployment strategy will improve with the introduction of "ClickOnce," a new technology that will bring the ease and safety of Web application deployment to Windows client applications (figure 11). Building on the strengths of self-describing assemblies, component manifests, and side-by-side component installation, ClickOnce will enable a developer to publish, install, and service Windows client applications without fear of breaking existing functionality on the client operating system. Whereas traditional deployment builds an MSI package which may require modifications to the system registry and installation to shared system folders, ClickOnce publishing is tailored to install isolated, registration-free assemblies. Developers will have the choice of choosing which model is best for their Windows client application: ClickOnce Publishing, MSI Deployment, or a combination of both.

New capabilities for Windows client applications installed using ClickOnce will include: support for running applications offline, rolling back to previous versions of an application, and listing an application in the Windows Start menu, as well as the Remove Programs catalog within the Control Panel. Additionally, ClickOnce Deployment in the .NET Framework 2.0 will enable developers to distribute the .NET Framework with a Windows client application.

Figure 11. The Publish Wizard enables Windows client applications to be deployed as easily as Web applications.

To further support this deployment model, significant investments are being made in code access security, which protects users from malicious code by governing the capabilities of applications deployed from a remote Web server. In the .NET Framework 2.0, the scope of permissible actions that may be carried out safely by the deployed application will be expanded. Additionally, enhancements to the .NET Framework will make it easier for systems administrators to safely roll out updates to code access security policy

Second, Windows Forms will include features and controls that increase developer productivity. These features and controls include the following: an Active Document Container for hosting Office documents, a Microsoft Office-style toolbar, intuitive splitter controls, a sound component that can run in partial trust, a Web browser control that can be accessed safely by way of managed code, and layout controls that automatically position and resize controls on a form as screen resolution or form dimensions change. In addition, implementation of multithreaded applications will be simplified through large investments in the Windows Forms asynchronous programming model. Many Windows Forms controls will feature asynchronous properties and will be complemented by a new, intuitive BackgroundWorker component to manage asynchronous tasks.

These new controls and components will work with enhancements planned for the Windows Forms designer, including smart tags, Snap Lines, data preview, and more. Using smart tags, Windows client application developers can easily customize the look and behavior of data-bound controls with a click of the mouse (figure 12); Snap Lines will simplify the layout of groups of controls within a form, and data preview will enable developers to view populated data-bound controls at design time.

Figure 12. Smart tags provide easy customization of data-bound controls and forms.

Web Application Development (ASP.NET)

Providing the thin-client counterpart to Windows client development is the Web application infrastructure ASP.NET, introduced as part of version 1.0 of the .NET Framework. Through dramatically improved performance, productivity and security, Visual Studio 2005 and ASP.NET 2.0 will deliver a simplified, high performance, and powerful Web development experience. ASP.NET 2.0 will feature a new set of controls and infrastructure that simplify Web-based data access and will include functionality that facilitates code reuse, visual consistency, and aesthetic appeal.

First, ASP.NET 2.0 data access will be refined through the introduction of new controls for interacting with data. The DataSource control will be used declaratively or programmatically in an application to encapsulate the query logic required to work with data from databases, XML files, middle-tier business objects, and other sources. The DataSource exposes a set of common interfaces so that data-bound controls can easily consume different types of data without requiring a unique API for each data type it supports.

While the DataSource control helps simplify the retrieval and update of data, ASP.NET 2.0 will also provide new controls that display and manipulate data. The GridView control is the successor to the ASP.NET DataGrid that adds the ability to automatically handle paging, sorting, editing, and deleting of data (figure 13). The DetailsView is a data-bound control that renders a single record at a time from its associated data source. Similar to the Form View of a Microsoft Access database, the DetailsView provides paging buttons to navigate between records. Developers can use the DetailsView control in a master-details scenario for updating and inserting new records where the selected record of the master control determines the DetailsView display record. The added functionality of these and other controls dramatically simplifies the building of dynamic, data-driven Web sites and Web applications.

Figure 13. The GridView control provides paging, sorting, editing, deleting, and selection of grid elements without additional code.

Second, ASP.NET 2.0 will include features that ensure consistency and code reuse across pages within a Web site. The introduction of Master Pages will enable developers to quickly share layout across multiple pages by designing templates that specify the location of controls, menu bars, headers, and footers (figure 14). Similar to visual inheritance in Windows Forms, Master Pages allow other pages on a Web site to inherit from a Master Page, automatically acquiring its look and feel. When a developer wishes to change the layout of all the pages, it is only necessary to make updates to the Master Page. Other platform productivity enhancements include a set of framework services that simplify many common Web scenarios, such as authentication, site navigation, administration, personalization, and more. These enhancements will reduce code bloat, increase maintainability, and simplify the implementation of most common Web application development tasks.

Figure 14. Master Pages enable efficient sharing of Web site layout across multiple pages. The gray area within the designer represents Master Page layout; the white represents editable page content.

Also new to ASP.NET is the ability to incorporate themes and skins to enhance the appearance of Web applications. A skin is a set of properties, templates, and custom code that can be used to standardize the size, font, and other characteristics of controls on a page. A theme incorporates multiple skins and stylesheets to specify the overall look and feel of a Web site. Themes and skins will be simple to package, transfer, and apply to other Web sites. In addition, ASP.NET will provide several built-in themes that developers can use to build aesthetically appealing Web sites out of the box.

Third, Web application developers using ASP.NET 2.0 will be able to increase their application performance by taking advantage of SQL cache invalidation. This method of data caching facilitates significant performance improvements by caching data retrieved from a SQL Server database until an update to that data is made. With currently available versions of SQL Server, ASP.NET will poll the database at specified intervals to determine if an update to the data has been made. Then, only when an update to the data is indicated will ASP.NET requery the database. When developing against a SQL Server 2005 database, however, developers will be able to cache data-driven pages for an indeterminate amount of time. This ability is due to SQL Server 2005's ability to proactively notify ASP.NET of changes made to the data. Internal testing of SQL cache invalidation has demonstrated performance benefits of up to 10 times that of non-cached data scenarios.

Fourth, Web application developers will experience dramatic improvements in productivity through the use of the Visual Studio 2005 IDE itself. With the new Web Developer IDE profile enabled, Visual Studio 2005 will optimize the development environment and user experience by exposing only that functionality which is pertinent to Web application development. In addition, a new directory-based project model will remove the overhead of solution files while enabling Web developers to enjoy a traditional file system-based project paradigm with support for direct IIS enumeration, FTP, and file system access. As a result, FrontPage Server Extensions are no longer a requirement for building ASP.NET pages.

Finally, enhancements to the ASP.NET code-behind model remove the reliance on fragile tool-generated code traditionally needed to coordinate an ASP.NET 2.0 Web page with its associated class file. Using partial classes, ASP.NET will provide a more robust model to separate presentation markup from code. Partial classes will also enable developers to easily write code inline (figure 15), thereby aligning with the model familiar to many Web developers. Other IDE productivity enhancements for Web development include a design-time validation engine, in-line CSS support, more flexible debugging, and more.

Figure 15. IntelliSense within script blocks enables statement completion and syntax checking at design time.

With improvements planned across the control set, visual designers, and coding experience, ASP.NET 2.0 will reduce the amount of code required to accomplish common coding scenarios by up to 70 percent, drastically streamlining and simplifying the Web application development experience.

Top of Page

Device-Based Development

With the release of Visual Studio .NET 2003 and the .NET Compact Framework, developers using Visual Basic and Visual C# gained the ability to build device-based applications using the same tools and methods used for desktop and Web-based development. In Visual Studio 2005, smart device programmability will be extended to include an updated version of the .NET Compact Framework and support for native Visual C++ smart device development from within the IDE.

The inclusion of native Visual C++ smart device development in Visual Studio 2005 provides developers with greater flexibility when developing applications for the Pocket PC, Smartphone, and other Microsoft Windows-powered devices. Developers targeting mobile devices will benefit from the tight integration of the native Visual C++ development features and a consistent development experience across all Visual Studio project types, ranging from smart devices to Windows servers.

For developers building managed applications using the .NET Compact Framework, Visual Studio 2005 will enable creation of applications that run on the latest devices, including Smartphone, Windows CE .NET -based devices, and the newest versions of the Pocket PC. This release will also introduce new classes and controls for accessing telephony features, messaging (MSMQ), and Short Message Service (SMS). Finally, native code interoperability enhancements, including improved marshalling, COM Interoperability, and runtime hosting will improve the smart device application development experience.

Data Access (ADO.NET)

With the initial release of the .NET Framework, Microsoft introduced ADO.NET, the evolution of ActiveX Data Objects (ADO). Designed to natively support XML as well as traditional datasets, ADO.NET offered strongly-typed, distributed data access and ensured against unnecessary occupation of database ports by making extensive use of local data caching and open database connections. The resulting improvements in performance and scalability have provided a foundation on which to enhance future versions of ADO.NET.

In the.NET Framework 2.0, data access will be enhanced not only through the addition of new data access controls, services, and the ability to integrate more seamlessly with SQL Server 2005, but also through improvements to the ADO.NET class libraries themselves. These enhancements focus on ease-of-use, code reusability, and improved support for XML./p>

First, numerous improvements will be made to the usability of the data access object model. While initial versions of the .NET Framework concentrated on providing a strong core for data access developers, The .NET Framework 2.0 will extend this core with additional classes to further increase developer productivity. In addition, tracing support will be improved for fine-grained debugging of data access components across multiple tiers and into .NET Framework managed code, as well as native code.

Second, the .NET Framework 2.0 will include enhanced tools for editing, debugging, and coding XML and related technologies (figure 16). In addition to delivering increased performance when accessing and managing XML, the 2.0 release of the .NET Framework will provide expanded functionality for performing common tasks involving the manipulation of XML as well as other XML based standards and technologies.

Figure 16. The new XML Editor supports outlining, validation, and editing of XSLT.

Finally, enhancements for creating XML schemas in Visual Studio 2005 include the ability to infer an XSD schema from any existing XML document, as well as native support for XML-based data processing using XML Query Language (XQuery).

Advanced Web Services

With Visual Studio .NET 2002 and 2003, developers benefited from the simplicity with which they could create, consume, discover, and deploy Web services. In Visual Studio 2005 , Microsoft's ongoing commitment to Web services will be demonstrated through support of the latest industry standards, implemented in the Web Services Enhancements (WSE) libraries. Updates to WSE will facilitate the creation of business-critical Web services that involve multiple trust domains, long-running operations, and peer-to-peer communication.

In addition, as WSE gains broad adoption and industry specifications for advanced Web service development mature, the WSE libraries will be integrated into the .NET Framework. Future releases of WSE will contain the latest version of these specifications and will include a policy framework, enhanced security model, and a SOAP messaging infrastructure. In addition, WSE will support hosting outside of IIS (as an executable or a Windows Service) and will support both HTTP and TCP communication.

Top of Page

Microsoft Office Solution Development

In October 2003, Microsoft released Visual Studio Tools for the Microsoft Office System. This new technology brings .NET Framework-based development to Word 2003 and Excel 2003 solutions by enabling developers to write managed code that responds to events within the Word and Excel automation models. Building on the long-standing success of Visual Basic for applications (VBA) and COM-based automation, Visual Studio Tools for Office (VSTO) provide developers with significant benefits for building Office solutions, including a familiar coding experience, improved deployment and maintenance of solutions, and improved security.

The 2005 release of VSTO brings significant enhancements to the development of business solutions based on Microsoft Office Excel 2003 and Microsoft Office Word 2003. Building on the foundation provided by this version of VSTO, Visual Studio 2005 Tools for Office will address some of the biggest challenges facing Office solution developers today, including separation of data and view elements, deployment of Office solution assemblies, server-side and offline scenarios, and seamless integration with the Visual Studio toolset.

One of the primary goals of VSTO 2005 is to separate "data" from "view" in Office documents in order to simplify the creation of Office-based solutions. Today, Excel spreadsheets and Word documents consist of an amalgamation of either cell values or text (representing the data) and descriptive information about the data, such as the font (representing the view). Because Word and Excel have no built-in concept of programmatic data, developers are limited in their ability to effectively develop solutions around the data stored within the documents.

VSTO 2005 will separate the data from the view in Office documents by enabling data to be embedded as an XML data island. This provides a well understood and easily addressable structure that developers can rely on when programming. The developer is able to separate view and data, and is thus able to update the data directly without concern of writing view code. Typed data sets will be used to provide a schema-oriented programming model for interacting with the data island, ensuring IntelliSense support for the managed code being written. Data binding will be used between the data island and the view to keep these two entities in sync. The developer will also be able to add validation code to the data that is independent from the document view components.

Programming directly to data by way of an XML schema-based model provides dramatically improved productivity for developers. Code that works with data does not need to address the Excel and Word object models. This simplifies much of the code involved in building Office solutions and makes solutions resilient to changes in the document. The resulting code is less brittle because it does not rely as heavily on references to specific cells, ranges and tables that can be arbitrarily moved around by end users. Rather, the managed code directly accesses XML data islands.

Making data in Office documents a transparent, directly accessible component enables new server-side opportunities. First, the data island embedded in the document can be manipulated without starting the Office application. This is a dramatic shift from the current model, by which, in order for code to manipulate the contents of the document, Excel or Word must be running. This limitation blocks many customers from implementing a common solution requirement—creating Office documents from within an ASP.NET application.

By contrast, the VSTO 2005 runtime will support instantiation on a server without the need to run Excel or Word. The data island in a document could then be manipulated from the server-side code. When the user opens the associated Office document the view would be re-synchronized with the data island and the user would be automatically presented with the updated data. In this model, Excel and Word are not needed to write to the data on the server, but rather only to view it on the client. This updated model will provide the scalability customers desire and the ability to perform high performance batch processing of documents containing data islands on the server.

Storing the data in a data island also provides a mechanism for enabling robust offline scenarios. When a document is first requested from the server or first opened by the user, the data island will be filled with the most recent data. The data island would then be cached in the document and made available offline. The data could be manipulated by the user and by code without a live connection. When the user reconnects, the changes to the data could be propagated back to a server data source.

In addition to radically improving the data programming model, the 2005 release of VSTO will introduce enhancements to the way developers programmatically access user interface, or view, elements, such as ranges, lists, and bookmarks. Even though developers can write code today to manipulate these elements, they are impacted by the extent to which the Office object models expose events, properties, and methods. For example, the Excel object model provides a WorkSheet_Change event, but does not provide similar events for individual cells or ranges, necessitating additional code to handle the occurrence of a change to a specific element. VSTO 2005 introduces enhancements to the Excel and Word object models in the area of view elements. Elements, such as cells, ranges, lists, and bookmarks will become first class controls that can be easily accessible in code. Each control will be uniquely identified, will enable data binding and will provide a more complete event model.

VSTO 2005 will also lower the barriers that currently exist when building Office solutions with managed code by integrating Excel and Word with Visual Studio. Currently, developers write managed code in Visual Studio .NET. Then, they must switch to Excel or Word in order to create the user interface. In VSTO 2005, Excel and Word will be hosted directly in the Visual Studio 2005 IDE as designers (figure 17). Developers will be able to design Office documents within the Visual Studio environment using the full collection of Windows Forms controls in Excel and Word by simply dragging and dropping managed controls, including third-party controls, from the Toolbox. As expected, double-clicking on a managed control in Excel or Word will invoke the code view in which customizations can be written inside the auto generated event handler for that control.

Figure 17. The Visual Studio 2005 IDE will support the hosting of Excel spreadsheets, as well as Word documents.

Managed control hosting within Word and Excel documents, combined with Excel and Word integration within the Visual Studio IDE, will reduce the differences that exist today between Office solution development and Windows and Web-based solution development.

Top of Page

SQL Server 2005 Solution Development

As part of Microsoft's plans to coordinate future versions of its developer tools with important platform milestones, Visual Studio 2005 will deliver deep integration and support for SQL Server 2005. SQL Server 2005 will incorporate CLR functionality into its database engine to bring a new level of integration between database and tool, reducing code and effort when developing data-centric applications.

First, SQL Server 2005 will introduce the ability to create database objects in managed code. This enables developers to build SQL Server procedural objects including functions, stored procedures, and triggers using languages, such as Visual Basic, Visual C++ and Visual C#. In addition, developers will be able to use managed code to build new SQL Server objects introduced in SQL Server 2005, including User-Defined Types and Aggregates. As a result, a development team could use Visual Studio 2005 to not only create and debug the presentation and middle tiers of a distributed application, but also the database objects that comprise the data tier. Moreover, the .NET languages will in many respects be richer than traditional Transact-SQL, offering an enhanced programming model with constructs and capabilities previously not available to the SQL developer.

Second, database objects written in managed code will provide enhanced safety and security. Because these database objects will run in a CLR environment hosted in the database engine, they will operate within the context of the fine-grained CLR security model. This model is more inherently secure than the extended stored procedures available in earlier versions of SQL Server. It also gives administrators greater control to define a permissible set of actions for the code when attempting to access or manipulate resources either internal or external to SQL Server 2005.

Finally, the use of managed languages to build SQL Server 2005 database objects will often yield notable gains in performance and scalability. Because of optimizations built into the Visual Studio 2005 language compilers and execution model, database objects, such as stored procedures, functions, and triggers written in managed code will deliver substantially improved performance over T-SQL in many circumstances.

Enterprise Development and Life-Cycle Support

Satisfying the application development needs of today's large-scale enterprises frequently requires complex, highly specialized sets of tools, technologies, and design methods. With Visual Studio 2005 Team System (VSTS), Microsoft addresses the growing complexities of application development life cycle by providing the tools and guidance needed to enable predictable, repeatable results without trading off productivity and innovation.

The Visual Studio 2005 Team System is an extensible life-cycle tools platform that helps software teams collaborate to reduce the complexity of delivering modern service-oriented solutions. Microsoft’s offerings now include integrated life cycle tools, a comprehensive set of proven process frameworks, best practices, and prescriptive architecture guidance that enable IT organizations to successfully deliver custom solutions on the Windows Server System. In addition, numerous industry partners will be extending the Visual Studio Team System with tools that provide even greater support for software life cycle. With Visual Studio 2005 Team System, organizations can:

• Reduce the complexity of delivering modern service-oriented solutions that are designed for operations
  
  
• Facilitate collaboration among all members of a software team, including business users, project managers, architects, developers, testers, and operations managers
  
  
• Customize and extend the Team System with their own internal tools and process frameworks or choose from over 400 supplemental products from over 200 partners

Visual Studio 2005 Team System consists of the following product offerings:

• Visual Studio Team Architect Edition, visual designers that enable architects and lead developers to design service-oriented solutions that can be validated against their operational environments
  
  
• Visual Studio Team Developer Edition, advanced development tools that enable teams to design for quality, early and often throughout the life cycle
  
  
• Visual Studio Team Test Edition, advanced load testing tools that enable teams to verify the performance of applications prior to deployment
  
  
• Visual Studio Team Foundation Edition, server-based team collaboration tools that enable organizations to effortlessly manage and track the progress and health of projects
  
  
• Proven process guidance, prescriptive architectural guidance, and solution accelerators that assist organizations in improving the predictability and reliability of delivering mission-critical solutions.

Figure 18. VSTS overview.

Complexity is the bane of modern business. It bleeds the bottom line, sacrifices the top line, and exerts pressure on everything in between. As their applications grow in complexity, software teams desperately need the same RAD principles of simplicity and flexibility to scale with them. Reducing complexity means enabling greater productivity, saving costs and pushing the bottom line lower, while saving time and offering more opportunity to increase the top line. In the following sections, we will discuss the technology offerings in Visual Studio 2005 Team System that help reduce complexity in building complex distributed systems in the following sections.

Analysis and Design—"Design for Operations"

Once the requirements for the application are gathered, organizations often design a detailed architectural model for their solution. These architectural designs don’t always translate well into code, and even if they do, the implementation and designs are not always in synchronization through the development life cycle. In addition, application architects must be able to reconcile their application designs with the data center requirements where their solutions will finally be deployed. In effect, application architects must be able to design their solutions with the operations infrastructure in mind.

With Visual Studio 2005, Microsoft delivers a set of designers (as part of Visual Studio 2005 Team Architect Edition) that enable architects and developers to easily design service-oriented applications and operations infrastructure simultaneously. These distributed system designers use the familiar drag-and-drop paradigm in Visual Studio to connect services that make up the application, and then validate the resulting applications against the logical datacenter environment. In this environment, the application can apply constraints such as security against the datacenter and vice versa. This way, application architects and infrastructure architects can work together to determine whether the application architecture works in the deployment environment upfront in the design process.

Figure 19. The Application Connection Designer will enable development organizations to complete applications to the original specification.

In offering a comprehensive distributed services design tools, Visual Studio 2005 enables organizations to more effectively complete their applications on time and to the original specification. Moreover, rather than using complex and domain-specific modeling languages as an intermediary format for the application architecture, the design tools in Visual Studio 2005 will provide coarse-grained abstractions from classes to components, Web services, assemblies, activities and processes, and maintain dynamic synchronization between the application model and the underlying source code.

When creating mission-critical software, application architects often find themselves communicating with their counterparts who manage data center operations. In the process of delivering a final solution, the application's logical design is often found to be at odds with the requirements and constraints of the deployment environment because of lack of early and proper communication between the teams. Typically, this communication breakdown results in lost productivity as architects and operations managers reconcile an application's capabilities with a data center's realities. In Visual Studio 2005, these differences are mitigated the Logical Datacenter Designer (Figure 20) that enables operations managers to specify their logical infrastructure and work with application architects to verify that the application are designed such that they will work within the specified deployment constraints.

Figure 20. The Logical Datacenter Designer will enable operations managers to specify infrastructure requirements.

In many cases, enterprise architects and developers will favor a more code-centric view of their solution. Visual Studio 2005 also includes a rich class designer (Figure 21) so that even the largest software projects can be quickly understood, designed and built.

Figure 21. The class designer provides RAD design for enterprise-critical applications.

Microsoft's distributed system designers enable architects, developers, and operations managers to participate in the envisioning phase of application development. As architects design their solutions using the application connection designer, operations managers can impose constraints using the logical datacenter designer. Architects and developers can communicate easily using the application connection designer and class designer. Together, these tools enable teams to enjoy better communication and greater productivity.

Building Robust and Reliable Software

To develop robust and reliable software, developers need an integrated set of analysis tools that help them in detecting code defects and performance problems earlier in the development cycle. The Visual Studio 2005 Team Developer Edition provides advanced development tools that enable teams to incorporate quality, early and often throughout the life cycle. The Static Code Analyzer helps developers detect coding and security related issues earlier in the development cycle thereby reducing the overall cost of fixing code defects. In addition, code analysis tools can be used as a part of the check-in policy for a nightly build process, enabling development teams to correct defects before code is checked into the source tree. Performance analysis tools in the Visual Studio Team Developer Edition enables developers to measure, evaluate, and target performance-related issues in their code, thereby identifying performance bottlenecks early on. The toolset also integrates the capability for developers to perform unit tests on their code modules during development.

The Static Code Analyzer offers information to developers about possible defects in their C/C++ source code including all-too-common code defects such as buffer overruns, un-initialized memory, null pointer dereferences, memory and resource leaks, and more. The Static Code Analyzer is fully integrated into the Visual Studio 2005 IDE to make it easy for developers to work using the tools and environment they already know.

Figure 22. The Static Code Analyzer generated for the source code appear in the Error List.

The Static Code Analyzer also detects code defects in managed code assemblies, and reports information about the assemblies, such as violations of the programming and design rules set forth in the Microsoft .NET Framework Design Guidelines. The Static Code Analyzer can also be invoked through the MSBuild system, giving developers the ability to run builds of their solutions over managed projects from the command-line.

Figure 23. Rule messages in FxCop identify relevant programming and design issues and when possible, supply information on how to fix the target.

Performance Tools in Visual Studio 2005 Team System help developers measure, evaluate, and target performance-related issues in their code. These tools are fully integrated into IDE to provide a seamless and approachable user experience.

Enabling Better Software Through Better Testing

The Visual Studio 2005 Team Test Edition introduces a suite of new test tools. These tools have been used internally at Microsoft and are being integrated into the Visual Studio 2005 Team Test Edition, for the first time. These testing tools not only work in their own testing framework, but are fully integrated into Visual Studio Team System thereby providing a complete software development life cycle solution.

Visual Studio 2005 Team Test introduces a new project type—the “test” project—that is displayed in the Solution Explorer along with the traditional project types. In doing so, all tests including unit, Web, load and manual testing are first class citizens in Visual Studio and can be shared across the organization. The test results can be published to a database, you can generate trend and historical reports, compare different kinds of data, see how many and which bugs were found as a result of testing, and identify which bugs are not linked to a test that could help reproduce them.

Figure 24. Unit testing UI includes a code coverage window, showing covered and uncovered code, by color.

The Visual Studio Team Test Edition supports a variety of testing mechanisms. Unit testing tools can be used for testing existing source code and they are an essential element of Test-Driven Development. Web tests on the other hand consist of a series of HTTP URLs that can be created or recorded from a browser session. Generic tests enable testers to work with their team's existing automated tests and tools. Load tests simulate multiple users running your automated tests. Manual tests can be used for stepping through tasks that you have not automated. In addition any automated test (all tests other than manual), as well as groups of tests, can be run from a command line.

Within Visual Studio 2005, testing is now treated as a top-tier activity that reduces the risks inherent with delivering complex Web and desktop applications, maximizes returns by reducing support costs, and is integrated in the overall software development life cycle.

Source Control and Work Item Tracking

Software Configuration Management (SCM) is a disciplined approach to managing and controlling the evolution of software development and maintenance practices as they change over time. With SCM, enterprise developers can make safe alterations to existing code, track changes across developers, projects, and time, manage the build process effectively, and track project defects and issues.

Visual Studio Team Foundation, the server component of the Visual Studio 2005 Team System provides integrated source control, work item tracking, reporting, and custom policies that enable teams to efficiently manage change in your software development projects. These change management components are seamlessly integrated into the development environment thereby offering unobtrusive SCM process and team-specific requirements in the developer’s daily workflow.

Visual Studio Team Foundation bridges source control, work item tracking and build management by enabling project contributors to associate work items with other types of configuration items such as work items, source files, changesets, and builds. A checkin policy validates that a developer's changes comply with organizational requirements before checking in a set of pending changes to the repository. Reports can be generated on the progress of an individual work item, track it to completion, and even view the code associated with its resolution. Also, without installing all of Visual Studio, teams may track work items using a Web interface shell of the work item tracking toolset. Overall, Visual Studio Team Foundation provides a flexible, integrated toolset that combines the productivity and innovative potential of Visual Studio with the predictability and reproducibility of a process-oriented solution to efficiently manage change in your software development projects.

Additionally, in Visual Studio 2005, Microsoft will extend Visual SourceSafe to offer support for Web service and Unicode projects, helping programmers more effectively meet the challenges of today's business. Further, Visual SourceSafe will better support team development with remote access, both by making common operations faster and asynchronous, and by enabling access through firewalls. Hence, developers will enjoy improved performance and tighter integration between Visual SourceSafe and the Visual Studio IDE.

Software Project Management and Process

The Visual Studio 2005 Team System delivers many different project management tools. The Visual Studio Project Management Tools enable better planning, scheduling, collaboration, communication, reporting, and process control. These tools are integrated with the Visual Studio integrated development environment (IDE), Microsoft Office, Windows SharePoint Services, and SQL Server 2005 Reporting Services.

The Visual Studio Team System collects all the work items on a project – requirements, features, tasks, bugs, issues, risks - in a single server-side database that the whole team can share. Teams can view, edit, track and analyze those work items from a number of different tools most familiar to them: Visual Studio, Microsoft Excel, Microsoft Project, and Windows SharePoint Services. These tools are tightly integrated and synchronized, sharing information and data to keep the teams constantly in communication with one another. This enables better planning, scheduling, collaboration, communication, reporting, and process control.

Figure 25. Project Management tools capture the views to store relationships between functional specifications, risk assessments, and project plans.

Throughout the life cycle of a project, the Visual Studio Team System collects and reports data about bug trends, code coverage status, build status and more. With rich, customizable reporting, the Visual Studio Team System gives all participants in the life cycle a quick, big picture view of the project.

Figure 26. Microsoft Excel add-in ties a list object in the spreadsheet to the work item database where all work items such as bugs, risks, and tasks are stored.

The Visual Studio Team System includes integrated process guidance, encapsulating the best practices from inside Microsoft and across the rest of software development industry and makes them easy to access and easy to follow. Selecting a Microsoft Solutions Framework (MSF) Methodology Template for a project configures all the tools in the Visual Studio Team System: customized work item types with workflow, custom reports, source code check-in policies and document templates for specifications, readiness plans, risk analysis, etc. The process guidance is fully customizable by end-users, teams, and systems integrators.

Visual Studio project management Tools will revolutionize the way IT departments manage their development process by enabling non-intrusive visibility and instrumentation into the project data and the life cycle.

Product Build

Historically, developers have struggled when trying to map a complicated build infrastructure into the Visual Studio IDE. Roadblocks traditionally center around the inability to fully customize or understand what happens when a project is built within the development environment; the failure to reproduce a build within a build lab environment where Visual Studio is not likely to be present; and the limitations of a build system that was not optimized to model entire products, but rather single projects.

The 2005 release of Visual Studio will radically improve this area of software development by introducing a new build engine called MSBuild. Key design goals for MSBuild include: delivering a file format that is well-documented and backed up by a published XML schema definition; making the MSBuild engine an integral part of the .NET Framework redistributable; allowing developers to customize, augment or completely redefine the build process; and providing seamless integration with the Visual Studio 2005 IDE.

First, MSBuild will introduce a new XML-based file format that is simple to understand and easy to extend. The MSBuild file format will enable developers to fully describe what artifacts need to be built, as well as how they need to be built under different configurations. In addition, the file format will enable developers to author reusable rules which can be factored into separate files so that builds can be done consistently across different projects within a product.

Second, MSBuild will ship as a core part of the .NET Framework 2.0 redistributable. This shift in philosophy will allow developers to rely on the MSBuild infrastructure regardless of IDE presence and licensing issues. In addition, by providing MSBuild class libraries as a core part of the .NET Framework, developers will be able to create and debug components of a customized MSBuild process using the managed language of their choice.

Third, MSBuild will be completely transparent with regards to how it processes and builds software. All build steps will be explicitly expressed in the XML project file regardless of whether it was authored by hand or auto-generated by the Visual Studio 2005 IDE. This also means that Visual Studio no longer treats any part of the "F5" build experience as a black box. A user can now understand, replicate, edit, remove, or augment any part of the build process.

Finally like its predecessors, MSBuild will be fully integrated into the Visual Studio 2005 IDE. This tight integration will enable developers to take advantage of all the built-in productivity features Visual Studio offers, while allowing developers to scale, customize, and adapt the Visual Studio 2005 build system to their unique infrastructure needs.

Deployment and Operations

In the last phase of the software life cycle, the completed application is placed into a production environment. The activities in this phase involve creating deployment packages and an operations plan that covers tasks, such as expected availability, backups, updates, and disaster recovery.

Visual Studio 2005, in conjunction with a variety of additional Microsoft and third-party software, including the Enterprise Instrumentation Framework, Microsoft Operations Manager, and more, will enable organizations to deploy and operate solutions after they are constructed and tested.

Moreover, the aforementioned distributed system design tools will enable operations managers to participate more closely with the overall development team.

Partner Enterprise Tools Support

In addition to these advances within Visual Studio, enterprise customers will continue to enjoy tremendous choice from a variety of the industry's leading application life-cycle tools vendors. With improved integration support, tools companies will be able to deliver products that offer seamless interoperability with the rest of the Visual Studio 2005 product. And, with a revamped Visual Studio Industry Partner (VSIP) program, independent vendors, as well as enterprise customers can gain free access to the APIs necessary to build life-cycle tools that are tightly coupled with Visual Studio 2005. For customers, the result will be a combination of Microsoft and partner tools that make enterprise application design, development, testing, and deployment significantly easier than before.

Visual Studio "Orcas"

The release of Visual Studio 2005 and the .NET Framework 2.0 will represent a significant milestone in the Microsoft developer tools roadmap. Following the SQL Server 2005 and Visual Studio 2005 wave of products, the next major platform update will be the Windows operating system release code name "Longhorn". The release of Visual Studio 2005 and the .NET Framework 2.0 will run on this landmark operating system release, as will applications built with Visual Studio 2005.

In addition, Microsoft is planning a version of Visual Studio, code name "Orcas," designed to take advantage of the features introduced in Windows Longhorn. These features include support for Longhorn advanced user interface capabilities (code name "Avalon"), storage services (code name "WinFS"), and Web services capabilities (code name "Indigo"). For example, Longhorn will introduce a declarative programming model (code name "XAML"), that will complement existing programming languages and Windows Forms by improving productivity when developing Longhorn-specific client UI.

In addition, Orcas will enable developers to take advantage of the WinFS capabilities to find, relate, and act on information, including support for event-based actions and synchronization classes. Finally, Orcas will deliver support for Indigo, Microsoft's next generation programming model for building Web services. Indigo introduces a unified model for developing connected applications on the Windows platform that seamlessly merges remote procedure calls, messaging, and remote object invocation. Future updates to this document will include additional information about the Orcas release and feature set.

Summary

With the launch of Visual Studio .NET 2002 and the Microsoft .NET Framework 1.0, Microsoft introduced a consistent programming model for Windows, Web, and mobile solutions, new and enhanced programming languages, and its most integrated and powerful developer toolset ever. One year later, Visual Studio .NET 2003 and version 1.1 of the .NET Framework built on the strength of the initial release and delivered unprecedented integration with the Windows Server 2003 operating system. Moving forward, Microsoft will continue this trend of integrating managed code support in major product releases—first with SQL Server 2005 and later in the Windows Longhorn operating system.

Over the course of this product roadmap, Microsoft plans a steady stream of innovation in both tools and framework, offering the businesses of today and tomorrow premier tools with which to meet their evolving business needs. Microsoft will continue its commitment to delivering productive tools that help customers take maximum advantage of the underlying platform and achieve success while building a wide range of software solutions.