Introduction

Microsoft .Net 3.5 was released almost a year ago (November 19, 2007) and has been out long enough for any kinks in the system to have been worked out. While the 3.5 Framework was built on top of 2.0, it has some great features which make it easier to develop applications as well as facilitating a better end-user experience. Some of the enhancements to the 3.5 framework are:

• Support for LINQ
• New Data Controls
• Cleaner Coding via Language Improvements
• Built-in ASP.NET AJAX support

LINQ

One of the enhancements we are most excited about is LINQ, which stands for Language Integrated Query. LINQ allows developers to build a query dynamically not only on databases, but also on objects and XML. We prefer to use stored procedures in our development and LINQ can also be used with the procedures.

LINQ to SQL

LINQ to SQL is an Object Relational Mapping implementation which allows developers to easily model a relational database and execute queries (to include inserts and updates). LINQ makes it very easy to query the database. Below is an example which shows how easily you can pull data from the database:

Easy way to Query Data using LINQ
//Create data context for LINQ
DataContext db = new DataContext(connectionString);
Table customers = db.GetTable();
//Query database
var custs = from c in customers select c;

LINQ to Dataset

In ASP.NET 2.0, neither the DataTable nor the DataSet implement IEnumerable or IQueryable, but LINQ to DataSet treats DataTables as enumerations of DataRow Objects and lets developers query DataSets and DataTables.

New Data Controls

In ASP.NET 2.0, the GridView, DataView, and FormView all have paging built in out of the box, but it has its limitations such as having the paging interface appear detached from the actual control itself. The DataPager control offered in 3.5, addresses these limitations by allowing the paging functionality to be independent of the control and appear anywhere on the web page.

The ListView is a new control which combines the best functionality of the DataGrid (editing features) and the Repeater (templating, control over markup) controls.

Cleaner Coding and Language Improvements

Improved HTML Markup

ASP.NET has never had a good reputation for generating clean HTML. While ASP.NET 2.0 provided more control over the HTML markup generated than 1.1, some of the controls still produced the same garbage, but with the new data controls in ASP.NET 3.5, the developer has more control over the HTML that is rendered which is a great thing for the end-users.

Automatic Properties

This improvement is best explained visually. Below is a nice “before and after” example but basically this would be an immense time saver especially when dealing in migration issues when many “supporting” methods and properties need to be re- created to facilitate platform migration.

In 2.0, the developer needed to declare a private property and then set Getters and Setters to access that property as in the example below:

Properties in the .NET 2.0 Framework
public string
{
get { return _address; }
set { _address = value; }
}

In 3.5, the C# compiler creates the Getters and Setters and the private field automatically. This is just an obvious time saver and makes code much cleaner for review and maintenance.

Automatic Properties in the .NET 3.5 Framework
public string Address {get; set;}

Object Initializers

In 2.0, when developers instantiate an object with a default constructor, they need to call the constructor, and assign values individually to the object’s properties:

Instantiating a class in the .NET 2.0 Framework
Employee emp = new Employee();
emp.FirstName = “Sara”;
emp.LastName = “Smith”;
emp.EmployeeID = “SI-12345”;

In 3.5, the C# compiler automatically generates the appropriate property setter code(s):

Object Initializers in the .NET 3.5 Framework
Employee emp = new Employee { FirstName=”Sara”, LastName=”Smith”};

Collection Initializers

When developers need to add a series of objects to a Collection in 2.0, it is necessary to add each object one by one to the collection. In 3.5 however, the C# compiler supports collection initializers which allows us to add as many objects as we want during the initialization process rather than adding them individually:

Collection Initializers in the .NET 3.5 Framework
List employees = new List {
new Employee { FirstName=”Sara”, LastName=”Smith”},
new Employee { FirstName=”Ben”, LastName=”Jones”}
};

Type Inference

This is something developers are used to seeing in JavaScript, but in 3.5, the C# compiler can infer what type of variable is being created simply by looking at the value being assigned. This type of intuitive functionality becomes a great “on the fly” feature

Type Inference in the .NET 3.5 Framework
var message = “Choose .NET 3.5!”;

Built-In ASP.Net AJAX

AJAX provides end-users with a rich, interactive, user-experience. .NET 2.0 required a separate download to work with ASP.NET AJAX, but 3.5 has this functionality built-in along with extra improvements. Visual Studio 2008 is optimized to work with the 3.5 framework.

Conclusion

As developers, the .Net 3.5 Framework provides us with a more concise and efficient way to work with objects and collections as well as working with data. With new controls like the ListView and DataPager, we have complete control over the markup sent to the browser, while still providing data paging and data manipulation capabilities. Using .Net 3.5 instead of 2.0 will allow us to build better applications, and build them quickly thus making the foundation for future releases and maintenance much more accommodating. .NET 3.5 has been thoroughly tested and is recommended for any new projects.

For projects still in their infancy and their future is not set in stone, taking the pro-active leap to incorporate a technology whose future is virtually guaranteed is the type of forward thinking decision which can only benefit all parties concerned. Since much of the product support is provided by the development community, as developers continue to move to 3.5, support for 2.0 will dwindle. We recommend using it over 2.0 because in the long run an application written in 3.5 will require less rewrites and make for a better final product for the user.