Topic: Introducing Microsoft Silverlight
Date: Saturday, July 28th, 2007
Location: STIC (Queen Rania Technology Center, Rabiah)
Time: 6:00 pm – 8:00 pm
Speaker: Bander ALSHARFI [MVP]

Bander is a Technical Consultant and has been a Microsoft Most Valuable Professional (MVP) for 2 years now. He is also the President of JorDev. So make sure not to miss out on next week’s Community Night, which promises to be a learning experience to remember!

For more information or directions to STIC please contact:
Ayman Farouk @ 0795727344

You’ll be able to check out some of the winning applications from the recent Software Design national finals in Europe, the Middle East and Africa and be able to hang out and chat online with the teams and students in Second Life.

And in addition they have a whole host of great bands, DJs and artists to entertain you including Natalie Moody, the most celebrated singer currently performing in Second Life.

You can teleport directly to the Microsoft Island in Second Life from 20:00 CET June 28 2007 to join the hottest party in Second Life

Contents

• Introduction
• New Language Features
• Automatic Properties
• Local Variable Type Inference
• Object Initializers & Collection Initializers
• Anonymous Types
• Lambda Expressions
• Extension Methods
• Query Syntax
• Final Notes
• References & Resources

Introduction

This article is about LINQ which I think is one of the most exciting features in Orcas. LINQ makes the concept of querying a first-class programming concept in .NET. The data to be queried can take the form of XML (LINQ to XML), databases (LINQ-enabled ADO.NET: LINQ to SQL, LINQ to Dataset and LINQ to Entities) and objects (LINQ to Objects). LINQ is also highly extensible and allows you to build custom LINQ enabled data providers (e.g.: LINQ to Amazon, LINQ to NHibernate, LINQ to LDAP).

I will discuss some of the new language features and improvements that are introduced in C# 3.0, and it is those features that enable the full power of LINQ which makes it possible to write something like this:

Remember that if you want to play around with LINQ or try the examples yourself, you will need to download Visual Studio Orcas Beta 1.
In case you don’t want to download the whole VS, you can check the LINQ Preview (May 2006 CTP)
which runs on top of VS 2005 (there are a few changes in Beta 1 from the way
LINQ worked in the May CTP).

New Language Features

I/ Automatic Properties

The above code simply defining a class with basic properties. Now with the new C# compiler in Orcas, we can write a shorter cleaner version using Automatic Properties which automatically generates the private fields with get/set operations :

The code above is even more readable and less verbose.
Note that this feature has nothing to do with LINQ, I just thought it would be appropriate to list it with the other new language features.

II/ Local Variable Type Inference

With this feature, the type of the local variable being declared is inferred from the expression used to initialize the variable. This is achieved using the var keyword (familiar to those who works with scripting language but actually is quite different). It allows us to write the following code:

The compiler would generate the same IL as if we compiled:

Note that there is no un-typed variable reference nor late-binding happening, instead the compiler is inferring and declaring the type of the variable from the right-hand side of the assignment, thus the var keyword is generating a strongly typed variable reference.

III/ Object Initializers & Collection Initializers

Lets use the same Point class defined earlier, an suppose we want to define an instance of this class. We will have to create the object and start setting its properties, the code would look like this:

This could be rewritten using Objects Initializers and combined into:

This feature can also be used with collection. Take a look at this example:

Note that the compiler will generate a long hand code equivalent to the above one. It makes calls to the Add() method to add elements to the collection one at a time.

IV/ Anonymous Types

This language feature enable us to define inline types without having to explicitly define a class declaration for this type. In other words, imagine we want to use a Point object without defining the class Point (it would be anonymous). We will use the same object initializer syntax discussed earlier but without the type name:

Inside Orcas you will have full intellisense support. So when you use the variable p you will get a list of properties this anonymous type has.

V/ Lambda Expressions

C# 2.0 introduced anonymous methods, which allow code blocks to be written “in-line” where delegate values are expected. While anonymous methods provide the power of functional programming languages, the syntax is rather verbose. Lambda expressions provide a more concise, functional syntax for writing anonymous methods. A lambda expression is written as a parameter list (can be implicitly typed), followed by the => token, followed by an expression or a statement block.

As an example lets define a delegate type MyDeleg as:

we can then write using anonymous methods:

Or we can use the new lambda expressions to write:

VI/ Extension Methods

Extension methods make it possible to extend existing types and constructed types with additional methods, without having to derive from it or recompile the original type. So instead of writing helper methods for objects they become part of that object itself.

As an example, suppose we want to check a string to see if it is a valid email address. We would do this by writing a function that takes a string as an argument and returns a true/false. With Extension Methods we can do the following:

We defined a static class with a static method containing the extension method. Note how the static method above has a this keyword before the first parameter argument of type string. This tells the compiler that this particular Extension Method should be added to objects of type string. And then we can call it from the string as a member function:

It is worth mentioning that LINQ syntax makes use of built-in Extension Methods (e.g.: where(), orderby(), select(), sum(), average() and many more) that reside in the new System.Linq namespace in Orcas and define standard query operators that can be used against relational databases, XML and any .NET objects that implement IEnumerable<T>.

VII/ Query Syntax

Query expressions provide a language integrated syntax for queries that is similar to relational and hierarchical query languages such as SQL and XQuery. It is a shorthand for writing queries using the LINQ query operators (i.e. from…where…select). Visual Studio provides full intellisense and compile-time checking support for query syntax.
When the C# compiler encounters a query syntax expression it actually transforms it into into explicit method invocation code that uses Extension Methods and Lambda Expressions.

To explain this, let me give an example:

The above code is equivalent to the following:

The advantage of using Query Syntax is that the code is easier and more readable.
Also note that a query expression begins with a from clause and ends with either a select or group clause.

Final Notes

Most of the language features introduced in C# v3.0 that we saw (such as variable type inference, object initializers, anonymous types and lambda expressions) are only “compiler tricks”/”syntactic sugar” that means that the IL the compiler generates is the same as the long code version, therefore they are independent from the framework (NetFX) and runtime (CLR). However, they do need some framework support and specifically the “green bits” (.NET Framework v3.5) System.Core.dll assembly. This is why extension methods which in fact works at compile time (syntactic sugar) still rely on System.Runtime.CompilerServices.ExtensionAttribute introduced in System.Core.dll
On the other hand, query expressions syntax is just a mapping to the extension methods implementations that resides in System.Linq, System.Data.Linq and System.Xml.Linq namespaces.

References & Resources

• “New Orcas Language Feature” Series by Scott Guthrie: Great series explaining LINQ
• LINQ Resources: Blog entries by Daniel Moth
• MSDN Magazine (June 2007): An article on C# 3.0 and LINQ
• Visual Studio Orcas Samples: C#/VB LINQ Samples for Beta 1
• Future Versions: C# 3.0
• The LINQ Project: Home of the LINQ Project

Topic: Building Desktop Applications using Microsoft Expression Blend
Date: Saturday, June 16, 2007
Location: STIC (Queen Rania Technology Center, Rabiah)
Time: 6:00 pm – 8:00 pm
Speaker: Ayman Farouk

Also they have free Donuts and Coffee from Dunkin’ Donuts for everyone!

I noticed that this version is not very stable, so you it may crash (it is a beta version after all), but the most important thing is that web developers can test their sites in Safari without buying a Mac.. Overall I’m not switching away from Firefox2.

One last thing, it appears that Silverlight doesn’t work on Safari for Windows although it seems to recognize the plug-in, I guess Microsoft will fix this in the next release of Silverlight (or may be not!!).

The Microsoft code name “Acropolis” Community Technology Preview 1 is a set of components and tools that make it easier for developers to build and manage modular, business focused, client .NET applications. Acropolis is part of the “.NET Client Futures” wave of releases, our preview of upcoming technologies for Windows client development.Acropolis builds on the rich capabilities of Microsoft Windows and the .NET Framework, including Windows Presentation Foundation (WPF), by providing tools and pre-built components that help developers quickly assemble applications from loosely-coupled parts and services. With Acropolis you will be able to:

• Quickly create WPF enabled user experiences for your client applications.
• Build client applications from reusable, connectable, modules that allow you to easily create complex, business-focused applications in less time.
• Integrate and host your modules in applications such as Microsoft Office, or quickly build stand-alone client interfaces.
• Change the look and feel of your application quickly using built-in themes, or custom designs using XAML.
• Add features such as workflow navigation and user-specific views with minimal coding.
• Manage, update, and deploy your application modules quickly and easily.

Check it out on http://windowsclient.net/Acropolis/
Download Acropolis CTP & Documentation
Also check out this Introducing Acropolis Video

iPhone combines three amazing products — a revolutionary mobile phone, a widescreen iPod with touch controls, and a breakthrough Internet communications device with desktop-class email, web browsing, maps, and searching — into one small and lightweight handheld device. iPhone also introduces an entirely new user interface based on a large multi-touch display and pioneering new software, letting you control everything with just your fingers. So it ushers in an era of software power and sophistication never before seen in a mobile device, completely redefining what you can do on a mobile phone.

A few days ago, Microsoft announced a new
product called “Microsoft Surface”.  If you haven’t checked out the
online videos of it yet, I highly recommend watching them here.  It is one of those products that looks and feels like it comes from a science fiction movie – but it is actually real.
Popular Mechanics also has a good article (including their own video) of how it works that you can read and watch online here.

To keep it short and simple, Popfly makes it easy for non-devs to create web sites, mashups, and more.
Drag, drag, click – you’ve got a Flikr + Virtual Earth mashup.
You can even point and click your way to a Vista Gadget.

I’ve got my own page at http://www.popfly.ms/users/amroamroamro but i’m still testing…

Start on http://www.popfly.com/ (You will need an invitation)

Google Gears (BETA) is an open source browser extension that enables web applications to provide offline functionality using following JavaScript APIs:

• LocalServer: Store and serve application resources locally
• Database: Store data locally in a fully-searchable relational database
• WorkerPool: Run asynchronous Javascript to improve application responsiveness