As part of my role in working with partners in the Visual Studio Industry Partner (VSIP) Program I have spent a lot of time documenting the new features and extensibility point of Visual Studio 2010 and Visual Studio Team System 2010.  I have been sharing this information with VSIP partners under NDA a long time in advance of Beta availability. We did this to ensure that partners get as much time as possible to upgrade their products which are integrated with Visual Studio to ensure that they are ready to release their Visual Studio extensions simultaneously with our release of VS2010.

 But now that VS 2010 Beta 1 has been released, the wraps are off and I can share this information publicly.

I will do this in two Blog posts.  Today (below) I will cover new features and extensibility points of Visual Studio 2010.  I will follow this up soon with a similar blog post on Visual Studio Team System 2010.

So, below is a high level description of some of the new features and extensibility points in Visual Studio (VS) 2010. As I already mentioned, it does not include new Visual Studio Team System (VSTS) or Team Foundation Server (TFS) features – these will be covered in a separate document due soon. This is not a complete list but focuses on those new features most likely to impact VSIP and other partners who develop solutions that integrate with VS.

For more detailed information please download the VS 2010 builds and VS2010 SDK as they become available and use the VS 2010 product documentation. Also search msdn.microsoft.com and the Microsoft Blogs at http://blogs.msdn.com/search/  for more information.  These links may also be of use:

You can download the beta here

General Visual Studio Information here

More Visual Studio 2010 information here

Jason Zanders Blog on Visual Studio 2010 here

You can find instructions for downloading the feedback and sharing your feed back here.  The best way to get prepared for VS2010 is to get VS2008 deployed today.  You can find everything you need on our home page here.

 

Visual Studio 2010 New Features, Extensibility Points and Partner Opportunities

 

New Code Editor and MEF

Visual Studio (VS) 2010 introduces a new Editor composed of extensible objects using the Microsoft Extensibility Framework (MEF). It is built on WPF to provide a 1st-class graphics engine with APIs written & designed for the latest version of .NET. This time around we are documenting APIs as part of our development process to improve documentation and help.  We are also focused on delivering improved data structures and algorithms. Immutable Text Snapshots allow access to stable version of text buffer from any thread.

The new editor represents one of the first Visual Studio components to move to a managed code, MEF architecture.  Other components moving to this architecture in VS2010 include the Visual Studio Languages, Web Tools, the Debugger,  the new C++ project system, DSL Tools, and SharePoint Designer.  Each of these components are using or offering MEF extension points.  The editor represents Visual Studio’s largest investment in a MEF architecture. These moves to managed code and MEF will be followed by others as much of Visual Studio moves to this new architectural foundation in following versions.

Shims will provide 80+ percent compatibility to minimize the work for partners migrating code to the new editor. However where possible partners should update their code to use the new managed editor interfaces for the VS2010 editor. This will result in better performance and simpler code that is easier to understand and maintain. It will also migrate to the follow-on version of Visual Studio with less problems because we will be deprecating the shims in the next version after VS2010.

Partners should also consider using MEF for their own extensibility requirements in their own .NET based applications, that is, other applications have nothing to do with Visual Studio.

 

WPF and the New Visual Studio UI

VS 2010 incorporates a new WPF-based presentation layer and many core UI assets have been migrated to WPF, for example the menus and toolbars, code editor, start page, etc. VS 2010 also incorporates a fresh new theme that will provide a pleasant and favorable work environment for developers.  Although not required for compatibility, VSIP partners should consider utilizing WPF for new UI, and in planning updates to their existing extensions, consider migrating UI  to WPF. VS 2010 makes it easy to integrate WPF UI with the VS WPF visual tree through the use of new VS window hosting interfaces, and in doing so, inherit VS 2010 theme styling. For partners with unmanaged extensions, the cost of adding new WPF UI to existing packages can be significantly reduced through the use of the new GelFx framework.  When using WPF in Visual Studio extensions please review the VS2010 IDE WPF Style Guidelines which are being added to the Visual Studio SDK documentation, to ensure a consistent user experience for Visual Studio developers.

VS2010 Shell 

The Visual Studio Shell enables developers to rapidly create and distribute their own custom tools by building them on top of the core Visual Studio IDE.  There are two shell “modes” and both are available via a royalty-free license. 

The Visual Studio Shell (Integrated Mode) enables developers to distribute a copy of Visual Studio containing only their tools.  If Visual studio is then installed, these tools will be integrated with the rest of the installed Visual Studio components.  An example of a Visual Studio Shell (Integrated Mode) application is the Visual Studio Team Foundation Client, which enables non-developers to query TFS work items, and vertically integrates with any VS SKU to allow developers to do the same.  The VS Shell (Integrated Mode) has proven to be popular with language developers as it allows them to ship a standalone tool but at the same time if used with Visual Studio Professional it allows their language to appear alongside C# and VB in the single instance of the Visual Studio IDE.

The VS Shell (Isolated Mode) allows developers to distribute tools and applications built on the VS IDE, but run as a separately branded and customized application on the user’s machine.  This can be ideal for applications targeting non-developers as it allows you to control and simplify  the User Interface. An example of a Visual Studio Shell (Isolated Mode) application is the AddOn Studio for World of Warcraft.  The VS Shell (Isolated Mode) is gaining adoption in vertical markets such as manufacturing and IT Operations. 

Since the underlying package formats are the same, components developed for one shell mode can be deployed to the other.

For the Visual Studio 2010 Shell, we’ve made targeted investments to the developer experience:

·        No more complicated load keys! - Developers are no longer required to procure a Package Load Key (PLK) or a Shell Load Key (SLK) to develop Visual Studio 2010 Shell applications!

·        No requirement for Registry. Packages can now be installed without requiring developers to update configuration settings in the Windows registry.  In many cases, this means that packages can now be x-copy deployed. 

·        Easier, more robust deployment – The redistributable shell installers have been updated to support Windows Installer source caching features, thus is during a repair, user’s won’t be required to point MSI to the original installation file or media.

·        Improved SDK tooling – New templates have been added to make it easier to get started with the Visual Studio Shell, and create common types of extensions.  For Visual Studio Shell (Isolated Mode) developers, we’ve significantly improved performance of our F5 Debugging experience.

 

Additionally, all enhancements to core Visual Studio 2010 components are included with the Visual Studio Shell.  Developers using the VS 2010 shell will have access to the new WPF Shell, the New Code Editor with Updated Intellisense, all new Debugger and Web features, and a New Help Infrastructure optimized for search and deployment.  

Visual Studio Help

Visual Studio 10 will come with a completely re-engineered Help system that introduces a new flexible,   standards based Help framework which will ultimately be used in other products beyond Visual Studio. Help3 is a help system replacement for Microsoft Help 2.x .   This new help system will be easier to produce content for,  and will interfere less with Visual Studio itself. The standards based approach delivers not only a much better local experience but also a seamless transition to an online web browser and with infrastructure and tooling much more consistent other Visual Studio and internet technologies. 

Visual Studio 2008 and prior versions use a proprietary help system in which content was normally packaged into .hxs or .chm file formats.  With VS2010 these formats will go away and moving forward help content will be stored primarily XHTML, will be packaged into Zip-format containers.  These containers will be based on the PKZip format.  These containers can conceivably hold any type of content, from HTML to XML, from art to videos.  The containers will have a special file extension (.mshcc – Microsoft Help Content Container).  Specific XML tags are used to control the behavior of the Help system. For example special tags are used to define “Contents” hierarchy and “Index” listings and “F1” help behavior. Viewers will access a specific topic through a URI provider using a standards protocol being defined for the purpose.

The primary Visual Studio 2010 help viewer will be a web browser (for either local or remote use).  At some stage third party viewers applications will also be supported but this may not be a supported scenario in the VS2010 release.

The new help system uses a custom full text search engine to index the VS (and partners’) help content providing a best of breed search speed and experience

The new storage architecture enables many new rich scenarios.  For example, VSIP partners can now add new containers of content to designated locations and have those tied to product content through the properties. Partner pages can be created as children of pages that are part of the standard Visual Studio help, thus they would then appear in the Help content tree under the standard Visual Studio pages.

The main implication for partners that extend Visual Studio is the need to migrate any help documentation and content to the work with the new Visual Studio help. Microsoft is working with Help Authoring product companies such as Component One (Doc2Help) and Innovasys (Help Studio) to work towards their support of this new format as soon as possible.

In the first version of this new help system, all APIs will be marked as internal and thus they can not be uses as extensibility points. In later versions of this software we plan to mark specific APIs as external to expose then as extensibility points for partners.

 

VS2010 Extension Manager

The VS2010 Extension Manager enables developers to more easily share, acquire and manage Visual Studio Extensions.  It will support extensions such as Project Templates, Item Templates, VS Packages, Managed Extensibility Framework (MEF) components, and even custom extension types .  Users will be able to use new features inside the VS IDE to browse, download and install content from the Visual Studio Gallery. Once installed, extensions can also be managed from within Visual Studio (view, enable/disable and uninstall). The extension manager will display the same content and extensions as the Visual Studio Gallery ( www.visulalstudiogallery.com ) which will continue to provide browser access as an alternative to view and download VS extensions .  The VS2010 Extension Manager also introduces a new file format for deployment of VS extensions. VSIX files are based on the Open Packaging Convention (OPC) Zip  format and contain a manifest and payload. At install time, the contents are then automatically  XCopy deployed respecting the folder structure inside the zip file. The Extension Manager and VSIX deployment model represent significant opportunities for VSIP Partners as it makes extensions much easier for partners to package into a single file for hosting, and provides an in product experience for customers to find and acquire extensions.  For Visual Studio users, it provides a single point for finding, downloading, installing and managing extensions.

Web Tools

Visual Studio 2010 includes an array of new functionality for Web developers which include support for new features now available in the 4.0 framework. The most notable improvements to date are all listed in the following document: What's new in FX4.0 and VS10.

VSIP and component developers should be aware of the multi-targeting model within the IDE, and be aware of the ASP.NET and project compilation model for both Web Sites and Web Applications. For example, controls and their associated designers operating in the IDE are always the latest (>4.0) regardless of the target framework. This means that such components need to be target-aware and perform operations based on the ‘filtered’ types, but also be aware of the target where behavioral differences in the components’ developer experience needs to be accounted for, for example smart-tag operations or dialogs that result in features only applicable for a given target. Similarly, the compilation system uses a model to determine the target based on the prescience of a target framework moniker in Web.config, but uses a mechanism to read specific sections of the relevant root Web.config for the given target.

 

ASP.NET components that target FX3.5 and therefore VS2008 should work without modification, but developers should note specifics related to other production targets such as Windows Azure.  As of March 2009, the Windows Azure Tools extend VS2008. Future releases of the Windows Azure Tools will support VS2010.  Windows Azure currently only supports running managed assemblies that work on the 3.5 framework. If you are producing components for FX4 only, you should note that Windows Azure, at this time, is not a supported platform.

Windows Azure supports ASP.NET and uses IIS; however, there are some differences for a developer writing Cloud Services than for a developer targeting ASP.NET/IIS on a Windows Server.  In particular:

·        Windows Azure provides a specific logging API that should be used

·        Windows Azure applications and services can preserve user and session state in each instance; to increase the scale of the application, additional Windows Azure instances can be created from the online management portal.  State can be shared across all instances. Please refer to the sample Role, Membership and Session providers in the Windows Azure SDK.  These providers require configuration in the application.

·        Cloud storage do not provide native SQL support so any VSIP component relying on SQL, LINQ to SQL or SQLDataSource may need to be updated.  SQL server functionality accessible from Windows Azure was announced at Mix ’09 and will be available in the future.

Please note that it is strongly recommended that partners do not release separate components for Azure but that they produce components that can deploy to either .NET or Azure. Microsoft wants the developer experience to be as seamless as possible as developers move applications between .NET on Windows and Azure.

 Web Deployment and Web Packaging

Today, deploying a web application is not as easy as it should be. Whether you are deploying your web to a shared hosting environment and paying monthly to maintain it OR whether you have a web server/s managed by your enterprise, there are a lot of manual steps involved in getting your application from point A to point B.

If you are deploying your web application to a shared hoster then today you have to use technologies like FTP which take a long time to get your web content to the hosted server. After deploying your content you have to manually go to hoster control panel and install your database by running sql scripts and configure various IIS settings like marking a folder as an application to isolate it from the rest of the application.

If you are in an enterprise environment and you want to get a web application deployed you have to systematically document each step that your server admins and DBAs have to perform. In most circumstances you also have to ask your admins to modify the web.config files and go to IIS Manager and configure your settings apart from deploying your web content. Your DBA has to do the necessary steps of running the SQL scripts in the right order to get your DB up and running. Such installations many a times take hours to complete.

With Visual Studio 2010 and IIS Web Deployment Tool (MsDeploy.exe) we are introducing a set of technologies which can seamlessly deploy your applications taking care of the problems stated above. Microsoft Web Deployment Tool is a free download available on the web (currently in Beta2). You can download MSDeploy from below location:

http://blogs.iis.net/msdeploy/archive/2008/10/29/the-web-deployment-tool-beta-2-is-now-available.aspx

Do note that installing Visual Studio 2010 will automatically install MSDeploy for you.

Web Deployment feature sets in VS 2010 can be broken down into following major areas:

1.      Web Packaging - VS 2010 uses MSDeploy to create a .zip file for your application which we call as a web package. This file contains meta data + the below artifacts

a.      All of your IIS Settings (e.g. application pools, error pages etc)

b.      Web Content (e.g. .aspx, .ascx, .js, images etc)

c.      SQL Server DB

d.      Various other artifacts like Security Certs, GAC Components, Registry etc

2.      A web package can then be taken to any server and installed either via IIS Manager UI Wizard or even via command line or API for automated deployment scenarios.

3.      Web.Config Transformation – With VS 2010 web deployment we are introducing XML Document Transform (XDT) which will allow you to transform your development time web.config file to production/deployment time web.config file. The transformation is controlled by web.config TRANSFORM files named web.debug.config, web.release.config etc. The naming of these files is tied to the MSBuild configuration you are trying to deploy. The transform file will need just the changes that you really want to make to your deployed web.config… You can control the type of changes by instructing the XDT engine using simple and easy to understand syntax…

e.g. the below syntax in web.release.config will replace the connectionString section with new values in the web.config file which is produced for deployment of your release configuration:

<connectionStrings  xdt:Transform=”Replace”>

               <add name=”BlogDB”  connectionString=”XYZ”/>

</connectionStrings>

4.      DB Deployment – VS 2010 allows you to deploy your application along with all of its dependencies including database dependencies on SQL Server. Just by providing the connection string of your source database VS10 will automatically script its data/schema and package it for deployment. VS will also allow you to provide custom .sql scripts and also sequence them correctly to run on the server. Once your DB is packaged along with your IIS Settings and web content you can choose to deploy it to any server by providing the connection string at the install time.

5.      1-Click Publish - VS 2010 will allow you to not only package your web applications with all of its dependencies but also use IIS remote management service to publish the application to remote server. VS 2010 will now allow you to create a publish profile of your hoster account or of various testing servers and save your credentials securely so that going forward you can deploy to any of these publish profiles with just one click using Web One Click toolbar. With VS 10 you will also be able to publish using MsBuild command line so that you can configure your team build environment to include publishing in continuous integration model.

Silverlight  and WPF Tools

The WPF Designer extensibility API will be changing in VS 2010 to accommodate both WPF and Silverlight. We will publish more details of these changes when we ship Beta1. In the meantime the VS2010 extensibility highlights are: 

·       A full extensibility model for both WPF and Silverlight designers

·       A much broader shared extensibility model with Blend 3 - Menu Actions, Adorners and so on are now available in both products - see Unni's blog for a peek http://blogs.msdn.com/unnir/archive/2009/03/27/a-sample-that-shows-the-new-blend-design-surface-extensibility.aspx

·       Richer property browser API including access to the EditingContext and Model from property editors

·       The ability to share design time across the WPF and Silverlight

·       Support for side-by-side VS 2008 and VS 2010 design time assemblies

 

SharePoint Integration

Visual Studio 2010 introduces new SharePoint tools in an effort to make SharePoint development easier and more intuitive for .NET developers.  These tools include new project and item templates you can use to create SharePoint sites, lists, document libraries, workflows and other types of SharePoint content. Visual Studio 2010 also provides new visual designers for Web Parts, application pages, business data catalog (BDC) models, and packaging. In addition, in Visual Studio 2010 you can now use Server Explorer to connect to your SharePoint sites and navigate the hierarchy and contents of these sites from within Visual Studio.

Although these projects and tools meet the requirements of many application development scenarios, you might discover some cases where different or new functionality is needed. In these cases, you can adapt the SharePoint project, templates and tools by using a new Visual Studio extensibility API. This API lets you create new types of SharePoint project items that application developers can use to build SharePoint solutions. It also allows you to extend existing SharePoint project items as well as enhance project deployment. Finally, you can use the extensibility API to add or extend content nodes for SharePoint sites in Server Explorer.

 

Visual Studio Multi Targeting

In Visual Studio 2010, we’ve extended Multi-Targeting beyond the limited support found in Visual Studio 2008 with two key goals in mind.  First, we sought to enable end user developers to leverage the new features found in Visual Studio 2010 to write code for their existing applications. This means that we fully support existing .NET Framework 2.0, 3.0 and 3.5 assets in Visual Studio 2010 with a high degree of fidelity.  Second, we sought to decouple Visual Studio 2010 from its target frameworks so that Microsoft can ship new frameworks, framework profiles, and framework service packs without patching Visual Studio.  This means that Visual Studio 2010 uses the same data driven mechanisms to light up IDE features for versions of Silverlight, the .NET framework, and other “.NET like” frameworks.  For adding entirely new platforms to Visual Studio 2010, see Platform Extensibility and the new C++ Project System.

For Visual Studio Industry Partner (VSIP) program members  this implies several key changes to the way you work with target frameworks in the Visual Studio 2010 IDE.  First and foremost, you can no longer assume the VS2010 IDE supports a fixed set of frameworks; depending on the installed frameworks the user can have 1 to n targetable frameworks installed.  The IDE provides framework enumeration mechanisms to help packages stay on top of this.  Second, the term framework no longer implies the .NET Framework.  With support for other related framework families such as Silverlight, or the .NET Compact Framework, via the same mechanisms, the assumption that you are working with the full, desktop, .NET Framework at all times must go away as well.  To that end we are deprecating the TargetFrameworkVersion project system property and replacing it with the Target Framework Moniker, a three component identifier that includes framework identifier, version, and profile.   Third, we’ve introduced the concept of “framework profiles” a mechanism that allows for arbitrary reductions in the type surface area of a given full framework.  For more information on working with profiles see the Multi-Targeting Problems and Solutions document.

 

To help deal with this new more dynamic Multi-Targeting experience Visual Studio 2010  now provides services to assist in providing the correct target framework appearance at all times.  For designer authors we’ve added type filtering services that allow you to use the data driven mechanisms to filter the appearance of the running framework so that it appears to be the users target framework.  For language vendors we have similar data driven mechanisms to provide compilers with the correct set of assemblies during compilation and IntelliSense production.  For those who develop code understanding tools a hybrid of these mechanisms will work best depending on the scenario.  We look forward to working with you all to make Visual Studio 2010 the best Visual Studio release ever.  With the right diligence we can make supporting new frameworks in your products as simple as dropping a few files on disk rather than a major servicing event.

Visual C++ Project/Build Extensibility

 

In Visual Studio 2010, the Visual C++ Build System will be based on MSBuild. On top of this build system, the new Common Project System ships for the first time with support for C++ only. The current plan is that the Common Project System will be used by the other VS languages in future versions of Visual Studio. One of the big advantages of moving to these new platforms is the ability to provide new compelling extensibility points on which VSIP partners can build their Project & Build related tools. An overview of these changes is available here: http://blogs.msdn.com/vcblog/archive/2008/11/20/printf-hello-msbuild-n.aspx

 

Adding a new tool to the build has never been easier. As a build tool developer you can choose:

 

·        Which build features you want to support and which to delegate to MSBuild components:

o   Task implementation:  You can implement your own  task or rely on the XAML Task Factory functionality to create a task on the fly based on your XAML definition (Custom Build Rule).

o   Incremental build support:  You can delegate to FileTracker to keep track of your tool's inputs and outputs in order to honor incremental builds.

o   Clean operations:  Customize clean operations if you are creating intermediate files during build.

 

·        What level of Project System's Property Pages support you want:

o   Basic support:  A simple XAML file similar in format with the Custom Build Rules file format  will be enough to show a property grid similar to the C++ or Linker nodes.

o   Customized Property Grid:  Simple MEF components allow extenders to provide custom Property Editors (i.e. Certificate picker, directory list editor, etc.) or custom Property Dropdown providers (i.e. a dynamic list of servers or a valid list of files considering other project settings). More details about MEF available here: http://code.msdn.microsoft.com/mef

o   Custom UI:  Combining a XAML definition and a MEF component, you can replace the property grid with your custom UI.

 

·        How you want to deploy your tool: central location (under Program Files) or enlistment based (checked in with the rest of the client's sources), or both.

 

Partner Opportunities in this area revolve around the possibility of marketing new Build related tools. Examples of this may include code generators, code analysis, language compilers, versioning or signing tools.

 

Visual C++ Platform Extensibility

 

One of the Visual C++ Project System extensibility points is the ability to add additional Platforms to the build system. This would allow developers for example to use the new Visual C++ Project System to target Mobile platforms running an Embedded operating systems. Platform extenders can provide their own customizations to the build system and wire new tools or replace existing ones as part of their platform specific targets. For more information about adding/replacing tools in the build see the Project/Build Extensibility topic above.

 

Once a new platform is installed, the Project System will light up to the changes allowing developers to add the new platform to their projects using the Configuration Manager, configure its settings in the Property Pages or Property Manager, build and debug.

 

A significant partner opportunity exists in providing tools for VS2010 to enable targeting of other popular platforms.

 

Further platform customizations are supported:

o   individual tool customizations as detailed in the Project/Build Extensibility topic,

o   new custom Debuggers or new Deployment tools the user can pick, configure and run.

 

Visual C++ Native Multi-targeting

 

Visual C++ 2010 ships with a lot of enhancements in the compiler and native libraries (i.e. C++0x support, a new Concurrency Runtime, Vista/Windows 7 support in MFC, etc.) but sometimes adopting the new IDE together with the new libraries can be a problem for developers because a lot of the 3rd party components being used may still be built against VC9 runtime. To ease adoption, VC++ 2010 supports Native Multi-targeting for all the PC platforms (x86, X64 and Itanium).

 

This enables developers to move to the latest IDE while still targeting the Visual C++ 9 tools and libraries that shipped with Visual Studio 2008 (this requires VS2008 to be installed on the machine). Out of the box, only VS2008 will be supported, but this is an extensibility point that can allow future additions (i.e. to support older versions of Visual C++, or future versions of the Windows SDK). Supporting older versions of the tools and libraries may be a opportunity for partners working in that area.

 

Also, Native Multi-targeting is not limited to the PC platforms as the same extensibility pattern can be used by other Platform Extenders.

 

Native Code tools

VS 2010 will include new native C++ libraries to help develop take advantage of Vista & Windows7 innovations. Examples of those features (but not limited to) are Restart Manager & Task Dialog support as well as MFC Style implementation of the Windows Ribbon. Partners with Native Code extensions to Visual Studio may want to consider using these new facilities.

 

Parallel Computing Platform (PCP)

The manycore shift presents an unprecedented business opportunity for developers to design new software experiences that take advantage of the performance power of manycore architectures. At the same time, parallel programming is complex, difficult and labor-intensive, for even the most skilled developers. Microsoft’s goal is to simplify parallel programming by taking a holistic approach and providing solutions which span from local to distributed computing and from task concurrency to data parallelism.

Microsoft plans to deliver a solution-stack consisting of OS resource management, a concurrency runtime, programming models, language extensions, libraries, and tools, which will make it simpler for both native and managed code developers to safely and productively build robust, scalable and responsive applications. This will also enable industry partners to complement Microsoft’s technologies in order to solve the complex problems associated with developing high-quality parallel software.

Visual Studio® 2010 and the .NET Framework 4.0 will introduce a number of technologies as part of Microsoft’s Parallel Computing Initiative to help programmers build innovative applications that utilize the power of  multi-core architectures. These include the following:

·        The Concurrency Runtime will simplify development by making it easy for developers to manage the resources of the underlying hardware. It will also manage the scheduling details of mapping programming tasks to the available hardware. The Concurrency Runtime gives developers the ability to choose from a rich set of coordination mechanisms such as message passing and locks that automatically interoperate with the scheduler. Further, it provides a common framework for the interoperation of different components, so component developers are free to use the techniques and patterns that fit their problem best.

·        The Parallel Pattern Library is a set of native libraries that align well with the C++ Standard Template Library (STL) and use the Concurrency Runtime to ensure the efficient and scalable use of system resources. It provides support for describing task centric work items and synchronization, for expressing structured and unstructured parallelism and for implementing speculation and transformation. It further provides a set of commonly used concurrent containers and messaging primitives for working with shared state and for coordinating state isolation via message passing. The Parallel Pattern Library also utilizes additional new support in the C Runtime Library (CRT) to ensure the proper propagation of exceptions. The Parallel Pattern Library uses a new language feature known as lambda functions, which were just approved into the C++ draft standard, to enable easier migration of sequential code to parallel implementations.

·        Parallel Extensions to the .NET Framework simplifies development by providing library-based support for introducing concurrency into applications written with any .NET language, including C# and Visual Basic. It includes the Task Parallel Library (TPL), which provides support for imperative data and task parallelism; Parallel LINQ (PLINQ), which provides support for declarative data parallelism and Coordination Data Structures (CDS), which provide support for work coordination and managing shared state.

·        Parallel debugging windows which will provide a view of tasks running in the application, and a graphical view of parallel call stacks. 

·        Parallel profiling views which will give developers an understanding of their application’s core utilization, thread behavior and contention blocking, and thread execution pattern per core.

For VSIP partners, the opportunities range from using these technologies to increase the performance of your software to providing complementary toolsets to help in the creation of parallel code.

More information is available at the MSDN Parallel Computing Development Center.

 

Deployment and Installation

The .NET Framework 2.0 introduced Click Once. Thus applications had two deployment options (1) Click Once (Click on a link and if you do not already have a current version of the assembly in your assembly cache, then  it is downloaded.  The Assembly can then run in the Browser Sandbox) or (2)  MSI – standard way is installation that does not require internet connectivity.

With .NET Framework 3.5 SP1 it is possible to customize the ClickOnce application install experience and enable scenarios like packaging the ClickOnce application files in a single installer along with the .NET framework installation. This is especially useful with the “Client Profile” of the .NET framework which is a smaller subset (approx 27 MB) of the full framework that provides the fastest framework install experience for client applications. An application that has been installed with a customized installer behaves just like any other ClickOnce application and keeps itself up-to-date by downloading new versions of the application assemblies as they become available. Through the custom installer the developer can control every aspect of the ClickOnce Install and Update experience like the trust prompts and downloading of updates.

Cloud Tools

As of March 2009, the Windows Azure Tools extend VS2008.  Future releases of the Windows Azure Tools will support VS2010. We are working to make VS 2010  the premiere development tooling for creating and deploying Windows Azure applications. Windows Azure currently only supports running managed assemblies that work on the 3.5 framework. If you are producing components for FX4 only, you should note that Windows Azure, at this time, is not a supported platform.

Windows Azure Tools for Microsoft Visual Studio includes project templates, configuration of the Service Model, integration with the Windows Azure local development tools, debugging, and publishing.

Windows Azure Cloud Services consist of a Web and/or Worker Role.  A Web Role has http and/or https endpoints and can make outbound calls to the internet.  A Worker Role can run managed code in a background process including making outbound calls to the internet.  A Worker Role does cannot have any endpoints.  By default, all Windows Azure Roles run in Windows Azure Trust, which is a slightly modified version of the ASP.NET Medium Trust.  Each role can be configured to run in Full Trust.  The instances of each Role can be increased or decreased independently and easily to increase or decrease the capacity of the Cloud Service.

ASP.NET components should work without modification with VS2010 and .NET 4.0.  It is recommended that ASP.NET Component Vendors update components to work not only on  .NET 4.0 on Windows  but also on Windows Azure.  Please note that it is strongly recommended that partners do not release separate components for Windows Azure but that they produce components that can deploy to either .NET or Windows Azure. This is because Microsoft wants the developer experience to be as seamless as possible as developers move applications between .NET on Windows and Windows Azure.

 Third party managed languages should work on Windows Azure.  To allow Visual Studio 2010 to deploy applications using third party applications correctly partners will need to have separate projects for each of the Windows Azure Web or Worker Roles and some integration work with the Windows Azure Tools is required.

Partners that deliver coding productivity features could consider a number of possible new features targeting Azure.  They could add code snippets or other forms of code generation targeting Windows Azure, or produce more complete or targeted Visual Studio Project templates targeting particular Scenarios.

Other partners may want to consider other value added solutions to provide High Performance Computing,  Backup,  or Storage  solutions on this platform. There may also be a market for Development Tools that plug in to Visual Studio to ease cloud based development. Finally there will be a broader opportunity for complete applications targeting the Microsoft Cloud platform.

 

Enhanced version of Dotfuscator Community Edition™

 

Microsoft Visual Studio 2010 also contains an enhanced version of Dotfuscator Community Edition™ (CE).  Dotfuscator CE, which has been included with every version of Visual Studio starting with Visual Studio 2003, prevents the reverse engineering of .NET applications. The Visual Studio 2010 version, renamed Dotfuscator Software Services Community Edition™, has been extended with instrumentation capabilities including tamper detection and defense, feature level application monitoring and automatic time limits on .NET application use.

 

Specific new features include:

·        The injection of feature and session monitoring (streaming usage data to a developer-specified endpoint),

·        The injection of application expiry dates, and

·        The injection of tamper defense and notification.

 

If you want a detailed walk through, check out Bill Leach’s blog entry at http://blogs.preemptive.com/post/Whate28099s-new-with-Dotfuscator-in-Visual-Studio-2010-Beta-1.aspx

 

There are opportunities for partners to

·        Provide cloud-based services around these capabilities

·        Launch their own customer experience improvement programs

·        Build BPM and BI solutions driven in part by application runtime intelligence

·        Monitor customer usage of their own product features

Terry Clancy