Musings and frustrations

Still lovin’ WPF

peteohanlon — Tue, 22 Apr 2008 20:12:35 +0000

In a previous post I looked at why WPF was something to really take a look at. I posted a bare bones WPF page that just contained a status bar. In this post, I’d like to show how to spruce the WPF up with just a little bit of effort (and hopefully to demonstrate why I really like it).

Anyway, without further ado, here is the updated class:

http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Main Window" Height="450" Width="600">
    
        
            
            
            
            
        
    
    
        
            
                
                    
                        
                            
                        
                        
                            
                            
                        
                    
                
            
            Ready
            
                Set

As you can see, we have declared a style (similar to the way you think of styles in CSS). The background of the statusbar is set to this style and, lo-and-behold, the status bar now has a nice blue gradient. In the next post, we’ll look at adding extra elements and see how the styling can help it to stand out more.

Lovin’ WPF

peteohanlon — Sun, 20 Apr 2008 20:49:42 +0000

Recently we’ve been moving more and more towards using WPF to deliver LOB applications (Line Of Business). It took me a while to persuade the team that WPF was something worth investing time and effort in, which is funny really because they normally jump at the chance to play with new technologies. So, how did I do it? Ironically - it was with a hugely trivial example; a status bar. Basically I showed them how the same code could be written in markup in two ways. The first one was:

while the second one was:

http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 x:Class="StatusBarInWpf.Window1"
 x:Name="Window"
 Title="Window1"
 Width="640" Height="480">

The thing I love about the second version is the way that the StatusBar template is removed from the actual implementation of the StatusBar, so you can move them into one place (currently in the Window.Resources but this could be put into a named template or the Application.Resources) and manage them really easily.

I won an armageddon button.

peteohanlon — Thu, 03 Apr 2008 12:03:44 +0000

Woo hoo. At www.community-credit.com, I won a nuclear war USB hub. It’s really cool. Check it out at http://www.community-credit.com/CommunityCreditPrizePage.aspx. Just look under March 2008 prizes. If you haven’t joined Community Credit, then I suggest you do so pronto.

Help me - I’m a user.

peteohanlon — Thu, 13 Mar 2008 14:14:44 +0000

I need help. I’m a user - I admit it. I love using the using statement in C# (I’m not talking about the one that’s equivalent to the #include statement). Imagine my surprise that some people haven’t heard of this wonderful, wonderful keyword.

So what does it actually do? Well, you can think of it as automatically calling Dispose on a disposable object. Effectively, it translates into a try/finally block where Dispose is called automatically in the finally section. So:

using (SqlConnection conn = new SqlConnection())
{
 // Do something...
}

translates into

SqlConnection conn = null;
try
{
  conn = new SqlConnection();
  // Do something..
}
finally
{
  if (conn != null && conn is IDisposable)
    ((IDisposable)conn).Dispose();
 
}

It’s perfectly possible to nest using blocks, and the compiler will ensure that Dispose is called in the correct fashion. So, if a class has a Dispose method, you should really consider wrapping it in a using(…) block.

Warning - If the class you are referencing in the using statement doesn’t implement IDisposable then you can’t do this.

Now, did you know that you can alias namespaces in a using statement? It’s true - if you don’t want to put in that StreamWriter is in the System.IO namespace all over your code and you are in the midst of classname conflicts, it’s a simple matter to put something like the following in your code:

using io = System.IO;

Then, elsewhere in your code you can use:

using (io.StreamWriter sw = new io.StreamWriter(@"c:\dev.txt"))
{
}

Note the “clever” use of the two different using types.

Returning status 500 from an HttpHandler

peteohanlon — Sun, 02 Mar 2008 20:28:19 +0000

Recently, on The Code Project, a question was posted about returning the status 500 and it not actually working. I suggested that an HttpHandler would be the way to cope with this, and the original poster asked how to do this. Rather than posting the answer there, I decided to post it here. Without further ado, this is how it is done:

/// 
/// Base class for ensuring that the handler always returns
/// a status code.
/// 
public abstract class StatusHandlerBase : IHttpHandler
{
  private int _returnStatus = 400;
  /// 
  /// Initializes a new instance of .
  /// 
  public StatusHandlerBase() {}
  /// 
  /// Initializes a new instance of .
  /// 
  /// The Http status code
  public StatusHandlerBase(int status)
  {
    _returnStatus = status;
  }
  /// 
  /// Don't let the response be cached by the browser. Set up the status code
  /// and return.
  /// 
  public virtual void ProcessRequest(HttpContext context)
  {
    context.Response.Cache.SetCacheablity(HttpCacheability.NoCache);
    context.Response.Cache.SetNoStore();
    context.Response.Cache.SetExpires(DateTime.MinValue);     ParseStatusCode(context, _returnStatus);
  }   /// 
  /// Actually set up the status code at this point, and return.
  /// 
  protected virtual void ParseStatusCode(HttpContext context, int statusCode)
  {
    context.Response.StatusCode = statusCode;
    context.Response.End();
  }   public bool IsReusable
  {
    get { return true; }
  }
} /// 
/// This concrete implementation of the  class
/// sets up the http handler to return a status code of 500.
/// 
public class Return500 : StatusHandlerBase
{
  public Return500() : base(500) {}
}

Now, one of the things I always like to do is to look for ways to abstract so even in a relatively trivial example like this, there’s abstraction. I’m sorry, but there you go - personality quirk and all of that. There you go though, an HttpHandler that returns a 500 status.

Return to Regex.

peteohanlon — Tue, 19 Feb 2008 15:57:15 +0000

Continuing with our series on regular expressions, here’s a more complex example of regular expression testing. In this example, we’re going to see how to check a date that comes in different formats. The extra wrinkle that we are providing here is that we’re constraining the date so that it can only be in certain centuries.

First of all, we’re going to define how the date is separated out. For instance, if we use DateSeparator.Slash, then the date will be separated by the / character.

/// 
/// Describes how the date is separated.
/// 
public enum DateSeparator
{
    /// 
    /// The parts of the date are separated by a space.
    /// 
    Space,
    /// 
    /// The parts of the date are separated by a slash (/)
    /// 
    Slash,
    /// 
    /// The parts of the date are separated by a dot (.)
    /// 
    Dot,
    /// 
    /// The parts of the date are separated by a hyphen (-)
    /// 
    Hyphen
}

Next we’re going to define the format of the date (without separator characters). This basically states the order of the different parts of the date so DateFormat.MonthYearDay corresponds to MMYYYYDD.

/// 
/// This enumeration tells you the date format that you want to use.
/// 
public enum DateFormat
{
    /// 
    /// Formatted as YYYYMMDD
    /// 
    YearMonthDay,
    /// 
    /// Formatted as MMYYYYDD
    /// 
    MonthYearDay,
    /// 
    /// Formatted as DDMMYYYY
    /// 
    DayMonthYear,
    /// 
    /// Formatted as YYMMDD
    /// 
    ShortYearMonthDay,
    /// 
    /// Formatted as MMYYDD
    /// 
    ShortMonthYearDay,
    /// 
    /// Formatted as DDMMYY
    /// 
    ShortDayMonthYear,
}

Finally we’re going to provide the methods to actually parse the date. Here there are 3 versions of the IsValidDate, with suitable overrides.

/// 
/// Checks to see if this is a valid date.
/// 
/// The date to check.
/// The  for this date.
/// True if the date is valid, false otherwise.
public static bool IsValidDate(string date, DateSeparator separator)
{
    return IsValidDate(date, separator, DateFormat.YearMonthDay);
} /// 
/// Checks to see if this is a valid date.
/// 
/// The date to check.
/// The  for this date.
/// The  for this date.
/// True if the date is valid, false otherwise.
public static bool IsValidDate(string date,
    DateSeparator separator,
    DateFormat format)
{
    List yearConstrain = new List();
    yearConstrain.Add(19);
    yearConstrain.Add(20);
    return IsValidDate(date, separator, format, yearConstrain);
} /// 
/// Checks to see if this is a valid date.
/// 
/// The date to check.
/// The  for this date.
/// The  for this date.
/// Any century periods that the
/// date needs constraining to.
/// True if the date is valid, false otherwise.
public static bool IsValidDate(string date,
    DateSeparator separator,
    DateFormat format,
    List yearConstrain)
{
    if (string.IsNullOrEmpty(date))
        throw new ArgumentNullException("date");
    // Ensure that we have some base periods to check for "long" date formats.
    if (format == DateFormat.DayMonthYear ||
        format == DateFormat.MonthYearDay ||
        format == DateFormat.YearMonthDay)
    {
        if (yearConstrain == null)
            yearConstrain = new List();
        if (yearConstrain.Count == 0)
        {
            yearConstrain.Add(19);
            yearConstrain.Add(20);
        }
    }     string dayFormat = "(0[1-9]|[12][0-9]|3[01])";
    string monthFormat = "(0[1-9]|1[012])";
    StringBuilder years = new StringBuilder();
    if (yearConstrain != null && yearConstrain.Count > 0)
    {
        foreach (int i in yearConstrain)
        {
            years.AppendFormat("{0}|", i);
        }
    }
    string yearFormatLong = string.Format(@"({0})\d\d",
        years.ToString().Substring(0, years.ToString().Length -1));
    string yearFormatShort = @"\d\d";
    string baseFormat = "{0}[{3}]{1}[{3}]{2}";
    int yearPos = 0;
    int yearLength = 4;
    int monthPos = 0;
    int dayPos = 0;
    string sep = string.Empty;
    switch (separator)
    {
        case DateSeparator.Dot:
            sep = ".";
            break;
        case DateSeparator.Hyphen:
            sep = "-";
            break;
        case DateSeparator.Slash:
            sep = "/";
            break;
        case DateSeparator.Space:
            sep = " ";
            break;
    }
    switch (format)
    {
        case DateFormat.DayMonthYear:
            dayPos = 0;
            monthPos = 1;
            yearPos = 2;
            baseFormat = string.Format(baseFormat,
                dayFormat,
                monthFormat,
                yearFormatLong,
                sep);
            break;
        case DateFormat.MonthYearDay:
            monthPos = 0;
            yearPos = 1;
            dayPos = 2;
            baseFormat = string.Format(baseFormat,
                monthFormat,
                yearFormatLong,
                dayFormat,
                sep);
            break;
        case DateFormat.ShortDayMonthYear:
            dayPos = 0;
            monthPos = 1;
            yearPos = 2;
            baseFormat = string.Format(baseFormat,
                dayFormat,
                monthFormat,
                yearFormatShort,
                sep);
            break;
        case DateFormat.ShortMonthYearDay:
            monthPos = 0;
            yearPos = 1;
            dayPos = 2;
            baseFormat = string.Format(baseFormat,
                monthFormat,
                yearFormatShort,
                dayFormat,
                sep);
            break;
        case DateFormat.ShortYearMonthDay:
            yearPos = 0;
            monthPos = 1;
            dayPos = 2;
            baseFormat = string.Format(baseFormat,
                yearFormatShort,
                monthFormat,
                dayFormat,
                sep);
            break;
        case DateFormat.YearMonthDay:
            yearPos = 0;
            monthPos = 1;
            dayPos = 2;
            baseFormat = string.Format(baseFormat,
                yearFormatLong,
                monthFormat,
                dayFormat,
                sep);
            break;
    }
    Regex regex = new Regex(baseFormat, RegexOptions.IgnoreCase
        | RegexOptions.Multiline
        | RegexOptions.IgnorePatternWhitespace);
    Match m = regex.Match(date);
    bool success = (m.Success);
    // Now, we need to do a little bit more processing
    // (taking care of invalid dates).
    if (success)
    {
        char sepChar = char.Parse(sep);
        string[] splitDate = date.Split(sepChar) ;
        int day = int.Parse(splitDate[dayPos]);
        int month = int.Parse(splitDate[monthPos]);
        int year = int.Parse(splitDate[yearPos]);
        if (yearLength == 2)
            year = 2000 + year;         if (month == 2)
        {
            if (day > 29)
                success = false;
            else
            {
                if (day == 29 && !(year % 4 == 0 &&
                    (year % 100 != 0 || year % 400 == 0)))
                    success = false;
            }
        }
        else
        {
            if (day > 30)
            {
                // The following months can only have 30 days.
                if (month == 9 || month == 4 || month == 6 || month == 11)
                    success = false;
            }
        }
    }
    return success;
}

The first thing that we do is check the input values to make sure they look valid. If no year constraints are applied then we default to the 20th and 21st century (Gregorian Calendar based).

    if (string.IsNullOrEmpty(date))
        throw new ArgumentNullException("date");
    // Ensure that we have some base periods to check for "long" date formats.
    if (format == DateFormat.DayMonthYear ||
        format == DateFormat.MonthYearDay ||
        format == DateFormat.YearMonthDay)
    {
        if (yearConstrain == null)
            yearConstrain = new List();
        if (yearConstrain.Count == 0)
        {
            yearConstrain.Add(19);
            yearConstrain.Add(20);
        }
    }

The next section is where we start to flesh out what we are actually going to use as the regular expression. We constrain the day format to be from 01 through to 31.

    string dayFormat = "(0[1-9]|[12][0-9]|3[01])";

The month format is constrained to 01 through to 12.

    string monthFormat = "(0[1-9]|1[012])";

Next we loop through the year constraints. This is where things become a little bit more complicated. Because we can cater for both long and short date formats, we need to put together constraints that suit both.

    StringBuilder years = new StringBuilder();
    if (yearConstrain != null && yearConstrain.Count > 0)
    {
        foreach (int i in yearConstrain)
        {
            years.AppendFormat("{0}|", i);
        }
    }
    string yearFormatLong = string.Format(@"({0})\d\d",
        years.ToString().Substring(0, years.ToString().Length -1));
    string yearFormatShort = @"\d\d";

Then we build up the format of the search that we will use. The base format consists of a number of placeholders that will be replaced in the regular expression. The {3} is the separator characters, and the other parts are the day, month and year values that will be put in in the order specified in the DateFormat.

    string baseFormat = "{0}[{3}]{1}[{3}]{2}";

You may notice that we do a little bit more checking once we get a match back. This final check ensures that nonsense dates such as 30th February and invalid leap years don’t pass through uncaught. Finally, to call it you can use it like this:

    string testdate = "2100/02/29";
    List list = new List();
    list.Add(21);
    if (!IsValidDate(testdate, DateSeparator.Slash, DateFormat.YearMonthDay, list))
    {
      Console.WriteLine("This is an invalid date.");
    }

I hope that this whets your appetite for delving into Regular Expressions and shows you how powerful they can be when combined with other coding techniques to build up a more flexible system. I know you can use DateTime.Parse to do a lot of what I have just shown, but this was intended to demonstrate composition of regular expressions.

Finally, I promised that we’d revisit the grab tags regex. Basically it allows you to grab tags regardless of whether or not it has nested < characters.

Regular Expressions revisited.

peteohanlon — Tue, 12 Feb 2008 13:58:21 +0000

Well - it’s time to visit Regex land again. Thanks to Mustafa for giving me the push I needed to continue with our journey into Regular Expressions. The following regular expression is a one that I find handy from time to time to identify text that occur near to each other. For instance, suppose I want to find all of the instances of time in this paragraph where there is another mention of time inside 10 words. This expression allows me to do this easily, and would be called as MatchCollection coll = FindNear(<>, “Time”, “Time”, 1, 10).

One little feature of this, is that you can set the minimum number of words that the text must be apart as well.

Anyway - without further ado, here’s the FindNear function.

/// 
/// Using this method, you can find instances of a particular word near other text.
/// For instance, you can find Dr near Who when the words occur near each other.
/// This is achieved by constraining the distance of the words that must be between the
/// instances.
/// 
/// The text to search.
/// The text to find.
/// The text to find the text near.
/// The minimum number of words the two words can be apart.
/// The maximum number of words the two words can be apart.
/// A match collection containing the find results.
public static MatchCollection FindNear(string text,
    string findText,
    string nearText,
    int minWords,
    int maxWords)
{
    if (string.IsNullOrEmpty(text))
        throw new ArgumentNullException("text");
    if (string.IsNullOrEmpty(findText))
        throw new ArgumentNullException("findText");
    if (string.IsNullOrEmpty(nearText))
        throw new ArgumentNullException("nearText");
    if (minWords > maxWords)
        throw new ArgumentOutOfRangeException("minWords");
    if (maxWords == 0)
        throw new ArgumentOutOfRangeException("maxWords");
    string reg = @"\b" + findText +
                    @"\W+(?:\w+\W+){" +
                    minWords +
                    "," +
                    maxWords +"}?" +
                    nearText + @"\b";
    Regex regex = new Regex(reg,
        RegexOptions.IgnoreCase
        | RegexOptions.Multiline
        | RegexOptions.IgnorePatternWhitespace
        );
    return regex.Matches(text);
}

So, how does it work? Well, it builds up the following regular expression (in the case of the above example):

\bTime\W+(?:\w+\W+){1,10}?Time\b

The “magic” part is the bit {1,10} which tells the expression how many words can exist between the words you are searching for. In this case it’s from 1 to 10 words.

I haven’t forgotten the first part of the series on regular expressions - we’ll come back to that one in the next installment when I cover a different way to handle dates. In the meantime, have fun playing around with this regular expression.

Config Files and Dlls.

peteohanlon — Wed, 23 Jan 2008 15:50:15 +0000

Well - A request recently came up on CodeProject asking how to associate a config file with a DLL and then use that configuration file. Like me you would think that this would be an easy thing to do, and that it would be taken care of for you automatically. Unfortunately, it would seem that this isn’t the case - it’s easy enough to do, but you have to do it yourself. One way to do it would be to use XML to read the configuration file directly and then deal with it from there, but it turns out that there is another way that allows you to use the ConfigurationManager directly. To do this, you need to load the application into a separate application domain and then use remoting to access it. This does give you the ability to load plugins with their own config file and isolate them from the main process just in case they are a bit naughty.

Here’s a quick overview of the process - suppose you have a config file for your plugin Dll that contains the following settings:

Your Dll class may implement the following interface:

public interface IPluginConfiguration
{
  string PluginName { get ; }
  string RequiredVersion { get ; }
} public class MyPlugin : IPluginConfiguration
{
  public string PluginName
  {
    get
    {
      return ConfigurationManager.AppSettings["PluginName"];
    }
  }
  public string RequiredVersion
  {
    get
    {
      return ConfigurationManager.AppSettings["RequiredVersion"];
    }
  }
}

Now, in your calling application you could do the following:

private IPluginConfiguration _config;
public void ActivatePlugin(string configFile, string domainName)
{ 
  AppDomainSetup setup = new AppDomainSetup(); 
  setup.ConfigurationFile = configFile; 
  AppDomain domain = AppDomain.CreateDomain(domainName, null, setup); 
 
  _config = (IPluginConfiguration)domain.CreateInstanceAndUnwrap("MyDll", "MyDll.MyDllClass");
  Console.WriteLine("Name {0}", _config.PluginName);
}

There you go - you can now refer to the localised config file. It’s that simple.

Sql Server, GetDate and Linq to Sql.

peteohanlon — Fri, 11 Jan 2008 09:44:04 +0000

OK, you’ve put a default value of GETDATE() on a column in your database and you’re inserting a record via InsertOnSubmit. Oh no, the current server date isn’t applied to your record. How can you get the server date and apply it?

Well, it turns out that there’s a really simple trick that just requires a little bit of skullduggery on your part. (I like that word). Create a partial class that corresponds to your data context. In that class, put the following code:

[Function(Name="GetDate", IsComposable=true)]
public DateTime GetSystemDate()
{
  MethodInfo mi = MethodBase.GetCurrentMethod() as MethodInfo;
  return (DateTime)this.ExecuteMethodCall(this, mi, new object[]{}).ReturnValue;
}

Then, all your code needs to do is call GetSystemDate() whenever you need to the current date from SQL.

Note: You may wonder why I’ve gone to all of this trouble, rather than using DateTime.Now in the client code. By using this method, we get the date and time based on the database server, rather than on client connections which may be set to different times.

Refining queries in Linq.

peteohanlon — Thu, 10 Jan 2008 09:59:12 +0000

The more I play around with Linq, the more it really appeals to me. It really is amazing how powerful it is, and how flexible it can actually make your applications. “Examples” I hear you cry, “give me examples”. Who am I to deny you when you ask so nicely?

Quite often, when an record is deleted in a database, the application design mandates that the record isn’t physically deleted. Instead, it is given a status of Deleted. This means that retrieval of live records needs to take this status into account. Now, in stored procedures you would add a check for the status in each query that you perform against one of these tables. As you can imagine, this quickly becomes very tedious.

So, how can Linq help to make this situation better? Well one of the tricks that you can employ with Linq is refining queries, so you start with a general query and then refine it until you get to a specific query. So, how does this work in practice? Well, take a look at the following query to get all of the records from a table (cunningly called MyTable in this example):

protected virtual IQueryable GetAll()
{
  IQueryable query = from myTable in context.MyTable // The context is the DataContext.
     select myTable;
  return query;
}

Now, as you can see, this query retrieves all of the records from MyTable regardless of status. However, we’ve already stated that we want a query that retrieves records that have been marked as Deleted (in MyTable, there’s a bit field called IsDeleted that states whether or not the record has been deleted). It turns out that it’s really easy to refine these queries. In the next example, we are going to provide methods that refine the original query further and further. We want a method that gets active products, and another method that gets active customers.

protected virtual IQueryable GetAllLiveItems()
{
  IQueryable query = GetAll();
  query = from myTable in query
          where myTable.IsDeleted == false
          select myTable;
}  public List GetActiveProducts(string name)
{
  IQueryable query = GetAllLiveItems();
  query = from myTable in query
          where myTable.ProductName == name
          select myTable;
  return query.ToList();
}  public List GetActiveCustomers(string name)
{
  IQueryable query = GetAllLiveItems();
  query = from myTable in query
          where myTable.CustomerName == name
          select myTable;
  return query.ToList();
}

I know, the table normalisation sucks big time, but this is intended to highlight how the queries have been refined. As you can see, the GetAllLiveItems method refines the original GetAll query so that it retrieves records that haven’t been deleted. The GetActiveCustomers and GetActiveProducts queries take the query from GetAllLiveItems and refine it further still to return the appropriate list. It’s this ability to refine and extend broad stroke queries that, in my mind, opens Linq up as a real rapid database application development tool.