By: Himanshu Poddar

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:

1. Implicitly typed local variables
2. Anonymous types
3. Extension methods
4. Object and collection initializers

1. 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[]. 
 2. 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.  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} 
 3. 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. 
4. 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) ; 

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” } ;

AJAX(ASP.Net) Implemetation

By Priyank Rach

In previous article on Ajax http://techmanthan.wordpress.com/2007/05/07/ajax/, Himanshu had discussed about the Ajax web application model, how it differs from classic web application model, Advantages & disadvantages of Ajax. In this article we will see how to start with Ajax in ASP.Net.

First you will have to download ASP.Net Ajax Extension. It can be free download from web. Now go for its installation. After the successful installation of it, you will able to see a new template in wizard of creating a new web site. It would be named as “ASP.Net Ajax Enabled Website”.

In this web site you will be able to see “Ajax Extensions” in toolbar. It has the controls like script manager, Update panel which gives Ajax benefits to your web application.

As you will be able to see there form is default loaded with script manager. It loads all necessary scripts for Ajax controls. Now you can drag the Update Panel. Update panel is the control which allows asynchronous post back to your application. Means you can refresh the controls inside the panel without refreshing the whole page.

Now as this indicate, controls within the update panel can refresh the portion covered by the panel. Similarly you can refresh the panel by control which is outside of that panel also. These can be gained using “Triggers”. In trigger also you can have the option to partially refresh the page or our convential refresh (whole page). Trigger can be fired on various events like Button click, dropdown selected index change or radio button state change etc.

This was related to creating a new Ajax enabled web site, but if you already have a web application and if you want to have Ajax features in it then you may need to create a dummy Ajax enabled application through template and copy the web.config file to your web application’s web.config file. You may need to copy only the Ajax related portion from your web.config file.

Let us know how useful you find this article…

Silverlight – Cross-Browser, Cross-Platform Plug-In

By: Himanshu Poddar 

Silverlight is a cross-browser, cross-platform plug-in for delivering the next generation of Microsoft .NET–based media experiences and rich interactive applications for the Web. Yes, Microsoft will make the Silverlight browser plug-in freely available for all supported platforms. AJAX, Visual Basic .NET, C#, Python, and Ruby and integrates with existing Web applications. Silverlight media capabilities include fast, cost-effective delivery of high-quality audio and video to all major browsers including Mozilla Firefox, Apple Safari, and Windows Internet Explorer running on Mac OS or Microsoft Windows. By using Microsoft Expression Studio and Microsoft Visual Studio, designers and developers can collaborate more effectively using the skills they have today to light up the Web of tomorrow. 

Key benefits of Silverlight include: 

1. Compelling cross-platform user experiences

Deliver media experiences and rich interactive applications (RIA) for the Web that incorporate video, animation, interactivity, and stunning user interfaces (UIs). Seamless, fast installation for users, thanks to a small, on-demand, easy-to-install plug-in that is under 2 megabyte (MB) in size and works with all leading browsers. Consistent experiences on Windows and on Mac OS without any additional installation requirements.   Create richer, more compelling Web experiences that take greater advantage of the client for increased performance. Stunning vector-based graphics, media, text, animation, and overlays enable seamless integration of graphics and effects into any existing Web application.  Enhance existing standards/AJAX-based applications with richer graphics and media and improve their performance and capabilities by using Silverlight. 

2. Flexible Programming Model with Collaboration Tools

Based on the Microsoft .NET Framework, Silverlight enables developers and designers to easily use existing skills and tools to deliver media experiences and RIAs for the Web. Choice of programming languages such as AJAX, Visual Basic .NET, C#, Python, and Ruby offers developers and designers the flexibility to use their existing skills without the need to learn a new language.   Simple integration with existing Web technologies and assets means Silverlight works with any back-end Web platform or technology. No “rip and replace” required. Silverlight integrates with your existing infrastructure and applications, including Apache and PHP, as well as with JavaScript and XHTML on the client.   Role-specific tools for both designers and developers that take advantage of Web standards and the breadth of the Microsoft .NET-connected software features. Designers will like that Expression Studio creates interactive UIs and media rich experiences, prepares media for encoding and distribution, and creates World Wide Web Consortium (W3C) standards-compliant sites by using modern XHTML, XML, XSLT, CSS, and Microsoft ASP.NET.

3. High-quality media, low-cost delivery

Unified media format scales from high definition (HD) to mobile with Windows Media Video (WMV), the Microsoft implementation of the Society of Motion Picture and Television Engineers (SMPTE) VC-1 video standard, as well as support for Windows Media Audio (WMA) and MP3 audio.   Add vector-based graphics and overlays to media with support for integration of graphics that scale to any size and broadcast-style overlays for tickers and closed captioning.  Flexible ad-insertion solutions with video and animation including the ability to deliver fluid, broadcast-style video or animated advertisements without any loss of visual fidelity or motion quality.  

4. Connected to data, servers, and services

Create mash-ups by incorporating data and services from anywhere on the Web by using Silverlight support for LINQ and LINQ-to-XML. Access data with common protocols like JSON, RSS, POX, and REST. Increase discoverability of RIA content that can be indexed and searched, thanks to the Silverlight text-based XAML format.   

Download Silverlight from: http://www.microsoft.com/silverlight/downloads.aspx

How to Use Embedded JavaScript Files in ASP.NET AJAX

By: Himanshu Poddar 

It’s pretty easy to setup a .js file in your web project with some code in it. Sometimes though the code in said file is associated with say a custom client control (something that inherits from Sys.UI.Control) that is in its own assembly (not your web project). This is how our controls are setup for our platform.  The problem is now that we have code in js files, they have to be replicated across all our web projects and that’s just no fun.  So instead we moved to having the js files embedded in our main class library.  The server controls register these files and they are then pulled out of the assembly and sent down to the client and cached.   Here’s how to set this up yourself…Add the following line as the last line in your js file:if (Sys != undefined) Sys.Application.notifyScriptLoaded(); 

This tells ASP.NET AJAX that the file is done loading.  This is needed because all embedded js files stream down in the same “file” so the end of the file isn’t necessarily the end of what’s streamed down to the client.  Unlike when you just like to a js file regularly. Now, in Visual Studio go to the properties window while your js file is selected.  Change the Build Action to Embedded Resource.  This will compile the file into the assembly as a resource.  If you open up reflector and venture through, you’ll find the js file.  Now in your server control, add this line so ASP.NET knows about the resource (and what mime type to send it down as): [assembly: WebResource("EvNet.Web.Templates.Scripts.Toolbar.js", "text/javascript")] Now anytime you add a ScriptReference to a ScriptManager, your file will be streamed down to the client.  Just specify the resource name (This is the physical file path down to the file starting at the root of your class library with slashes replaced by periods) and the assembly the resource is in and you’re done.  No need to worry about where the file is anymore.   This of course works when implementing IScriptControl.GetScriptReferences in your server control too:

public IEnumerable<ScriptReference> GetScriptReferences()
{
     return new ScriptReference[] { new ScriptReference(“EvNet.Web.Templates.Scripts.Toolbar.js”, “EvNet”) };
} 

Enjoy!