For those of you still playing with the VS2010 and .NET 4.0 CTP bits, be aware that it will stop working on Jan 1st. MS has not released any word if we will be getting an updated CTP or a beta anytime soon. This is a bit unlike them where they had a bit of overlap between a VS CTP and the beta.

There are some ways around this. I found a nice post that covers some of the options and links to the information
http://blogs.msdn.com/granth/archive/2008/12/10/visual-studio-2010-ctp-vpc-will-expire-jan-1-2009.aspx

Basically you need to disable time syncronization for the VPC image.

I was worried about this since the get go. I wanted to do some talks coming up on .NET 4.0 and the new parallelism features but it's very hard to do that when you're not sure if you'll even have a working copy to demonstrate on.

Well I took my MCPD: ASP.NET 2.0 test yesterday and passed. It has been just over a year since I took my .NET 2.0 Foundation test. In that time I've taken MCTS for windows and web and now MCPD. There are many more certs to go. Next stop I think are the new .NET 3.5 TS certs.

I'm definitely installing this one when I get a chance. http://channel9.msdn.com/posts/briankel/PDC2008-ShowOff-Entry-Clipboard-History-for-Visual-Studio/

Basically it keeps a history of your clipboard items like Office but with one killer twist. "Paste as {Language}". It will take the C# you copied and Paste it as VB. I'm sure it's not 100% but still helps quite a bit.

All of these new C# 4.0 dynamic features require parts of the DLR. Thus it looks like MS is taking the DLR and making it a first class citizen in the CLR. This also I'm guessing will make IronPython and IronRuby first class citizens as well. A huge win for the dynamic languages community. For C# 4.0 it is bittersweet. It means better interoperability when calling things created in IronRuby or IronPython but there are limitations. Below is an excerpt from the C# 4.0 WhitePaper (available here http://code.msdn.microsoft.com/csharpfuture)

Open issues

There are a few limitations and things that might work differently than you would expect.

·         The DLR allows objects to be created from objects that represent classes. However, the current implementation of C# doesn’t have syntax to support this.

·         Dynamic lookup will not be able to find extension methods. Whether extension methods apply or not depends on the static context of the call (i.e. which using clauses occur), and this context information is not currently kept as part of the payload.

·         Anonymous functions (i.e. lambda expressions) cannot appear as arguments to a dynamic method call. The compiler cannot bind (i.e. “understand”) an anonymous function without knowing what type it is converted to.

One consequence of these limitations is that you cannot easily use LINQ queries over dynamic objects:

dynamic collection = …;

var result = collection.Select(e => e + 5);

If the Select method is an extension method, dynamic lookup will not find it. Even if it is an instance method, the above does not compile, because a lambda expression cannot be passed as an argument to a dynamic operation.

There are no plans to address these limitations in C# 4.0.

To me this is a very huge limitation. I can already see that most of my interop with dynamic languages will probably involve collections of some sort. Also this would come into play with collections from Dynamic COM objects. LINQ is so powerful and easy to use, it may end up being a major annoyance to have to move away from it for dynamic typing. I hope they work on this for C# 4.5

While browsing through MSDN blogs I came across this nice little post. http://blogs.msdn.com/dparys/archive/2008/10/28/neue-m-glichkeiten-in-c-4-0.aspx . After translating the page I found that he linked to the new C# 40 page http://code.msdn.microsoft.com/csharpfuture

I played around with VS 2010 last night. I was able to test the dynamic keyword. It works as advertised but the biggest thing one has to realize is using it removes intellisense for that variable. Compiling type safety as well. I hope they'll be able to add some sort of limited intellisense by looking at the last assigned type.

Also on the Dynamic front is DynamicObject. A new base object type that allows for on the fly Property declaration. The DynamicObject uses a PropertyBag (looks like a Dictionary<string,object>). You can declare properties on the fly. Like

public class MyBag : DynamicObject
{
// überschreibt Getter / Setter
} 
dynamic b = new MyBag();
b.Id = 124;
b.Name = "Windows 7"
b.Price = 499.99m;
b.IsAvailable = false;

One thing I was unable to figure out was the optional, default and named parameters. Again the blog provided some answers.

public void InsertCustomer( int customerId,
                          string companyName = "Neue Firma",
                          decimal creditLimit = 2000m )
{
}

InsertCustomer( 1, creditLimit: 2000m );  

InsertCustomer( creditLimit: 2000m, customerId: 1 );

Well I spent most of the day working on some peculiar problems with PICK. Then left to take my girlfriend out for her birthday. Just now catching up on whats gone on today at PDC. Man it seems like it was a huge day.

First off Windows Azure and the new .NET Services. From what I've read so far I can see some compelling uses for the .NET services and sharing content, id's and roles around the web.

The big one that I haven't seen much press on yet is C# 4.0. Looks like we are getting dynamic binding in the language. While this loses compile type safety it gives C# good ground against things like Ruby and PHP.

Named, Optional and Default parameters. Oh how I've been waiting for these since switching to .NET from PHP. I used to take advantage of these features all the time. It annoys me when I can use them in Attributes in C# but not on actual methods. I'm going to love this.

VS2010 and C# will CTP are available in a virtual PC here

Here's a better overview stolen from http://blogs.msdn.com/samng/archive/2008/10/28/microsoft-visual-studio-2010.aspx

1. Dynamic binding. We've introduced a new type, dynamic, which behaves much like object, but allows the operations performed on your object to be bound at runtime instead of compile time.
2. Named and Optional parameters. You can now specify default values for your parameters, allowing them to be optionally specified at the call site. We've also added the ability for your arguments to be passed by name, so that you can specify exactly which arguments you want to give, and refrain from specifying the rest (assuming they're optional).
3. Com interop features. We've done quite a bit of work to improve COM interop. These include:
• No ref for COM calls. For all COM calls that take ref arguments, you can specify an argument without a ref, and the compiler will generate a local for you and generate a ref to that local as the argument.
• No PIA. We have introduced the ability to deploy your applications which use Primary Interop Assemblies (PIAs) without referencing the actual PIA at runtime. This allows compiling against them, but not needing to ship them with your application.
• Implicit dynamic for COM types. We now give you the option of turning all objects returned from COM into dynamics so that you can perform late bound calls off of them instead of having to cast the result in order to make it useful.

So today I was tasked with helping a client move an old custom VB6 app to a new Windows 2003 server. The company that created it was asking for an arm and a leg for a simple transfer. After we moved the entire program directory over everything seemed to be fine until we encountered an "ActiveX component can't create object" error. I was perplexed on how to track down the issue. There were not accompanying DLLs or OCX files. I tried Process Explorer to see if I could find any failed openings and the strings contained in the exe.

After some searching on the net I found this lovely page http://www.cryer.co.uk/brian/windows/trbl_nt_axccco.htm . It details on how to use Sysinternals Regmon to track down issues with failed ActiveX creation. Basicall you watch your program for registery key openings and look for any failed opens in the HKCR/Classes path. After running the program and encountering the error I found it.
HCKR\Classes\cdonts

When I saw that come up I immediately knew what to do. cdonts is no longer included with windows server. It is an emailing library using cdo. I've had to install it on new Windows 2003 servers more than once so old ASP classic sites could run. All I needed to do after figuring it out was copy the cdonts.dll over to the C:\windows\system32\ directory and run regsvr32 on it. Everything was golden.

I've been using Sysinternals for years. I'm always amazed at what new ways I can use their utilities to track down issues. Process Explorer has been a godsend for me over the years. After discovering it, removing malware from computers took me less than half the time it used to. It gives me so much information I'm not sure how I got by without it.

The Sysinternals Suite is a must have for any serious windows programmer or administrator. It ranges from programs to monitor network connections to being able to see and suspend individual threads in a program.

The other day I was posed with a problem to implement a "Send as Attachment" feature to an existing application. I thought, well this should be easy I've seen many other do it before. I quoted the work at a few hours, figuring some quick searching would give my my answers. I was wrong.

Sending an email using the default email client is very easy with the mailto: protocol. The problem lies in adding an attachment. Common mail programs like Outlook and Thunderbird do not support the attachment option. So, I started looking at MAPI the native API for doing this. I could not find any .NET wrappers. I did find that there were controls created by MS for VB6. Most of the .NET examples I found used COM interop with the ActiveX controls. But after trying these controls (which look like they were last updated in 98) I found them to not work in XP SP3. I'd get random exceptions and was never able to actually get an email dialog to pop up.

After failing with the ActiveX controls I was out of time. The MAPI native commands may have worked but it would take too long to set up the native calls and test it. After discussing with the client we ended up coming up with a bit hackish but workable solution. I would use the mailto: protocol and then launch explorer with the attachment selected. To them this is a minor annoyance that is acceptable. To me this an unfortunate sign of the times.

Things that were once "easy" for native applications become complicated and buggy for managed. It seems too often that I must make use native calls or old unsuported COM objects to get the job done. While MS has done a great job building up the .NET Framework. It seems that many native API's still remain unwrapped. Furthermore some places I read that the MAPI api is unstable on Vista. It seems that some API's are slipping through the cracks.

There are blogs on MSDN popping up that SilverLight 2 is indeed gold and will be public tomorrow Oct 14th. They also announced Silverlight Tools for Eclipse with the promise of cross platform development for Silverlight. I think this is a huge step in the right direction for MS. By giving developers on OS's other than windows to do Silverlight Development in a fairly competent IDE it will give them a better position against Flex.

I have done some playing around in Silverlight 2 and really loved it. I'm just hoping for a Silverlight 2 project to come our way at Sierra Bravo.

I look forward to downloading the public bits and seeing what I can do with the full version.

Well Code Camp 5 is in the bag. It was a large turn out and many great talks. My talk however drew no interest. Oh well, I tried and will try again. I'm thinking of making my post about LINQ and Refactoring into a talk.

The talks I went to:
The Intersection of F# and LINQ
This was a great talk about how F# takes LINQ and adds much more value to it with it's functional nature. The demonstration was a ray tracer that used LINQ to build up all of the reflected pixels. It was quite impressive. Combine it with the Arc talk and I am now very interested in Functional programming.

The Arc Programming Language
I had seen this talk a few days earlier. The speaker was hilarious and did a great job of bringing excitement back to lisp. Arc is a new dialect of Lisp that aims to cut down on parenthesis and add shorthand for common operations. He added objects to Arc with six lines of code, quite impressive.

BOO! A Wrist-Friendly Language for the CLI
BOO! is a another language along the lines of Lisp where it can redefine parts of itself through macros. The difference is it is statically typed like C#. It does offer quite a bit of reduction in code written. The presenter Justin Chase did a good job showing many aspects of the language. I also won a shirt for figuring out that the mystery function was calculating a fibonocci sequence. The code for it was quite cool, a,b = b + a or something like that.

Building MyTube with Microsoft Silverlight 2
Jeff Brand from Microsoft was giving this talk. It was a basic overview on SilverLight, the purpose for it and how to implement a simple youtube interface. I didn't stay for the entire thing, I had to go get ready for my talk.

My talk "Pick/Multivalue 101"
No one that was interested showed. Not that I was surprised but still a bit disappointed.  While giving the talk at my work we had over 15 people show. One of my co-workers showed and the other guy that showed was just looking for a place to sit. So instead we talked about LINQ, customized programming in Linux and a bit about Multivalue

I went to the speakers after party, got to gossip with some people from Magenic. Learned that Justin Chase left Magenic a few weeks ago to work on the Blend team at MS. He's a lucky guy and seemed rather excited for the features they are working on that he can't talk about. I'm sure some of them may come up soon at PDC. I did hear some gossip earlier in the day that SilverLight 2 RTM is going to be released as early as tomorrow (Oct 13th).