FryHard

Selecting distinct records using Castle ActiveRecord

Fryhard — Tue, 26 May 2009 04:14:36 GMT

A while ago I jumped through the hoops of fire to find out how to select distinct records from a table using Castle ActiveRecord. Although it turned out to not be too difficult it is not one of those code snippets that I keep in brain’s cache. It is for this reason that I am adding it to my blog with the hope that it may help me and others in the future.

The below query will select a distinct list of companies who have employees whose name starts starts with a J.

DetachedCriteria distinctCriteria = DetachedCriteria.For(typeof (Company))
    .SetProjection(Projections.Distinct(Property.ForName("Identifier")))
    .CreateCriteria("Employees")
        .Add(Restrictions.Like("Title", "j%"));

DetachedCriteria fullCriteria = DetachedCriteria.For(typeof(Company))
    .Add(Subqueries.PropertyIn("Identifier", distinctCriteria));

Company[] result = ActiveRecordBase<Company>.FindAll(fullCriteria, new Order[] { new Order("Title", true) });

I have mocked up an example that show the select as it would normally be performed which returns duplicate date. The example then shows the above select distinct query which does not return the duplicates. You can download it from here.

Useful C# snippets

Fryhard — Sat, 28 Feb 2009 08:55:24 GMT

I recently sat down at my computer at home, opened up Visual Studio and came to the realisation that I cannot program at home. I cannot program at home, not because I have cool games to play (everyone please check out Burnout Paradise, it is awesome), not because I have fun series to watch (once again, WHY did they cancel FarScape), but merely because my computer at home is just not set up to program!

I don’t have any of the cool things set up like they are at work. This as you all know is a sad situation to be in and since I started this blog to be a place where I could put useful stuff, I decided that I should start doing exactly that. (That or I am just procrastinating, because I cannot work at home!)

Visual Studio introduced snippets quite a while ago and I have to say that in most cases I do not use them. Mostly one will see snippets in demo videos where the presenter does not show how badly he types. Though there is one personal snippet that I cannot live without as I learnt this morning. This snippet we affectionately refer to as sgs, Short Get Set.
Type in sgs, hit Tab and you will end up with { get; set;}. 4 key presses for 12, quite a good deal I think. Also remember developers can’t type!

With a short amount of searching I was able to find the MSDN page that shows you how to make a snippet, and recreated my beloved sgs. Below is the code. Save it as sgs.snippet into your \Documents\Visual Studio 2008\Code Snippets\Visual C#\ folder and the next time you type sgs and Tab it will work!

    1 <?xml version="1.0" encoding="utf-8"?>
    2 <CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    3   <CodeSnippet Format="1.0.0">
    4     <Header>
    5       <Title>Short get set</Title>
    6       <Shortcut>sgs</Shortcut>
    7       <Author>FryHard</Author>
    8       <HelpUrl>blog.fryhard.com</HelpUrl>
    9     </Header>
   10     <Snippet>
   11       <Code Language="CSharp">
   12         <![CDATA[{get; set;}]]>
   13       </Code>
   14     </Snippet>
   15   </CodeSnippet>
   16 </CodeSnippets>

Visual Studio: No files were found to look in. Find was stopped in progress

Fryhard — Fri, 28 Nov 2008 04:34:02 GMT

This week seems like the week for strange errors. Luckily it is also the week for "easy" fixes.

When conducting a find in files (CTRL + SHIFT + F) in Visual Studio (for me this is VS 2008) the search completes in a second and returns with the results.

No files were found to look in.
Find was stopped in progress.

Google-ing for this errors shows that it has been around for as long as it has been confusing people. Franny's Abode gave a fix way back in Visual Studio 2003!!!

Spin around on your chair 3 times,
clap your hands twice and then press...
CONTROL + SCRLK (scroll lock)

Visual Studio 2008 closes at build, Outlook 2007 Add-In

Fryhard — Wed, 26 Nov 2008 09:41:33 GMT

I am currently working on a Microsoft Outlook Add-in component to the group of applications that happily live on my back. I was given a sample application by the BA that was meant to be a basic mock that I now need to neaten up and flesh out.
Yet for the life of me I was unable to get this project to run without it pulling down Visual Studio in the process. Many hours of searching and found an answer that for the moment is working. So I decided to replicate the information here on my site in the hopes that it will be easier to find for the next person looking for help.

The Back story:

1. Open Microsoft Visual Studio 2008 Team Edition running .Net 3.5 SP 1
2. Create a new Office 2007 Add-In (File > New Project > Visual C# > Office > 2007 > Outlook 2007 Add-In)
3. Choose a Name for your project and select OK.
4. Select Build or Run or press F5
5. BOOM (well not so much a boom as a *poof*). Visual Studio is gone. You are back on the desktop and you don’t even get to tell Microsoft about it!
6. Check the event view and we find a nice error that looks like this: .NET Runtime version 2.0.50727.3053 - Fatal Execution Engine Error

The Real Problem:

I finally found a solution here.

This is not a PowerCommands issue but rather a problem with the CLR itself where this problem manifests if assemblies are loaded in a certain order.

Installing PowerCommands and then creating a new Outlook 2007 project causes assemblies to get loaded in a way that this problem surfaces.

Looking at the source code for PowerCommands, we see a Reference to System.Core.dll. Attaching a debugger to the VS2008 IDE, we see the following being logged just before the crash: CLR: (C:\Windows\assembly\GAC_MSIL\Microsoft.VisualStudio.Tools.Office.Runtime.v9.0\9.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.Tools.Office.Runtime.v9.0.dll) Rejecting native image because dependency C:\Windows\assembly\GAC_MSIL\System.Core\3.5.0.0__b77a5c561934e089\System.Core.dll is not native

This is supposed to be fixed for the next version of the CLR.

The Solution:

1. Uninstall PowerCommands.
2. Remove the native image cache of the VSTO DLL (per the workaround instructions).

Removing the native image cache:

Delete the native image generated for VSTO.

To do this, open a command prompt, navigate to the directory below, and enter the text indicated below in that directory to initiate the deletion.

This removes the Native Image Cache of the VSTO DLL. It does not delete the VSTO DLL.

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727>ngen /delete Microsoft.VisualStudio.Tools.Office.Runtime.v9.0

The main copy of the VSTO DLL will remain untouched, so no functionality is lost, there may be a small performance penalty. Neither the engineer nor I noticed a performance hit.

To re-install the VSTO DLL into the cache, run the NGEN command on the DLL. For example, here is the command to re-install. Note, you need to be in the same folder as the DLL.

ngen Microsoft.VisualStudio.Tools.Office.Runtime.v9.0.dll

New Look?

Fryhard — Mon, 03 Nov 2008 04:48:42 GMT

For those that visit my blog regularly you will notice that it's look and feel has changed. This is because I recently upgraded to SubText 2 and couldn't get my old skin to work. I am OK with the change since the old skin used to have some nasty errors that I kind of just ignored. I have no yet noticed any problems, but if you spot any please leave me a comment on this post.

Generator Studio available on Codeplex

Fryhard — Fri, 31 Oct 2008 05:35:23 GMT

For those of you that happen to also read The Darkside you would have noticed that he and I (more he) recently released one of our most useful tools onto CodePlex.

Generator Studio is a code generation tool that points to a database and from uses the Velocity Template Language to generate code from template files. It will allow you to easily generate Castle Active Record ORM classes from a database. These classes will have your correct namespace and have all of the reasonably hard to remember attributes set up and ready to go. Yet, this is not the soul of the tool, by manipluating the template you can easily also generate controller, WinForm, WebForm, or any other code/file.

*NOTE* The application is a work in progress that we alter as we see fit (for the better). So we would love to hear what you have to say, see templates that you may be able to contribute, or hear that our code is bad :)

Castle ActiveRecord Async data fetching

Fryhard — Thu, 11 Sep 2008 04:50:28 GMT

As I may have said before I am working on a project that makes use of Castle ActiveRecord as the ORM to map the data in the database to the objects in the application. The project, as all applications should be :P, is a windows application and this therefore lends itself to some nifty async data calls to fetch our data while not locking the UI.

This is however were we run into a problem: It seems that a vanilla implementation of ActiveRecord is not happy when you fetch data on one thread and other related data on another thread.

   35 [ActiveRecord("Company", Schema = "dbo")]
   36     public class Company : BaseObject
   37     {
   38         [HasMany(typeof(Person), Table = "Person", ColumnKey = "CompanyId", Lazy = true, Where = "IsDeleted=0")]
   39         public virtual IList<Person> Employees { get; set; }
   40     }

This is easily show (as in the example) by creating an object that has a list of child objects that has been marked as list. In this case we have Companies and People. Companies have many people as employees. We don’t want to fetch all employees every time that we fetch a company so we mark it as lazy.

We will fetch the company in an async load and in the call back try and fetch the linked people. This is not really a perfect example since obviously one would rather fetch the small company object synchronously and then retrieve the large list of people asynchronously, but it works for this example.

When trying to fetch the list of employees in the originating thread a "failed to lazily initialize a collection, no session or session was closed" is thrown. This is the problem.

We are working on a solution to this rather annoying problem and will keep you posted when/if we find one.

Looks like we have a SOLUTION! Well most of one, check out www.darkside.co.za for help.

DevExpress XtraBars separator

Fryhard — Mon, 07 Jul 2008 13:07:52 GMT

Are you using DevExpress to make your winforms look pretty?
Are you using a XtraBars.Bar as a Toolbar?
Not sure how to add a separator between buttons?

Simple!

Right click on the button that you want to create the separator before and select “Begin Group” from the context menu. This will insert a separator in front of the button.

The toolbar before the group was added:

Select Begin a Group from the context menu.

And there you have it

RocketDock – Mac menu for Windows

Fryhard — Mon, 02 Jun 2008 06:26:27 GMT

RocketDock

At a recent LAN I spotted a cool looking application running on a one of my friends PC’s. It turned out to be RocketDock. This application is self described as “a peace offering from the Mac community to you”; it is the creators’ hope that by providing Windows users with a pretty interface that the OS wars will end. :)

The best way to describe RocketDock is as the (cool) Mac menu for Windows. It supports opaqueness, bouncy icons while applications load and is really really pretty to look at and play with.

This application will probably not help you code better, play games better or be more productive, but on those days when you are feeling down and Windows XP is boring you to death it may just put a smile on your face.

The Mac menu that we all know

Transposing Columns and Rows in Microsoft Excel

Fryhard — Wed, 28 May 2008 05:11:19 GMT

Recently I have needed to invert / swap / transpose the data I had represented as columns into data represented as rows. The data as in most cases was a table stored in Microsoft Excel. Finding the answer (the first time) took a few Googles through the web (the second and third time was a lot easier).

I was expecting there to be a menu option hidden somewhere under Format or Data or some other obscure place, but it turns out that this function has been provided in the copy paste functionality of Excel.

All you need to do is copy your data (make sure you select all of it) and then use the Paste -> Transpose function to paste it over the old data or into a new sheet.

The Original data set

The Final data set

StackOverFlow

Fryhard — Sat, 19 Apr 2008 17:04:10 GMT

A quick post to mention the next developer helping, knowledge base, Q&A website.

www.stackoverflow.com is being created as a joint venture by Joel Spolsky and Jeff Atwood and I have a feeling that it will finally do the job right! No more paying to see an answer. No more rants posted by 12 year old script jockeys. No more irritating adverts. No more flame wars against microsoft mid answer (well maybe some).

This site will be done properly! They are currently talking about paper prototyping the site in the announcement conversation that is available for download from the site.

Paper Prototyping! Good Design! Clever People! Yes Please!

Launchy: Replacing [Windows]+R?

Fryhard — Fri, 18 Apr 2008 09:53:45 GMT

For as long as I can remember (well maybe not quite) I have made use of the run functionality within windows. For the most part you able to run the command/ program/ URL that you want to by simply pressing Windows key and R and then typing what you want to do.

Then came Windows Vista with its new fancy type and filter start bar (.

You are able to pop open the start bar and type what you want, be it a program, file, email or previous command that you have run and it will display in a list above the search so that you can choose what you want to run.

My foray into the use of Windows Vista was cut short with me moving jobs and I am now back to [Windows]+R and Windows XP. Though, in the space of the last week, I have heard of the applicaiton Launchy twice. So I downloaded it and can now say that I am hooked.

By simply pressing [Alt]+[Space] the Launchy window pops up and you are able to type what you want to do and let it suggest programs. From here it is a simple [Enter] and you are running your program.

Congratulations to the creators of a great free app.

Attributing: Fancily dressed Classes

Fryhard — Tue, 15 Apr 2008 15:18:38 GMT

Creating Attribute Classes in C# .Net

Recently I have found the need to add attributes to a class. The plan was to reflect a child form’s attribute’s properties from the base from and in this way gain access to the forms display name and the name of the data type that the form would be displaying. By doing this we would not need to force each child form to implement a pointless interface to provide this detail. It turned out that attributes were easy to make, easier to use and provided a wealth of functionality.

This "mini" post will hopefully introduce you to attributes and provide you with a slightly better understanding of what they actually do.

[Section (“Start”)]
So I guess we need to start by introducing attributes and explaining what they are. It turns out that attributes are classes. Yes, those funny little [] things on top of your classes and methods are for lack of a better explanation, instances of attribute classes. By declaring [Naming("Window Location Capture")] we are creating an instance of the Naming attribute class and passing the string “Window Location Capture” to its single parameter constructor.

[Section (“Well know Attributes”)]
To realise that these attribute classes affect our every day programming lives think of the UI code that you use when creating a custom control. In order to set up the controls behavior in the properties window we decorate our control’s properties with [Browsable(true)] and/or [Category("Foo Category")] and/or [Description("Foo")]. Doing so allows us to specify that the property must be displayed in the property box. That it must fall under the category called Foo Category and that it must display “Foo” as the description for this category.

The above were all property attributes, that being they can only be applied to properties. A well knows class attribute is the [Serializable] attribute. You will notice that this attribute takes no parameters.

[Section (“Enough with the basics”)]
Right, so on with how to make your own attribute.

Doing this is rather easy and involve three basic steps.
1.

     [AttributeUsage(AttributeTargets.Class)]

Deciding what type of attribute you want to create: Assembly, Class, Constructor, Delegate, Enum, Event, Field, GenericParameter, Interface, Method, Module, Parameter, Property, ReturnValue or Struct.
I will not even try and give you an example of each, but rather let you choose and research which you want to use.

2.

    public class Naming : Attribute

Inherit the Attribute class.

3.

    public string DisplayName { get; set; }

Add you properties and set up the constructor.

That’s it. You now have an attribute class that can be applied to whatever you decided you wanted to apply it to.

[Section (“Reading your attributes”)]
So everyone is now thinking great! We have attributes on all our methods, now what do we do. Well to make use of these attributes we need to use reflection. By reflecting the class or property that we are looking for we can query if attributes have been applied. If attributes have been applied we can retrieve them and gain access to their properties.

We get the type that we are working with. In this case we are working form a base form and accessing the attributes on the child class.

   Type t = this.GetType();

Having retrieve the type of the child class we check if the specific attribute has been applied to the class.

   if (Attribute.IsDefined(t, typeof(Naming)))

If the attribute has been applied we can gain access to an instance of that attribute.

   Naming myAttrib = (Naming)Attribute.GetCustomAttribute(t, typeof(Naming));

Now we can gain access to the properties of this attribute.

   this.Text = "Attribute Example | " + NamingAttrib.DisplayName;

[Section (“Further examples”)]

I have mocked together some code that displays some the principles that I have talked about. Hopefully you will be able to find enough information to work out how you can use attributes.

There is also a write up on attributes over at MSDN http://msdn2.microsoft.com/en-us/library/aa288059(VS.71).aspx

The Nokia Morph

Fryhard — Wed, 19 Mar 2008 09:04:08 GMT

The Morph in "Phone mode"

Whenever I hear the word morph I always think of Morph or Morphie (not moffie for our Afrikaans readers) from the movie Treasure Planet. This little guy was able to change into any shape that he felt like changing into. Though the change was governed by his size. I.e. he (or would it be it) could not change into something the size of Godzilla.

It seems that Nokia (one of my least favorite cell phone manufacturers) also enjoyed the movie, paired up with the bright kids at Cambridge and are working on a morphing cell phone that makes use of all the nifty abilities that nano-technology provides.

I am impressed. If a phone like the one they propose exists I would buy it, now!

Take a look at the cool designs that they have proposed and if that is not enough for you to salivate over, you can head over to the Nokia Morph’s site and watch a short skit on the possibly features.

All I can say at the moment is: “I am still not buying your silly phones, but make this one and I will be there in a heartbeat! Go Nokia go!”

The Morph in "Wrist Mode"

Women implement the Factory Method Pattern???

Fryhard — Thu, 13 Mar 2008 17:01:17 GMT

The other day while trawling the archive of the web comic xkcd (My thanks go out to singe for showing me the light. It is GOOD!) I happened upon the comic that is the inspiration for this post.

Now before I get started, I have to mention that a while ago I studied Design Patterns, but I brushed then off as silly nuisance. Back then they were nothing more that people writing about obvious facts that any/everyone knows and seemed more general knowledge. What I have recently noticed is that that is EXACTLY what they are. Design patterns common problems with solutions that can be used over and over again to solve them.

Back to the subject at hand: The web comic expresses a man’s (who must be a geek) unbelief and fascination of how a woman has a factory for creating more of herself. For those that have not noticed, this is along the lines of the Factory Method Pattern, and that it the subject of this post.

Factory Method Pattern

The factory method pattern allows classes to defer instantiation to their subclass.
In the basic form, the factory method pattern involves a creator and a product. The product is an abstract representation of a group of products while the creator is the base class of a possible creator hierarchy. A user asks the creator for an instance of a product and the creator will return it as a product. Rather confused? Not to worry? Remember, we are talking about the factory method pattern. What do factories do? They create stuff? Some pretty black pictures may help.

As we can see from the above the Creator creates instances of Product. The user does not need to worry about how the concreteproduct is created or what type of product it is since the concretecreator will return the concreteproduct via its interface. The words polymorphasism spring to mind. The creator similarly reliese on the concretecreators to create the correct concreteproject. Each conctretecreator is responsible for its own conctreteproduct.

As I said at the beginning this is only the vanilla flavor of the factor method patter. Derivatives allow for the creator to return a default instance of the product and more excitingly for the creator to be told what type of product it should create.
As I typed that last sentence I could see a big switch statement appear in my mind.

switch (productType)
{

case ConcreteProduct1:

return (Product) new ConcreteProduct1();
break;

case ConcreteProduct2:

return (Product) new ConcreteProduct2();

break;

...

But this is silly code that we would have written back in 2002 or before. Thanks to .Net (and other frameworks :)) we have funky things like Generic Types and Reflection. Using these we can do some rather funky things like create and instance of a class from a passed class type and return it as an interface that passed class implements.

public static class Creator
{

public static I Create<I,C>()

where I : class

where C : class,I

{

return (I) Activator.CreateInstance(typeof (C));

}

What we now have is a single creator class that can create an instance of any class and return it as an interface that that class implements. I have to admit that this code is rather staggering (WOW) for me (says something about what I have been writing in the past). I have to credit DarkSide for its creation.

Hopefully this has helped you build an idea of what factory classes are all about. If not, or you think that I may have missed something let me know.

Oh... if you are interested take a look at this (FactoryPattern.zip) code example as a supliment for the above discussion.