Software Development

Visual Studio 2008 SP1

Colin Angus Mackay — Tue, 12 Aug 2008 22:23:06 GMT

Visual Studio 2008 SP1 is here and can be downloaded. Details of the downloads are here, and information on what SP1 brings is here. The big items for me are the Entity Framework and the performance improvements in LINQ.

However, before you go rushing off to install SP1 there are some caveats. If you've been running the beta Martin Hinshelwood has some advice and has also run in to problems running the Team Foundation Server SP1 install too.

Once you've installed the Service Pack you might want to download the Enhancements Training Kit in order to learn what's new.

Finally, if you have Visual Studio 2008 Standard edition or above (not including trials) you can download the IconWorkshop Lite from Axialsis.

Technorati Tags: Visual Studio,sp1,vs2008,Visual Studio 2008,Team Foundation Server

Mixins in .NET (again)

Colin Angus Mackay — Sun, 10 Aug 2008 23:55:22 GMT

A while ago I wrote about Mixins in C# 3.0, at the time I was saying that you can get some of the functionality, but not all, from some of the new language features in C#3.0. The solution is a bit of a fudge because the language doesn't support the concept. I've been looking at Oxygene recently and it has some language features that go a bit further than C# does and will support greater mixin-like functionality which it calls interface delegation.

Interface delegation is again a bit of a fudge, but not quite like C#. In this case the language supports this mixin-like functionality and the fudge happens in the compiler. Let's take the class hierarchy that I used the last time:

In Oxygene the Dog class looks like this:

interface

type
  Dog = public class(Mammal, IRun, ISwim)
  private
      runInterfaceDelegate : RunMixin; implements IRun;
      swimInterfaceDelegate : SwimMixin; implements ISwim;
  protected
  public
  end;
  
implementation

end.

From this we can see that Dog inherits from Mammal and implements IRun and ISwim. The IRun interface has one method (Run), and the ISwim interface has only one method also (Swim). Of course, there could be as many methods and properties as you like.

The C# version of the Dog class, as produced by Reflector, looks like this:

public class Dog : Mammal, IRun, ISwim
{
    // Fields
    private RunMixin runInterfaceDelegate;
    private SwimMixin swimInterfaceDelegate;

    // Methods
    void IRun.Run()
    {
        this.runInterfaceDelegate.Run();
    }

    void ISwim.Swim()
    {
        this.swimInterfaceDelegate.Swim();
    }
}

As you can see, there are two private fields holding a reference to the appropriate mixin, in each of the methods the responsibility for carrying out the action is delegated to the appropriate surrogate mixin object.

What you will also notice is that you still have to instantiate the surrogate mixin objects. Under normal circumstances that would be in the constructor. If it were a real mixin you wouldn't have the option as the mixin would be created at the same time as the object it is used with. In fact, the mixin would be mixed in as part of the object itself. So, perhaps interface delegates gives you slightly greater power than with a real mixin as you could reuse the surrogate mixin object. Then again, would you want to? I've not been able to think of a scenario where I would, but perhaps it could be useful.

I'd like to see interface delegates in C# at some point in the future (sooner rather than later). In fact, I'd like to see proper mixin functionality, but I recon that will require changes to the CLR to support multiple inheritance. In the meantime, I think I'll have to write some sort of snippet in C# to quickly generate the code that Oxygene gives me in one line. Either that or start writing in Oxygene... Now, there's a thought!

Technorati Tags: Oxygene,C#,interface delegates,mixin

Crazy Extension Methods Redux (with Oxygene)

Colin Angus Mackay — Thu, 07 Aug 2008 20:45:07 GMT

Back in April I blogged about a crazy thing you can do with extension methods in C#3.0. At the time I was adamant that it was a bad idea. I still think it is a bad idea, however, my thoughts have evolved a little since then and I have, possibly a solution to my hesitance to use said crazy feature.

So, if you can't be bothered to click the link, here is a quick recap. You can create an extension method and call it on a null reference and it will NOT throw a NullReferenceException like a real method call would. At the time I was saying it was not best practice because it breaks the semantics of the dot operator which is used for member access.

Last night, I attended an excellent talk by Barry Carr on Oxygene, an Object Pascal based language that targets the .NET Framework. Oxygene has a very interesting feature, it has a special operator for dealing with calls on a reference that might be null. If that language can do it, what's so wrong with the functionality that Extension methods potentially give? Semantics. Notice that I said that Oxygene has "a special operator". It doesn't use the dot operator. The dot operator still breaks if the reference is null. It has a colon operator. In this case if the reference is null (or nil as it is called in Oxygene) then the call to the method doesn't happen. No exception is thrown.

For example. Here is the code with the regular dot operator:

class method ConsoleApp.Main;
var
  myString: String := nil;
begin
  Console.WriteLine('The string length is {0}', myString.Length);
  Console.ReadLine();
end;

And the result is that the NullReferenceException is thrown:

Here is the code with the colon operator:

class method ConsoleApp.Main;
var
  myString: String := nil;
begin
  Console.WriteLine('The string length is {0}', myString:Length);
  Console.ReadLine();
end;

And the result is that the program works, it just didn't call the property Length as there was nothing to call it on:

At this point I really would like to show you what this looks like in Reflector to show you what is going on under the hood, however, I get a message that says "This item is obfuscated and can not be translated" and the code afterwards isn't quite right. However, the crux of it is like this in C#:

int? length;
if (myString != null)
length = myString.Length;
Console.WriteLine("The string length is {0}", length);

Now, back to these extension methods. After seeing this I was thinking that perhaps my total unacceptablity of allowing a null reference to be used with an extension method was perhaps incorrect. In a normal situation with an accidental null reference exception being used the NullReferenceException wouldn't be thrown at the point of the method call (after all, the null reference is actually being passed in as the first parameter in an extension method), but somewhere in the method itself. Normal good practice would place a guard block at the start of the method so that it would be caught immediately.

However, what if you wanted to create similar functionality to the colon operator in Oxygene and have it ignore the null reference and do nothing? Well, my advice would be to create a naming convention for your extension methods to show that null references will be ignored. That way you can get the functionality with a slight semantic fudge of the dot operator. Of course, you still have to do the work and set up guard blocks to handle the null situation yourself in the extension method.

Here's an example:

class Program
{
    static void Main(string[] args)
    {
        string myString = null;
        Console.WriteLine("The string length is {0}", myString.NullableLength());
        Console.ReadLine();
    }
}

public static class MyExtensions
{
    public static int? NullableLength(this string target)
    {
        if (target == null)
            return null;
        return target.Length;
    }
}

Technorati Tags: extension methods,dot operator,colon operator,c#,oxygene,semantics

Oxygene talk in Dundee

Colin Angus Mackay — Thu, 07 Aug 2008 13:28:13 GMT

Last night's talk in Dundee on Oxygene was excellent.

My journey up was a little fraught as an accident on the A80 meant that it took me 1h15m to travel the 20 miles from Glasgow to Stirling. By that point was running late and had 45 minutes to cover the last 55 miles. In the end I arrive 15 minutes late, but that was okay because they hadn't actually started yet.

The journey back afterwards was a bit hellish too because the rain was coming down hard and the M80 between Cumbernauld and Stirling doesn't seem to be able to drain water quickly enough. Even reducing my speed I was aquaplaning every few hundred metres.

Anyway, Oxygene, if you don't know, is a Object Pascal based language that targets the .NET Framework. In terms of features it contains a lot of things that would be beneficial to C# such as interface delegates, parallel coding constructs and null handling.

I will be blogging in more detail about some of these features as I plan to look further in to this language.

Tip of the Day #8 (string performance)

Colin Angus Mackay — Mon, 04 Aug 2008 12:00:54 GMT

Concatenating strings in .NET can be very easy. There is the overloaded + operator that makes stringA + stringB + stringC statements very easy to write. But, it isn't very performant. The reason is that strings are immutable, and concatenating strings in this way causes lots of short-lived objects to be created and thrown away, which in turn causes the garbage collector to run frequently.

There are two better ways in .NET to concatenate strings. One is to use the string.Concat() method. The other is to use the StringBuilder class. They both perform better than adding strings together, but you still have to know when to use each.

According to this article on "Performance considerations for strings in C#" string.Concat() is good up to 600 strings. But, only if you have 600 strings to concatenate in a single statement. StringBuilder is better if you have more than 600 strings to concatenate, but you can do so over multiple statements. In reality, I think the benefits of appending strings over multiple statements with StringBuilder will work out better even with much less than 600 strings because to get the performance out of string.Concat() you'll have to perform some form of setup operation to line all those strings up - and that will take time.

So, today's tip is don't use the plus operator to combine strings except in quick / throw-away applications. Use string.Concat() or StringBuilder instead.

Technorati Tags: string,concatenation,concat,stringbuilder

What's New in Visual Studio 2008 Service Pack 1

Colin Angus Mackay — Thu, 31 Jul 2008 13:18:26 GMT

Finally, Microsoft have a date for an event in Scotland. It is on 16th of October in their new offices in Waverley Gate, Edinburgh. Here are the details:

[Register for the event here]

16 October 2008 13:30 - 16:15
Welcome Time: 13:00

Microsoft Scotland
Waverley Gate
2-4 Waterloo Place
Edinburgh EH1 3EG

Event Overview

Timings
13.00 for 13.30 Registration

13.30 - 14.45 Session 1

14.45 - 15.00 break

15.00 -16.15 Session 2

16.15 close

Overview:

“Service Pack? We’re calling it a Service Pack? Are you kidding??!?!”

Visual Studio 2008 Service Pack 1 will release later in 2008 alongside .NET Framework V3.5 Service Pack 1 and, together, they represent a significant upgrade to Visual Studio 2008. There are enhancements across many areas of the .NET Framework such as data access, windows application development and web development and there are also corresponding changes in the development environment to support the new framework features.

Session 1: What’s New for Web & Windows Development?

Here we’ll explore the changes to web and windows development with Service Pack 1. In the web space, we’ll take a look at the new controls added to ASP.NET for easy playback of media and Silverlight content and we’ll take a good look at the new Dynamic Data framework for quick “scaffolding” of a web site. In the Windows world, we’ll look at the new capabilities of Windows Presentation Foundation V3.5 Sp1 and the new, smaller, subset of the .NET Framework in the .NET Client Profile that makes deployment of WPF applications much easier.

Session 2: What’s New for Data?

The ADO.NET team have been busy for Service Pack 1 of Visual Studio 2008. There are two major new pieces of functionality – the ADO.NET Entity Framework provides a level of abstraction over your data store with a LINQ-enabled, object-relational-mapping API. The other new piece of functionality, ADO.NET Data Services easily exposes arbitrary data over a RESTful set of web services. In this session, we’ll explore both to give you an idea of what’s happening in data access. We’ll also make a brief mention of the changes around SQL Server 2008 data types and tooling.

Speaker Biogragphy:

Mike Taulty

Mike Taulty, Microsoft: Mike has been in the team since 2003 and is currently looking at technologies such as Visual Studio 2008 Service Pack 1, Silverlight V2 and SQL Server 2008. Before joining the Community team, Mike worked in Microsoft's Services group as a developer consultant focused on helping ISVs and Enterprises develop their applications. Prior to joining Microsoft, Mike spent the previous nine years working as a software developer for a number of different software houses, end-users and consultancies, making use of various operating systems, databases and what used to be called 'middleware’.

Read Mike's blog

Eric Nelson

After many years of developing on UNIX/RDBMS (and being able to get mortgages) Eric joined Microsoft in 1996 as a Technical Evangelist (and stopped being able to get mortgages due to his new 'unusual job title' in the words of his bank manager). He has spent most of his time working with ISVs to help them architect solutions which make use of the latest Microsoft technologies - from the beta of ASP 1.0 through to ASP.NET, from MTS to WCF/WF and from the beta of SQL Server 6.5 through to SQL Server 2008. Along the way he has met lots of smart and fun developers - and been completely stumped by many of their questions!

In July 2008 he switched role from an Application Architect to a Developer Evangelist in the Developer and Platform Group. Currently Eric’s interests include digging into LINQ to Entities, ADO.NET Data Services and switching from C# to Visual Basic development.

At home, he battles rat infestations, comes second to the family dog and uses any spare moments he has after 10pm to team up and play online with and against friends - keep an eye out for 'erknel' and say 'hi'

Read Eric’s blog

[Register for the event here]

Technorati Tags: msdn,microsoft,visual studio,sp1,software development

Tip of the Day #7 (SysInternals)

Colin Angus Mackay — Wed, 30 Jul 2008 14:47:33 GMT

I've visited the SysInternals site a few times over the course of my career because of some strange problem that I just couldn't track down. The amount of information about what is actually happening on your system that the SysInternals tools provide is phenomenal. The site was run by Mark Russinovich and Bryce Cogswell until they got hired by Microsoft. However, the tools are still available and being updated, only now they are hosted by Microsoft themselves.

So, today's tip is to visit the SysInternals page on Microsoft's TechNet site and familiarise yourself with what is available. You might find that one day it will save you hours of frustration.

Scottish Developers July Newsletter

Colin Angus Mackay — Mon, 28 Jul 2008 23:28:18 GMT

Welcome

We are now in the middle of summer, however as I write this over a period of several days I can tell you that it has been chucking it down and it has been roasting.

If you are interested in SQL Server, the SQL Bits III conference (13^th September) has now opened registration and session voting. They've opted to allow people to register for the event before they've even finalised which sessions are going to run. So, you could take pot luck and register now, or you can wait and see and take your chances that there will be places left.

I would have also been advising you of the ALT.NET conference in London (also 13^th September) but when I last checked it was full already! Delegate Registration had only been open for a few days. If you've not signed up already there is always the Glasgow ALT.NET User Group. Added to that ALT.NET supporter Paul Cowan will be talking at Scottish Developers in Glasgow in September.

We also have exciting news that we have finally (and formally) merged with the North East Scotland .NET User Group. This gives us a permanent presence in Dundee. It also means that we should be able to put on events in Aberdeen from time-to-time. If you are from either city then get in touch and let us know what you'd like us to be putting on for you.

Our new committee is as follows: Colin Mackay (Chairman), Gary Short (Secretary), Frank Kerrigan (Treasurer), Barry Carr (UG Coordinator) and Craig Murphy (UG Coordinator).

As always, we are on the look out for new speakers. If you would like the opportunity to do a presentation on a software development topic from 10 minutes to 90 minutes then get in touch with me at colin@scottishdevelopers.com. If you are interested, but don't think you have the skills to stand up and talk to a group of developers Microsoft are running some technical speaking training courses for those that want to speak to user groups. The courses will be held in Reading. The first is on 29th August. If you are interested drop me an email.

Regards,
Colin Mackay, Chairman, Scottish Developers

Events

6-August-2008 @ 19:00 in Dundee (Scottish Developers)
An Introduction to Oxygene and its parallel coding features
FREE - Registration optional

Oxygene (formerly known as Chrome) is an advance .NET (and Mono) language by RemObjects influenced by Object Pascal. Oxygene has all the features of C# plus several more powerful features unique to itself. These include: Interface Delegation which provide a similar behaviour to Mixins; A null safe member access operator; Full support for "Design by Contract"; Virtual static members and Virtual constructors that can make writing object factories a breeze.

9-September-2008 @ 18:30 in Glasgow (Scottish Developers)
An Overview of ALT.NET Technologies
FREE - Registration optional

Most of the patterns and practices that come out of Redmond A.K.A Microsoft are purely to get a response from attendees of conferences like MIX. The same old drag and drop demo ware is both untestable and unmaintainable. Examples of such demo ware are the CAB application block, SCSF (smart client software factory), ObjectBuilder (a very poor IOC container) and the Entity Framework which many believe to be the catalyst for the ALT.NET movement. The recent ASP.NET MVC framework appears to be an acknowledgement from Microsoft that they want to embrace some of the ALT.NET concepts. The discussion will outline some of the following techniques and frameworks by way of a code review. Attendees are encouraged to participate with questions throughout the duration of the discussion. Some of he concepts and frameworks include: * Test Driven Development (TDD) * Nhibernate (Object Relational Mapper) * Castle Windsor (Inversion Of Control or Dependency Injection) * AOP (Aspect Oriented Programming) * ASP.NET MVC Framework * JQuery (a write less JavaScript library from a very talented team).

8-October-2008 @ 19:00 in Edinburgh (BCS)
The Three Ghosts of Microsoft Security
FREE - Registration Required

Taking efficiency one step further - F# Microsoft Research describes F# as "a scripted/functional/imperative/object-oriented programming language". Combining all those aspects in one language is certainly not an easy task, but they've done a good job of it. F# is interesting both as a language to actually consider for your projects and as a source of features that might make it into the mainstream .NET languages tomorrow. The session uses many examples to give you a good general overview of F#. To complement the introductory session, Oliver is going to show some more advanced samples from his talk “Data Handling in F#” and there will also be room for Q&A as well as discussion.

Further Afield

September:
SQL Bits III (Hatfield)

October:
Frank Kerrigan talks about SSIS (Glasgow)

November:
VBUG Conference (Reading)
TechEd Developers (Barcelona)
Developer! Developer! Developer! (Reading)

December:
Andrew Westgarth on ASP.NET development on IIS7 (Glasgow)

Sponsor's message

SQL Know How are offering top quality SQL Server training courses at excellent value. Not only is the price great, but by entering the site from the links in this newsletter or on the Scottish Developer's website you'll get an additional 5% off the price. Their upcoming courses include the following

Best Practices in Performance and Availability for SQL Server 2005/2008
Kimberly L. Tripp and Paul S. Randal 1st - 3rd September 2008 Hatfield, Hertfordshire

Indexing for Performance in SQL Server 2000/2005/2008
Kimberly L. Tripp and Paul S. Randal 8th - 9th September 2008 Edinburgh

Smart Database Design
Paul Nielsen 22nd - 23rd September 2008 Hatfield, Hertfordshire

Smart Database Design
Paul Nielsen 29th - 30th September 2008 Edinburgh

SQL Server Data Storage Formats: Internals, Performance and Best Practices
Kalen Delaney 3rd November 2008 Harpenden, Hertfordshire

SQL Server Concurrency Control: Locking, Blocking and Row Versioning
Kalen Delaney 4th November 2008 Harpenden, Hertfordshire

SQL Server Data Internals and Tuning
Kalen Delaney 5th - 7th November 2008 Harpenden, Hertfordshire

How I got started in Software Development?

Colin Angus Mackay — Sat, 26 Jul 2008 13:14:02 GMT

There is a meme going around at the moment and I thought I'd join in even although I've not been specifically tagged by it, it looks good fun. I spotted it on Phil Haak's blog with his response.

How old were you when you started programming?

I was 8 years old.

How did you get started in programming?

When my dad bought a ZX Spectrum in 1983 (It was a Mark II, 48K RAM). I started by typing in programs from the manuals, then by creating my own programs. One of the first I remember creating was to stop my sister using the computer. She was younger than me and the program was something like this:

10 PRINT "How old are you?"
20 INPUT a
30 IF a < 8 THEN PRINT "You are too young to use this computer."; GO TO 10

What was your first language?

ZX Spectrum Basic

What was the first real program that you wrote?

The first real program that I wrote as part of a job was a tool to summarise and format certain data in a database. What today would be handled by a few drag & drop operations and some mouse clicks in SQL Server Reporting Services took me about a week or so back then. It was written in a language called Magik (yes, with a K)

What languages have you used since you started programming?

Well various flavours of BASIC (ZX Spectrum, BBC, Visual Basic, VBA, etc.), COMAL (used by my high school), PASCAL, C/C++, COBOL, Magik, javascript, C#. There are probably a whole slew of other languages that I've touched over the years but not spent any significant time with that I've missed out here.

If you knew then what you know now, would you have started programming?

Yes, I would still have started programming. I probably would have done it a lot better though. There are a lot of things I've learned along the way that I wish I knew earlier. But, then again, if I never made those mistakes what lessons would I be learning? I guess I would be answering this questions pretty much the same way, but thinking of a different set of mistakes. Or would I? Maybe, since I didn't make those mistakes in the first place I would end up being an incredibly arrogant insufferable arsehole.

If there is one thing you learned along the way that you would tell new developers, what would it be?

Last year, I interviewed for 3 months to hire a developer. From that, the one major thing I think people need to understand is that in software development you must continue to learn constantly. I was interviewing candidates with 10+ years experience that had pretty much never learned anything since leaving university. Sure, they were using new languages since leaving, but they never learned about how to really use this fancy new object oriented language, or how to defend against SQL Injection Attacks. Most of them couldn't even write a fizz-buzz program for goodness sakes.

So, my answer would be life long learning. If you don't want to do it then do something else.

Who do I tag?

It is an interesting set of questions, and I'd like to know the answer from the following people:

Technorati Tags: meme,software development,programming

Monitoring change in XML data (LINQ to XML series - Part 5)

Colin Angus Mackay — Sat, 19 Jul 2008 16:57:00 GMT

This is the 5th part in a series on LINQ to XML. In this instalment we will look at monitoring changes in XML data in the XML classes added to .NET 3.5.

The XObject class (from which XElement and XAttribute, among others) contains two events that are of interest to anyone wanting to know about changes to the XML data: Changing and Changed

The Changing event is triggered prior to a change being applied to the XML data. The Changed event is triggered after the change has been applied.

An example of adding the event handler would be something like this:

XElement root = new XElement("root");
root.Changed += new EventHandler<XObjectChangeEventArgs>(root_Changed);

The above example will trigger for any change that happens in the node the event handler is applied to and any node downstream of it. As the example is applied to the root node this means the event will trigger for any change in the XML data.

The event handler is supplied an XObjectChangeEventArgs object which contains an ObjectChange property. This is an XObjectChange enum and it lets the code know what type of change happened.

The sender contains the actual object in the XML data that has changed.

Adding an element

Take the following example where an element is added to the XML data.

XElement child = new XElement("ChildElement", "Original Value");
root.Add(child);

In this case the ObjectChanged is Add and the sender is the XElement: <ChildElement>Original Value</ChildElement>

A similar scenario happens when adding an attribute. However, instead of the sender being an XElement it will be an XAttribute.

child.Add(new XAttribute("TheAttribute", "Some Value"));

Changing an element value

If the value of the element is changed (the bit that currently says "Original Value") then we don't get one event fired. We get two events fired. For example:

child.Value = "New Value";

The first event with ObjectChanged set to Remove and the sender set to "Orginal Value" (which is actually an XText object) and the second event with the ObjectChanged set to Add and the sender set to "New Value" (again, this is actually an XText object).

Changing an element name

If the name of the element is changed then the ObjectChanged property will be set to Name and the sender will be the XElement that has changed.

child.Name = "JustTheChild";

Changing an attribute name

Unlike changing an element value, when the value of an attribute changes the ObjectChanged property will be Value and the sender will be the XAttribute.

child.Attribute("TheAttribute").Value = "New Attribute Value";

Technorati Tags: c#,.net,.net 3.5,xml