One of the things my company does on a monthly basis is hold technology meetings to allow the consultants to get together and discuss the latest technologies. Having just come back from PDC there is definitely two technologies that stick out: LINQ and Atlas. In this month's meeting I plan on sharing what I have learned about LINQ. As I dove into some of the new featuresets in the technology preview I began to come to the conclusion that a lot of what I love about javascript is being added to .NET. Think I'm crazy? Well here is just a few examples.
Inferred types
C# gets a new construct called var. No, it does not stand for variant for those of you familiar with VB. It means that the type of the variable is decided based off of the value that is set.
For example
var i = 5; //an int is assumed
var s = "a"; //a string is assumed
While javascript only has a few inherent types (Number, Date, String, and Object) this has always been the way variables are assigned a type, in fact, the syntax is exactly the same as C#.
Dynamic Identifiers
A javascript object that has a property can be accessed in two ways.
myobject.FirstName;
or
myobject["FirstName"];
The later way you may note is a string (and could be a variable as well). This type of functionality allows for many interesting and powerful use cases that is not easily accomplished in .NET.
Well the equivalent in VB.NET is now
myobject.("FirstName") 'Note the .(
Extension Methods
For those of you who don't know, javascript is more of an emulation language than a real language. It can emulate many things, including objects and inheritance (even multiple inheritance). To define an object in javascript you would code the following.
function customer(ID) //Constructor
{
this.id = ID;
this.FirstName = '';
this.LastName = '';
}
To instantiate the object you would write
var oCustomer = new customer(1); //note the inferred type
Lets say that this object is in a script libary that is outside of your control. Lets also say that you feel there should be another method on this object to get the full name. You could write your own script file containing the following code.
customer.prototype.GetFullName = function()
{
return this.FirstName + ' ' + this.LastName;
}
By importing this script library into your page you could now invoke a method that extends the original object (hence Extension method).
oCustomer.GetFullName();
You may be wondering what this has to do with .NET. Well most of the magic that LINQ brings to the framework is accomplished through something called an Extension Method. What They have done is allow for any object to be extended by simply importing a namespace that contains an extension method. (Hopefully you see the similarity to JS). Most of their samples involve extending the base IEnumerable type which most collections already implement. Lets say we have the following C# code.
using System; //Needed to make LINQ work
using System.Query; //Needed to make LINQ work
namespace CountEx
{
public static class MySample
{
public static int MyCount(this System.Collections.IEnumerable source)
{
int i = 100;
foreach (object item in source)
i++;
return i;
}
}
}
If I have a program that contains any collection (i.e. ArrayList) I can now extend the object by simply importing (using) the CountEx namespace.
using System; //Needed to make LINQ work
using System.Query; //Needed to make LINQ work
using CountEx; //Import Extended Method(s)
static void Main()
{
ArrayList oArr = new ArrayList();
Console.WriteLine(oArr.MyCount());
}
Note: When working with the samples and incorrect documentation included, it took me some time to distinguish the difference between IEnumerable and IEnumerable<T>. This is mainly because these two interfaces reside in different namespaces. If you are planning on playing with the LINQ preview make sure you undersand the difference between these interfaces (i.e. IEnumerable is used in "old" collection objects whereas IEnumerable<T> is used in the new collections).
These are just a few similarities that I have seen and have time to mention. Object Initializers have similarities with JSON, the ASP like <% %> syntax has similarities with the javascript eval, and things like closures will now be possible in .NET. One thing to note is that the .NET implementation does not carry the bad baggage that javascript does. All the stuff is type checked and will generate meaningful compile time errors (eventually).
I should mention that I have been a VB programmer from the start. When I started experimenting in javascript I was amazed at what I could do, only I did not have formal terms to call them. I found it really interesting to listen to Anders Hejlsberg at PDC explain that javascript has its origins in languages like LISP/Scheme and not really java, and that these types of constructs have been there for some time.
The .NET framework is just now starting to adopt these methodologies. I find it interesting that the same time MS is focusing on this for the .NET framework they are also working on Atlas and making the support for Javascript better in VS.NET.