knom's developer corner : Visual Studio 2008

LINQ-To-Everywhere – List of LINQ Providers

knom — Mon, 27 Apr 2009 12:23:05 GMT

This weekend I’ve built a small application, which queries the “Simpsons” seasons guide data and updates the filenames/descriptions. To do this I needed to query a CSV file. While searching for a LINQ to CSV file implementation I’ve found an interesting list of LINQ Providers provider by MVP Charlie Calvert.

LINQ to CSV

LINQ to Amazon

LINQ to Active Directory

LINQ to Bindable Sources (SyncLINQ)

LINQ to C# project

LINQ to Continuous Data (CLinq)

LINQ to CRM

LINQ To Geo - Language Integrated Query for Geospatial Data

LINQ to Excel

LINQ to Expressions (MetaLinq)

LINQ Extender (Toolkit for building LINQ Providers)

LINQ to Flickr

LINQ to Google

LINQ to Indexes (LINQ and i40)

LINQ to IQueryable (Matt Warren on Providers)

LINQ to Metaweb(freebase)

LINQ to MySQL, Oracle and PostgreSql (DbLinq)

LINQ to NCover

LINQ to Opf3

LINQ to Parallel (PLINQ)

Slides and Demos from BigDays 2009 are online!

knom — Mon, 23 Mar 2009 00:22:00 GMT

These days I'm travelling around austria with our biggest developer & IT Pro event Big>Days 2009!

This year's theme was "packen wir's an" - translated "let's get to work"!

Accompanying the theme we built a multi-tier application with .NET 3.5 and Silverlight called "Rent-A-Worker"!

You can download the sources at http://www.codeplex.com/BigDays09/!

If you're interested in the slides of my four sessoins, feel free to get them here

Upgrade TFS 2008 Workgroup Edition to Standard Edition

knom — Mon, 09 Feb 2009 19:46:33 GMT

I’ve had a little playground TFS 2008 installation for a while for use with some “pet-projects”. I used TFS 2008 Workgroup Edition for this, as this is already part of MSDN subscription package. This edition works the same as the full one, but is limited to 5 users.

Now that I needed more user accounts for a larger project I tried to upgrade to TFS 2008 Standard Edition.

This seems to be pretty easy:

1.) Open Add/Remove Programs in control panel.
2.) Select “Visual Studio 2008 Team System – Team Foundation Server” and choose “Change”.

3.) At the TFS setup, select “Upgrade” and enter the new serial number.

4.) Finished.

(Summarized from Brian Harry's Weblog)

This is great, but unfortunately the serial number boxes are disabled / grayed out on my system (and all others as well) :-)

So it’s harder than expected…

But.. thanks to a thread in the MSDN Forums I found a way to change the serial number.

All you need to do (as step 0.) is open setup.sdb in
"Program Files\Microsoft Visual Studio 2008 Team Foundation Server\Microsoft Visual Studio 2008 Team Foundation Server - ENU"
and change the [Product Key] value (skip the dashes).

Voila!

WPF Webcast - New Year's resolutions

knom — Wed, 07 Jan 2009 13:34:39 GMT

I’ve a lot of New Year’s resolutions for 2009 :-) One of them is to blog more often (we’ll see how this works..) another is to do a series of webcasts around WPF.
We’re starting with our first WPF webcast on Friday, January 9th at 10am with an overview over WPF and XAML.

Topics we’ll cover:
*) Why a new UI framework
*) What tools, frameworks, .. do we need for WPF?
*) What is XAML, what is it’s syntax.

>> Register now at the Webcast Website

WPF Day in Dublin

knom — Wed, 17 Dec 2008 17:56:00 GMT

Last week I was in Dublin doing two sessions on WPF for Microsoft Ireland.

They did a "Client-UI Day", where they featured WPF and Silverlight.

The first session was given by the Irish Developer Evangelist Ronan Geraghty, who did an introduction to the Microsoft Client Platform, showing the differences between AJAX, Silverlight, WPF and when to use what.

Next I did a WPF for beginners session, where I showed all the details of XAML, Databinding, Styles, Templates, etc...

Afterwards my colleague Martha Rother from Ireland did a session on Silverlight.

Last but not least I showed how to leverage WPF and Composite WPF Guidance ("Prism") to build business applications.

Overall a really nice event, with around 80 attendees and a lot of interesting ideas and feedback on the Microsoft Client Continuum.

If you're interested in my slides on WPF Introduction and Composite WPF, find them here:

WPF Sessions.zip

Going home from Ireland I took two flights via London.. What a bad choice.. I drove to Dublin Airport at 6:30 am, arriving in Vienna at 5pm :-) Almost half a day of traveling and waiting...

Using the VS Templates for Composite-WPF-Guidance

knom — Wed, 22 Oct 2008 18:28:28 GMT

This is about using the templates for a new project.

First of all you need to download the templates and install them from the links below.

Download the ZIP-File containing sources and built binaries here.

See the post on how to install the binaries or build the sources here.

Let's start setting up our new project:

Create a new root folder for your solution (e.g. C:\temp\DemoClient\).
Within the root folder create a Libraries (or other named) folder for the P&P assemblies, like Unity and Composite App Library.
Copy the necessary assemblies to the Libraries folder (build the Composite Application Guidance projects to get them):
Now open Visual Studio choose "File - New Project" and select "Composite WPF Solution" from "Visual C# > Composite App Guidance".
Enter the name of your overall solution (like "CompositeClient") and specify the root folder created before.

Important: "Create directory for solution" should be unchecked, to automatically insert references later. Press "OK" then.
A new wizard pops up:

You can now change your root namespace or the namespaces for the shell and infrastructure project.
It's important to specify the relative path to the Library folder (starting from the specified root folder). In this case it's Libraries. After that, the new solution is going to be created.
Select "Add New Project" on the Modules folder.
Choose "Composite WPF Module" and enter the Modules path of the solution as the location
(e.g. C:\temp\DemoClient\CompositeClient\Modules\).
Enter a name for the module (e.g. CompositeClient.Modules.Foo).
The New Module Wizard pops up.

Press Finish (or change the IModule class name or module namespace).
A new project is created, containing an IModule implementation and a module controller class.
When choosing Add-New Item, you can add a new Composite WPF View and Presentation Model to the module.

Enter a name for the new items (not containing "View" or any other types). Just use "DoFoo" for instance.
The New View Wizard pops up, letting you choose the names for view, presentation model and interfaces.
Choose Finish.
A new subfolder is created, containing the files necessary for the view.

Note 1: When using the item template for the first time, you might get a dialog requesting to trust the template. Press trust there!

Note 2: The wizards say "Composite WPF Guidance Contrib", as I hope to get into the Contrib project with this ;-)

Visual Studio Templates - Composite WPF Guidance - Installation

knom — Wed, 22 Oct 2008 18:25:10 GMT

First of all download the template package from here.
For an overview of the functionality see another post.

Extract the zip file and move to the Bin folder.

In the bin folder three files are located:

install.bat does all the work to setup the templates (run the .VSI and add the .DLL to the global assembly cache)
CompositeTemplateWizards.dll contains the Wizards used from the project templates. This assembly must be installed into the GAC.
Templates.vsi is VSI installer package with all the templates (need the wizard assembly in the GAC).

If you prefer building the code by yourself have a look into the Source folder. What you have to do is build the C# project, and zip all the project templates. Then zip all three zip-files together with the .VSContent file to a .ZIP archive and rename it to .VSI.

Have fun :-)

And see this post for usage of the templates.

Team System + Gadgets + Outlook

knom — Wed, 15 Oct 2008 16:44:12 GMT

If you're using Team Foundation Server, these utilities might be useful for your everyday's work:

*) WorkItem Outlook Plugin

Create a workitem directly out of the mail view.

Download

*) Team System Build Monitor Gadget

Always be aware of the status of your TFS builds in the sidebar.

Download

*) Two useful WorkItem Gadgets

Get the state of your open workitems, or the work items per project.

Download

A Must Have Tool - VS 2008 Snippet Designer

knom — Thu, 09 Oct 2008 14:23:25 GMT

Mathew Manela from the Online Tools Group at Microsoft has written a really cool tool, which adds a feature missing for a long time in Visual Studio: Code Snippet Creation.

The tool, which is available at http://www.codeplex.com/SnippetDesigner allows a bunch of functionality for working with custom snippets.

Add a new .SNIPPET file via File-New-File--Code Snippet File
Export existing code into a snippet:
Simply right click on the selected code and press "Export as Snippet".
Edit snippets (set placeholders, etc..)
The editor is opened after exporting something.
Additionally you can later on open .snippet files out of the "Snippet Explorer" (see below).
The Snippet Explorer
Go to "View - Other Windows - Snippet Explorer" to search for existing snippets.

The snippets you build are stored under the path %USERPROFILE%\Documents\Visual Studio 2008\Code Snippets\Visual C#\My Code Snippets.

You can either insert them via the context menu "Insert Code Snippet"
(Ctrl+K-X) or you can assign a short-phrase (shortcut).

With the shortcut you just need to type e.g. prop<tab><tab> to insert a property code snippet.

You can set the shortcut (and other things as well) in the property window of the snippet editor.

.NET Roadshow - Demo Solution

knom — Fri, 19 Sep 2008 17:07:00 GMT

The demo solution from our .NET Beginners Roadshow is no ready for download for attendees and all others.

The scenario is event management.

The solution consists of 4 parts:

*) Data Access layer using ADO.NET Entity Framework

*) Business Logic Service hosted as a WCF service.

*) Web Site, written in ASP.NET, which allows attendees to register and view their events, including a

*) Silverlight Web Control

*) Desktop Client using WPF, for managing the events.

Here some screen shots:

Feel free to have a look at the source code here.

On the road - The .NET Beginners Road Show

knom — Tue, 12 Aug 2008 14:41:31 GMT

From September 16th to 25th I'll be on the road with the .NET Beginners Road Show together with my colleague Mario.

Our goal is to target newcomers to .NET and show them, how to implement a simple solution over the three tiers.

Target audience are VB6 guys, as well as Java, C++ or Delphi people.

As the schedule is pretty tight, we expect the attendees to know the principles of object oriented programming.

Andreas has produced a series of webcasts, called "Get the basics", which introduce OOP in .NET for those who don't know (so they can also attend).

The videos are 15 minutes each (at a maximum) and are going to be published before the event (obviously :-)).

The roadshow stops in Dornbirn, Innsbruck, Salzburg, Linz, Graz and Wien.

So pretty much everywhere over Austria.

It's going to be a tough week travelling around for us two - as we have events every day and have to move on to the next stop in the evening ;-)

The attendee fee is 85 € for a one day power event full of demos (and food as well *ggg*).

Visit http://www.microsoft.com/austria/msdn/netstartups/ for more informations - and don't forget to register soon, as the venues have only restricted seats available.

BigDays 2008 - Slides and Demos

knom — Wed, 16 Apr 2008 19:32:55 GMT

Here are the slides and demos of my four sessions at the Austrian Launch Tour "Big>Days 2008".

Sorry for the delay.. I've been in a hurry during the last days.. So following the high demand, here they are :-)

Visual Studio 2008

Language Integrated Queries with C# 3.0

Slides
Demos

Silverlight 2.0

Slides
Demos

Windows Presentation Foundation for Line-Of-Business Applications

Slides
Demos

WcfSvcHost and WcfTestClient in VS 2008

knom — Mon, 24 Mar 2008 22:09:57 GMT

There are two nice helper apps included in Visual Studio 2008, which allow you to test-host your WCF service and invoke the methods to check they're working correctly.

The two apps are called WcfSvcHost.exe and WcfTestClient.exe.

By default they are set as default debugging activity in all WCF libraries. See how to get use of them:

Create a new WCF Service Library
Build an interface "ISayMyNameService" with a class parameter named "Name"
Implement a new service class
Change the class name of the hosted service in app.config:
Press F5 and start debugging.
Voila - the WcfSvcHost is started an displays a successfull message. Click on the message for details:
At the same time the WcfTestClient got started and is now displaying a n UI for testing our simple WCF service. Double click on "HelloYou()" to invoke the method with parameters:
Press "Invoke" and wait for the service to complete. You'll then get back the response as a formatted list or in raw XML.
If you don't want the WcfTestClient, but your custom test client you can change the setting under the project properties:

Behind the Scenes of LINQ - Part 2

knom — Thu, 10 Jan 2008 16:36:13 GMT

Last time we started by translating a LINQ query

List<int> ints = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8 };

var filteredInts = from i in ints where i > 5 select i;

into an extension method (as the C# compiler does in background):

var filteredInts = ints.Where(i => i > 5);

But where do we go from here? What is the strange => arrow doing within my method call?!
This is basically a different notation for an anonymous method.

Let's start with a default .NET 2.0 code doing a calculation with the use of anonymous methods.

        delegate int CalcDelegate(int a, int b);

        static void Main(string[] args)
        {
            CalcDelegate add = delegate(int a, int b)
            {
                return a + b;
            };
            var result = add(10, 5); // 15
        }

With C# 3.0 we could change this code into the new notion of a lambda expression:

            CalcDelegate add = (a, b) =>
            { // Statement Body
                return a + b;
            };
            var result = add(10, 5); // 15

The => arrow indicates a lambda expression. This expression has a statement body - meaning it has curly brackets and some C# code within. You can skip the delegate keyword, the types of a and b will automatically be inferred regarding the signature of the delegate.

You could do anything within the statement body, like:

            CalcDelegate add = (a, b) =>
            {
                Console.WriteLine("Hello World");
                ...
                return a + b;
            };

If you only have a return statement within your expression's body, you can also switch to an "expression body" (instead of statement body).

The lambda expressions then look like this:

CalcDelegate add = (a, b) => a + b; // Expression Body

The return statement and the curly brackets are then removed.

If you disassemble the lambda expressions (either with statement or with expression body) you'll find out, that the compiler generates an anonymous method out of the expression automatically in background.

With the expression body you can basically use every statement which returns a type similar to the return value-type of the delegate.

Instead of creating your own delegate type, you can use a predefined generic delegate called Func. This delegate takes one return type and up to four parameter types. To get the same delegate as our custom CalcDelegate you could use:

Func<int, int, int> add = ...;

Func<string, int, bool> check = (text, length) => text.Length == length;

The second method checks, whether a passed string's (first parameter "text") length matches a passed int (second parameter length). The result is returned as boolean.

What, if you want to analyze a lambda expression to transform it into a SQL query for instance? You could use reflection of course to go over the code of the generated anonymous method, but this is rather difficult.

So for lambda expressions with an expression body (like the one above) there is a special notation called expression trees.

If you specify

Expression<Func<int, int, int>> addExp = (a, b) => a + b;

this is going to be changed into an expression tree of some delegate in background:

      ParameterExpression par1;
      ParameterExpression par2;
      Expression<Func<int, int, int>> addExp = Expression.Lambda<Func<int, int, int>>(
         Expression.Add(
            par1 = Expression.Parameter(typeof(int), "a"),
            par2 = Expression.Parameter(typeof(int), "b")
         ), par1, par2);

What you get is logical view of your lambda expression (called tree), which you can then analyze by using it's Body property.

If you want to execute the expression tree later as a delegate , you need to compile it to source code by calling:

     Func<int, int, int> addDel = addExp.Compile();
     var result = addDel(1, 2);  // 3

So when you specify a lambda expression (with an expression body), the compiler will either produce an anonymous method, or an expression tree out of it, depending on what the target type requires (if it is a delegate or Expression<delegate>).

In my opinion this is pretty neat!

While LINQ-To-XML and LINQ-To-Objects use Func<T..> as parameter, LINQ-To-SQL uses Expression<Func<T..>>, so that the tree can be translated into a SQL Statement.

Behind the Scenes of LINQ - Part 1

knom — Mon, 12 Nov 2007 19:43:00 GMT

Now it's getting confusing :-) As a prequel to my LINQ-To-Sql Article, I'd like to digg into the details of LINQ in generel!

Language Integrated Queries is a new feature of C# 3.0 in conjunction with .NET 3.5. This means LINQ is purely solved at a language compiler and .NET library level. .NET 3.5 doesn't come with a new CLR, but consists only of additional framework libraries (like System.Core.dll). So the MSIL code produced below is purely MSIL 2.0 code!

So how do LINQ queries work?
Let's take a basic query as a sample:

List<int> ints = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var filteredInts = from i in ints where i > 5 select i;

foreach (int i in filteredInts)
{
   Console.WriteLine(i);
}

First of all we generate a new list of integers, which is initialized with values 1-10 (with the new C# 3.0 Collection Initializers feature).

Then we query the list with a LINQ query.

The query returns an C# 3.0 infered type, which means, we do not need to specify the type, but use var instead. .NET will automatically substitute it with the actual type.

This is exactly the same as in these samples:

var s = "Hallo"; // Substitute with string
var i = 10;      // Substitute with int
var f = new List<AppDomain>(); // Substitute with List<AppDomain>

In the same way the type IEnumerable<int> is filled in by the compiler instead of var above.

Like with every IEnumerable we can iterate through the filteredInts with a foreach loop and output all the filtered integers.

So how does the actual LINQ query work ?!

The LINQ query

var filteredInts = from i in ints where i > 5 select i;

could be rewritten into:

var filteredInts = ints.Where(i => i > 5);

which is what the compiler does.

So it calls a method Where on the IEnumerable and passes it a Lambda Expression.

First of all: Where does the Where method come from? This is an extension method to the type IEnumerable. What this means is, the method is not really implemented at the List<int> but only extends it.

Extension methods are static methods in a static class, which take a special argument:

public static void ConsoleWrite(this IEnumerable enumerable);

would be an extension method for all IEnumerable implementing classes (because of the this keyword in front of the parameter, this is the extended type).

If we look into the class Enumerable we find a bunch of extension methods there, like Average, Sum, OrderBy or...

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source,
 Func<TSource, bool> predicate)

This is the method used here. It extends IEnumerable types and has a delegate as a parameter!

What does it do? Something similar to this:

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, 
            Func<TSource, bool> predicate)
{
  List<TSource> result = new List<TSource>();
  foreach (TSource item in source)
  {
    if (predicate(item) == true)
      result.Add(item);
  }
  return result;
}

It iterates through all items of the source collection and calls the delegate for each of them, then adds only those for which the delegate is true to the results.

So i=> i > 5 is basically a different syntax for specifying the delegate!

How do they play together?! Get back for the next part of the article!