Difference between ASP.NET and ASP Dear friends here is a list of differences of the ASP.

NET technology and the classic ASP technology.Hope it is informative. Please send your feedback or/and add if you have additional information.

Introduction
These are the list of differences which I came across while working on ASPand ASP.NET projects.

Background
I have seen many articles on Internet where in I came across the differences of ASP.NET and ASP. These articles are jumbled across the websites. I have compiled all those and published this article to give better understanding on the differences of both.

Description
Process Isolation ASP is run under the inetinfo.exe(IIS) process space and hence susceptible to application crashes as a result the IIS needs to be stopped or restarted. ASP is related to the process isolation setting in IIS. But, ASP.Net The ASP.NET worker process is a distinct worker process, aspnet_wp.exe, separate from inetinfo.exe ( IIS process), and the process model in ASP.NET is unrelated to process isolation settings in IIS. Note :- IIS is still the entry point to a ASP.NET application Non-MS Platform Support Classical ASP had no mechanism of running itself on non- Microsoft technology platforms like the 'The Apache Web Server'

But, ASP.NET ASP.NET could be run on non-Microsoft Platforms also. Cassini is a sample Web server produced by Microsoft which, among other projects, has been used to host ASP.NET with Apache.

Multi Language Support in WebPage

In ASP only two languages were available for scripting VBScript and Jscript/Javascript. But in ASP.NET We are no longer constrained to the two scripting languages available in traditional ASP: Any fully compliant .NET language can now be used with ASP.NET, including C# and VB.NET.

Note :- (C# and VB.Net are both server Side languages.) Interpretation Vs Compilation In ASP, ASP engine executes server-side code, which is always through an interpreter (JScript or VBScript). When a traditional ASP page is requested, the text of that page is parsed linearly. All content that is not server-side script is rendered as is back to the response. All server-side script in the page is first run through the appropriate interpreter (JScript or VBScript), the output of which is then rendered back to the response. This architecture affects the efficiency of page rendering in several ways. First, interpreting the server-side script on the fly.As a side effect, one common optimization for ASP applications is to move a lot of server-side script into precompiled COM components to improve response times. A second efficiency concern is that intermingling server-side evaluation blocks with static HTML is less efficient than evaluating a single server-side script block, because the interpreter has to be invoked over and over again. Thus, to improve efficiency of rendering, many ASP developers resort to large blocks of server-side script, replacing static HTML elements withResponse.Write() invocations instead. Finally, this ASP model actually allows different blocks of script within a page to be written in different script languages. While this may be appealing in some ways, it also degrades performance by requiring that a particular page load both scripting engines to process a request, which takes more time and memory than using just one language. But in ASP.NET, In contrast, ASP.NET pages are always compiled into .NET classes housed within assemblies. This class includes all of the server-side code and the static HTML, so once a page is accessed for the first time (or any page within a particular directory is accessed), subsequent rendering of that page is serviced by executing compiled code. This eliminates all the inefficiencies of the scripting model of traditional ASP. There is no longer any performancedifference between compiled components and server-side code embedded within a page they are now both compiled components. There is also no performance difference between interspersing server-side code blocks among static HTML elements, and writing large blocks of server-side code and using Response.Write() for static HTML content. Also, because the .aspx file is parsed into a single code file and compiled, it is not possible to use multiple server-side languages within a single .aspx file. Debugging benefits In classic ASP it was very difficult for us to debug the application. ASP developers had time to debug application due to limited support due to the interpreted model.

But in ASP.NET In addition to improved performance over the interpreted model, pages that are compiled into classes can be debugged using the same debugging tools available to desktop applications or component developers. Errors with pages are generated as compiler errors, and there is a good chance that most errors will be found at compilation time instead of runtime, because VB.NET and C# are both strongly typed languages. Plus, all the tools available to the .NET developer are applicable to the .aspx developer. Server-Side code placement Web Page class=docText>Especially if you are using ASP pages it is possible to include executable code outside the scope of a function within a script block marked as runat=server, and , it is possible to define a function within a pair of server-side script tags. But in ASP.NET, In ASP.NET it is no longer possible to include executable code outside the scope of a function within a script block marked as runat=server, and conversely, it is no longer possible to define a function within a pair of server-side script tags.

Note also that the generated class definition provides a default constructor for you, and if you try to define your own default constructor within your page, it will cause a compiler error. This can be somewhat frustrating if you are trying to properly initialize elements of your class (such as filling up our array of values or subscribing to events). Fortunately, an alternative technique gives you more complete control over the class definition while separating the layout from the page logic. This technique is called code-behind. Deployment Strategies In traditional ASP applications, components used by pages and deployed in this fashion were notoriously difficult to update or replace. Whenever the application was up and running, it held a reference to the component file so to replace that file, you had to shut down IIS (temporarily taking your Web server offline), replace the file, and restart IIS. But in ASP.NET, The goals of ASP.NET was to eliminate the need to stop the running Web application whenever components of that application need to be updated or replaced that is, updating an application should be as simple as using xcopy to replace the components on the Web server with the new updated versions. To achieve this xcopy deployment capability, the designers of ASP.NET had to ensure two things: first, that the running application not hold a reference to the component file and second, that whenever the component file was replaced with a new version, that new version was picked up with any subsequent requests made to the application. Both of these goals are achieved by using the shadow copy mechanism provided by the Common Language Runtime (CLR). Shadow copying of assemblies is something you can configure when you create a new application domain in .NET. The AppDomainSetup class (used to initialize an AppDomain) exposes a Boolean property called ShadowCopyFiles and a string property called CachePath,

and the AppDomain class exposes a method called SetShadowCopyPath() to enable shadow copying for a particular application domain. The Boolean property turns the mechanism on for a particular application domain, the CachePath specifies the base directory where the shadowed copies should be placed, and the SetShadowCopyPath() method specifies which directories should have shadow copying enabled. ASP.NET creates a distinct application domain for each application it hosts in its worker process and for each application domain, it enables shadow copying of all assemblies referenced in the /bin directory. Instead of loading assemblies directly from the /bin directory, the assembly loader physically copies the referenced assembly to a separate directory (also indicated in the configuration settings for that application domain) and loads it from there. This mechanism also keeps track of where the assembly came from, so if a new version of that assembly is ever placed in the original /bin directory, it will be recopied into the Noteshadow" directory and newly referenced from there. In addition to shadow copying of assemblies, ASP.NET needs the ability to create and load assemblies on the fly. The first time an .aspx page is referenced, as we have seen, it is compiled into an assembly and loaded by ASP.NET. What we haven't seen is where those assemblies are located once they are compiled. Application domains also support the concept of a "dynamic directory" specified through the DynamicBase property of the AppDomainSetup class, which is a directory designed for dynamically generated assemblies that can then be referenced by the assembly loader. ASP.NET sets the dynamic directory of each application it houses to a subdirectory under the system Temporary ASP.NET Files directory with the name of the virtual directory of that application. One consequence of both dynamic assembly generation and shadow copying is that many assemblies are copied during the lifetime of an ASP.NET application. The assemblies that are no longer being referenced should be cleaned up so that disk space usage doesn't become a limiting factor in application growth. In ASP.NET shadow copied assemblies are removed as soon as possible after a new version of that assembly is copied, and dynamically generated assemblies that are no longer used are cleaned up the next time the ASP.NET worker process is bounced and the particular application associated with the dynamic assemblies is run again. In general, this means that you shouldn't have to worry about unused assemblies generated by ASP.NET wasting space on your machine for very long. New Page Directives In ASP you must place all directives on the first line of a page within the same delimiting block. For example: <%LANGUAGE="VBSCRIPT" CODEPAGE="932"%> But in ASP.NET, you are now required to place the Language directive with a Page directive, as follows: <%@Page Language="VB" CodePage="932"%> <%@QutputCache Duration="60" VaryByParam="none" %> You can have as many lines of directives as you need. Directives may be located anywhere in your .apsx file but standard practice is to place them at the beginning of the file. Several new directives have been added in ASP.NET. I encourage you to look these up in the ASP.NET documentation to see how they may benefit your application.

Threading Issues The threading model of COM object created using VB within a web-based application is STA. ASP worker thread resides in its own STA and hence the compatability is fine in this case with a little performance hit. But in ASP.NET, The ASP.NET threading model is the Multiple Threaded Apartment (MTA). What this means is that components that you are using that were created for the Single Threaded Apartment (STA) will no longer perform or function reliably without taking some extra precautions in ASP.NET. This includes, but is not limited to, all COM components that have been created using Visual Basic 6.0 and earlier versions. You will be glad to hear that you can still use these STA components without having to change any code. What you need to do is include the compatibility attributeaspcompat=true in a <%@Page> tag on the ASP.NET page. For example, <%@Page aspcompat=true Language=VB%>. Using this attribute will force your page to execute in STA mode, thus ensuring your component will continue to function correctly. If you attempt to use an STA component without specifying this tag, the run time will throw an exception. Setting this attribute to true will also allow your page to call COM+ 1.0 components that require access to the unmanaged ASP built-in objects. These are accessible via the ObjectContext object. If you set this tag to true, your performance will degrade slightly. I suggest doing this only if you absolutely need to.

Validation & Browser scripting capabilities ASP has no inbuilt facility for Validation of controls.i.e, checking whether a textbox is left blank or not or a combo is selected or not or if a phone number does not fit a particular pattern for a area and many such examples. The user had to write the client side Javascript code for all these kind of validations. Client and server side validation both were the headache of the of the developer. Javascript code to fit a particular Browser was also the developer's burden. He had to write specific code so that it could fit a set of browsers. It took lot of the developers time.

But in ASP.NET, In built validation controls are provided which are as easy to implement and the developer has to worry the least. The features provided by ASP.NET validation controls is :-

Browser Independent coding :- Developer does not have to worry about the browser how the controls would render to. Client-Side or Server-Side :- The Validation Controls manage the code checking if the client side code is disabled the validation is done on the server side.

Rich Validation set :- There are 6 types of validation which cater to the needs of the validation requirements:

RequiredFieldValidation Control - Requires that the control not be left blank. CompareValidator Control - Used to compare Data in Two Controls RangeValidator Control - Used to check for Range validation.(also supports various data Type - Date , string etc..) RegularExpressionValidator Control - Used to check the complicated patterns in the user input. CustomValidator Control- The final control we have included in ASP.NET is one that adds great flexibility to our validation abilities. We have a custom validator where we get to write out own functions and pass the control value to this function.

This control also provides Client side and server side validation of which the Server side validation could be a different function altogether. Validation Summary - The validation summary control will collect all the error messages of all the non-valid controls and put them in a tidy list. The list can be either shown on the web page (as shown in the example above) or with a popup box

Conclusion
This article targets to the developers who have directly started working on ASP.Net and also for the web developers who have migrated from ASP to ASP.Net. This article is at the draft level and might need additions which I intend to do.I welcome suggestion or criticism!! I would request to add as much feedback to this article post as possible. I would keep this post updated.

ASP.NET: 1. 2. 3. 4. 5. ASP.Net ASP.Net ASP.Net ASP.Net ASP.Net web forms have a code behind file which contains all event handling code. web forms inherit the class written in code behind. web forms use full fledged programming language web applications are configurable (web.config) webforms can use custom controls through the @ register directive

6. ASP.Net web forms have ADO.Net which supports XML integration and integration of data from two or more data sources

ASP:

1. 2. 3. 4. 5. 6.

ASP does not have such facility to separate programming logic from design. ASP does not have the concept of inheritance. ASP pages use scripting language. ASP applications are not. It is not available with ASP. while ASP has ADO which is a simple COM object with limited facilities.

Features of ide are:

Visual Studio 2008 code name "Orcas" Beta 2 has just hit the road and, since it is Beta 2, this means Visual Studio 2008 is feature complete and is ready for RTM. Below, we would find a brief introduction of some of the new featuresintroduced with VS 2008 and .NET 3.5 Beta 2. A quick list of some of the new

features are:

Multi-Targeting support Web Designer and CSS support ASP.NET AJAX and JavaScript support Project Designer Data LINQ Language Integrated Query

The features listed and explained in this paper are not complete and this document intends to give you a forehand to start off with VS 2008.

1. Multi-Targeting Support
Earlier, each Visual Studio release only supported a specific version of the .NET Framework. For example, VS 2003 only works with .NET 1.1, and VS 2005 only works with .NET 2.0. One of the major changes with the VS 2008 release is to support what Microsoft calls "MultiTargeting". This means that Visual Studio will now support targeting multiple versions of the

.NET Framework, and developers will be able to take advantage of the new features that Visual Studio provides without having to migrate their existing projects and deployed applications to use a new version of the .NET Framework. Now when we open an existing project or create a new one with VS 2008, we can pick which version of the .NET Framework to work with. The IDE will update its compilers and feature-set to match the chosen .NET Framework.

Features, controls, projects, item-templates, and references that do not work with the
selected version of the Framework will be made unavailable or will be hidden. Unfortunately, support has not been included to work with Framework versions 1.1 and earlier. The present release supports 2.0/3.0 and 3.5 .NET Frameworks. Microsoft plans to continue multi-targeting support in all future releases of Visual Studio.

Creating a New Project with Visual Studio 2008 that Targets .NET 2.0 Framework Library
The screenshots below depict the creation of a new web application targeting .NET 2.0 Framework. Choose File->New Project. As we see in the snapshot below in the top-right of the new project dialog, there is now a dropdown that allows us to choose which versions of the .NET Framework we want to target when we create the new project. The templates available are filtered depending on the version of the Framework chosen from the dropdown:

Can I Upgrade an Existing Project to .NET 3.5?

When we open a solution created using an older version of Visual Studio and Framework, VS 2008 would ask if migration is required. If we opt to migrate, then a migration wizard would start. If we wish to upgrade our project to target a newer version of the Framework at a later point of time, we can pull up the project properties page and choose the Target Framework. The required assemblies are automatically referenced. The snapshot below shows the properties page with the option Target Framework marked.

2. Web Designer, Editing and CSS Support

One feature that web developers will discover with VS 2008 is its drastically improved HTML designer, and the extensive CSS support made available. The snapshots below depict some of the new web designer

features in-built into VS 2008.

Split View Editing

In addition to the existing views, Design view and Code view, VS 2008 brings along the Split view which allows us to view both the HTML source and the Design View at the same-time, and easily make changes in any of the views. As shown in the image below, as we select a tag in code view, the corresponding elements/controls are selected in design view.

CSS Style Manager

VS 2008 introduces a new tool inside the the CSS style sheets for the page.

IDE called "Manage Styles". This shows all of

It can be used when we are in any of the views - design, code and split views. Manage Styles tool can be activated by choosing Format -> CSS Styles -> Manage Styles from the menu. A snapshot of the same would look like the following:

Create a new style using the new style dialog window as show in the snapshot below.

Now, the style manager would show .labelcaption style as well in the CSS styles list. However, if we observe that the body element has a circle around it but the .labelcaption does not have one, this is because the style is not in use yet.

We will not select all the labels below and apply our new style .labelcaption.

We can choose to modify the existing style through GUI using "Modify style..." menu option in the dropdown menu as shown above or choose to hand edit the code by choosing the option "Go To Code".

CSS Source View Intellisense

The designer is equipped with the ability to select an element or control in design-view, and graphically select a rule from the CSS list to apply to it. We will also find when in source mode that we now have intellisense support for specifying CSS class rules. The CSS Intellisense is supported in both regular ASP.NET pages as well as when working with pages based on master pages.

Code Editing Enhancements

Below is a non-exhaustive list of a few new code editing improvements. There are many more about which I don't know yet. Transparent Intellisense Mode While using VS 2005/2003 we often find ourselves escaping out of intellisense in order to better see the code around, and then go back and complete what we were doing. VS 2008 provides a new feature which allows us to quickly make the intellisense dropdown list semi-transparent. Just hold down the "Ctrl" key while the intellisense drop-down is visible and we will be able to switch it into a transparent mode that enables us to look at the code beneath without having to escape out of Intellisense. The screenshot below depicts the same.

Organize C# Using Statements One of the small, but a nice new feature in VS 2008 is support for better organizing using statements in C#. We can now select a list of using statements, right-click, and then select the "Organize Usings" sub-menu. When we use this command the IDE will analyze what types are used in the code file, and will automatically remove those namespaces that are declared but not required. A small and handy feature for code refactoring.

3. ASP.NET AJAX and JavaScript Support

JavaScript Intellisense
One new feature that developers will find with VS 2008 is its built-in support for JavaScript Intellisense. This makes using JavaScript and building AJAX applications significantly easier. A double click on HTML control in design mode would automatically create a click event to the button and would create the basic skeleton of the JavaScript function. As we see in the depicted image below, JavaScript Intellisense is inbuilt now. Other JavaScript Intellisensefeatures include Intellisense for external JavaScript libraries and adding Intellisense hints to JavaScript functions.

JavaScript Debugging
One new JavaScript feature in VS 2008 is the much-improved support for JavaScript debugging. This makes debugging AJAX applications significantly easier. JavaScript debugging was made available in VS 2005 itself. However, we had to run the web application first to set the breakpoint or use the "debugger" JavaScript statement. VS 2008 makes this much better by adding new support that allows us to set clientside JavaScript breakpoints directly within your server-side .aspx and .master source files. We can now set both client-side JavaScript breakpoints and VB/C# serverside breakpoints at the same time on the same page and use a single debugger to step through both the server-side and client-side code in a single debug session. This feature is extremely useful for AJAX applications. The breakpoints are fully supported in external JavaScript libraries as well.

4. Few Other Features and Enhancements

Below is a list of few other enhancements and new Studio 2008.

features included in Microsoft Visual

Project Designer
Windows Presentation Foundation (WPF) applications have been added to Visual Studio 2008. There are four WPF project types: WinFX WinFX WinFX WinFX Windows Application Web Browser Application Custom Control Library Service Library

When a WPF project is loaded in the IDE, the user interface of the Project Designer pages lets us specify properties specific to WPF applications.

Data
Microsoft Visual Studio 2008 Beta 2 includes the following new data into applications:

features to incorporate

The Object Relational Designer (O/R Designer) assists developers in creating and editing the objects (LINQ to SQL entities) that map between an application and a remote database Hierarchical update capabilities in Dataset Designer, providing generated code that includes the save logic required to maintain referential integrity between related tables Local database caching incorporates an SQL Server Compact 3.5 database into an application and configures it to periodically synchronize the data with a remote database on a server. Local database caching enables applications to reduce the number of round trips between the application and a database server

LINQ Language Integrated Query

LINQ is a new feature in VS 2008 that broadens great querying capabilities into the language syntax. LINQ introduces patterns for querying and updating data. A set of new assemblies are provided that enable the use of LINQ with collections, SQL databases, and XML documents.

Visual Studio 2008 Debugger

The Visual Studio 2008 debugger has been enhanced with the following

features:

Remote debugging support on Windows Vista Improved support for debugging multithreaded applications Debugging support for LINQ programming Debugging support for Windows Communications Foundation Support for script debugging, including client-side script files generated from serverside script now appear in Solution Explorer

Reporting
Visual Studio 2008 provides several new reporting

features and improvements such as:

New Report Projects: Visual Studio 2008 includes two new project templates for creating reporting applications. When we create a new Reports Application project, Visual Studio provides a report (.rdlc) and a form with a ReportViewer control bound to the report. Report Wizard: Visual Studio 2008 introduces a Report Wizard, which guides us through the steps to create a basic report. After we complete the wizard, we can enhance the report by using Report Designer. Expression Editor Enhancement: The Expression Editor now prov ides expressions that we can use directly or customize as required. PDF Compression: The ReportViewer controls can now compress reports that are rendered or exported to thePDF format.

License
This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below. A list of licenses authors might use can be found here

About the Author

Ramana. Gali Software Developer (Senior) Singapore Member C# Developer have Hands on Web Developement using ASP.NET, Web Services, Win Serivces, Pocket PC, Smart Device,Enterprize Security Applications and Win Forms Development using .NET FW 1.1 & 2.0.

Microsoft Visual Studio is an integrated development environment (IDE) from Microsoft. It is used to develop console andgraphical user interface applications along with Windows Forms applications, web sites, web applications, and web services in both native code together with managed code for all

platforms supported by Microsoft Windows, Windows Mobile, Windows CE,.NET Framework, .NET Compact Framework and Microsoft Silverlight. Visual Studio includes a code editor supporting IntelliSense as well as code refactoring. The integrated debugger works both as a source-level debugger and a machine-level debugger. Other built-in tools include a forms designer for building GUI applications, web designer, class designer, and database schema designer. It accepts plug-ins that enhance the functionality at almost every level including adding support for source-control systems (like Subversion and Visual SourceSafe) and adding new toolsets like editors and visual designers for domain-specific languages or toolsets for other aspects of the software development lifecycle(like the Team Foundation Server client: Team Explorer). Visual Studio supports different programming languages by means of language services, which allow the code editor and debugger to support (to varying degrees) nearly any programming language, provided a language-specific service exists. Built-in languages include C/C++ (via Visual C++), VB.NET (via Visual [3] Basic .NET), C# (via Visual C#), and F# (as of Visual Studio 2010 ). Support for other languages such as M, Python, and Ruby among others is available via language services installed separately. It also supports XML/XSLT, HTML/XHTML, JavaScript and CSS. Individual language-specific versions of Visual Studio also exist which provide more limited language services to the user: Microsoft Visual Basic, Visual J#, Visual C#, and Visual C++. Microsoft provides "Express" editions of its Visual Studio 2010 components Visual Basic, Visual C#, Visual C++, and Visual Web Developer at no cost. Visual Studio 2010, 2008 and 2005 Professional Editions, along with language-specific versions (Visual Basic, C++, C#, J#) of Visual Studio Express 2010 are available for free to students as downloads via Microsoft'sDreamSpark program.
Contents
[hide]

1 Architecture 2 Features

o o o o o

2.1 Code editor 2.2 Debugger 2.3 Designer 2.4 Other tools 2.5 Extensibility

3 Supported products

o o

3.1 Included products 3.2 Previous products

4 Editions

o o

4.1 Visual Studio Express 4.2 Visual Studio LightSwitch

o o o o

4.3 Visual Studio Professional 4.4 Visual Studio Premium 4.5 Visual Studio Tools for Office 4.6 Visual Studio Ultimate

o o

4.6.1 Visual Studio Team System

4.7 Test Professional 4.8 Editions feature grid

5 Version history

o o o o o o o

5.1 Visual Studio 97 5.2 Visual Studio 6.0 (1998) 5.3 Visual Studio .NET (2002) 5.4 Visual Studio .NET 2003 5.5 Visual Studio 2005 5.6 Visual Studio 2008 5.7 Visual Studio 2010

5.7.1 Visual Studio Ultimate 2010

5.8 Upcoming version

6 Visual Studio Application Lifecycle Management 7 See also 8 References 9 External links

[edit]Architecture Visual Studio does not support any programming language, solution or tool intrinsically, instead allows the plugging of functionality coded as a VSPackage. When installed, the functionality is available as a Service. The IDE provides three services: SVsSolution, which provides the ability to enumerate projects and solutions; SVsUIShell, which provides windowing and UI functionality (including tabs, toolbars and tool windows); and SVsShell, which deals with registration of VSPackages. In addition, the IDE is also [4] responsible for coordinating and enabling communication between services. All editors, designers, project types and other tools are implemented as VSPackages. Visual Studio uses COM to access the VSPackages. The Visual Studio SDK also includes the Managed Package Framework (MPF), which is a set of managed wrappers around the COM-interfaces that allow the Packages to be written in any CLI [5] compliant language. However, MPF does not provide all the functionality exposed by the Visual Studio [6] COM interfaces. The services can then be consumed for creation of other packages, which add functionality to the Visual Studio IDE.

Support for programming languages is added by using a specific VSPackage called a Language Service. A language service defines various interfaces which the VSPackage implementation can implement to [7] add support for various functionalities. Functionalities that can be added this way include syntax coloring, statement completion, brace matching, parameter information tooltips, member lists and error [7] markers for background compilation. If the interface is implemented, the functionality will be available for the language. Language services are to be implemented on a per-language basis. The implementations [7] can reuse code from the parser or the compiler for the language. Language services can be implemented either in native code or managed code. For native code, either the native COM interfaces or [8] the Babel Framework (part of Visual Studio SDK) can be used. For managed code, the MPF includes [9] wrappers for writing managed language services. Visual Studio does not include any source control support built in but it defines two alternative ways for [10] source control systems to integrate with the IDE. A Source Control VSPackage can provide its own customised user interface. In contrast, a source control plugin using the MSSCCI (Microsoft Source Code Control Interface) provides a set of functions that are used to implement various source control [11][12] functionality, with a standard Visual Studio user interface. MSSCCI was first used to integrate Visual SourceSafe with Visual Studio 6.0 but was later opened up via the Visual Studio SDK. Visual Studio .NET 2002 used MSSCCI 1.1, and Visual Studio .NET 2003 used MSSCCI 1.2. Visual Studio 2005, 2008 and 2010 use MSSCCI Version 1.3, which adds support for rename and delete propagation as well as [12] asynchronous opening. Visual Studio supports running multiple instances of the environment (each with its own set of VSPackages). The instances use different registry hives (see MSDN's definition of the term "registry hive" in the sense used here) to store their configuration state and are differentiated by their AppId (Application ID). The instances are launched by an AppId-specific .exe that selects the AppId, sets the root hive and launches the IDE. VSPackages registered for one AppId are integrated with other VSPackages for that AppId. The various product editions of Visual Studio are created using the different AppIds. The Visual Studio Express edition products are installed with their own AppIds, but the Standard, Professional and Team Suiteproducts share the same AppId. Consequently, one can install the Express editions side-by-side with other editions, unlike the other editions which update the same installation. The professional edition includes a superset of the VSPackages in the standard edition and the team suite includes a superset of the VSPackages in both other editions. The AppId system is leveraged by [13] the Visual Studio Shell in Visual Studio 2008. [edit]Features [edit]Code

editor

Visual Studio, like any other IDE, includes a code editor that supports syntax highlighting and code completion using IntelliSense for not only variables, functions and methods but also language constructs [14] like loops and queries. IntelliSense is supported for the included languages, as well as for XML and for Cascading Style Sheets and JavaScript when developing web sites and web [15][16] applications. Autocomplete suggestions are popped up in a modeless list box, overlaid on top of the code editor. In Visual Studio 2008 onwards, it can be made temporarily semi-transparent to see the code [14] obstructed by it. The code editor is used for all supported languages. The Visual Studio code editor also supports setting bookmarks in code for quick navigation. Other navigational aids include collapsing code blocks and incremental search, in addition to normal text search

and regex search. The code editor also includes a multi-item clipboard and a task list. The code editor supports code snippets, which are saved templates for repetitive code and can be inserted into code and customized for the project being worked on. A management tool for code snippets is built in as well. These tools are surfaced as floating windows which can be set to automatically hide when unused or docked to the side of the screen. The Visual Studio code editor also supports code refactoring including parameter reordering, variable and method renaming, interface extraction and encapsulation of class members inside properties, among others. Visual Studio features background compilation (also called incremental compilation). As code is being written, Visual Studio compiles it in the background in order to provide feedback about syntax and compilation errors, which are flagged with a red wavy underline. Warnings are marked with a green underline. Background compilation does not generate executable code, since it requires a different [20] compiler than the one used to generate executable code. Background compilation was initially [19] introduced with Microsoft Visual Basic but has now been expanded for all included languages. [edit]Debugger Main article: Microsoft Visual Studio Debugger Visual Studio includes a debugger that works both as a source-level debugger and as a machine-level debugger. It works with both managed code as well as native code and can be used for debugging applications written in any language supported by Visual Studio. In addition, it can also attach to running [21] processes and monitor and debug those processes. If source code for the running process is available, it displays the code as it is being run. If source code is not available, it can show the disassembly. The [22] Visual Studio debugger can also creatememory dumps as well as load them later for debugging. Multithreaded programs are also supported. The debugger can be configured to be launched when an application running outside the Visual Studio environment crashes.
[18][19]

[17]

[17]

The debugger allows setting breakpoints (which allow execution to be stopped temporarily at a certain [23] position) and watches (which monitor the values of variables as the execution progresses). Breakpoints can be conditional, meaning they get triggered when the condition is met. Code can be stepped over, i.e., [24] run one line (of source code) at a time. It can either step into functions to debug inside it, or step over it, [24] i.e., the execution of the function body isn't available for manual inspection. The debugger supports Edit and Continue, i.e., it allows code to be edited as it is being debugged (32 bit only; not [25] supported in 64 bit). When debugging, if the mouse pointer hovers over any variable, its current value is displayed in a tooltip ("data tooltips"), where it can also be modified if desired. During coding, the Visual Studio debugger lets certain functions be invoked manually from the Immediate tool window. The [26] parameters to the method are supplied at the Immediate window. [edit]Designer This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (May
2008)

Visual Studio includes a host of visual designers to aid in the development of applications. These tools include:

Visual Studio Web Designer in code editor view

Visual Studio 2005 in Class Designer view

Windows Forms Designer The Windows Forms designer is used to build GUI applications using Windows Forms. Layout can be controlled by housing the controls inside other containers or locking them to the side of the form. Controls that display data (like textbox, list box, grid view, etc.) can bebound to data sources like databases or queries. Data-bound controls can be created by dragging items from the Data Sources window onto a design surface. WPF Designer The WPF designer, codenamed Cider,
[28] [27]

The UI is linked with code using an event-

driven programming model. The designer generates either C# orVB.NET code for the application.

was introduced with Visual Studio 2008. Like the

Windows Forms designer it supports the drag and drop metaphor. It is used to author user interfaces targeting Windows Presentation Foundation. It supports all WPF functionality including data binding and automatic layout management. It generates XAML code for the UI. The generated XAML file is compatible withMicrosoft Expression Design, the designer-oriented product. The XAML code is linked with code using a code-behind model.

Web designer/development Visual Studio also includes a web-site editor and designer that allows web pages to be authored by dragging and dropping widgets. It is used for developing ASP.NET applications and supports HTML, CSS and JavaScript. It uses a code-behind model to link with ASP.NET code. From Visual Studio 2008 onwards, the layout engine used by the web designer is shared with Microsoft Expression Web. There is also ASP.NET MVC support for MVC technology as a separate download
[29] [30]

and ASP.NET Dynamic Data project available from Microsoft

Class designer The Class Designer is used to author and edit the classes (including its members and their access) using UML modeling. The Class Designer can generate C# and VB.NET code outlines for the classes and methods. It can also generate class diagrams from hand-written classes. Data designer The data designer can be used to graphically edit database schemas, including typed tables, primary and foreign keys and constraints. It can also be used to design queries from the graphical view. Mapping designer From Visual Studio 2008 onwards, the mapping designer is used by LINQ to SQL to design the mapping between database schemas and the classes that encapsulate the data. The new solution from ORM approach, ADO.NET Entity Framework, replaces and improves the old technology. [edit]Other

tools

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (May 2008) Open Tabs Browser The open tabs browser is used to list all open tabs and to switch between them. It is invoked using CTRL+TAB. Properties Editor The Properties Editor tool is used to edit properties in a GUI pane inside Visual Studio. It lists all available properties (both read-only and those which can be set) for all objects including classes, forms, web pages and other items. Object Browser The Object Browser is a namespace and class library browser for Microsoft .NET. It can be used to browse the namespaces (which are arranged hierarchically) in managedassemblies. The hierarchy may or may not reflect the organization in the file system. Solution Explorer

In Visual Studio parlance, a solution is a set of code files and other resources that are used to build an application. The files in a solution are arranged hierarchically, which might or might not reflect the organization in the file system. The Solution Explorer is used to manage and browse the files in a solution. Team Explorer Team Explorer is used to integrate the capabilities of Team Foundation Server, the Revision Control System into the IDE (and the basis for Microsoft's CodePlex hosting environment for open source projects). In addition to source control it provides the ability to view and manage individual work items (including bugs, tasks and other documents) and to browse TFSstatistics. It is included as part of a TFS install and is also available as a download for Visual Studio separately
[31][32]

Team Explorer is also available as a stand-alone environment solely to access Data Explorer

TFS services.

Data Explorer is used to manage databases on Microsoft SQL Server instances. It allows creation and alteration of database tables (either by issuing T-SQL commands or by using the Data designer). It can also be used to create queries and stored procedures, with the latter in either TSQL or in managed code via SQL CLR. Debugging and IntelliSense support is available as well. Server Explorer The Server Explorer tool is used to manage database connections on an accessible computer. It is also used to browse running Windows Services, performance counters, Windows Event Log and message queues and use them as a datasource.
[33]

Dotfuscator Software Services Community Edition Visual Studio includes a free 'light' version of PreEmptive Solutions' Dotfuscator product for code obfuscation and application-size reduction.
[34]

Starting with Visual Studio 2010, this version of

[35]

Dotfuscator will include Runtime Intelligence capabilities that allow authors to gather end-user usage, performance, and stability information from their applications running in production. Text Generation Framework Visual Studio includes a full text generation framework called T4 which enables Visual Studio to generate text files from templates either in the IDE or via code. ASP.NET Web Site Administration Tool The ASP.NET Web Site Administration Tool allows for the configuration of ASP.NET websites. [edit]Extensibility See also: List of Microsoft Visual Studio Add-ins and Visual Studio Extensibility

Visual Studio allows developers to write extensions for Visual Studio to extend its capabilities. These extensions "plug into" Visual Studio and extend its functionality. Extensions come in the form of macros, add-ins, and packages. Macros represent repeatable tasks and actions that developers can record programmatically for saving, replaying, and distributing. Macros, however, cannot implement new commands or create tool windows. They are written using Visual Basic and are not [6] compiled. Add-Ins provide access to the Visual Studio object model and can interact with the IDE tools. Add-Ins can be used to implement new functionality and can add new tool windows. Add-Ins are plugged in to the IDE via COM and can be created in any COM-compliant [6] languages. Packages are created using the Visual Studio SDK and provide the highest level of extensibility. They can create designers and other tools, as well as integrate other programming languages. The Visual Studio SDK provides unmanaged APIs as well as a managed API to accomplish these tasks. However, the managed API isn't as comprehensive as the [6] unmanaged one. Extensions are supported in the Standard (and higher) versions of Visual Studio 2005. Express

Editions do not support hosting extensions. Visual Studio 2008 introduced the Visual Studio Shell that allows for development of a customized version of the IDE. The Visual Studio Shell defines a set of VSPackages that provide the functionality required in any IDE. On top of that, other packages can be added to customize the installation. The Isolated mode of the shell creates a new AppId where the packages are installed. These are to be started with a different executable. It is aimed for development of custom development environments, either for a specific language or a specific scenario. The Integrated mode installs the packages into the AppId of the Professional/Standard/Team System editions, so that the tools integrate into these [13] editions. The Visual Studio Shell is available as a free download. After the release of Visual Studio 2008, Microsoft created the Visual Studio Gallery. It serves as the central location for posting information about extensions to Visual Studio. Community developers as well as commercial developers can upload information about their extensions to Visual Studio .NET 2002 through Visual Studio 2010. Users of the site can rate and review the extensions to help assess the

quality of extensions being posted. RSS feeds to notify users on updates to the site and tagging features are also [36] planned. [edit]Supported

products
[edit]Included

products

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and remo ved. (May 2008) Microsoft Visual C++ Microsoft Visual C++ is Microsoft's implementation of the C and C++ compiler and associated languages-services and specific tools for integration with the Visual Studio IDE. It can compile either in C mode or C++ mode. For C, it follows the ISO C standard with parts of C99 spec along with MS-specific additions in the form of libraries. with a few C++0x features.
[38] [37]

For C++, it follows theANSI C++ spec along

It also supports the C++/CLI spec to write managed code, as well

as mixed-mode code (a mix of native and managed code). Microsoft positions Visual C++ for development in native code or in code that contains both native as well as managed components. Visual C++ supports COM as well as the MFClibrary. For MFC development, it provides a set of wizards for creating and customizing MFC boilerplate code, and creating GUI applications using MFC. Visual C++ can also use the Visual Studio forms designer to design UI graphically. Visual C++ can also be used with the Windows API. It also supports the use of intrinsic functions,
[39]

which are functions recognized by the compiler itself and not implemented as a
[40]

library. Intrinsic functions are used to expose the SSE instruction set of modern CPUs. Visual C++ also includes theOpenMP (version 2.0) spec. Microsoft Visual C# Microsoft Visual C#, Microsoft's implementation of the C# language, targets the .NET Framework, along with the language services that lets the Visual Studio IDE support C# projects. While the language services are a part of Visual Studio, the compiler is available separately as a part of the

.NET Framework. The Visual C# 2008 and 2010 compilers support versions 3.0 and 4.0 of the C# language specifications, respectively. Visual C# supports the Visual Studio Class designer, Forms designer, and Data designer among others.
[41]

Microsoft Visual Basic Microsoft Visual Basic is Microsoft's implementation of the VB.NET language and associated tools and language services. It was introduced with Visual Studio .NET (2002). Microsoft has positioned Visual Basic for Rapid Application Development.
[42][43]

Visual Basic can be used to

author both console applications as well as GUI applications. Like Visual C#, Visual Basic also supports the Visual Studio Class designer, Forms designer, and Data designer among others. Like C#, the VB.NET compiler is also available as a part of .NET Framework, but the language services that let VB.NET projects be developed with Visual Studio, are available as a part of the latter. Microsoft Visual Web Developer Microsoft Visual Web Developer is used to create web sites, web applications and web services using ASP.NET. Either C# or VB.NET languages can be used. Visual Web Developer can use the Visual Studio Web Designer to graphically design web page layouts. Team Foundation Server Included only with Visual Studio Team System, Team Foundation Server is intended for collaborative software development projects and acts as the server-side backend providingsource control, data collection, reporting, and project-tracking functionality. It also includes the Team Explorer, the client tool for TFS services, which is integrated inside Visual Studio Team System. [edit]Pre

vious produc ts
Visual FoxPro Visual FoxPro is a data-centric object-oriented and procedural programming language produced by Microsoft. It derives from FoxPro (originally known as FoxBASE) which was developed by Fox Software beginning in 1984. Visual FoxPro is tightly integrated with its own relational database engine, which extends FoxPro's xBase capabilities to support SQLqueries and data manipulation. Visual FoxPro is a full-featured
[citation needed]

, dynamic programming language that does not require

the use of an additional general-purpose programming environment. Microsoft announced in

2007 that Visual FoxPro has been discontinued after version 9 Service Pack 2, but will remain supported until 2015.
[44]

Visu al Sour ceSa fe Microsoft Visual SourceSafe is a source control software package oriented towards small software-development projects. The SourceSafe database is a multi-user, multi-process filesystem database, using the Windows file system database primitives to provide locking and sharing support. All versions are multi-user, using SMB (file server) networking.
[45][46][47]

However,

with Visual SourceSafe 2005, other clientserver modes were added, Lan Booster and VSS Internet (which used HTTP/HTTPS). Visual SourceSafe 6.0 was available as a stand-alone product
[48]

and was included with Visual Studio 6.0, and other products such as Office Developer

Edition. Visual SourceSafe 2005 was available as a stand-alone product and included with the 2005 Team Suite. Team Foundation Server has superseded VSS as Microsoft's recommended platform for source control. M i c r o s o ft V i s u a l J + + / M i c r o s o

ft V i s u a l J # Microsoft Visual J++ was Microsoft's implementation of the Java language (with Microsoft-specific extensions) and associated language services. It was discontinued as a result of litigation from Sun Microsystems, and the technology was recycled into Visual J#, Microsoft's Java compiler for .NET Framework. J# was available with Visual Studio 2005 but has been discontinued in Visual Studio 2008. V i s u a l I n t e r D e v Visual InterDev was used to create web applications using Microsoft Active Server Pages (ASP) technologies. It supports code completion and includes database server management tools. It has been replaced with Microsoft Visual Web Developer. [ e d i t ]

E d i

t i o n s
M i c r o s o f t V i s u a l S t u d i o i s a v a i l a b l e i

n t h e f o l l o w i n g e d i t i o n s o r S K U s :
[ 4 9 ]

[ e d i t ]

V i s u a l S t u d i o E x p r e s s
V i s u a l S t u d i o E x p

r e s s E d i t i o n s a r e a s e t o f f r e e l i g h t w e i g h t i

n d i v i d u a l I D E s w h i c h a r e p r o v i d e d a s s t r i p p e d

d o w n v e r s i o n s o f t h e V i s u a l S t u d i o I D E o n a

p e r p l a t f o r m b a s i s o r p e r l a n g u a g e b a s i s , i . e

. , i t i n s t a l l s t h e d e v e l o p m e n t t o o l s f o r t h e

s u p p o r t e d p l a t f o r m s ( w e b , W i n d o w s , p h o n e ) o r

s u p p o r t e d d e v e l o p m e n t l a n g u a g e s ( V B , C # ) o n t o

i n d i v i d u a l V i s u a l S t u d i o S h e l l A p p I d s . I t i n

c l u d e s o n l y a s m a l l s e t o f t o o l s a s c o m p a r e d

t o t h e o t h e r s y s t e m s . I t d o e s n o t i n c l u d e s u p

p o r t f o r p l u g i n s . x 6 4 c o m p i l e r s a r e n o t i n c l

u d e d i n t h e V i s u a l S t u d i o E x p r e s s e d i t i o n I D E

s , b u t a r e a v a i l a b l e a s p a r t o f a W i n d o w s S o f

t w a r e D e v e l o p m e n t K i t t h a t c a n b e i n s t a l l e d s

e p a r a t e l y .
[ 5 0 ]

M i c r o s o f t t a r g e t s t h e E x p r e s s

I D E s a t s t u d e n t s a n d h o b b y i s t s . E x p r e s s e d i t i

o n s d o n o t u s e t h e f u l l M S D N L i b r a r y b u t u s e

t h e M S D N E s s e n t i a l s L i b r a r y . T h e l a n g u a g e s a v

a i l a b l e a s p a r t o f t h e E x p r e s s I D E s a r e :
[ 5 1 ]

V i s u a l B a s i c E x p r e s s

V i s u a l C + + E x p r e s s

V i s u a l

C # E x p r e s s V i s u a l W e b D e v e l o p e r E x p r e s s E x p r e s s

f o r W i n d o w s P h o n e

[ e d i t ]

V i s u a l S t u d i o L i g h t S w i t c h
M i c r o s o f t V i

s u a l S t u d i o L i g h t S w i t c h i s a n I D E s p e c i f i c a l l

y t a i l o r e d f o r c r e a t i n g l i n e o f b u s i n e s s a p p l

i c a t i o n s b u i l t o n e x i s t i n g . N E T t e c h n o l o g i e s

a n d M i c r o s o f t p l a t f o r m s . T h e a p p l i c a t i o n s p r o

d u c e d a r e a r c h i t e c t u r a l l y 3 t i e r : t h e u s e r i n

t e r f a c e r u n s o n M i c r o s o f t S i l v e r l i g h t ; t h e l o

g i c a n d d a t a a c c e s s t i e r i s b u i l t o n W C F R I A

S e r v i c e s a n d E n t i t y F r a m e w o r k , h o s t e d i n A S P .

N E T ; a n d t h e p r i m a r y d a t a s t o r a g e s u p p o r t s M i

c r o s o f t S Q L S e r v e r E x p r e s s , M i c r o s o f t S Q L S e r

v e r a n d M i c r o s o f t S Q L A z u r e . L i g h t S w i t c h a l s o

s u p p o r t s o t h e r d a t a s o u r c e s i n c l u d i n g M i c r o s

o f t S h a r e P o i n t . L i g h t S w i t c h i n c l u d e s g r a p h i c a

l d e s i g n e r s f o r d e s i g n i n g e n t i t i e s a n d e n t i t y

r e l a t i o n s h i p s , e n t i t y q u e r i e s , a n d U I s c r e e n

s . B u s i n e s s l o g i c m a y b e w r i t t e n i n e i t h e r V i

s u a l B a s i c o r V i s u a l C # . T h e t o o l c a n b e i n s t a

l l e d a s a s t a n d a l o n e S K U o r a s a n i n t e g r a t e d

a d d i n t o V i s u a l S t u d i o 2 0 1 0 P r o f e s s i o n a l a n

d h i g h e r .
[ 5 2 ]

[ e d i t ]

V i s u a l S t u d i o P r o f e s s i o n a l
V i s u a l S t u d

i o P r o f e s s i o n a l E d i t i o n p r o v i d e s a n I D E f o r a

l l s u p p o r t e d d e v e l o p m e n t l a n g u a g e s . A s o f V i s

u a l S t u d i o 2 0 1 0 , t h e S t a n d a r d e d i t i o n w a s d r o

p p e d .
[ 5 3 ]

M S D N s u p p o r t i s a v a i l a b l e a s M S D N E

s s e n t i a l s o r t h e f u l l M S D N l i b r a r y d e p e n d i n g

o n l i c e n s i n g . I t s u p p o r t s X M L a n d X S L T e d i t i n

g , a n d c a n c r e a t e d e p l o y m e n t p a c k a g e s t h a t o n

l y u s e C l i c k O n c e a n d M S I . I t i n c l u d e s t o o l s l

i k e S e r v e r E x p l o r e r a n d i n t e g r a t i o n w i t h M i c r

o s o f t S Q L S e r v e r a l s o . W i n d o w s M o b i l e d e v e l o p

m e n t s u p p o r t w a s i n c l u d e d i n V i s u a l S t u d i o 2 0

0 5 S t a n d a r d , h o w e v e r , w i t h V i s u a l S t u d i o 2 0 0 8

, i t i s o n l y a v a i l a b l e i n P r o f e s s i o n a l a n d h i

g h e r e d i t i o n s . W i n d o w s P h o n e 7 d e v e l o p m e n t s u

p p o r t w a s a d d e d t o a l l e d i t i o n s i n V i s u a l S t u

d i o 2 0 1 0 . D e v e l o p m e n t f o r W i n d o w s M o b i l e i s n o

l o n g e r s u p p o r t e d i n V i s u a l S t u d i o 2 0 1 0 ; i t i

s s u p e r s e d e d b y W i n d o w s P h o n e 7 .

[ e d i t ]

V i s u a l S t u d i o P r e m i u m
V i s u a l S t u d i o P r e

m i u m E d i t i o n i n c l u d e s a l l o f t h e t o o l s i n V i s

u a l S t u d i o P r o f e s s i o n a l a n d a d d s a d d i t i o n a l f

u n c t i o n a l i t y s u c h a s c o d e m e t r i c s , p r o f i l i n g ,

s t a t i c c o d e a n a l y s i s , a n d d a t a b a s e u n i t t e s t

i n g . y e s

[ e d i t ]

V i s u a l S t u d i o T o o l s f o r O f f i c e
V i s u a l

S t u d i o T o o l s f o r O f f i c e i s a n S D K a n d a n a d d -

i n f o r V i s u a l S t u d i o t h a t i n c l u d e s t o o l s f o r

d e v e l o p i n g f o r t h e M i c r o s o f t O f f i c e s u i t e . P r

e v i o u s l y ( f o r V i s u a l S t u d i o . N E T 2 0 0 3 a n d V i s

u a l S t u d i o 2 0 0 5 ) i t w a s a s e p a r a t e S K U t h a t s

u p p o r t e d o n l y V i s u a l C # a n d V i s u a l B a s i c l a n g

u a g e s o r w a s i n c l u d e d i n t h e T e a m S u i t e . W i t h

V i s u a l S t u d i o 2 0 0 8 , i t i s n o l o n g e r a s e p a r a

t e S K U b u t i s i n c l u d e d w i t h P r o f e s s i o n a l a n d

h i g h e r e d i t i o n s . A s e p a r a t e r u n t i m e i s r e q u i r

e d w h e n d e p l o y i n g V S T O s o l u t i o n s .

[ e d i t ]

V i s u a l S t u d i o U l t i m a t e
V i s u a l S t u d i o U l

t i m a t e p r o v i d e s s e t o f s o f t w a r e a n d d a t a b a s e

d e v e l o p m e n t , c o l l a b o r a t i o n , m e t r i c s , a r c h i t e c

t u r e , t e s t i n g a n d r e p o r t i n g t o o l s i n a d d i t i o n

t o t h e f e a t u r e s p r o v i d e d b y V i s u a l S t u d i o P r

e m i u m . A s o f V i s u a l S t u d i o 2 0 1 0 , t h e T e a m S u i

t e e d i t i o n w a s r e n a m e d t o t h e U l t i m a t e e d i t i o

n .
[ 5 3 ]

V i s u a l S t u d i o U l t i m a t e o f f e r s a s u p e r s

e t o f t o o l s e t s b a s e d o n t h e A p p l i c a t i o n L i f e c

y c l e M a n a g e m e n t ( A L M ) r o l e i t i s b e i n g u s e d f

o r . [ e d i t ]

V i s u a l S t u d i o T e a m S y s t e m
P r i o r t o V

i s u a l S t u d i o 2 0 1 0 , V i s u a l S t u d i o T e a m S y s t e m

p r o v i d e d f o u r r o l e s p e c i f i c e d i t i o n s a r e :
[ 5 4

T e a m E x p l o r e r ( b a s i c T F S c l i e n t )

A r c h i t e c t u

r e E d i t i o n D a t a b a s e E d i t i o n D e v e l o p m e n t E d i t i o n

T h e c o m b i n e d f u n c t i o n a l i t y o f t h e f o u r T e a m S

y s t e m E d i t i o n s i s p r o v i d e d i n a T e a m S u i t e E d

i t i o n . T h e D a t a b a s e E d i t i o n , c o d e n a m e d " D a t a D

u d e " , w a s i n i t i a l l y r e l e a s e d a s a s e p a r a t e e d

i t i o n a f t e r V i s u a l S t u d i o 2 0 0 5 ' s i n i t i a l r e l e

a s e . I t i s i n c l u d e d w i t h V i s u a l S t u d i o 2 0 0 8 a

s a s e p a r a t e e d i t i o n , b u t M i c r o s o f t d i d r o l l

i t s f u n c t i o n a l i t y i n t o t h e P r e m i u m E d i t i o n w i

t h V i s u a l S t u d i o 2 0 1 0 .
[ 5 5 ]

[ e d i t ]

T e s t P r o f e s s i o n a l
V i s u a l S t u d i o T e s t P r

o f e s s i o n a l i s a n e d i t i o n w h i c h w a s i n t r o d u c e d

w i t h V i s u a l S t u d i o 2 0 1 0 . I t s f o c u s i s a i m e d

a t t h e d e d i c a t e d t e s t e r r o l e a n d i n c l u d e s s u p

p o r t f o r t h e m a n a g e m e n t o f t e s t e n v i r o n m e n t s ,

t h e a b i l i t y t o s t a r t a n d r e p o r t o n t e s t s a n d

t o c o n n e c t t o T e a m F o u n d a t i o n S e r v e r . I t d o e

s n o t i n c l u d e s u p p o r t f o r d e v e l o p m e n t o r a u t h

o r i n g o f t e s t s .
[ 4 9 ]

[ e d i t ]

E d i t i o n s f e a t u r e g r i d

Produc

Expres

Professio

Premiu

Ultimat

Test Professio [ e d i t ]

V e r s i o n h i s t o r y
P r i o r

t o V i s u a l S t u d i o V e r s i o n 4 . 0 t h e r e w e r e V i s u a

l B a s i c 3 , V i s u a l C + + , V i s u a l F o x P r o a n d S o u r

c e s S a f e a s s e p a r a t e p r o d u c t s .

Product name

Visual Studio

Visual Studio

97

Visual Studio 6.0

Visual Studio .NET (2002)

Visual Studio .NET 2003

Visual Studio 2005

Visual Studio 2008

Visual Studio 2010 /Ultimate 2010

C# and Partial Classes

.Net 2.0 provided us with new feature called partial classes. Using partial classes we can use multiple files to keep the code of same class. Yes - we can put some methods to one file and the others to another file. Although partial classes may be extremely useful they can be also used to ruin system's technical design if developers don't know what happens behind the compiler. Visual Studio uses partial classes to keep Windows and Web forms automatically generated code separately of user written code behind the forms. Let's see one very simple partial class that has two methods. The parts of this class can be also defined in same file if needed.

public partial class PartialClass { public void MethodA() { Console.WriteLine("I am A!"); } } public partial class PartialClass { public void MethodB() { Console.WriteLine("I am B!"); } }

If we try to call methods of this class we can see something like this on screen.

As we can see, IntelliSense doesn't say a thing about separation of these methods. You can see hint of extension methods if you check out one of my previuos entries Extension methods - how they look like after compiling. Let's compile this code now and let's see what has compiler done. Here is the class shown in Reflector.

As we can see there is no separation of methods after compiling - all parts are compiled together and we can see it as one class. No separation anymore! This is also prove to multi-tier arcitecture example I gave in entry titled as Behind the Compiler.
Partial Class A class defined in two or more files is called a partial class. The keyword partial is used to define the class. When working on large projects, spreading a class over separate files allows multiple programmers to work on it simultaneously. During compile time all the partial class are compiled into one type only.