.Net 3.0

New in Visual Studio 2008

Gaurav Taneja — Wed, 02 Apr 2008 04:27:16 GMT

What is new in Visual Studio 2008

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 "Multi-Targeting". 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 IDE called "Manage Styles". This shows all of the CSS style sheets for the page.

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 drop-down 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 Intellisense features 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 client-side JavaScript breakpoints directly within your server-side .aspx and .master source files.

We can now set both client-side JavaScript breakpoints and VB/C# server-side 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 features included in Microsoft Visual Studio 2008.

Project Designer

Windows Presentation Foundation (WPF) applications have been added to Visual Studio 2008. There are four WPF project types:

WinFX Windows Application
WinFX Web Browser Application
WinFX Custom Control Library
WinFX 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 features to incorporate data into applications:

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 server-side 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 provides 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 the PDF format.

Features in .Net 3.0

Gaurav Taneja — Wed, 02 Apr 2008 04:24:33 GMT

A Preview of What is New in C# 3.0

On the heels of the Visual Studio 2005 and C# 2.0 releases, Microsoft has
given a sneak preview of what to expect in the version after the next: C#
3.0. Even though C# 3.0 is not even standardized yet, Microsoft provided
a preview release at its Professional Developers Conference (PDC) in
September so eager developers could try out some of the expected features.
This article discusses the following major new enhancements expected in C#
3.0:

Implicitly typed local variables
Anonymous types
Extension methods
Object and collection initializers
Lambda expressions
Query expressions
Expression Trees

Implicitly Typed Local Variables

C# 3.0 introduces a new keyword called "var". Var allows you to declare a
new variable, whose type is implicitly inferred from the expression used to
initialize the variable. In other words, the following is valid syntax in C# 3.0:

var i = 1;

The preceding line initializes the variable i to value 1 and gives it the type of
integer. Note that "i" is strongly typed to an integer—it is not an object or a VB6
variant, nor does it carry the overhead of an object or a variant.

To ensure the strongly typed nature of the variable that is declared with the var
keyword, C# 3.0 requires that you put the assignment (initializer) on the same
line as the declaration (declarator). Also, the initializer has to be an expression,
not an object or collection initializer, and it cannot be null. If multiple declarators
exist on the same variable, they must all evaluate to the same type at compile time.

Implicitly typed arrays, on the other hand, are possible using a slightly different
syntax, as shown below:

var intArr = new[] {1,2,3,4} ;

The above line of code would end up declaring intArr as int[].

The var keyword allows you to refer to instances of anonymous types (described
in the next section) and yet the instances are statically typed. So, when you create
instances of a class that contain an arbitrary set of data, you don't need to predefine
a class to both hold that structure and be able to hold that data in a statically typed
variable.

Anonymous Types

C# 3.0 gives you the flexibility to create an instance of a class without having to write
code for the class beforehand. So, you now can write code as shown below:

new {hair="black", skin="green", teethCount=64}

The preceding line of code, with the help of the "new" keyword, gives you a new type
that has three properties: hair, skin, and teethCount. Behind the scenes, the C#
compiler would create a class that looks as follows:

class __Anonymous1
{
   private string _hair = "black";
   private string _skin = "green";
   private int _teeth   = 64;
   public string hair {get { return _hair; } set { _hair = value; }}
   public string skin {get { return _skin; } set { _skin = value; }}
   public int teeth {get { return _teeth; } set { _teeth = value; }}
}

In fact, if another anonymous type that specified the same sequence of names and
types were created, the compiler would be smart enough to create only a single
anonymous type for both instances to use. Also, because the instances are, as you
may have guessed, simply instances of the same class, they can be exchanged
because the types are really the same.

Now you have a class, but you still need something to hold an instance of the above
class. This is where the "var" keyword comes in handy; it lets you hold a statically
typed instance of the above instance of the anonymous type. Here is a rather simple
and easy use of an anonymous type:

var frankenstein = new {hair="black", skin="green", teethCount=64}

Extension Methods

Extension methods enable you to extend various types with additional static methods.
However, they are quite limited and should be used as a last resort—only where
instance methods are insufficient.

Extension methods can be declared only in static classes and are identified by the
keyword "this" as a modifier on the first parameter of the method. The following is
an example of a valid extension method:

public static int ToInt32(this string s)
{
   return Convert.ToInt32(s) ;
}

If the static class that contains the above method is imported using the "using" keyword
, the ToInt32 method will appear in existing types (albeit in lower precedence to existing
instance methods), and you will be able to compile and execute code that looks as follows:

string s = "1";
int i    = s.ToInt32();

This allows you to take advantage of the extensible nature of various built-in or defined
types and add newer methods to them.

Object and Collection Initializers

C# 3.0 is expected to allow you to include an initializer that specifies the initial values
of the members of a newly created object or collection. This enables you to combine
declaration and initialization in one step.

For instance, if you defined a CoOrdinate class as follows:

public class CoOrdinate
{
   public int x ;
   public int y;
}

You then could declare and initialize a CoOrdinate object using an object initializer,
like this:

var myCoOrd = new CoOrdinate{ x = 0, y= 0} ;

The above code may have made you raise your eyebrows and ask, "Why not just write
the following:"

var myCoOrd = new CoOrdinate(0, 0) ;

Note: I never declared a constructor that accepted two parameters in my class.
In fact, initializing the object using an object initializer essentially is equivalent to
calling a parameterless (default) constructor of the CoOrdinate object and then assigning the relevant values.

Similarly, you should easily be able to give values to collections in a rather concise and
compact manner in C# 3.0. For instance, the following C# 2.0 code:

List<string> animals = new List<string>();
animals.Add("monkey");
animals.Add("donkey");
animals.Add("cow");
animals.Add("dog");
animals.Add("cat");

Now can be shortened to simply:

List<string> animals = new List<string> {
   "monkey", "donkey", "cow", "dog", "cat" } ;



Lambda Expressions: The Espresso of Anonymous Methods
C# 1.x allowed you to write code blocks in methods, which you could invoke
easily using delegates. Delegates are definitely useful, and they are used
throughout the framework, but in many instances you had to declare a method
or a class just to use one. Thus, to give you an easier and more concise way
 of writing code, C# 2.0 allowed you to replace standard calls to delegates 
with anonymous methods. The following code may have been written in .NET 1.1
or earlier:
 
class Program
{
   delegate void DemoDelegate();
   static void Main(string[] args)
   {
      DemoDelegate myDelegate = new DemoDelegate(SayHi);
      myDelegate(); 
   }
   void SayHi()
   {
      Console.Writeline("Hiya!!") ;
   }
}

            

            In C# 2.0, using anonymous methods, you could rewrite the code as follows:

            

            
            

            class Program
{
   delegate void DemoDelegate();
   static void Main(string[] args)
   {
      DemoDelegate myDelegate = delegate()
         {
            Console.Writeline("Hiya!!");
         };
      myDelegate();
   }
}

            

            Whereas anonymous methods are a step above method-based delegate invocation,

            

            lambda expressions allow you to write anonymous methods in a more concise, 

            

            functional syntax.

            

            

            

            
            

             
            

             
            

            You can write a lambda expression as a parameter list, followed by the =>

            

            token,followed by an expression or statement block. The above code can

            

            now be replaced with the following code:
            

            class Program
{
   delegate void DemoDelegate();
   static void Main(string[] args)
   {
      DemoDelegate myDelegate = () => Console.WriteLine("Hiya!!") ;
      myDelegate();
   }
}

            

            Although Lambda expressions may appear to be simply a more concise way of

            

            writing anonymous methods, in reality they also are a functional superset

            

            of anonymous methods. Specifically, Lambda expressions offer the following 

            

            additional functionality:
            

            

                They permit parameter types to be inferred. Anonymous methods will 

                

                require you to explicitly state each and every type. 
                

                They can hold either query expressions (described in the following 

                

                section) or C# statements. 
                

                They can be treated as data using expression trees (described later).

                

                This cannot be done using Anonymous methods. 
                

            
            

             
            

            Query Expressions
            

             
            

            Even though further enhancements may be introduced in the coming months

            

            as C# 3.0 matures, the new features described in the preceding sections 

            

            make it a lot easier to work with data inside C# in general. This feature,

            

            also known as LINQ (Language Integrated Query), allows you to write 

            

            SQL-like syntax in C#.For instance, you may have a class that describes your

            

            data as follows:
            

             
            

            public class CoOrdinate
            

            

            

            {

            

            public int x ;

            

            public int y;

            

            }

            

            You now could easily declare the logical equivalent of a database table 

            

            inside C# as follows:
            

            // Use Object and collection initializers
List<CoOrdinate> coords = ... ;

            

            And now that you have your data as a collection that implements 

            

            IEnumerable<T>, you easily can query this data as follows:

            

            
            

            var filteredCoords =
   from c in coords
   where x == 1
   select (c.x, c.y)

            

            In the SQL-like syntax above, "from", "where", and "select" are query 

            

            expressions that take advantage of C# 3.0 features such as anonymous 

            

            types, extension methods, implicit typed local variables, and so forth.

            

            This way, you can leverage SQL-like syntax and work with disconnected 

            

            data easily.Each query expression is actually translated into a C#-like

            

            invocation behind the scenes. For instance, the following:
            

            

            

             
            

            where x == 1
            

            Translates to this:

            

            
            

            coords.where(c => c.x == 1)
            

            As you can see, the above looks an awful lot like a lambda expression 

            

            and extension method. C# 3.0 has many other query expressions and rules 

            

            that surround them.
            

            

            

             
            

             
            

             
            

            Expression Trees
            

             
            

            C# 3.0 includes a new type that allows expressions to be treated as data

            

            at runtime.This type, System.Expressions.Expression<T>, is simply an 

            

            in-memory representation of a lambda expression. The end result is that 

            

            your code can modify and inspect lambda expressions at runtime.
            

            

            

            

            

             
            

             
            

            

            

             
            

            The following is an example of an expression tree:
            

            Expression<DemoDelegate> filter = () => Console.WriteLine("Hiya!!") ;
            

            With the above expression tree setup, you easily can inspect the contents 

            

            of the tree by using various properties on the filter variable.
            

             
            

            One to Grow On
            

             
            

            C# 3.0 offers incredible new features that make your work as an application 

            

            developer and architect a lot easier, and yet it remains a programming 

            

            language that lends itself to stricter and cleaner architecture.
            

             
            

            C# 3.0 is in its infancy right now and it will mature in the coming months,

            

            but given the sizable impact its changes will have on the surrounding .NET 

            

            Framework, its recommended architecture, and design patterns, definitely 

            

            keep your eye on it.