Show Me The Money

On Feb 2nd 2011 they announced that they would be charging $35 for the tool. When a product has been available for many years for free the market expects it to remain free. Especially when Lutz sold it to Red Gate and the impression people received at the time was that a version of  it would remain forever free.

This has created some backlash from developers, not all developers, but a vocal minority who feel they have been bait and switched. More importantly it created a hole in the market at the free price point. Two commercial companies have jumped into that space with JustDecompile from Telerik and dotPeek from JetBrains. Both of these are free. There is also an open source project called ILSpy that is making progress in replicating .NET Reflector functionality.

Back Flip
In response Red Gate have backtracked slightly with the following announcement. Basically it says that existing users of .NET Reflector can continue using version 6.8 for free into the future but all new customers will still need to pay. You can see the pricing for new customers here. This whole flip flop has really damaged the reputation of Red Gate.

It has also opened up a free for all where alternative tools will be developed when previously no one considered it worthwhile. I wonder if in a couple of years this will all be forgotten or will Red Gate look back and rue the decisions they made?

So what was the problem? I already had VS2008 installed and had setup the symbol server settings so I could step into and see the source code for the framework Windows Forms code. This has been very handy in the past for tracking down problems by allowing me to see exactly what was happening in the base classes. Reflector is an excellent tool but there is nothing quite like stepping through the real code.

Well it seems that VS2010 was using the already defined settings and this was the cause of the issue. I removed the symbol server settings and it all working perfectly. Put them back again and it takes essentially forever to try and start-up debugging an application. It never occurred to me until I checked that VS2010 would automatically be using the same settings as defined in VS2008. I just assumed you had to set them up manually for each Visual Studio version.

Microsoft Connect - Bug Report

In the meantime I have restored a system image that I prudently took immediately before the install and so I’m back again working away although only with VS2008 at the moment. Even-money says the fix from Microsoft will be to wipe the machine and install everything from scratch. Not something I am looking forward to doing as it takes a couple of days to get everything up and running to the point of being able to build Krypton automatically again.

All I have to do is the following…

1, Startup VS2010
2, File -> New -> Project ->
3, Select C# -> Windows Forms Project template
4, Press F5 to compile and run

And then wait forever because after compiling it never runs the application. It makes no difference if I select the .NET Framework 4.0 or 2.0 or any of the others. They fail all the same. It makes no difference if you run as administrator or indeed any other setting I can think of. It’s just plain broken.

I sometimes also get the following error…

Now I find it hard to believe that something so basic would be broken so I must assume it is the setup of my machine helping to expose the problem. I have Windows 7 Professional 64bit with VS2005, VS2008 and now VS2010 all working side by side. Is anyone else using a similar setup and finding it does or does not work with the above steps?

I quickly realised it would take more time than I had available. It also have the disadvantage of expecting all site visitors to either already have or be willing to install Silverlight. I don’t want to alienate some visitors by having a Silverlight install request as the first thing they see.

Turns out there is another good reason not to bother. Now that Windows Azure and SQL Azure are live it seems Australia has not been invited to the party. If your company is based in the US, UK, Japan, Germany or a good many others then you could sign up. Australia? Thanks but no thanks. You have to wait until some unspecified time in the future before you can use our service.

Good job I dropped the Silverlight idea.

Imagine you have a Panel somewhere in your application and you add a Button onto that Panel. Set the Button.Visible to be False and then back again to True. It works exactly as you would expect by hiding the control and then displaying it again.

Now move up a level and try setting the Panel.Visible to be False so the whole Panel, including the contained Button, is hidden away. Whilst hidden try asking for the Button.Visible value and you will see it comes back with False! This is bad because it’s clearly returning a value indicating if the Button is currently visible rather than a value indicating if the Button would like to be visible. There is a big difference between those two semantics.

This problem becomes evident when you want to create your own custom layout panel. Your custom control will need to scan the set of child controls and decide how to arrange them. To make your control behave itself you want to honor the visible setting of child controls. But your stuck because asking a child control for its visible property will not always give the correct answer. If your control performs a layout when it happens to be hidden then all the children will automatically say they want to be hidden as well. Not because they really want to be invisible but purely because at the time the child control was asked the parent chain had a control that was not currently visible.

What we really need is two properties. The Control.Visible should act as an indication of the visible state the control would like to have. So the ‘get’ should return the same value as the last ‘set’. Then a new property called Control.CurrentlyVisible that returns if the control is currently visible based on the state of all the parent controls up the chain of controls up to and including the owning Form.

This is something I have had to get around for the KryptonNavigator and KryptonWorkspace controls because they suffer from exactly this issue. They both have child collections of controls and need to honor the visible state of those controls. Luckily I can get around it because they can only have child controls of a type I have defined. So I can easily add the extra properties needed to those defined types. But this would fail if my collection could take any arbitrary control and not just my own types.

WPF, the big brother of Silverlight, has been around since Vista was released and although a critical success has only slowly gained traction in desktop development. I think this is because WinForms, despite many shortcomings, is good enough for most business focused applications. With few ‘must have’ reasons to immediately make the jump, adoption is rising but only slowing.

Silverlight adoption has the potential to happen much faster for two reasons. First is the continuing trend towards richer internet applications. Although you can create nice websites using Ajax, jQuery and HTML it takes great developers pushing the limits to achieve it. Silverlight makes it possible for average developers to do the same but in less time.

The second force is just shear weight of numbers. With about a million .NET developers in the world you are instantly opening up rich internet development for them all. Asking a C#/WinForms developer to learn all about Ajax, jQuery, CSS and so forth is a steep learning curve with no leverage of existing skills. But ask the same developer to keep using C# and much of the same base class library and it becomes much more appealing. Plus once you have mastered Silverlight you can transition that knowledge over to your desktop apps with WPF.

This entire preamble merely explains why I find Silverlight interesting as an area I should start thinking about. I would like to hear bad about others opinions and get a discussion going about this topic.

1, Should Component Factory get involved in Silverlight?

2, What type of controls/components etc would be useful?

I have started a forum thread for this discussion. This will make it easier to track the full set of responses on an ongoing basis. Thanks.

Silverlight 3 Beta Site
Silverlight Development Links

Visual Studio 2010

1 – ?? Operator
The ?? operator is called the null-coalescing operator and is used to define a default value for a nullable value types as well as reference types. It returns the left-hand operand if it is not null; otherwise it returns the right operand. So instead of using code like this…

if (reference == null)
   return _defaultInstance;
else
   return reference;

You can just write the following statement instead…

return reference ?? _defaultInstance;

Much cleaner and it even works for nullable value types.

2 - DebuggerStepThrough
This attribute can be added to a method or property accessor and used to speed up debugging. When debugging and using step-into the debugger will step past the method with this attribute. This is really useful in preventing you stepping in and out of the many one liners in the code. To apply do this…

public string Name 
{
   [DebuggerStepThrough]
   get { return _name; }
    
   [DebuggerStepThrough]
   set { _name = value; }
}

3 – Automatic Properties
Sick and tired of adding get/set code for simple properties? This is no longer a problem with the automatic properties added in C# 3.0. Instead of this…

private string _name;
public string Name
{
   get { return _name; }
   set { _name = value; }
}

…just do this…

public string Name { get; set; }

4 - Object Initializers

Also introduced in C# 3.0 are object initializers. This allows you to set property values inside the new statement. Without this you either create additional overloaded constructor with the possible set of initial values or you write the long hand like this…

Employee emp = new Employee();
emp.Name = "John Smith";
emp.Age = 10;

…but this is clearer…

Employee emp = new Employee {Name="John Smith", Age=10}

5 - Constant flags

Want to specify a float instead of a double for a constant? Most people know the ‘f’ modifier after a constant number informs the compiler to make it a single float value. But did you know the full list of others flags?

100m  (decimal)
100f  (float)
100d  (double)
100u  (uint)
100l  (long)
100ul (ulong)

Let me know if I have missed one you really like.

To help make this process as easy as possible you can now buy a pack of 265 icons. As an introductory offer the price is just $79 during this month. Each icon has…

Three different sizes

Three different states

6 different file formats

- PNG, GIF
- ICO, PSD
- BMP (24bit & 32bit).

You can see a preview of all the icons here.

Fast forward to today and there would seem to be inflation in the number of product releases from Microsoft. From the release of Vista onwards we have the following client side technologies…

  WPF   WCF   WF   LINQ

Each of these covers a large area that would require many months to really understand well. In fact WPF alone is going to take you a year of full time use before you can say you’re truly proficient in it. If you want to include the server side then add the following into the mix…

  ASP.NET AJAX  
  ASP.NET MVC
  ASP.NET Dynamic Data
  ADO.NET Entity Framework
  Silverlight

I think I know why this rapid increase has happened and it’s all the fault of the .NET Framework. When I switched from developing applications with MFC/ATL to WinForms I noticed my productivity increased several fold. Maybe as much as a 5 fold increase in output once I was up to speed with using all the .NET goodness. Now you apply this same productivity increase to all the cubicles at the mothership and you have the above technology tsunami.

When I started as a Windows developer the only real distinction between us was the language that you used (C++ or VB). With the rise of the Internet the community split into server side and client side specialists. It was very hard to master both areas because of the sheer amount of knowledge needed although the better programmers could probably just about manage it.

Now I see the community is splitting again into even smaller groupings. Do you use WinForms or WPF? Do you use classic ASP.NET or the MVC Framework? Over time I expect to see this kind of fracturing into smaller and smaller groups to continue. Or at least that’s what I was expecting to happen. Maybe Microsoft has seen this trend and decided to try and reverse it. Is the use of XAML with WPF and Silverlight an attempt to unify your client and web developers back into one happy community again? Time will tell.

A worrying trend for Microsoft is that your average programmer is not even bothering to try and learn all the latest goodness. How many developers in your outfit actually use generics beyond List<T>? Generics have been around forever, at least compared to the above technologies, and still most developers are hardly using it. I heard a podcast where an interviewer for a .NET position found that only around 20% of the candidates actually used generics at all. Yikes.

Actually this is not really surprising as the majority of developers spend all day working on business applications that are going to generate revenue. When do you have the time to learn WPF/WCF/LINQ/etc when learning them is almost a full time job in itself? It is all very well for Scott Guthrie or Scott Hanselman to tell the world how great the new stuff is but real developers just don’t have the schedule to stop and learn for six months.

For me this is the biggest problem that Microsoft is facing. They have some great technologies but the challenge is how to get the bulk of developers, the average developer, to move forward and learn them. I expect the upcoming PDC2008 will release even more new tech but I wonder what they are going to do that makes it easier or more compelling for businesses to move forward and actually use them.

It seems that if you are building on .NET then they want to make it real easy to just push a button and have that application deployed into the ‘cloud’ so that it just works. Taking away the headache of finding a hosting provider, installing and configuring software such as SQL Server would certainly appeal to many. I suspect that the operating system is really just some extensions on top of Windows Server 2008. Just like Small Business Server is not really a different operating system but just Windows with some packaging for businesses placed on top.

Amazon are also extending some love to .NET developers by adding support for Windows Server and SQL Server within their EC2 (Elastic Compute Cloud) service. Currently in private beta testing this addition will help Windows developers that need to scale their web service without needing to handle all the scaling issues themselves. You pay only for the compute time used.

If we look into the future a little way we can image what Microsoft would like to achieve. They want .NET developers working on web applications to be able to sign up for a ‘cloud’ account and then just press a button within Visual Studio to have it deployed as a live system. With Microsoft, Amazon, Network Solutions and so on being providers of the actual hardware and providing a scalable system for you. Then you pay only for the amount of CPU/Disk used and need never worry about where the server is located. Add in Hyper-V and it becomes much easy for a provider to give every account their own isolated operating system that can then be moved around to different servers as needed.

Another new technology from Microsoft called Live Mesh is going to be presented at the PDC later this month and may well integrate into this story. It seems that the mothership has well and truely embraced ‘cloud computing’. But whatever you do don’t use that term with Larry Ellison from Oracle. When someone asked Larry what ‘cloud computing’ meant he said…

“The interesting thing about cloud computing is that we’ve redefined cloud computing to include everything that we already do. I can’t think of anything that isn’t cloud computing with all of these announcements. The computer industry is the only industry that is more fashion-driven than women’s fashion. Maybe I’m an idiot, but I have no idea what anyone is talking about. What is it? It’s complete gibberish. It’s insane. When is this idiocy going to stop?

We’ll make cloud computing announcements. I’m not going to fight this thing. But I don’t understand what we would do differently in the light of cloud computing other than change the wording of some of our ads. That’s my view.”

I expected it to take time because any new platform needs a chance to mature and the associated tooling be created. Even so I expected that by now it would be getting into its stride and starting to overtake WinForms as the client technology of choice. I think there are two reasons why this has not happened.

WPF Tooling
So far this has not reached the level needed to make it easy for average developers to use. Sure, we have Expression Blend and the Visual Studio design time environment but neither is as simple to use as the WinForms design time surface. If you’re not a designer, and most coders never will be, then Blend is really not that easy to use. It’s easy to create bad designs with Blend but you’re going to need to be a skilled designer to make it really sing for you.

So unless your organization has the resources to employ a designer you’re stuck with using the standard out of the box look and feel. That standard appearance will not have your customers or boss into begging for WPF applications.

Now this would not be such as issue if there were some great component suites that you could buy and just drop into your application, along with a selection of great themes. The current component suites for WPF are getting better all the time but still at least 1 or 2 years away from providing the depth and range required.

WPF Applications
Our second roadblock to adoption is that we have no good examples of WPF applications in the wild. Yes there are plenty of cool niche apps but I mean really popular apps that are on everyone’s desktop. Something along the lines of Microsoft Word with a WPF front end. Something that gets the mass market asking for the same sophistication from all the applications they use. This would create a demand side pull on software companies.

Of course, the problem here is that you cannot take several million lines of code inside Office and just stick a WPF front end on. This reminds me of an interview I heard from a developer on the Outlook team. It took a team of three developers two years to create the Outlook 2007 navigation control that you see on the left hand side. So we cannot expect the consumer market to get anything from Microsoft in the immediate future that is going to really fire them up.

Supply Side Push
If a demand side pull is unlikely to bring WPF to the masses then the only alternative is for Microsoft to create a supply side push. I think this is the main reasoning behind the recent announcement that Visual Studio 2010 is to have a new text editor built using WPF. They also stated that Version 11 (Visual Studio 2012?) will have the entire shell rewritten in WPF.

Now you can imagine that a million Visual Studio developers will see the cool and slick WPF environment and decide they want to get in on the act. At this point WPF will be the default choice for developing rich client applications and by then the component vendors will also have some nice offerings.

So my new prediction for WPF uptake is a slow but steady increase over the next four years and a tipping point at around 2012 that sees it become the de facto standard for developing client applications. But if you think differently then let me know in the comments!

Microsoft has just released a tool that integrates into Visual Studio and is used to look at your C# source code and report style violations. This is great for any project manager that wants to become style enforcer. The intent is to provide compile time warnings/errors about C# code that violates its rules.

For example, you might want to enforce a rule that all source files have a header at the top containing a copyright notice along with the company name. You can configure the utility so that it produces either a warning or an error whenever this rule is violated. The current list of rules that it comes with can be turned on or off depending of which are applicable to you.

Personally I like the idea and I think it would be a great tool to use on a new project. Everyone of the team can sit down at the start and agree a set of style guidelines that can then be automatically enforced. But on existing projects I think it would be almost pointless, as the number of violations is going to be huge and the time needed to prettify your code not really be justifiable.

Download Current Release
Associated Microsoft Blog

I hope Chris can manage to keep up the current level of detail. Maybe he should try offering advertising spots to help cover the bandwidth and server costs.

There have been many times when it would have been very helpful to set breakpoints in the base classes such as Control. Until now I used .NET Reflector to see the base code implementation, but that is hard work to follow.

Follow these instructions to get started…
Step-by-Step Guide

Mole Homepage
Mole Silverlight Videos
http://karlshifflett.wordpress.com/mole-for-visual-studio/

Mole Authors Blog
http://karlshifflett.wordpress.com/

Strong Signed
To strong sign an assembly you need to generate an encryption key and use this key to sign the assembly. The signing process generates a hash of the generated code and attaches this using the key to the end of the assembly. Whenever the CLR loads the assembly it notices the signing information and uses it to check that the code generates the same hash code as when it was originally compiled. If the hash code no longer matches then the assembly has been tampered with and so the CLR refuses to load it.

Placing an assembly into the global assembly cache (GAC) requires you strong sign the assembly. This is a reasonable precaution because there might be many different applications that are using the GAC assembly and you want to be sure it has not been modified to inject some malicious code.

However, just signing the assembly is not very secure. Anyone can remove the signing information from an assembly, modify the assembly and then sign it again. They cannot sign it with the same original encryption key because, hopefully, that is safely tucked away at the publishers. But they can generate a new key and use that is sign it with instead.

So the second half of the equation is the reference in the calling assembly. When the calling assembly was compiled it embedded a public token for the signed assembly into its reference information. So now when the application loads it not only knows the name of the assembly it wants to load but also it knows that it should be signed with a particular key.

This prevents the attack just mentioned. If someone takes the System.Windows.Forms assembly in the GAC, injects some dodgy code and then resigns it your application is protected. Your application starts up but the CLR loader says the GAC assembly is not signed with the right key to match the one you expected from compile time. Hey presto the load fails and you know something is wrong.

Publisher Signing
The internet adds a whole new level of threat to your machine. Any bored developer could write a Trojan horse application and offer it for download from a benign looking website. That free Spyware Remover application actually installs a key logger to grab your bank account details. They have signed all the assemblies in the application so it looks well behaved. But all the signing does is tell you the Trojan horse application is intact and in the original condition intended by the nefarious developer!

This is where the trust based security model comes into play. Whenever you download an application, or installer, from the internet and then try to run it Windows will tell show you a warning. Asking you if you really want to run this software and then present you with information about the publisher of the software. If you trust the publisher then you would let it run, it you don’t trust the publisher or if there is no publisher details at all then you should not run it.

As a publisher you can get hold of a publisher certificate from one of the big providers such as VeriSign and use that to sign the application/installer. Then the downloader gets shown you publisher details and can be sure it is from a trusted source and has also not been tampered with since it was created.

Component Factory has its own certificate from VeriSign and we sign all our installers so you can be sure it is in the original intended state and has not been tampered with.

Publisher Signing Assemblies
As well as publisher signing your application/installer you should also publisher sign all of the individual assemblies as well. This has a couple of benefits.

First of all the end user can right click any of your assemblies and see that it is signed and examine the certificate details. This should give them a nice cozy feeling and allow your support people to show that it is not your assembly that has been hacked on your end users infected machine.

But the most important benefit is that it allows your assemblies to be used by an application that is undergoing Vista certification. The certification requirements to get the Vista logo require that your application, and crucially all the assemblies that it references, be publisher signed. As a component vendor it is essential that our own assemblies are therefore signed so that applications built by our customers can pass the logo requirements.

Component Factory Assemblies
This requirement only came to light today when a customer needed publisher signed copies of the Krypton 2.5.1 release so they could progress with Vista logo certification. If you also need them just fire off an email to use and we can provide them on demand. All future releases of Krypton will have them signed automatically as part of the build process.

As a component vendor I want to sign my own installers so all users of Krypton can have confidence in the downloads. This is especially important with Vista as it shows the signing information, or lack of, at the slightest opportunity.

Software Publishers Credentials
In order to sign an installer you a private key (extension .pvk) and a software publishers certificate ( extension .spc). Obviously signing system would not be very secure if just anybody could create their own software publishers credentials with whatever company name they like. So instead you need to get your credentials from an approved provider that will then perform some background checking. They check you really are the company you say you are and not just impersonating someone at Microsoft!

I used VeriSign to purchase my publisher credentials at a cost of $499.

I would recommend you start the process of getting your credentials before you need them as it can a few days to work your way through the process. In my case I had to get a legal notary to sign a document proving I was the person I said I was. This is a reasonable precaution when dealing with a small one man company, you might find the process quicker and easier if you work at a large corporation.

So once you have paid your money and proved your identity you end up with two files.
MyCompany.pvk
MyCompany.spc

Signing the Installer
If like me your are signing several installers and/or signing on a regular basis then you will want to automate it as part of your build process. In this case you want to use the SignTool utility to perform the actual signing of the installer .msi file. But you cannot provide your two files as parameters directly because SignTool only takes a personal information exchange file (extension .pfx) as input. As luck would have it there is a utility called pvk2pfx that takes our two input files and outputs a .pfx file.

So to sign your installer you need to perform the following two commands:-

Pvk2pfx
-f
-pi “password”
-pvk “MyCompany.pvk”
-spc “MyCompany.spc”
-pfx “MyCompany.pfx”

Signtool
sign
/p “password”
/f “MyCompany.pfx”
/d “Product Description”
/du “http://www.myCompany.com”
/t “http://timestamp.verisign.com/scripts/timstamp.dll”
/v “MyInstaller.msi”

In practice I put these into a batch file and then just pass to the batch file the password, product description and installer filename. All the other parameters will remain constant.

Now when the user downloads and then tries to run the installer you get some publisher information in the warning dialog.

You can examine the certificate information in more detail by right clicking the installer and looking at the digital signature tab.

Just because you have a garbage collector does not prevent you from having a memory leak. In this context a memory leak is where you are not releasing all references to an object; so that object is never garbage collected.

So how do you work out where that rogue reference is that prevents it from being cleaned up?

Use the following steps inside Visual Studio 2005.

Step 1
You need to set your managed project to allow unmanaged code debugging. To do this you right click the project and select Properties. The project properties will be shown and from there you select the Debug page of settings. Then ensure the Enable unmanaged code debugging option is ticked. Just like below.

Step 2
Run your application in Debug and set a breakpoint at the place where you know the problem will have already occured. Use your application until you hit your breakpoint.

Step 3
Show the Immediate window so you can begin entering some debugging commands. If the window is not present then use the View -> Other Windows -> Command Window menu option to bring up the Command window. Inside the command window you use the Immed command and then the Immediate window will be displayed.

Step 4
Use the !load sos command in the Immediate window to load the Son Of Strike debugging extensions that allow us to examine managed memory.

Step 5
Use the !dumpheap -stat command. This will then list out all the different types of object that are on the heap.

Each line gives the number of instances of that type, the total amount of memory those instances occupy, the name of the type and a MT address. The MT (Method Table) address is the address of the type and not of any particular instance of the type.

You can see below an abbreviated example of the output.

You need to search this list for the type of the object that you think should have already been garbage collected and so should not actually be present.

We will use System.Drawing.Color[] as the example type from this point onwards. Looking at the above output you can see it has four instances.

Step 6
Use the !dumpheap -mt 7ae7bde4 command to list out the four individual instances of the type. Obviously you need to substitute the address from the MT column of the type you are actually interested in.

In our debugging session the four instances are listed as.

Step 7
Use !dumpobj 013070f8 to list out information about the specific object instance we are interested in from step 6. Again, you need to substitute the actual address with the relevant value found in the previous step. Here is the actual output for the Color[] instance.

Step 8
Now that we have found the rogue instance we believe should not exist we need to find the reference that points to it. Use !gcroot 013070f8 in order to search for all the references to the instance and also display the call stack for each reference.

In our example there is a single reference to the Color[] and the call stack of the object that references it is displayed in the output.

The first object in the stack is the windows form which references the next object down; which itself referencs the one below it and so forth.

In summary, the set of commands are as follows…

List all types of objects
!dumpheap -stat

List instances of a type
!dumpheap -mt {addr}

Examine an instance
!dumpobj {addr}

Find references to instance
!gcroot {addr}

Step 1 – Create a new UserControl class

Create a new project and add a new UserControl class to your project. In our example we will add the smart tag to a UserControl but in practice you could add it to any of your existing controls or components.

Drag a new instance of the control onto your Form and then select it. This will result in something even less exciting than this picture of the selected control on the Form.

I customized my control by changing the background color, asking for a border to be drawn and then painting a string in the client area. The full code for the example generated from these steps is available from a link at the end of the article, so there is no need to type in the code from each step.

Step 2 – Add the designer attribute

We need to provide a customized designer for the control in order to provide the information the design time environment needs for showing the smart tag. In order to associate a designer class with the control class we add the following attribute to the control class definition.

[Designer(typeof(UserControl1Designer))]
public class UserControl1 : UserControl

Step 3 – Implement the designer class

The default designer associated with a UserControl is called ControlDesigner and so our custom designer class derives from this. Extending the designer involves overriding just a single property of the base class called ActionLists. This is used to return to the caller a collection of lists that are used to populate the smart tag window.

The default implementation from the ControlDesigner returns an empty collection, hence the absence of the smart tag button when you select the control at design time. Our implementation creates an action list and adds it to the list collection. Here is the complete code for the class.

public class UserControl1Designer : ControlDesigner
{
  public override
             DesignerActionListCollection ActionLists
  {
    get
    {
      DesignerActionListCollection actionLists =
          new DesignerActionListCollection();

      actionLists.Add(
          new UserControl1ActionList(this));

      return actionLists;
    }
  }
}

Step 4 – Implement an action list

This is the class that performs the real work. All action lists must derive from the DesignerActionList base class. We provide a constructor that takes a reference to the designer instance and used it to cache a reference to the control instance.

public class UserControl1ActionList
    : DesignerActionList
{
  private UserControl1 _control;

  public UserControl1ActionList(
      UserControl1Designer owner)
    : base(owner.Component)
  {
    _control = (UserControl1)owner.Component;
  }

Our simple example is going to expose a BackColor entry on the smart tag window that alters the property with the same name on the UserControl1 instance. Whenever you provide a property action you need to implement the property on the action list class itself. Our implementation of the BackColor just calls onto the underlying UserControl1 instance that was cached in the constructor.

  public Color BackColor
  {
    get { return _control.BackColor; }
    set { _control.BackColor = value; }
  }

Our last task is to override the GetSortedActionItems method. This is the method that returns a collection of items that are required to be displayed on the smart tag window. In our case we need to add just a single entry for the BackColor.

  public override DesignerActionItemCollection
      GetSortedActionItems()
  {
    DesignerActionItemCollection actions =
        new   DesignerActionItemCollection();

    actions.Add(new DesignerActionPropertyItem(
                      "BackColor",
                      "BackColor",
                      "Appearance",
                      "Background color."));

    return actions;
  }
}

Step 5 – Compile and open in design mode

Once you have compiled the above code you should be able to select an instance of the UserControl1 control at design time and then access the defined smart tag. You can see it here in it’s full glory!

You can download the source code for this sample from here.

Despite the headline this blog entry has absolutely nothing to do with the Matrix set of films. In fact it is about using the ColorMatrix capability of the ImageAttributes class for drawing images.

Not only does that description not fit into the title but there is no chance you would have read the entry without the Reloaded part of the name. A marketing guy would call this technique a Teaser. The rest of us call this very sneaky.

If I was selling fish fingers, or any other food, then this would be called a breach of the trade descriptions act and the local council would be onto me. In fact they would already have closed me down. Luckily no one cares about accurate descriptions in the software industry and so we will continue without fear.

Drawing a Disabled Image

I am in the closing stages of writing a Button control and want to make it look good when it was disabled. There are two ways to handle this issue. The easiest solution for me is to get the developer to provide two images, one for when the control is disabled and another for when it is enabled.

Not only is this lazy but it demands extra work from the developer to use my control. The whole point of our library is to make the developers application look good with a minimum of effort from the developer himself. So the alternative solution, and the one I am taking, is to take the enabled image and then draw it in a disabled appearance.

In the past I have used the ControlPaint.DrawImageDisabled method provided by the framework but I am no longer happy with that solution. I want to provide more flexibility in the appearance and so let the developer choose a variety of different ways the image could be manipulated.

Enter The ColorMatrix

This is where the ColorMatrix comes into play because it can be used to modify the colors of the image when it is being drawn. So now my button control allows the developer to specify an enumeration of different ColorMatrix settings to be applied.

Here is a picture with three buttons. The name of the enumeration value is used as the button text and the image is drawn in the named style.

The first is called normal and has no color modification applied. In the second the matrix is used to convert from color to a black and white scale. Last of all the disabled appearance is achieved by using a gray scale but also making the colors 10% brighter than normal. This gives a more subtle look and feel.

GrayScale Matrix Code

new ColorMatrix(new float[][]{

});

The first three lines of the matrix are used to convert the Red, Green and Blue colors of the pixel in that order. The fourth line is used to convert the alpha channel and the fifth line for adding/subtracting values.

So in this example the fourth and fifth lines use a value of 1 to show they are leaving the alpha channel alone and not applying any addition/subtraction.

The values in column 0, 1 and 2 of the first three lines are the same because in order to convert to a grayscale we need to ensure that the RGB values are the same for the R, G and B. Notice that the 0.3, 0.59 and 0.11 values add up to exactly 1.

These three relative factors are used because the eye has better acuity in the green range than in the red and the red is better than the blue. Hence we want to take more account of the green (0.59) than the red (0.3) than the blue (0.11).

Color Intensity

There is no limit to the color manipulation you can achieve and so I also added some extra enumeration values for making the image lighter or darker in appearance. These might prove useful in many different situations. Here they are in operation.

Breaking Point

As an experiment I tried converting just two of the colors to grayscale and leaving the third alone. In the example below you can see GrayScale R where the blue and green have been gray scaled but the red left alone. Below that are the other two versions for blue and green variations.

The reason they are not coming out perfectly is that the three circles are not filled with pure red, pure green and pure blue. Hence the conversion is not achieving the exact effect I was intending. I have decided to leave these enumeration options in the code although they will not be used very often.

Pain Points

By providing these different effects out of the box the developer has more options in presenting the button image. They might decide to have the button appear gray scaled normally but become full color when the mouse tracks over it. Alternatively they might want to use a darker version of the image normally and only use the normal image on hot tracking.

The important point is the developer provides just a single image and can then apply different effects without needing to create them using a separate package, such as Paint Shop Pro. To use a really stupid management style phrase, we are removing a Pain Point for the developer.

Version 2 of the .NET Framework is a great improvement for Windows.Forms developers. Each time I investigate a new area I find some cool new feature that makes life so much easier than before.

Control.DisplayRect

My previous technical entry has already mentioned use of the DisplayRect property as a way of controlling the child space available for positioning children. This is a great feature and without this it would be a real pain to achieve the same effect.

Control.AutoSize

Now I have noticed another great addition that will save developers time. There is a new Control property called AutoSize that does exactly what it says. When defined it will automatically resize the control appropriately.

For instance, if you create a Button control instance then the control will size itself to fit the Text content. Now this might not sound very exciting, but in the past you had a real pain getting a control such as a Button to size properly.

For a start you would have to get the Font used by the Control and then measure the size of the Text for that Font. Then you need to add on a sensible spacing gap around the text and finally add the border allocation. Not rocket science but still a pain to have to write the code.

Header and Button

Knowing this great new property is available means I want my own controls to provide the same functionality. If a user can take advantage of AutoSize on a standard windows Button then they will, quite reasonably, expect my own controls to provide the same functionality.

As the image from a previous post show, I have completed the simple Header control for the library. I am now into the process of creating a Button control that reuses the same rendering process.

After a little investigation I worked out how to hook into the auto sizing process. It turns out to be really easy and I recommend that anyone else writing a custom control also adds the capability.

GetPreferredSize

All you need to do is override the virtual method called GetPreferredSize and return from it a Size instance the is the preferred size you would like your control to be. That’s it. Just override that one method and your done.

This is so simple there is no excuse for not adding it to your own controls.