Dot Net Technologies -- MS Tech talk and more - Design

Tip of the Day: Creating a control that displays multiple types of messages using the IValidator interface

Daryl — Tue, 10 Aug 2010 05:06:51 GMT

Today's tip is more than a tip. It's a full project which contains a sample of a control I call the MessageCenter. When developing interactive applications, it's important to provide the user convenient feedback in a consistent location. In my current application I am working on, there are three types of messages (which are typical for most applications) -- errors, informational messages, and warnings.

I wanted to make sure each one appeared different enough so the user could quickly determine which ones needed the most attention. There are a lot of ways I could have accomplished this, such as a class/collection which maintained the type of message, and each class has it's own CSS for displaying. However, I opted for a siumpler solution which is available to every ASP.Net page -- The Validators collection (part of the page object).

The Validators collection maintains a list of objects which implement the IValidator interface. This collection is automatically bound to the ValidationSummary control on the page before (for client-side validation) and after a postback. During a postback for example, you can add a new error to the Page.Validators collection by calling the Add method, and supply a class which implements the IValidator interface.

In the sample project, I implemented three classes -- ValidationError, ValidationNotification and ValidationWarning -- to specify my three different types of messages. Each implements the IValidator interface essentially the same way. I can use the ErrorMessage property of the interface to display the message I want to convey to the end user.

In my page base class, I implemented members to easily add these messages to the Page.Validators collection, as shown below:

 public void DisplayError(string message)
{ this.Validators.Add(new ValidationError(message));
} public void DisplayError(string message, params string[]
p) { DisplayError(String.Format(message, p)); } public void DisplayMessage(string message)
{ this.Validators.Add(new NotificationValidator(message));
}

Note in some of the methods, I can pass in a list of parameters, so I can format the message displayed with a variety of details.

The MessageCenter.ascx control is where the work is done. When added to a page, it provides a ValidationSummary control to handle the clientside validation, and a Repeater which handles the postback messages. With some work, you could integrate the two, but that is way beyond what I needed.

During the Page_Load event of the MessageCenter control, I bind the Page.Validators collection to the Repeater. I also remove these from Page.Validators collection afterwards, as I don't want them displaying in the ValidationSummary control I use for client validation.

 protected void Page_Load(object sender,
EventArgs e) { rptNotification.DataSource = this.Page.Validators;
rptNotification.DataBind(); rptNotification.Visible = (this.Page.Validators.Count
!= 0); for (int idx = (this.Page.Validators.Count - 1);
idx >= 0; idx--) { IValidator val = this.Page.Validators[idx]; this.Page.Validators.Remove(val);
} }

During the ItemDataBound event of the repeater, I determine the type of IValidator, and set the appropriate image to the row of data. I bind the IValidator class ErrorMessage property to the label inside the repeater row as well, and set the appropriate CSS class so it displays in the color format I like.

protected void rptNotification_ItemDataBound(object sender,
RepeaterItemEventArgs e) { try { if ((e.Item.ItemType
== ListItemType.Item) || ((e.Item.ItemType == ListItemType.AlternatingItem))) { IValidator
val = Page.Validators[e.Item.ItemIndex];
Image img = (Image)e.Item.FindControl("imgNotice"); if (img
!= null)
{ if (val is NotificationValidator)
img.ImageUrl = "~/images/info.png"; if (val is ValidationError)
img.ImageUrl = "~/images/error.png"; if (val is ValidationWarning)
img.ImageUrl = "~/images/warning.png";
} Label lblInfo = (Label)e.Item.FindControl("lblDetails"); if (lblInfo
!= null)
{ lblInfo.Text = val.ErrorMessage; if (val is NotificationValidator)
lblInfo.CssClass = "NotificationItem"; if (val is ValidationError)
lblInfo.CssClass = "ErrorItem"; if (val is ValidationWarning)
lblInfo.CssClass = "WarningItem";
} } } catch (Exception
ex) { //TODO:
Log the error } } }

The end result is a control which sits on top of the page (and is only visible when there are messages to display) and looks like this:

Notification[1].zip (38.27 KB)

UPDATE: Had a bug in the original file, so I updated the project (and cleaned out all the ancillary junk in it as well) and posted it again.

Tip of the Day: The evolution of dynamic, case insensitive LINQ to Object search

Daryl — Mon, 09 Aug 2010 04:34:12 GMT

I designed a control to filter data dynamically, and I wanted to be able to be able to use it to filter either SQL Data (via a DataTable) or a List<T> of objects. Sorting the DataTable dynamically is easy using the DataTable, as you can create a DataView and perform case insensitive searches like this:

DataView
dvData = new DataView(data);
dvData.RowFilter = “SomeField=’Test’”;

You can also create widcard searches like this:

DataView
dvData = new DataView(data);
dvData.RowFilter = “SomeField
LIKE ’Te%’”;

But providing that functionality with List<T> and LINQ was going to be a challenge. If you know the properties you want to find in advance, the syntax is easy using Lambda functions:

List<MyObject>
objectResults = MyList.FindAdd(x
=> x.MyProperty.ToLower() == “Value”);

That’s well and good, but in my filter control, I wanted to be able to specify a property by name for a comparison. Something like this:

List<MyObject>
objectResults = MyList.FindAdd(x
=> “MyPropertyName” == “Value”);

Unfortunately, that’s not going to work. I needed something that would dynamically specify the property I want to search. In a previous post I described how I could use a defined Lambda Expression to dynamically sort a list in a similar fashion.

So in my first attempt and doing a lot of searching on Google, I came up with this method:

 public static IEnumerable<T>
DynamicFilter<T>(this IEnumerable<T>
source, string propertyOrFieldName, string searchValue)
{ Func<T, bool>
predicate = CreatePredicate<T>(propertyOrFieldName,
searchValue); return source.Where(predicate);
} static Func<T, bool>
CreatePredicate<T>(string propertyOrFieldName, string searchValue)
{ var arg = Expression.Parameter(typeof(T), "arg");
var body = Expression.Equal(Expression.Property(arg,
propertyOrFieldName), Expression.Constant(searchValue)); return Expression.Lambda<Func<T, bool>>(body,
arg).Compile(); }

Usage:

List<Employee>
emps = Employee.LoadListCollection();
List<Employee> empList = emps.DynamicFilter("FirstName", "Angie").ToList();

This worked great for a case-sensitive search, but I still didn’t have a way to do a case-insensitve search or a wildcard search. So after some more searching and more trial-and-error, I came up with this for a wildcard search:

public static IEnumerable<T>
ContainsString<T>(this IEnumerable<T>
data, string propertyOrFieldName, string searchValue)
{ var param = Expression.Parameter(typeof(T), "x");
var body = Expression.Call( typeof(BusinessObjectBase).GetMethod("Like",
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public),
Expression.PropertyOrField(param, propertyOrFieldName), Expression.Constant(searchValue, typeof(string)));
var lambda = Expression.Lambda<Func<T, bool>>(body,
param); return data.Where(lambda.Compile());
}

A couple things to note here. First, I needed to add a method “Like” to my base object (BusinessObjectBase in this case) of the collections I am searching. It looks like this:

///
<summary> ///
comparison operator. Needed for dynamically filtering the objects ///
</summary> ///
<param name="a">A.</param> ///
<param name="b">The b.</param> ///
<returns></returns> static bool Like(string a, string b)
{ return a.ToLower().Contains(b.ToLower());
}

Now I can do a search where I specify the property name, and it returns and value of that property that contains any part of that string (and it is also case-insensitive).

List<Employee>
emps = Employee.LoadListCollection();
List<Employee> empList = emps.ContainsString("FirstName", "An").ToList();

Then it occurred to me that I was specifying the name of the static routine in the call. What would happen if I specified the name of the operator dynamically? Would it work right?

var
body = Expression.Call( typeof(BusinessObjectBase).GetMethod("Like",
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public), 


Became this:




var
body = Expression.Call( typeof(BusinessObjectBase).GetMethod(operatorName,
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public), 
Now
I could create two static operators (or as many as I might ever need) to provide this
dynamic functionality.



public static IEnumerable<T>
RunOperator<T>(this IEnumerable<T>
data, string operatorName, string propertyOrFieldName, string searchValue)
{ var param = Expression.Parameter(typeof(T), "x");
var body = Expression.Call( typeof(BusinessObjectBase).GetMethod(operatorName,
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public),
Expression.PropertyOrField(param, propertyOrFieldName), Expression.Constant(searchValue, typeof(string)));
var lambda = Expression.Lambda<Func<T, bool>>(body,
param); return data.Where(lambda.Compile());
} In my BusinessObjectBase class, I added the following methods (Like
for wildcard searches, and Equals for a case-insensitive search):

 static bool Like(string a, string b)
{ return a.ToLower().Contains(b.ToLower());
} static bool Equals(string a, string b)
{ return a.ToLower()
== b.ToLower(); } 
I can call both of these methods like this:

public List<T>
FilterData<T>(List<T> data, bool wildcardSearch)
{ List<T> results = data; if (wildcardSearch)
results = results.RunOperator("Like",
fi.DataField, fi.FilterValue()).ToList(); else     results = results.RunOperator("Equals",
fi.DataField, fi.FilterValue()).ToList();     return results;
} So let’s break it down a little. First, the first parameter of a lambda
expression, which is what we are building here, is the input parameter, or in this
case, the x portion of x =>.

var
param = Expression.Parameter(typeof(T), "x");Next,
we’re setting up the call which is made to the right of the => of the Lambda expression.
The code below is saying “grab the method name provided by the operatorName variable,
which can be found in any class which implements the BusinessObjectBase class.



typeof(BusinessObjectBase).GetMethod(operatorName,


The result of the expression defined above will be returning a boolean, as defined
here:

var
lambda = Expression.Lambda<Func<T, bool>>(body,
param);Finally, we return the data which evaluates in the lambda expression
as true via this line of code:



return data.Where(lambda.Compile());Note
the delegate lambda expression is compiled into executrable code and produces a delegate
which represents the lambda expression.

Obviously, understanding how to dynamically call methods and compare properties using
LINQ is extremely powerful and has many,many possibilities. I hope this helps someone
else trying to do the same thing!

Tip of the Day: More useful information on INFORMATION_SCHEMA

Thu, 11 Mar 2010 04:02:00 GMT

Recently, I posted a script which would identify all the procedures which did not have appropriate permissions set, which is great for last minute deployment checks. I realized I needed to explore INFORMATION_SCHEMA closer as there is a LOT of useful metadata about the database available. Today's tip is about some of that useful information.

INFORMATION_SCHEMA is a specia schema which contains several views of the database metadata. Previous to these views, database developers were forced to join on several sys tables. Many of my earlier scripts for example rely on this method. However, in SQL Server 2005 system views were provided which made this task significantly easier. Here's some of the more useful views to look at. Explore them with code like this and see what they contain.

SELECT * FROM INFORMATION_SCHEMA.COLUMNS

I have found the following most useful, although in truth I suspect over time I will have use for all of them.

COLUMNS --> I frequently use this to find what tables a particular column name is found in

CONSTRAINT_COLUMN_USAGE --> identify what keys (primary, foreign) are defined, and on what fields

ROUTINES --> allows me to explore procedures and functions using this view

TABLES --> Get information about the various tables in the database

VIEW_COLUMN_USAGE --> obtain information on the fields the view contains

Here's a good link where you can find more information on the INFORMATION_SCHEMA.

Tip of the Day: Dynamically sorting a List collection using Lambda.Expression

Wed, 30 Dec 2009 04:58:02 GMT

In the past week, I created some CodeSmith templates for my client so we could quickly generate the business objects for our web site. Since the project will be VS2008, I decided to bing objects to List<T> collections of objects, so I could start leveraging LINQ to Objects in the code.

They wanted every field in the GridView sortable, and I always looks for an reusable way to do things when possible. Since we were going to have many, many grids, this was a great opportunity to use generics and LINQ to come up with a flexible solution.

In this case, I wanted a way of taking in a field name, and sort direction, and sorting the collection. It was easy to do using a Lambda expression if I knew in advance all the field names, such as MyCollection.OrderBy(a => a.Name) to sort by name. Obviously, that wasn't going to work. I needed to create a delegate for sorting on the right field dynamically.

Below is the result of that effort. By using the Lambda.Expression (provided by System.Core.dll), I was able to dynamically set the Lambda expression to the property I wanted. Depending on the direction, I used OrderBy or OrderByDescending with the dynamic sort expression. I created it as an extension method to all List<T> objects for quick and easy access, which every business object in my solution supports.

/// <summary>
/// Sorts a list of objects by passing in the parameter and direction.
/// Usage: List<MyObject> newList = oldList.SortList("SomeColumn", "SomeDirection");
/// Requires System.Core be included in the project.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list">The list.</param>
/// <param name="sortColumn">The sort column.</param>
/// <param name="direction">The direction.</param>
/// <returns></returns>
public static List<T> SortList<T>(this List<T> list, string sortColumn, string direction)
{
var param = Expression.Parameter(typeof(AutoClassParams), sortColumn);
var sortExpression = Expression.Lambda<Func<T, object>>(Expression.Convert(Expression.Property(param, sortColumn), typeof(object)), param);

List<T> newList = null;

if (direction.ToUpper() == "ASC")
newList = list.AsQueryable<T>().OrderBy(sortExpression).ToList<T>();
else
newList = list.AsQueryable<T>().OrderByDescending(sortExpression).ToList<T>();

return newList;
}

New features of VS2010 which have me smiling (Part 2)

Sat, 07 Nov 2009 03:45:19 GMT

Session compression – For out-of-process session maintenance, the session state is compressed using the System.IO.Compression.GZipStream class. It also looks like it will only do this when CPU cycles are available (but I need to investigate this further). If that’s the case, you might want to set up some Performance indicators or alerts when it’s not being compressed because that might indicate further problems.

Link: <http://www.asp.net/learn/whitepapers/aspnet4/default.aspx>

Multi-Targeting – I’ve mentioned this before, but it allows you to specify which .Net version you are writing for in the VS2010 IDE. This expands the support that VS2008 has by adaptively changing the IDE to the targeted environment. The IDE adjusts its Intellisense and compilation towards the targeted version. The whitepaper indicates ASP.Net, so I need to test and see if it applies to WPF and WinForm as well. Some features:

Specified in the .config file, defaults to 4.0 when not specified.
Compiles the code to the
Intellisense adapts to the current version of the framework selected

Link: <http://www.asp.net/learn/whitepapers/aspnet4/default.aspx>

Link: http://weblogs.asp.net/scottgu/archive/2009/08/27/multi-targeting-support-vs-2010-and-net-4-series.aspx

Script Loading – The AJAX library includes the ability to have better control of script loading in .Net 4.0. It loads the scripts automatically, and in the order needed. From the whitepaper, here’s the features:

· Automatically loads all resources that are required by a script.

· Makes sure that each script is loaded only once.

· Improves performance by loading scripts in parallel and by combining scripts.

· Supports loading scripts only when they are needed (“lazy loading”).

· Supports loading third-party scripts like jQuery and your own scripts.

· Supports loading scripts from the Microsoft Ajax Content Delivery Network

One of the client features is the Sys.require. When a component and a function is provided, the callback function is called when the scripts are done loading.

Link: <http://www.asp.net/learn/whitepapers/aspnet4/default.aspx>

jQuery integration – Speaking of jQuery, it’s now included as part of the ASP.Net Web forms and the MVC project.

Link: <http://www.asp.net/learn/whitepapers/aspnet4/default.aspx>

ClientID changes – I am mixed about this one, simply because once In understood how ASP.Net set its clientIDs upon rendering, I could generate my script accordingly in my code behind. However, it’s been simplified in VS2010 to allow the user to have control over setting the client IDs. Be forewarned though, this could open you up to naming issues within container controls as such. Regardless, I am always supportive of giving the developer the option of more control. There’s a new property at the configuration file, page and control level called ClientIDMode which has the following settings:

AutoID – mimics the previous version naming scheme
Static – This specifies that the ClientID value will be the same as the ID without concatenating the IDs of parent naming containers.
Predictable – useful for controls which will be generated in template controls
Inherit – take the setting of the parent control (lots of this in VS2010, which is great, since I have been a champion for UI inheritance and control-centric programming).

Link: <http://www.asp.net/learn/whitepapers/aspnet4/default.aspx>

Improved “Add Reference” functionality – Over the past couple of days, I found myself converting a project from VS2005 to VS2008. As a result, I found myself needing to change some references as well as I changed some of the related projects. This change in VS2008 is sort of a “nice to have”. While it’s not a big win, it’s still nice as it can get painful at times changing the references. Here are the changes with this:

The .Net and COM tabs are loaded asynchronously
Defaults opening to the project tab (I find myself using this a LOT anyways, but would have preferred this to start at the “Browse” tab, or better, consider this like a MRU action and remember where I was last time)

Link: <http://weblogs.asp.net/scottgu/archive/2009/10/29/add-reference-dialog-improvements-vs-2010-and-net-4-0-series.aspx>

UML Support! Visual Studio 2010 will support the creation of UML diagrams via a modeling project. I like Visio and all, but I look forward to being able to create UML diagrams right from the same IDE I develop in. As of now, there’s no code generation support. I do think a clever developer could possible do some code generation from the saved file via CodeSmith or IDE programming, so I bet we’ll see something like that soon if Microsoft doesn’t provide it first. Check out the link below and you can see some of the functionality.

Link: http://weblogs.asp.net/gunnarpeipman/archive/2009/11/04/visual-studio-2010-uml-modeling-projects.aspx

Although available in v3.5, VS2010/v4 will have the chart control integrated into it. In the past, your options were a third-party control for charting or to use Interop and Excel, or writing your own charting libraries (gulp!). The link below lists some details on this impressive charting library if you’ve never used it.

Link: http://weblogs.asp.net/scottgu/archive/2008/11/24/new-asp-net-charting-control-lt-asp-chart-runat-quot-server-quot-gt.aspx

Developers will have more deployment options Web application

Get it here: http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

New features of VS2010 which have me smiling (Part 1)

Sat, 31 Oct 2009 04:22:38 GMT

As I mentioned before, I historically have avoided beta software. However, this time I am breaking that rule and really digging into VS2010 early. Below are a few of the things which have me very excited to see this release (and with Web Spark, I get it for free! Join now!) This is part one of a multi-part entry of the things I find really appealing about the upcoming version of Visual Studio 2010.

IntelliTrace – allows you to playback and trace a session to assist with debugging. The major features are:

Application Event Recording
Playback Debugging (a.k.a Time Travel Debugging)
Record and Playback of Manual Test Failures
Debugging Build Acceptance Tests
Diagnosing Unit Test Defects
Debugging Load Test Failures

Link: http://blogs.msdn.com/habibh/archive/2009/06/02/an-in-depth-look-at-the-historical-debugger-in-visual-studio-2010-part-i.aspx

Auto-Start applications – Helps mitigate large startup processes which may run during the web application “Application_Start” event. Provides a controlled approach for starting up the application.

Link: http://weblogs.asp.net/scottgu/archive/2009/09/15/auto-start-asp-net-applications-vs-2010-and-net-4-0-series.aspx

Better ViewState management – By default, ViewState is enabled for web controls in past versions of ASP.Net. In VS2010, ViewState can be disabled by default and onlt enabled for those that actually need it, and it now supports “inheritance” through the ViewStateMode property. This allows you to set it to “Inherit” the value from the parent control.

Link: http://www.asp.net/learn/whitepapers/aspnet4/

Outut Caching everywhere -- Now you can take advantage of caching in applications other than web based, as the cache API is exposed without using the System.Web.Cache in a WinForm application. There are also more providers, and the ability to create your own through extensibility.

Link: http://www.asp.net/learn/whitepapers/aspnet4/

Reduced web.config size – Most of the configuration settings have been moved to the machine.config file, which greatly simplifies the configuration settings in the web.config file.

Link: http://www.asp.net/learn/whitepapers/aspnet4/

Get the VS2010 Beta 2 here: http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

Tip of the Day: Using generics to simplify getting a value from a DataRow or DataReader

Fri, 30 Oct 2009 04:17:54 GMT

Once you have data loaded into a DataRow or SqlDataReader, you’d typically do something like this:

string someValue = (string)drData["MyValue"];

In order to place it in the variable, you need to cast the
type correctly (in this example, using the(string)). Also, what happens if “MyValue”
is null?  You’ll need to do an additional check, and then assign the value you
want for the situations where it is null.

Today’s tip uses generics to return the correct type. It
also allows you to return a default value if the value is null. 

        /// <summary>

        /// Gets
the data row value.

        /// </summary>

        /// <typeparam
name="T"></typeparam>

        /// <param
name="valueName">Name of the value.</param>

        /// <param
name="drData">The dr data.</param>

        /// <param
name="defaultValue">The default value. Note,
this must be cast to the expected return type. For example, decimal.Parse("0").</param>

        /// <returns></returns>

        protected T
GetDataRowValue<T>(string valueName, DataRow drData,
T defaultValue)

        {

            if (drData[valueName]
== DBNull.Value)

                return defaultValue;

            else

                return (T)drData[valueName];

        }

        /// <summary>

        /// Gets
the data row value.

        /// </summary>

        /// <typeparam
name="T"></typeparam>

        /// <param
name="valueName">Name of the value.</param>

        /// <param
name="drData">The dr data.</param>

        /// <param
name="defaultValue">The default value. Note,
this must be cast to the expected return type. For example, decimal.Parse("0").</param>

        /// <returns></returns>

        protected T
GetDataRowValue<T>(string valueName, SqlDataReader drData,
T defaultValue)

        {

            if (drData[valueName]
== DBNull.Value)

                return defaultValue;

            else

                return (T)drData[valueName];

        }

Here’s
how it’s used. Notice that through the use of generics, one routine can handle multiple
types. 
 

            int myID
= GetDataRowValue("SomeID", drData, 0);

            DateTime myDate
= GetDataRowValue("SomeDate", drData, DateTime.Now);

            decimal myAmt
= GetDataRowValue("SomeDecimalAmount", drData, decimal.Parse("0"));

            string myString
= GetDataRowValue("SomeString", drData, String.Empty);

Tip of the day: Validate string meets length requirements

Wed, 28 Oct 2009 04:09:54 GMT

This routine checks the specified minimum and maximum string lengths, and either returns True/False that it meets those requirements, or could also throw an exception (based on the throwException parameter value).

This would also be a good candidate for an extension method. To do so, add a parameter (in the first position) as “this string”.

        /// <summary>

        /// Checks
the length of a string to see if it meets the minimum and maximum length

        /// </summary>

        /// <param
name="checkString">string to check</param>

        /// <param
name="minLength">minimum string length</param>

        /// <param
name="maxLength">maximum string length</param>

        /// <param
name="stringName">description of the value to
check</param>

        /// <param
name="throwException">T/F to throw an exception
if it exceeds the maximum</param>

        /// <returns>T/F</returns>

        public static bool ValidString(string checkString, int minLength, int maxLength, string stringName, bool throwException)

        {

            if ((checkString.Length
>= minLength) && (checkString.Length <= maxLength))

                return true;

            else

            {

                if (checkString.Length
< minLength)

                    if (throwException)

    throw new System.ArgumentOutOfRangeException("The
argument string - " + stringName + " was less
than the minimum length.");

                    else

    return false;

                if (checkString.Length
> maxLength)

                    if (throwException)

    throw new System.ArgumentOutOfRangeException("The
length (" + checkString.Length.ToString() + ")
of argument string - " + stringName + " was longer
than the expected length(" + maxLength.ToString() + ").");

                    else

    return false;

                return false;

            }

        }

Tip of the Day: Winform: Displaying the form derived from a base class

Wed, 14 Oct 2009 05:27:16 GMT

When starting a project, I always recommend inheriting objects from a base object, regardless of whether you know you'll need it or not. Usually, they will contain common functionality like error handling, debugging or other common methods which you'll use over and over.

In WinForms, however, this can cause a problem if you make the base form an abstract class (another thing I recommend). For example, take this simple form:

Now let's say I decide to derive this form from an abstract base class, which I will call BaseForm:

    5 using System.Windows.Forms;

    6 

    7 namespace TestForm

    8 {

    9     public abstract class BaseForm : Form

   10     {

   11         protected void SomeCommonMethod()

   12        
{

   13 

   14        
}

   15     }

   16 }

When I go to edit the UI again, I see this, and it scares
the heck out of me (looks scarier in VS2005)....

What this is telling you is that it can't render an abstract class BaseForm. So while you are creating the application, you might remove the abstract identifier from UI related base classes (with a note that they should be inherited from, not used, as well as a /TODO marker to make sure you mark it as abstract before deployment).

Doing this will allow you to inherit from a base class while at the same time edit the UI.

Tip of the Day: Directly accessing a Master Page

Tue, 29 Sep 2009 04:34:35 GMT

When using master pages, there are times when you want to access part of the Master Page (e.g. a public property). One way of doing this is by defining the master page with the MasterType directive.

<%@ MasterType VirtualPath="~/MyMasterPage.master"%>

By doing this, you can now access the MasterPage as a class Master, and programatically (and with the benefits of compilation checking) access it.

Interviewing Question of the Day: Virtual Keyword

Wed, 23 Sep 2009 04:45:06 GMT

It's time I got back to the interviewing tips as well. So here's an OOP question a suprising number of candidates miss:

Question: In C#, what's the virtual keywork used for.

Answer: A method marked virtual has an implementation, but inheriting objects may override the implementation and provide their own implementation. This differs from the abstract keyword in that the base class does not have an implementation, and the deriving class must provide an implementation.

This is a key concept to object-oriented programming. If you missed this one, you can get more information on Microsoft's MSDN site.

Looking into Microsoft Expression -- A design tool

Sat, 05 Sep 2009 15:55:17 GMT

As I was looking through Scott Hanselman's List of Tools for 2009, I saw a reference for Microsoft's Sketchflow (part of Microsoft Expression), which allows you to design (among other things) and work through ideas prior to coding. I am going to check it out this weekend, and maybe some of the alternate tools he recommended for his post. I might even have to dust off my Table PC, as it seems like a good combination.

Tip of the Day: A brief explanation of extension methods

Fri, 04 Sep 2009 05:10:29 GMT

There’s a very powerful feature in .Net 3.5 called extension methods. In an earlier blog, I used an extension method in my LINQ to XML to format the date retrieved from an RSS feed. If you’re new to the 3.5 framework, you may be wondering what the big deal is.

As a consultant, I have to look at a lot of old and 3^rd party code. There are times when I don’t have access to the source code, and I need to add some additional functionality to a class. If I can inherit from the base class, I can just inherit the class and extend it. But what do I do if the class is sealed? Prior to .et 3.5, my options were limited and certainly not as object oriented. I’d have to write some type of wrapper of common function to create the functionality.

As an example, let’s say I wanted to extend string with some additional functionality, such as adding in functionality to reverse a string easily. I create my new class, and try to inherit from the String class, but I get a compilation error. Let’s look at the definition of the String class in .Net:

[SerializableAttribute]

[ComVisibleAttribute(true)]

public sealed class String : IComparable,

ICloneable, IConvertible, IComparable<string>, IEnumerable<char>,

IEnumerable, IEquatable<string>

Because the class is sealed, I can’t inherit from it. Prior to .Net 3.5, I am going to have to create a function and pass in the string. By using extension methods, I am no longer restricted by the “sealed” keywords.

/// <summary>
/// Reverses the specified string.
/// </summary>
/// <param name="s">The string to reverse.</param>
/// <returns>Reversed string</returns>
public static string Reverse(this string s)
{
   char[] arr = s.ToCharArray();
   Array.Reverse(arr);
   return new string(arr);
}

The code above extends any string with a new Reverse function, which reverses the referenced string. Here’s how it is used:

string testString = "MyString";
string reversedString = testString.Reverse();

The new reverse function shows up in Intellisense for any string, which helps speed up coding as well.

So how did this work? It’s all in the definition. First, the class and the function has to be defined as static. Second, the first parameter must begin with this and is a reference to the type this method extends.

There are some restrictions to static methods. For example, the extension method can only access public methods of the referenced class.

Below are some more examples of extending the string class with some additional functionality. A couple of days ago, I posted some examples of getting values from a DataRow safely. This would be another great refactor opportunity to extend the DataRow class to provide this functionality right from the DataRow itself.

using System;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading;

namespace Rubicon.Common
{
public static class StringExtensions
{
/// <summary>
/// Reverses the specified string.
/// </summary>
/// <param name="s">The string to reverse.</param>
/// <returns>Reversed string</returns>
public static string Reverse(this string s)
{
   char[] arr = s.ToCharArray();
   Array.Reverse(arr);
   return new string(arr);
}

/// <summary>
/// Converts the string to title case.
/// </summary>
/// <param name="s">The string to convert.</param>
/// <returns>A title case string.</returns>
public static string ToTitleCase(this string s)
{
   CultureInfo ci = Thread.CurrentThread.CurrentCulture;
   TextInfo ti = ci.TextInfo;
   return ti.ToTitleCase(s);
}

/// <summary>
/// Returns true if string is over the specified max length
/// </summary>
/// <param name="s">The string to check.</param>
/// <param name="maxLength">max length.</param>
/// <returns></returns>
public static bool OverMaxLength(this string s, int maxLength)
{
   return (s.Length <= maxLength);
}

/// <summary>
/// Returns true if string is under the specified min length
/// </summary>
/// <param name="s">The string to check.</param>
/// <param name="minLength">min length</param>
/// <returns></returns>
public static bool UnderMinLength(this string s, int minLength)
{
   return (s.Length <= minLength);
}

/// <summary>
/// Checks the length of the string to make sure it is within the set bounds.
/// </summary>
/// <param name="s">The string to check.</param>
/// <param name="minLength">min length</param>
/// <param name="maxLength">max length</param>
/// <returns></returns>
public static bool WithinValidLength(this string s, int minLength, int maxLength)
{
   return ((s.Length >= minLength) && (s.Length <= maxLength));
}

/// <summary>
/// Determines whether the string is alpahbetic only.
/// </summary>
/// <param name="s">The string to check.</param>
/// <returns>
///     <c>true</c> if [is alpha only] [the specified s]; otherwise, <c>false</c>.
/// </returns>
public static bool IsAlphaOnly(this string s)
{
   Regex regPattern = new Regex("[^a-zA-Z]");
   return !regPattern.IsMatch(s);
}

/// <summary>
/// Determines whether the string is alphanumeric.
/// </summary>
/// <param name="s">The string to check.</param>
/// <returns>
///     <c>true</c> if [is alpha numeric] [the specified s]; otherwise, <c>false</c>.
/// </returns>
public static bool IsAlphaNumeric(this string s)
{
   Regex regPattern = new Regex("[^a-zA-Z0-9]");
   return !regPattern.IsMatch(s);
}

}
}

Extension methods are a very powerful tool, and enhance OOP concepts like encapsulation. They will help you organize your code, and extend the functionality of classes previously you could not modify. I obtained my first taste of Extension Methods in this book as I was learning LINQ, and I highly recommend it.

Starting new projects.. how to approach it?

Thu, 03 Sep 2009 19:41:58 GMT

Next week, I’ll be starting a new project, which is always exciting for me. In this case, it will be a WinForms application, which I really enjoy working on. Since everything is more web-oriented these days, there just aren’t as many WinForms projects. In fact, I haven’t done one in about two years where I built an application for a major phone system manufacturer which takes Oracle data/Excel spreadsheets, imports the data and generates a PDF price list.

I know a lot of people dread deployment of WinForm apps, which is one of many reasons web development has taken off. From my perspective, it’s an even trade because web development has many challenges.. scalability, security, browser compatibility, etc. Mostly, since WinForm apps are so rare these days, it’s going to be a fun contract to do something different for a change.

But that’s not the point of this post. I was thinking about how I approach a new project (in this case, it’s a re-write of an older application) and what I do to get it started.

In this case, it will look something like this:

· Get oriented (passwords, system information, high-level project overview)

· Get the environment set up

· Get a high level view of what the project entails

From there, it’s time to dig in. In this case it’s a re-write, so one of the many questions I ask will be to find out what was lacking or has changed since the first application, and what the new desired features are. Ultimately, this may entail a semi-working prototype. I’ll also want to familiarize myself with how the old application works. This is important, as most people don’t like a lot of change unless it really improves the process, so it’s good to understand how they currently use it, and how they want to use it. You need end user buy-in to be successful, so it’s important that any change you make will be accepted.

So now we get to designing and ultimately coding. It usually involves a few things:

· Architecting the application

· Data Mining/design

· Designing tests

· Deployment Strategy

· Post-deployment support

· Documentation

To architect the application, I need to see if there are any existing architectures in place. Very rarely am I given free reign to build the data access layer, but it does happen. A lot of contractors really push this, or ignore current architectures, but that’s a mistake. I say this because you need to leave an application which your client can support. If I do change the existing practices in place, I make sure I know WHY, communicate it and document it.

Now come the tools. Some clients won’t allow you to bring your own software licenses. In that case, I may have to do a CodeSmith demo to help justify the purchase of the tool. I’ll look for opportunities to generate code and speed up development. I have had a LOT of push back on that from other contractors though, in that they feel you are losing billable time by generating all that code, but I disagree. First, as a consultant, I feel I have a duty to save my client money and time where I can. Second, when you do quality work and it’s fast, I assure you that you’ll be either getting more projects or called back. In my 13 years of consulting, almost every client I have has brought me back for subsequent projects for that exact reason.

I also bring things like my data mining queries in my other blog posts which help find what I need to find quickly.

What tools/techniques do you use?

How I have used reflection

Tue, 25 Aug 2009 05:12:16 GMT

Earlier today, I blogged an interview question about reflection. Earlier this year, as part of the interviewing process I was tasked to write a simple calculator. There would only be 2 integer inputs with a single operation. For example, if the invoked the program, and entered in 1 U 2 (U being the operation for addition), the program would output 3.

The assignment also mentioned they would want the possibility to expand the operations later. Instead of just commenting on it, I decided to implement that into the design.

I won't go into retrieving the data from command prompt, but I will provide the project at the end and you can see how that is accomplished. I made it robust by accounting for spaces, etc. As a programming concept, you should always program defensively and assume the work (and you'll be glad with the results).

First, I created a base class each operand would inherit from, so that each works similarly. The base class OperationBase looks like this:

using System.Diagnostics;

namespace CalcLibrary

{

    [OperatorIndex("")]

    public abstract class OperationBase

    {

        private int value1;

        private int value2;

        private string errorInformation
= String.Empty;

        public int Value1

        {

            get { return value1;
}

            set {
value1 = value; }

        }

        public int Value2

        {

            get { return value2;
}

            set {
value2 = value; }

        }

        public string ErrorInformation

        {

            get { return errorInformation;
}

            private set {
errorInformation = value; }

        }

        //NOTE: We may want
to return a string as the division will round every time, but we will keep this as
an int

        public abstract int Calculate();

        protected void ErrorHandler(Exception ex)

        {

            try

            {

                //While
in a production app we would want to hide the internals of an error, in this app we
will show them

                this.ErrorInformation
= "An unexpected error occurred (" + new StackTrace().GetFrame(2).GetMethod().Name
+ ")-" + ex.Message;

            }

            catch 
{}

        }

    }

}

You'll notice this abstract class defines taking two int
inputs (Value1 and Value2), handles the errors, and forces every implementation to
provide a definition of the "Calculate" method. When inheriting from this class, any
operand will be very simple to define -- all it needs to do is determine what to do
for a Calculation, as seen by the addition operand implementation.

namespace CalcLibrary

{

    [OperatorIndex("U")]

    public class AdditionOperand : OperationBase

    {

        public override int Calculate()

        {

            return this.Value1
+ this.Value2;

        }

    }

}

The next task was to determine which operand to use given
the user's input. We could write an "if" statement or a factory method, but I wanted
to make sure if anyone came in to add a new operand, they would not have to change
any code -- just add a new class, inherit from OperationBase and implement
the Calculate() method. To accomplish this task, I decided to use reflection.
By decorating each Operand class with an attribute, I could designate how it reacts
to the inputs. 

First, I needed to define my attribute:

using System;

namespace CalcLibrary

{

    [System.AttributeUsage(System.AttributeTargets.Class)]

    public class OperatorIndex :
System.Attribute

    {

        public string OperatorId
= String.Empty;

        public OperatorIndex(string operatorId)

        {

            OperatorId = operatorId;

        }

    }

}

Next, I need to decorate my operands with the appropriate
attribute. Again, I will use the AdditionOperand, which is indicated by the "U" notation.
When I define my class, I decorate it with the attribute letter I want to use to define
that function.

> 

    [OperatorIndex("U")]

    public class AdditionOperand : OperationBase

Now that I have
defined my operations, I need to use them. I created a publically exposed static class
called CalcEngine which loads all the operations, validates the inputs, and
processes the calculations. I created this as a class library so it could be used
with a console application (as it is being called from in the supplied example), a
web application, etc.

In the constructor,
I call a method LoadOperators() which uses LINQ to Reflection to quickly
retrieve all classes of type OperatorBase and have the OperatorIndex defined.
I load the resules into a dictionary object so I can quickly retrieve them for my
calculations. Below is how I load the operators using LINQ to Reflection.

private static void LoadOperators()

        {

            //Using
LINQ to Reflection, load all classes from the assembly that inherit from our base
Operator type, 

            //and
have the attribute set into a dictionary, so we can quickly reference the operator
we want

            operations =

                (from a in AppDomain.CurrentDomain.GetAssemblies()

                from t in a.GetTypes()

                where Attribute.IsDefined(t,typeof(OperatorIndex))

                where t.BaseType
== typeof(OperationBase)

                let attribute
= Attribute.GetCustomAttribute(t,typeof(OperatorIndex)) as OperatorIndex

                where attribute.OperatorId
!= ""

                select 

                    new OperatorDetails

{

    AssemName = a.GetName().Name,

    ClassName = t.FullName,

    OperatorId = attribute.OperatorId

}).ToDictionary(p => p.OperatorId,p => p);

        }

The main Calculate method
validates the input, retrieves the right operand key from the dictionary, late binds
to the proper OperatorBase class and invokes the Calculate() method,
as seen below.

                //locate
the correct operator from our dictionary

                OperatorDetails operatorInfo
= operations[mathOperator];

                //dynamically
load the operator class. I chose to do it using reflection so that we wouldn't need
a

                //factory,
which would need to be changed every time a new operator was added.

                //ENHANCEMENT:
you could actually detect other assemblies and load them as well

                Type calcClass
= Type.GetType(operatorInfo.ClassName);

                OperationBase calculator
= (OperationBase) Activator.CreateInstance(calcClass);

                calculator.Value1
= value1;

                calculator.Value2
= value2;

                int calculatedResult
= calculator.Calculate();

>>
>
 
Using
a console application, it looks like this:
 
Here's the sample code to look at and play with.. Enjoy!

SampleProj.zip
(89.4 KB)

Topical: The use of the var keyword revisited

Tue, 25 Aug 2009 04:28:04 GMT

Today has been an insanely busy day, but I have so much I want to blog about, and this one won't wait. A few days ago, as I was using some code I found on the net, I commented here about the over-use of the var keyword.

Seems I am not the only one who has an opinion on the matter. I subscribe to the CodeProject newsletter, and each issue features a survey. This week, the survey relates to the opinion of the var type in C#. You can see the survey results here. Make sure you click through to the "optional text answers" for some funny comments (and a few relevant ones as well).

The interesting thing to note from the survey is that the answers tend to skew towards the "never use that scenario" range. The two areas where it is most prevalent is with LINQ, and with anonymous types, which makes total sense.

Tip of the Day: Technical Interview question: What's Reflection?

Mon, 24 Aug 2009 14:27:02 GMT

Question: What's reflection, and how have you used it to solve a problem?

Answer: Reflection is a way to look at assembly metadata and look in and see what is contained. It also allows you to use late binding and call methods within those assembles.

For the second part, a simple explanation is all you need to show that you understand how it is used.

So what if you've enver used reflection? First, shame on you (kidding!). It DOES serve a very important purpose and allows for some great solutions, especially at an architectural level. If you've never used it, I recommend immediately trying it out, and you'll find many, many uses. Here's a tutorial I found that looks decent. That way, when asked this question (and I get this one a lot) you can answer how you *might* really use it. Honestly, you've probably used it and didn't realize it if you've added certain attributes to your code.

I have used reflection for everything from identifying certain classes and functions. For example, for a coding sample, I used LINQ for Reflection and attributes to identify classes which supported certain calculations. By doing this, I could add more functions dynamically and the UI would pick it without changing code. Since LINQ for Reflection is not discussed much, I'll post some about that later.

There are some costs associated with Reflection though. Speed! Late Binding is slower by it's nature, as well as all the processing looking for methods, so plan and use wisely!

Useful Links -- An overview

Sun, 23 Aug 2009 16:28:00 GMT

As a full time developer, I search the web... a lot. If you are writing a lot of new code without at least searching to see what exists, you're either getting paid by the hour (or line of code), stubborn or a glutton for punishment. Even if I don't use it, I can get some guidance on what someone else tried, and how it worked out before I start coding. Granted, it usually requires a lot of refactoring the code to my standards or needs, but it's a great start.

As I was thinking of things I wanted to put on my site, I realized it would be nice to share my "favorites"...sort of. If I found something useful, I wanted to be able to show what it was, how I found it useful and where someone else can find it. In a way, I am also helping to promote someone else's hard work and improving their search engine visibility to return the favor of their sharing their work.

Out of this, I came up with an idea for a "Useful Links" section. I wanted to be able to add links and commentary, and also add it to my Activity Aggregator to show help show the content of the site has changed. Later, as I was using Bing, I got the idea to add some webthumbs to enhance the page graphically, so the reader would know what the site looked like before going there. I also needed to add an admin page for creating the useful links (and ultimately maintaining them -- which is on my TODO list). I'll also leave out the icon creation part, although I really need to farm out for a new cool looking icon, which is also on my list of things to do.

I'll skip the admin section, as it's just data entry fields. The process for creating the entries does change a bit, as I needed to do a few extra steps.

Save the UsefulLink class
Default the webthumb image to a default "safety" image in case we can't get a webthumb
Make a request to get a webthumb image of the target site
Once the image is retrieved, update the UsefulLink record to point to the new webthumb
Update the Activity Aggregator to show we have a new useful link.

Step 3 is where things get tricky. How in all getout do we get webthumb images? There are controls out there you can get, and they are reasonably priced as well. But I decided to keep searching so I could write this one on my own, as it seems like an interesting challenge.

My next thought was to create my own service to do this. There's plenty of code out there, but the easiest way to do this would require some WinForms programming. Don't get me wrong, I LOVE programming WinForms. The problem is I don't want to have to install it everywhere I am at, as I need a service. I could possibly create a Web and Windows service to do this as well, but that seemed overly complex. So I did a search, and I found this, which is a service which does it for you. What's even nicer is that they expose a nice API to use. As of now, the first 100 images a month are free, and after that, the fees are very reasonable. Even though I doubt I will go over 100 images per month, I am so impressed I may pay just to keep the service going.

I was also able to find some c# code to make learning the API fast. I did end up changing it some, but in general it worked very well. You can find it here.

So when the service returns with my image (I used the medium size), I save it to a thumbs directory (had to add write permissions to the directory, or I got an obscure GDI+ error), and call a method on my UsefulLink class to update the record with the thumbnail image. I name the image with the current date and time so that the names will be unique as well.

Finally, once I have downloaded the image and updated the UsefulLink record, I add a call to my Activity class which creates an entry for the Activity Aggregator. As I add more items to throw into the Activity Aggregator, I am considering refactoring things to do some delegate multicasting for all the updates, or perhaps creating a factory where you provide class (should be easy since my business objects share the same base class) or interface, and it knows how to create the activity record instead of making individual calls. That's on my list down the road. :)

Here's what the Activity Aggrgator looks like, with a special Useful Link icon():

And here's what the Useful Link section (which has the webthumbs) looks like. I will only be showing 10 at a time to save web page real estate. But I also don't want to lose older links off the page. I am debating now whether to use paging, or just have a smaller hyperlink-only section below the most recent links. I am leaning towards paging, as I have a very neat service I want to implement which makes paging and sorting incredibly fast and easy (more on that someday.. I need to upgrade it to user .Net 3.5 functionality before I post it).

WebThumbs working.. but an aside about VS.Net 2008's var keyword

Sun, 23 Aug 2009 06:09:25 GMT

Today, I was super-dad AND got a lot of coding done, and I managed to get my useful links controls done for my site here. It was actually a complex process to get things like the webthumbs integrated, update the activity aggregator, create an admin page. The end result needs some cleanup, but I think for a first run, it came out nice. Tomorrow I will blog on the details and some code on how I did everything in case someone decides they want something similar.

Tonight, I am tired. But as I was coding, I came across some code for accessing my webthumbs, and something struck me. In .Net 3.5, there's a new keyword "var" which allows for anonymous casting (sort of). When it compiles, the underlying code is cast to the correct type, and in using the var typed variable, it acts like the cast-type. It would definitely speed up development if you used it a lot. For those old-school VB fans, it really reminds me of the variant data type (which it is not). Read more about it here if you want some details.

However, as with all things, there is a cost. For me, it's readability. In English anyways, we read left to right. When I see a "var" vast variable, I have to keep reading to understand the type, then see how it is used. Not too difficult (unless it is coming out of a function or LINQ query), but it does take a little more time to figure it out. For example..

var doc = new XDocument(

                new XElement(

That being said, you can get around using it by declaring the variable to the expected type when you code it. I have some samples I will post later when I was using LINQ I forced myself to do this so I would fully understand what was happening in my LINQ. Here's someone else who is taking a similar take on it.

Anyone have any thoughts on that?

Tip of the Day: Interview Questions- Access modifiers in C#

Fri, 21 Aug 2009 04:06:04 GMT

Here’s another question which is very basic, and is mandatory to be able to answer for C# developers:

Question: What are the various access modifiers in C#?

Answer: public, private, protected, internal, protected internal

Depending on how the person answers the question (e.g. if it’s obviously an easy question for them, I move on), I may follow up with “So what does the protected keyword mean?”

So here’s the answers to each… you absolutely need to know what each of these are!

Public – accessible to anything

Private – can only be access by code in the same class or struct

Internal – accessible only within the same assembly

Protected – accessible in the same class, or in a derived class

Go here for some more info if needed: http://msdn.microsoft.com/en-us/library/ms173121.aspx

Tip of the Day: Technical Interview question: The difference between a abstract class and an interface

Tue, 18 Aug 2009 15:02:10 GMT

I've been doing technical interviews for about 5 years now for .Net, and hired a lot of developers in that time. As a result, I have become proficient at quickly assessing a level of technical expertise as well as how a developer may fit within an organization. I will blog another time about what characteristics I look for in a candidate, but for now, I will go through some of the technical questions I ask, answer them, and explain why I ask the question.

Question: What's the difference between an abstract class and an interface

Answer: They have some similarities in that they both define abstract members which have to be implemented. An interface is really just a contract where you are stating "if I implement this interface, I will implement these methods". However, an abstract class can have an implementation, where an interface cannot. An abstract class can also have constructors and field data.

One advantage of an interface is that you can implement more than one interface per class, but you can only inherit from one class.

Note there's a lot more you could talk about with them both (and you don't want to overtalk any question), but the above will demonstrate you have a good knowledge of OOP design, which is what I was looking for. It's surprising how many developers cannot get this question right.

To learn more, here's a good article which discusses them in more detail (more than you'd need to answer the question for sure, but good knowledge to have!)

Tip of the Day: Get the Application Architecture guidelines!

Mon, 17 Aug 2009 00:21:50 GMT

As developers, we tend to get stuck in development boxes. By that, a lot of times you're so busy heads down, things change around you and you don't get a chance to do different things unless a problem comes up and you research the solution to it.

As new developers, the amount of information available can seem overwhelming. When do I use a web service? What are Design Patterns? What's the recommended way to..... you get the idea.

Fortunately, there's a guide on CodePlex which present high level concepts and recommendations for architects and would-be architects. It's a great reference, and best of all, it's free! If you have not downloaded it, I highly recommend you rush here and get it.

Logging Blog Activity to my Activity Aggregator

Sat, 15 Aug 2009 20:13:22 GMT

I have to get some landscape rock put out before my home owner's association has a cow, but I decided to do some more work on my activity aggregator. Today, I decided to integrate my blog feed into it, so when I post here, it will automatically update this activity on my home page (and soon to be in my developer's area).

Here's what the end result looks (for now).

Doing it was fairly easy with the design I implemented in my last post. My BlogFeed class inherits the BaseFeed class, which means I need to implement the ParseFeed() method. Since the RSS feed from my blog is XML, I was easily able to adapt the same code from my TwitterFeed class to work for this RSS feed (which should actually work for any RSS feed I pass in).

I also created another Extension method (for practice) to convert the RSS feed date time to a C# DateTime object. I will post that code as "Tip of the Day" but I have to give Dan Wahlin credit for it, as I adapted some sample code he provided.

Here's how the RSS feed (aka BlogFeed) uses LINQ to XML for creating my activity object.

    internal class BlogFeed : BaseFeed

    {

        public override int ParseFeed(XDocument doc)

        {

            try

            {

                ReturnCode code
= ReturnCode.Success;

                if (doc
!= null)

                {

                    var activityList
= from e in doc.Descendants("item")

                   select new RubiconPortal.BusinessObjects.Activity

{

   ActivityTypeID = ActivityTypes.Blog.Code,

   ActivityDate = e.Element("pubDate").Value.RSSDateTime().ToShortDateString()
+ " " + e.Element("pubDate").Value.RSSDateTime().ToShortDateString(),

   ActivitySummary = HttpUtility.HtmlDecode(e.Element("title").Value),

   ActivityDetailsURL = e.Element("link").Value

};

                    foreach (Activity item in activityList)

{

    //We need to check and see if the item
exists

    if (!Activity.CheckEntryExists(item.ActivityTypeID,
item.ActivityDetailsURL))

    {

        int results
= item.Save();

        if (results
!= ReturnCode.Success.Code)

            code = ReturnCode.Failure;

    }

    else

        return code.Code;   //we
can break once we hit one we've already logged (for performance reasons

}

                }

                return code.Code;

            }

            catch (Exception ex)

            {

                ErrorHandler(ex, "An
unexpected error occurred in TwitterFeed.ParseFeed() - " + ex.Message);

                return ReturnCode.Failure.Code;

            }

        }

    }

My next step will be to integrate some AJAX so when
the user hovers over the link, they can see things like the date, more of the topic,
etc. I also need to integrate my "Useful Links" dicussion as well.>

Creating my activity aggregator

Fri, 14 Aug 2009 06:40:31 GMT

Tonight was a very enjoyable night of coding. I created the first phase of my "activity aggregator". I actually had a more clever name for it, but being tired, it slips my mind right now.

Currently, I post several places.. short updates for on Twitter. Longer discussions end up on here, my blog. I have some other sources I plan on integrating over time, such as links I found useful (similar to Digg, but also where I can place why I found it useful). That means growth, and when it comes to design, it's best to design change into it up front.

The first thing I needed to do was create my table and business object to collect these activities. In my table, I store ActivityDate, what type of activity it was (foreign key to another table -- ActivityType), a brief summary of the activity text, and finally the url someone interested could click on to get more information. The internal members of my activity class look like this:

   15    
    #region Private Members

   16 

   17         private int activityID;

   18         private int activityTypeID;

   19         private string activityDate;

   20         private string activitySummary;

   21         private string activityDetailsURL;

   22 

   23    
    #endregion

Each private member has
a publically exposed property.

Most of my activities will
have XML feeds, such as the RSS feed of my blog, and the Twitter API. Therefore, I
enforce a similar implementation by creating an abstract base class, called BaseFeed,
which looks like this:

    1 using System.Xml.Linq;

    2 using RubiconPortal.Common;

    3 

    4 namespace RubiconPortal.BusinessObjects

    5 {

    6     internal abstract class BaseFeed :
BaseClass

    7    
{

    8 

    9    
    public abstract int ParseFeed(XDocument
doc);

   10 

   11     }

   12 }

So now I have a "contract"
that I need to use to have a similar method for any activity I want to log. I could
have used an interface for this, since there's no true implentation here, and I may
refactor it later to do so, but I do have some ideas where I may want to provide some
implementation, so that's why I chose an abstract class.

So the first item I wanted
to do was implement capturing my Twitter
posts in this activity, since I currently don't have a way to capture and post
them on my site. I will add the rest of the activities later. In a previous post,
I described how I took the Yedda Twitter API and modified it to return XDocuments,
and here's another chance to take advantage of that change with LINQ.

When I post to my Twitter
feed, I want to make sure my home page automatically reflects this activity. So I
implement a TwitterFeed object, which implements the BaseFeed method ParseFeed. Using
LINQ to XML, I pull out the pieces of the response I want, and populate the public
properties of my Activities class, then save my activity. Here's what my TwitterFeed
class looks like:

    1 using System;

    2 using System.Linq;

    3 using System.Web;

    4 using System.Xml.Linq;

    5 using Rubicon.Common;

    6 using RubiconPortal.Common;

    7 

    8 namespace RubiconPortal.BusinessObjects

    9 {

   10     internal class TwitterFeed :
BaseFeed

   11     {

   12         public override int ParseFeed(XDocument
doc)

   13        
{

   14        
    try

   15        
    {

   16        
        if (doc != null)

   17        
        {

   18        
            var activityList
= from e in doc.Descendants("status")

   19        
                   
           select new RubiconPortal.BusinessObjects.Activity

   20        
                   
           {

   21        
                   
               ActivityTypeID
= ActivityTypes.Twitter.Code,

   22        
                   
               ActivityDate
= (e.Element("created_at").Value.ParseDateTime()).ToShortDateString()
+ " " + (e.Element("created_at").Value.ParseDateTime()).ToShortTimeString(),

   23        
                   
               ActivitySummary
= HttpUtility.HtmlDecode(e.Element("text").Value),

   24        
                   
               ActivityDetailsURL
= "http://twitter.com/" + e.Element("user").Element("screen_name").Value

   25        
                   
           };

   26 

   27        
            foreach (RubiconPortal.BusinessObjects.Activity
item in activityList)

   28        
            {

   29        
                item.Save();

   30        
            }

   31        
        }

   32 

   33        
        return ReturnCode.Success.Code;

   34        
    }

   35        
    catch (Exception ex)

   36        
    {

   37        
        ErrorHandler(ex, "An
unexpected error occurred in TwitterFeed.ParseFeed() - " + ex.Message);

   38        
        return ReturnCode.Failure.Code;

   39        
    } 

   40        
}

   41 

   42     }

   43 

   44 }

Within the ParseFeed
method I am using LINQ to XML to populate my business object calling the save()
method to write it to the database. As you can see, using LINQ to XML can be
a lot simpler than using XML/XPath. Once in the database, I can query it in my user
control, and display it on my home page here.

Now, when I make my Twitter
post, all I need to do is take the XDocument the Twitter API returns, and pass it
into the ParseFeed method, which looks like this...

   35        
            //Post
my tweet to Twitter

   36        
            TwitterAPI twit = new TwitterAPI();

   37        
            XDocument doc = twit.UpdateAsXML(Settings.TwitterUserName(),
Settings.TwitterPassword(), txtPost.Text);

   38 

   39        
            //Save
it to the activity table for displaying the activity

   40        
            TwitterFeed feed = new TwitterFeed();

   41        
            feed.ParseFeed(doc);

Simple and neat! Now when
I implement it for my blog, it will be just as quick and easy!

Props go out to this post I
snagged an extension method for formatting the Twitter posting date to something a
human can use (and my C# class can use to manipulate and save!)

Some neat things I found today...

Wed, 12 Aug 2009 05:31:11 GMT

Tonight was a short night of development, as my folks were in town as my dad needed to go to the doctor. I did get some database work done, and my business objects done. I use a hybrid of Rockford Lhotka's CSLA. I don't need all the functionality (such as layers of undo) so I trimmed them back the amount of functionality I needed and created CodeSmith templates to generate my classes. Let me just say I can code really fast now. :) If you haven't taken a look at Lhotka's Business Objects book, I highly recommend taking a look at them. I began using his concepts in VB, and they have proven very reliable and scalable.

QDJ: Do you use ORM's, and if so, what flavor do you like?

I have to admit, I am not the biggest fan of the various ORMs I have tried. They do serve a purpose though, but I have found most inflexible. I am currently using nHibernate, and while they make themselves readily available to code generation, so far, it seems like a lot of code. See my previous comments about another ORM I tried. My brother uses it, and seems to be happy with it. I just thought the learning curve was very steep, and the documentation was very lacking. I took a beating for that opinion. :)

So tonight, I want to post a couple of links I used today. Soon there will be a control for this on the Rubicon Computing site, but until then, I will post them here.

First, I referred to this before, but here's a site with a lot of good links to various "cheat sheets". Some are really good and useful. You can find those here.

Next, I found some neat add-ins for Visual Studio 2008. The first is the Source Code Power Toy. It outlines your code in a treeview, which makes navigating your code, especially in complex classes, very easy. Best of all, it's free! It's available for VS2005 as well.

I also installed the Power Commands for the VS 2008 IDE. It has some useful right-click functionality, such as opening a command prompt, and opening the containing folder, and that's just a small glimpse of what it can do. It seems to be well documented, and I look forward to exploring all it's functionality. And best thing, this one is free too.

I'll probably post some useful CodeSmith templates I created. I love CodeSmith, but sometimes it's tough to find out exactly how to do things, so I will spare the world the trial-and-error where I can. In the current project I am working on, our team saved 1,100+ hours, and over $50,000 dollars last month alone by generating nHibernate code from the templates we created. Yeah, I earned my rate last month for sure. :)

As we march across the Rubicon, we have Admin pages!

Tue, 11 Aug 2009 05:05:59 GMT

Tonight I didn't get as much time to work on the site as I would have liked, so I focused on getting the admin pages up on the production server so I could do some "behind-the-scenes" work remotely. This required some security, which I started last night, but the data migration for that was a bit more daunting, so I needed to finish it tonight. While the authentication providers and controls do handle a LOT, it has an interesting learning-curve, and deployment can be a challenge as well. All-in-all, it sure beats writing all that code by myself.

I tried to use a lot of caching and cached settings to help improve the performance on certain pages, especially my client list. On my admin pages, I made sure to create a means to reset that cache without having to do a complete server reset. Actually, the same approach I took would work well for high availability sites, as the method I used to complete this would not require a server reset to re-load systems. When I was int he banking industry, high-availability was a huge issue, and simple config changes meant waiting for a scheduled system outage or worse, an emergency outage. When I redesigned that site, that was one of the top priorities I had.

It occurred to me how much time it takes to set up the infrastructure of a site: master pages, common libraries, configuration files, CSS, etc. Once those are done, if done properly, the rest of the site should go fast. One thing I have found to speed that up was the use of Visual Studio Project Templates. Combined with code generation like CodeSmith, you can really generate web sites extremely fast, and get on to coding the "fun" items. I will write about both of those in the future (CodeSmith and Project Templates) once the site is stabilized.

Tomorrow night may not have a lot of development, as my parents will be in town. Later this week, I will be coding my next control: the activity feed. When posts and feeds are made or read, this control will snag it, and place a brief "teaser" on the home page.

More progress on my site -- Client List!

Mon, 10 Aug 2009 04:58:40 GMT

I finally managed to get my client list online today. From a technological standpoint, it was pretty straight forward. I store the information in the database, and use my CodeSmith templates to create a class for extracting the data, and then use a Repeater to present the information in a table format. I still need to make some changes to it, but all in all, it works well. Since the data won't be changing often, I did cache the data to make it come back faster.

I started working on security for my Administration pages. I need to get that set up before I can activate the admin pages, but I have run into some issues getting it all configured. I ran into this once before with the ASP.Net forms authentication security provider, but this time is a little different, as I only want to secure one folder. Certainly not too difficult to do, but not as easy as I would have hoped either.

Once I get the security and login page worked out, I'll begin working on my "links" page. The idea here is that when I blog, or post to twitter, or a few other ideas I have, it will update the dark blue control on the home page with a summary and hopefully someone will click through to get the rest of the details. This should be fairly straightforward to do. Since most of the services respond in XML, I'll just use a factory method to instantiate the proper object, which will know exactly what information I want to extract from the XML feed. As I add more items I want to track, I will simply have to implement the same interface and it will plug right in to my "updater". For the items which return XML (e.g. RSS or Twitter), I will use LINQ for XML to grab just want I want and populate the data right into my classes.

Which brings up a point...

I could probably do this almost as easy with XPath. When does it make sense to move to the more "sexier" technology as opposed something proven and works well? For example, a lot of times, when a new technology is rolled out, it tends to be buggy and some of them historically have not performed well (e.g. early XML for those who have been around a while). All things equal, when does it make sense? Just a rhetorical question, but one I got hit with recently.

I was in a technical interview for a job I wasn't planning on taking (drive was too far -- the company I was representing knew this as well, they just wanted me to be on their radar for the future). I was asked about a particular implementation of the new List object. Honestly, I know how to use the List object, and he was asking about some of the internals I really hadn't needed to know.

If I was having performance issues, I would want to know, and then I would look into it further. In this case, I was able to provide at least 4 other reasonable implementations based on the criteria I was given, yet, I still couldn't get the "sexy" answer he was looking for. At what point does it really matter? For my part, I didn't like NOT knowing, and I did look it up when I left, but in the big picture, when does it become relevant? In my book, the practical solution to a relevant problem always supercedes technical "sexiness".

A not-so-shameless plug

Fri, 07 Aug 2009 05:02:11 GMT

I finally got around to updating my resume, and I pasted it temporarily on my home page at Rubicon Computing Solutions. That's my company, and it's been a great run of 13 years. I say temporarily simply because it will better positioned later, but I realized I really should have it on there so it gets picked up by some search engines, recruiters and in general people looking for .Net development in the Phoenix area.

I am in some talks with some other very senior developers I have had the pleasure of working with over the past couple of years about banding our talent together. I've tried that before, but these developers have been on their own for a long time, so we have a very similar background and strong work ethic to build upon. I have always struggled in the past with partnering up with other developers, as I have very high expectations of any project I work on. In fact, this is why I have had trouble hiring help, as my standards of quality aren't met by most developers without substantial coaching. These developers already have that skill, along with maturity and experience, which makes this a very exciting opportunity. Interesting how this economy drags some people down, yet others, like myself see it as an opportunity.

One of the limiting factors I have always had was that I was limited on the size of projects I could take alone. This changes that dynamic dramatically.

So if you're looking for some quality application development (web or windows), I specialize in quality service and coding in a Microsoft environment. I can work alone, with a team, or build and lead teams. You can find more details about those skills here. Thanks!

Yedda library, Twitter Responses and LINQ to XML

Wed, 05 Aug 2009 05:34:05 GMT

Tonight's coding session went by WAY too fast. I integrated Yedda's Twitter API into my admin pages so I could post directly without having to use another client or browse to Twitter to do it. The next step will be to read my blog feed and Tweet automatically about the topic. That's for another night though, as tomorrow night is poker night, and yes, I still play. :)

One change I made to the Yedda library (ok, two.. I ran into an issue with an error code 471 being returned, but a quick Google search fixed that (sometimes I how effeciently we coded before Google). I wanted to use LINQ to XML to parse out my response code. So Instead of returning the XML Document, I convert it to an XDocument using the Parse method, and return that, like this:

         public XDocument UpdateAsXML(string userName, string password, string text)

        {

            string output
= Update(userName, password, text, OutputFormatType.XML);

            if (!string.IsNullOrEmpty(output))

            {

                XDocument xmlDocument
= new XDocument();

                xmlDocument
= XDocument.Parse(output);

                return xmlDocument;

            }

            return null;

        }

Next, if I want to grab the status from of the post to Twitter, I can use LINQ as follows (in this case, I want the id so I can see if it was successful):

TwitterAPI twit = new TwitterAPI();

                    XDocument doc
= twit.UpdateAsXML(Settings.TwitterUserName(), Settings.TwitterPassword(),
txtPost.Text);

                    var status
= from s in doc.Descendants("status")

             select (string)s.Element("id");

                    bool found
= false;

                    foreach (string id in status)

    found = true;

I am sure there is a better way to determine if it was successful, but this will work for now, as there are other things I want to do with the response as well. Since this worked so well, I plan on converting all the XML calls to XDocuments so I can use LINQ to work with the response.

That's it for today!

Conditional Compilation and the VS2008 IDE

Tue, 04 Aug 2009 05:15:10 GMT

Today has been a very productive day in general for my .Net development. I came up with a few ideas of integrating Twitter with the site, as well as some longer range plans for using trending APIs for a concept I will tentatively call sociolytics^® (I would have preferred socialytics^®, but the name was taken, so I will coin both and trademark them both). :)

So today's topic will encompass some of the design considerations. First, I needed to create an admin page to allow me "behind the scenes" access to posting and functionality. I made sure to create the page it its own subdirectory to simplify access control to those pages. I created a separate master page for this section, as I might need more real estate for the controls which will reside on this page. Which brings up another topicI will bring up at some point --> control oriented encapsulation.

One of the controls was to allow me to post to Twitter directly from the page. I debated a couple ways to do this.. limit my control to 140 characters, or allow more, and do multiple posts. I opted one post per submit, as I want to make sure my posts are complete. I wil add a link to create "tiny URLs" via a web service next, to aid in quickly creating short links for things I want to tweet. I picked up a nice article on that over at CodeProject.

But the topic of this post relates to a cool feature in the Visual Studio 2008 IDE. Maybe this has been there all along, and I didn't notice it, but today I did. I needed to create a control which allows me to quickly encrypt values. For example, until I get OAuth implemented, I want to hide my Twitter credentials. However, when I post this functionality, I really don't want the world playing with this functionality if they manage to hit this page.

So enter the conditional compilation. I wrap the calls in the following code, and when I compile for release, it's not included. What's nice is that the IDE even reflects the code won't be available when compiling in Release mode. Pretty nifty!!

            try

            {

#if DEBUG

    if (txtValue.Text.Trim().Length > 0)

    {

        lblResult.Text = Settings.EncryptString(txtValue.Text);

    }

    else

        lblResult.Text = String.Empty;

#endif

            }

            catch (Exception ex)

BTW, thanks to CopySourceAsHTML for
making posting snippets so easy!

First Control -- RSS Feed

Sun, 02 Aug 2009 14:54:16 GMT

As the main site is developed, I'll detail what decisions I used to create the site, then a high level overview of how I designed it. Just a warning though, some of the decisions will seem very arbitrary, as they were. I made them simply because working on your own site gives you a luxury of trying things you normally can't do with a client. In my case, a lot of my decisions will be over-engineered, because I may want to re-use them later.

Of course, the first thing I had to come up with was an overall site layout. I won't go into that here, as one thing I will never profess to be is a layout guru. I got a decent design, and I set them up as a master page so the rest of the site development will go easy. I used VS2008 and C#, and began implementing AJAX where it made sense. For example, there's a control which updates the current time every 30 seconds or so, so I could use the update panel and timer control.

The first real functionality I wanted to add was a link to this blog. So I created a user control, and placed it on the front page. However, I do plan on posting a lot more here, so I knew it wouldn't be feasible to show every post, so I decided to limit it to the latest three posts. I wanted to display the title, the date and the first bit of the post to hopefully catch a reader's attention.

But reading from a feed from sites at two different hosting providers can be tricky. Not from a security standpoint, as RSS feeds are open, but more from a performance standpoint. Anyone coming to my portal site should be able to see the latest posts, and quickly. The fastest way of doing this would be to create a Windows service which periodically reads the feed, and stores the information in a database. However, I am not sure I would be able to install a Windows service on my service provider's server. So......

What I can do however is read the feed, and place it in cache. Periodically, I can expire the cache and re-load it, and unless you are the unlucky soul to have to wait while it loads, the majority of the users will have a quick response. For that poor soul who waits while cache is refreshed, I used Ajax and the UpdateProgress control to provide some visual feedback that the page is doing something.

The rest was pretty straightforward. I either request the XML from the RSS feed (or cache), and use XSLT to display it. It's been a while since I have used XSLT, but there is a lot of potential there, I expect I will be using a lot more of it in future controls. I created the class generically so that I could pull any RSS feed I wanted from it as well.

One great use I found for XSLT was on a high-availability web site which sent a lot of emails. We wanted to be able to change the email format frequently without bringing the site down. Using XSLT, we could change the email template files any time to create very nice HTML based email messages. I read a great article recently about calling C# functions in your XSLT templates using extension methods, which I plan to use extensively, as C# is my main domain. Maybe I will use them... I say that as I really would like to improve my XSLT skills, as I think the technology is highy underused in the .Net world.

So now I am playing with Twitter feeds and getting the rest of the site content set up. I also used the AJAX popup control to help prevent any 404 errors as I complete the functionality. If you've been putting off using the AJAX Control Toolkit for some reason.. STOP! The amount of functionality these controls offer is amazing, and you can't beat the price.

That's it for now! If you want more details on how I accomplished this or some sample code, just send me a comment. Upcoming posts will address the development of the rest of the site, along with some major wins recently using CodeSmith.

New feature in .Net 2.0 Exception object

Tue, 13 Jun 2006 15:42:38 GMT

There's a pretty useful feature (IMHO) in the .Net 2.0 Exception object which I hadn't noticed before. The Exception object contains a new Data interface, which is essentially an IDictionary for applying additional values to the exception object. I am currently using it with my integration of the new VS2005 Enterprise Library into our framework.

I want to log exceptions to a database, but I have found it useful in the past to have an Error #. In the old days (VB 6, for example) I could usually look at the error number of an application and tell exactly what the problem was. When .Net came into being, we lost the error number, and there was no easy way to get around it. You could roll your own exception classes of course and add these properties, but this is only a limited solution because other exception handlers wouldn't be capable of handling the additional features by default.

Now this feature is going to allow me to take advantage of error numbers by classifying each exception type, and appending an error number to the exception object. I can use this information in my database to classify and group errors by type to identify weak areas in an application as well. Not Earth shattering, but still a useful feature full of all kinds of possibilities.

A change of directions...

Fri, 28 Apr 2006 15:38:06 GMT

So it has been hit or miss posting here, but I am trying to correct it by bringing on some additional help. I set up a new blog, developernation.net, and begun getting some content on there. Likely I'll crosspost on here too (my content anyways) but likely most new entries are going to be there first. I figured if I could get someone else on there helping doing some content, it will have more regular posts. This blog will continue, just a lag a few days on the content of theother site, and contain more personal observations.

So swing on by and pop in. I've started off with a bang, and I am in the process of posting a web service design I created and tested which handles paging and sorting of data on the server, which my initial tests have shown to be highly efficient. I am walking through the entire design, and by the end of the weekend I hope to have the series done and the code posted. If not, you can wait a few days and I will post it all here as well.

Thanks!

MSDN Universal Discount for MCSD/MCDBA

Fri, 07 Oct 2005 15:57:27 GMT

A year ago, I completed my MCSD for .Net. One of the attractive
benefits of this certification (as well as the MCDBA) was a $500
discount on a one-year MSDN Universal subscription during the first
year of certification.

Although the MCSD benefits page still lists this benefit
(http://www.microsoft.com/learning/mcp/mcsd/benefits.asp), they
quietly removed it as of April 2005. The text on the page still
states the following:
Rebates or discounts on a one-year subscription to MSDN during the
first year of certification.

If you call or write to get the certificate as I did, you'll get the
terse response it's no longer available, and they just haven't
updated the site. I figured I would help them get the word out since
they didn't deem it important enough to change on their site or
announce. It would be a shame if anyone expected this benefit based
on the MS web site information.

-------------------------------------------------------------------------

Above is what I posted to our local .Net community group on Yahoo. Now I am going to add some personal comments. Once again, MS has dropped the ball in supporting the developer community. Earlier this year, MS announced the MSDN Universal would not include the new .Net Team Development system (or some name like that -- I am too lazy to go look it up). Fortunately, enough of an uproar went out that they reversed that decision. Their waning support of VB also caused a petition/uproar. Likely, since the MCSD/MCDBA community is a lot smaller, there isn't likely to be a huge outcry on this issue.

This is a HUGE mistake on MS's behalf. Someone that is likely to spend the extra time and money to get certifications are the ones MS should really cater to. There's always been a criticism that the certifications are worthless, and that benefit alone made it real easy to justify spending the money on books, training materials and exam costs for achieving the certification. I won't argue the merits of the certifications here, but I have a lot of them -- MCP, MCDBA, MCSD for VB, MCSD for .Net (C#), and MCAD. Will I continue? I may have to given I am an Independent Contractor and it helps to get me in the door. Will I recommend it to someone not in my position? Not likely.

Don't get me wrong, the MSDN Universal is still a great deal. My disgust over this situation is that the benefit is still listed, as well as no announcement in April 2005 when they made this decision (or if they did, I sure didn't see it). I have been one of the most stalwart supporters of Microsoft over the years, and I have personally been involved in projects which have generated millions in licensing revenues for Microsoft in the last 10 years. The past 1.5 years I have watched MS anger the core base of developers.

I think this is indicative of the internal problems at MS, and why Google is going to be a viable competitor to MS. In a paraphrase of the words of Stephen King, and the Dark Tower series, MS has forgotten the face of their father. One of the reasons MS dominated the market over Apple was that MS supported developers way beyond the norm. In the name of profit, I think we are seeing this slowly change.

See the LLBLGen comments from July 18th...

Wed, 20 Jul 2005 20:31:12 GMT

OK, time for a little fairness in the world. When I wrote my blog entry on Monday, I was certainly frustrated with LLBLGen. Franz Bouma has responded to my comments about LLBLGen (little did I know I had such illustrious visitors!). So in fairness, I want to make sure anyone out there reading my blog sees those comments so they can see both sides of the review and form opinions on more than just my emotional outbursts, and my semi-apology for blogging while frustrated. :)

When code generation goes bad....

Tue, 19 Jul 2005 04:49:51 GMT

I have tons I need to blog about but no time to do it, as once again I am up to my head in projects. So this entry is going to be to vent....

One of my current clients is requiring me to use a product called LLBLGen Pro (see it at http://www.llblgen.com). I am certain it's a powerful product, and while it generates enough code to make a COBOL program to look efficient, it seems to perform OK, although my gut tells me this thing would be a pig in a high-demand environment. But here's my gripe -- the documentation is horrendous. I have spent at least 50 hours trying to get this thing to generate code effectively as well as consistantly. And even then, I don't understand a tenth of what's generated. I understand enough to make minor changes, and after a lot of wrestling, I can finally get it to generate code. OK, 50 hours may not seem like a lot to learn a new paradigm which might reap a lot of benefits later, but let me tell you what that 50 hours (billable to my client, I might add, since I begged them after 10 hours to scrap it) bought you. I managed to add 2 fields to a table, and add two tables. The two new table still don't work right.

Let's put that into perspective. First, I code lightning fast. Not spaghetti code mind you, but robust code which typically is right the first time. In that 50 hours, I could have re-written a good chunk of the app, and believe me, it needs it. Fortunately, I did my consultant's duty to bring that point up. It would have taken me three hours tops to make the changes which we are looking at 50 hours and still not working.

Second, the code is difficult to read at best. The project has fallen behind because of the insistance we use this tool, so they brought on two other developers. Guess what, they are having the same problems. They have spent two solid days now, and not one line of code written. Using standard objects, any developer with experience in .Net can peruse the object model quickly and begin coding. Not with this tool!

You can't compare CodeSmith, which I have praised before, with LLBLGen. LLBLGen is far more sophisticated, unfortunately to the point of being unusable. I know there are a few people who swear by it, and that's great, but I get paid to come in and make a difference fast, and LLBLGen has proven to be more an expensive hindrance than a solution.

OK, that's the end of the vent. I have been deploying some web services for another client, and once we have everything debugged, I have a ton of tips related to web services and deployment which I promise will save a ton of hours to other developers entering into this domain. Until then!

It just occurred to me...why extremes are bad in programming

Fri, 27 May 2005 17:28:46 GMT

Extremes in anything (IMHO) are typically not good. Extreme temperatures, religeons, attitudes -- you name it, likely there is a downside. In programming, it's no different. Now, while not a big fan of Extreme Programming, there's a couple of extremes from it that bother me. One is that you shouldn't include documentation. The other, which I suspect was someone's personal preference, was not to use the “Region” directives in C# (or I guess VB.Net either). Here's a little history...

This guy was a former Java programmer working for a large chip manufacturer. He was supposed to be a XP guru, so he was transferred to the local site to help a team in it's transition to the XP methodology.

Strike 1 -- he knew the methodology well, but he was by no means an expert in the language of the group. Why was this a strike? I guess technological bias in that his preferences to his other language directed him to want to make the .Net environment the same as a java environment.

Strike 2 -- It was his way or the highway. The environment was such that one or two developers had 95% of the say on development decisions. Part of the reason for this is that wacky trend in which everyone is ranked from best to worst in terms of raises, options and promotion (for more info what I am talking about, read this article, which is the same process -- Saying Goodbye). No one would ever argue with the two for fear of getting a bad ranking for being considered a troublemaker.

Regardless, I digress, but I do think it's important to understand why sometimes these extremes come about in an environment. I was a contractor brought on to bring some quick wins for a project, and it was my first (and likely last) venture into the XP methodology. They needed code, and they needed it fast.

One problem I addressed was the lack of uniformity on the project. We had three developers, which meant three different styles of programming. Even with XP, that meant one of us was alone, and the other two would spend the pair time arguning over which style was a standard and best (even though standards existed -- they were just never used because of informal rules imposed by the 2 'chiefs'). I decided to create a template which would standardize (and speed up) our development. I organized the code within the controls into regions, and deployed them onto our machines with anticipation I easily saved our team15-20 minutes each time we created a new control.

Alas, it was scrapped instantly. Why? Well, it seems in my templates, I placed the code into logical “regions” -- e.g. Public Properties, Public Methods, Private Methods, etc. I was “informed” (even though I had been using regions for a couple of months now) that regions were not allowed, because all they did was hide bad code. WHAT???!! Well, I liked the contract, and knew the results if I stood up to them, so I bit my tongue and moved on. It has bothered me ever since, but I never took the time to formulate an argument as to why regions are actually a good idea.

Why bring this up today after a year has passed? Well, I was coding something, and the constructor was hidden by a region. I was thinking “Hmm, if we just left the constructors out of regions, it would be easy to read, because the regions would hide the internal implementations I don't care about, yet at a glance I can see how to instantiate the object” (hmm, I think they call that encapsulation) and use it. Now that right there justifies the use of regions alone.... I can actually think of a lot of reasons to use regions, and I do it religeously where my client has no opition about it.

Just a flashback from the past.... anyone got a counter opinion? Regardless, it just goes to show extreme anything typically isn't a good thing in my mind. You have to be flexible in your approach to life if you plan on growing...

Self Promotion

Thu, 26 May 2005 23:33:35 GMT

Tentatively, my current project is set to end in October. No big deal there, as I have had absolutely no bench days in the past 10 years as an Independent Contractor. In fact, during most of those 10 years I have been working 55-80+ hours per week and having a great time doing it. I don't do the book thing or magazine article thing because quite frankly, I don't have time because I am busy doing billable work which pays a lot more. I havn't needed self-promotion thing either because almost all my business comes from referrals from current or past customers.

Then along come kids, and dang if you don't suddenly want to spend more time at home and improve their quality of life (and mine). My current project wants to bring me on full time, and we've had some preliminary discussions on it, and I am willing to take the pay cut in my pay for one simple thing: I want to work remotely and raise my kids in the country. Their attitude is like mine, which is that should be fine since I have a strong work ethic and can get things done, what does it matter where I work as long as I have a phone and internet connection. However, there are data security concerns and management concerns which would need to be overcome.

I have plenty of time, since barring disaster, the contract won't be over until October sometime. But I figure I will start self-promoting just in case someone from a company who doesn't mind remote employees stumbles on this blog. Towards October, I will go full bore trying to close something out, and in the meantime I plan on blogging much more so I can display what talents I can bring to the table.

If any companies out there that come up on this, and want a great employee (C#/VB developer with lots of SQL Server and architect/designer/coding and full-life cycle development) that brings a lot of experience, a great professional attitude and presence as well as the ability to code like the wind (and good code at that..), then drop me a line and let's talk.

Here's a resume just in case..

CodeSmith rocks!

Thu, 26 May 2005 23:19:32 GMT

I bought CodeSmith back in v2, but I was so busy I never got a chance to do more than play around with it. So now v3 is released, and I was looking at the improvements (like Intellisense) and decided I would take a look at it again. Boy, was I glad I did..

Don't get me wrong, I wasn't putting it off because I think code generation and templates are bad. In fact, quite the opposite. When I first started my business, I had a few people working with me part-time, and then finally full time as the business grew. What I found was that in the end, I apparently hold my coding standards to a higher value than others and I would end up coding 90% of the application myself. I realized quickly there were a few huge advantages to automated code generation. Here's a few:

Fewer errors (as long as you fix the templates as errors are encountered)
One developer can do the work of 4-5 once you get a good architecture set up
Standards enforcement is a no-brainer when you are all working off the same templates
You can spend more time on UI usability and data structure because 90% of the infrastructure stuff is done automatically
Changes are easy. Change the structure and regenerate the code, and you are off again.

I could go on and on about it. I had written a series of VB6 addins which I used based off Rocky Lhotka's BusinessObjects book for VB5. In hours I could generate almost all of my middle and data tier code. A tweak here and there, and I was doing the fun stuff like UI coding.

Along comes .Net, and my addins were irrelevant. I created a couple of quick and dirty addins, but I was so busy heads-down coding, I didn't have time to create new templates to reflect the impact of .Net. I did create some common libraries of functions which got me through a good chunk of redundant coding, so that was going to have to do the job for the time. I had always intended on going back and re-coding some new templates, but it never happened.

I am currently working on a project and we are horribly understaffed, and there's no relief in sight. There are some huge deadlines coming up, and it's time to make the rubber hit the road. I already code fast (and tight), but I needed to clone myself a couple times over to make the deadlines. So when the announcement came this week of CodeSmith 3.0, I decided I would take a new serious look at it and see what it could do for me.

Holy crap! In a matter of hours I had some pretty solid templates up and running, which will save the team many, many hours of redundant coding tasks in building this application. I have so many ideas for new templates it's scary, and I have only scratched the surface for what the tool can do. If you haven't looked at it yet, I recommend immediately going to CodeSmith and downloading a trial.

Error Handling Discussion

Thu, 14 Apr 2005 16:49:54 GMT

There's a lot of debate on the best type of error handling, where to log it (if at all), and when to do it. For example, here's a debate today:

http://weblogs.asp.net/alex_papadimoulis/archive/2005/03/29/396141.aspx

In this debate, the question is Return codes vs. Throwing an Exception. You can read the blog entry to see the debate. Here's my take, and why.

First, I always handle the exception where it happens, and rarely bubble it up. Why? First, what if the calling code doesn't handle the exception? Now you have an unhandled error, and it could cause an application to crash. On a recent project for a large chipmaking client, I got into this debate a few times with all levels of developers. It was always an interesting debate with senior developers because they at least adopted their belief into action and a bigger strategy. For example, they may trickle it up and handle it at the highest level, but if they forget to handle it, the best developers handle the uncaught errors at the thread level. The advantage is they have the error information and can use it to provide the user some feedback as to the nature of the problem.

But those are good developers, and I would say the top 10%. As an example, I had this debate with a mid-level developer who was convinced he was a senior level developer. Now, as I tell this story, let me mention I am a very good poker player. He adamantly felt errors should be bubbled up and handled at the UI. I countered him with the standard “What happens when the exception isn't handled?” He advised me he never forgets. Enter the poker player in me.

Being a consultant, you have to know when to shut up and let the “hand” play out. This was an XP project (never again), and as we paired, I watched him write some code, and I even reminded him about error handling. For the most part, with my diligence and because we had just had the discussion this guy was being fairly consistant in his exception handling at the UI level. However, I stopped reminding him (it's instinct for me to do it now), and sure enough, he forgot, and the application crashed a horrible death. The reason I wanted to have this discussion with him was because his code was causing about 80% of the crashes on the team, and I was trying to help him improve his skills (and our project). To finish the story, the guy's ego was so big he refused to accept responsibility for the crashes or even acknowledge that I had a valid point about forgetting error handling, and kept on his merry way.

Back to the point, IMHO error handling should be handled where the error occurs. This is especially true in multi-developer projects, as you cannot guarantee someone who calls your code is diligent enough to handle things when problems occur.

But that has a serious downside -- how do you let the user know there was a problem, and it was handled? The answer -- return values. OK, there's a little more to it than that. An error code is never enough information to provide feedback or to decide what to do when the caller receives notice an error occurred. Even worse, a number is useless in trying to relay relevant info to the end-user.

What I have adopted is this: I have a base class which my other classes inherit from. In that class, I have an ErrorMessage property (string) which is set where the error occurs, or in a central error handler. When a method encounters an error, it returns an integer value indicating failure. The calling routine (if desired) can check the ErrorMessage property and use that value for displaying a message or get details as to the nature of the problem. It can also ignore it if it wants. The key thing though is that the error will never go unhandled and cause the application to crash.

I'll be happy to post up some examples if there is interest. This is just a very important topic to me, and one I think which separates the wheat from the chaff, as they say!

In the debate listed above, there's an argument over performance. There's a balance here: you need to perform well, but performance is killed when the application crashes. Find a solution which is robust but also performs. Not handling an exception is not an option for robustness.

Tip of the Day -- Great Exception Handling article

Wed, 09 Mar 2005 17:47:50 GMT

I am currently trying to go through a Code Review at a large bank to get our code approved for release on the internet. One thing that came up was in some situations, we are displaying the raw exception message which was listed as a no-no, which I disagree with. While it's not particularly informative to the user which is potentially an issue, I can't see where “Invalid use of null” is going to be particularly useful to a hacker, but to a developer, that tidbit may help identify the problem when the user calls for help (good application logging aside in this example). Ironically, when errors weren't handled because the developer forgot, this passed code review.

So my intent was to enumerate all the default error messages to determine if there are any which would be particularly helpful to a hacker. While I am still looking to find or create an application which will enumerate all the default messages that .New throws out, I did come across a great article which lists the various error handling philosophies, and tries to weigh out the pros and cons of each. Here's where to get this pearl of wisdom:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnbda/html/exceptdotnet.asp

Test Driven Development (Test First) -- is it everything it's supposed to be?

Wed, 24 Nov 2004 04:10:05 GMT

I spent the past 11 months (as I mentioned previously) as part of a team of developers on an 'agile' project, using the Extreme Programming methodology. As I was working out today, I was reading the December 2004 issue of asp.net Pro magazine. The featured article is about Test Driven Development (TDD), and it's place in agile development.

First, let me preface this topic by saying I am absolutely FOR Test Driven Development. In my opinion, there's too little focus given by developers on focusing in what can go wrong with an application -- testing, error handling, malicious users, and a myriad of other potential gotchas. The purpose of this blog is simply to provide some alternative views on TDD, and some potential pitfalls, since there is little seen on the topic, especially from those of us in the trenches. Combine this in your approach to TDD, and you'll have a much better experience.

Here's an executive summery of the caveats to TDD from my experience:

No code is supposed to be written before the tests. Design first, then write the tests, or you'll end up with a bad design.
When tests take longer to write and modify than the actual coding, the process gets in the way.
TDD gives way to the erroneous philosophy that if your automated tests work, that's all the testing you need (except user acceptance).
There is the dangerous thinking that you can write automated tests to cover every scenario. See point 2 again.
There becomes a belief that the number of tests somehow correlates to the quality of testing, or the the mere existence of an automated test provides a better application.
UI testing tools (especially the open source varieties) are lacking in the ability to generate UI tests, at least from the web perspective in the trench I sat in.
When you data shunt the data access (and manipulation) portion of a class, that's not a very valid test. The database MUST be tested, and your tests must accurately reflect how the users are going to be actually using your objects for TDD to be of any use.

Let's look at each point in a bit of detail, so I can provide some details on my OPINIONS here...

First, the statement is made no code should be written before the test. OK, what exactly are you going to be testing for? For example, let's say you might be wanting to test customer creation. You envision the routine you want to test to return an integer which ties to the ID the database generates. OK, great! But guess what, that's a DESIGN DECISION. Why not set a read-only property of a class, and return a standard return code? Are you going to follow this exact style with the rest of your classes? Will the other developers do the same? Will the routine throw an error, or handle it itself? If handled, how will I know there was an error?

I know for a fact that if you don't lay out some very specific coding guidelines and design, four developers are going to design the same class four different ways, even when pairing. Given that fact, how can you possible write meaningful and consistent tests without doing a basic architecture/design first.

Second, writing tests is time consuming. Maintaining tests can be even worse. On this same project, test maintenance at times took more time than making a simple change. Why? When the change is made, many times a refactoring occurs (in our case it was almost a given since there was little thought placed on a unified design -- some day I will write on why that occurred as part of a human dynamics of development topic). Suddenly, the test needs to be re-written because the test now fails as a result of the refactoring. A simple business rule change has now turned into a design and test change. A task that might have taken an hour now takes two days. Sorry, as a business owner, it's a bitter pill to swallow.

Another mistake occurs when the developer takes on the attitude that when the automated tests pass, the testing is complete. Let's face it, as developers, testing sits right up there with documenting code. No one wants to do it, but it HAS to be done. With TDD, it's an easy trap to fall into. I even heard “My tests run, let the customer catch anything else in User Acceptance.” Wrong! The customer's are why we as developers have jobs. We need to do due diligence in functional testing, integration testing as well as usability testing. Automated testing is NOT going to do that for us. To think your automated tests are going to catch all the errors is dangerous thinking. No one has every promoted TDD to accomplish this, but I can tell you from experience, the possibility that this mindset can exist is there.

As I mentioned before, I am all for TDD and automated testing. However, I also like to be thorough. I also only like to write valid tests. If I was to sit there and ponder every single possible scenario, at my bill rate the client is going to be looking elsewhere thinking I am nor getting enough done. Consultants beware! But seriously, even if I could take the time to come up with test which can adequately test the possible scenarios, how much have I gained (in the short term -- long term is a whole other story which TDD clearly wins)? Testing scripts which repeatedly test the application, written by the users and repeated each time in user acceptance is a far more effective testing methodology (OK, devil's advocate time -- can you really get them to test it completely every time? The tester also suffers from laziness or lack of attention in repetitive tasks..) So writing tests is going to also be an iterative process which never ends. When a bug shows up, we need to refactor our testing to cover that scenario in the future. Now I am maintaining two projects which is even more time consuming.

The next fallacy in TDD is that the sheer number of tests (metrics) means you have good testing. In the environment I was working in, their reviews were actually based in part on the number of tests they wrote. Never mind that the majority of the test written were actually an effective test, but the sheer count was taken to be effective testing. Quality in testing should be your number one priority. If you can only come up with one test which effectively tests an object, then so be it. Adding five more test which do nothing other than add time during a refactoring is little help to the cause of good software.

Right now, automated testing really focuses on the Data Access Layer (DAL) and Business Objects Layer (BOL). When I discuss shunting next, you'll see it actually comes down to the BOL in many cases. What about the UI? The tools, especially for ASP.Net in the open source community are severely lacking in automated testing. How will you know if the javascript works both on Netscape and IE without running it yourself? It's the UI the user sees, which is why the UI has to be thoroughly tested in both how you expect the user to use it, and how they might use it. Users always come up with useful scenarios to break our applications. Think of it as a fun challenge and you'll be far less frustrated.

To test out our BOL, we shunted the data using XML or pre-defined data tables. It actually works great, but it's a limited test. What happens when the database schema changes? If you've shunted the data, you'll never know the impact unless you do your due diligence and fully integrate test, or the user finds it in user acceptance testing (which is not where you want to catch these things). If you do shunt your data, that's great and fine. Just make sure you test against the schema the application is going to be deployed against as well. See my blog about getting a random record using NewId() if you want to generate some good database based tests.

OK, it probably sounds like I am really bummed about automated testing after my recent experience with it. That belief is the farthest from the truth. In fact, I am going to introduce it on my current project because I feel it can certainly add a key dynamic to a complete testing process. But as Test Driven Development gains acceptance, I felt it was time someone at least mentioned the things to consider so it can be a more effective tool in your development cycle. Plan ahead and determine how you can avoid these pitfalls and hopefully your investment in time will generate more dividends from Test Driven Development.

My trek into automated builds

Tue, 23 Nov 2004 21:47:25 GMT

On my last project, as part of the agile process, we utilized nAnt with Draco.Net to create automated builds. I didn't implement that part of the project, but I certainly did see the value in automating the build. So, while I set up my environment for my topic of Component Based Development, I am going to write my learning's on generating an automated build. If you've used these tools, feel free to hop in and add some help.

That's one downside of open source projects -- the documentation can either be lacking or just as distributed. So hopefully by blogging about it, I can save someone some frustration.

So I am going to start by looking at the tools I am planning on using:

nAnt Home Page -- Get nAnt here. nAnt is the tool you'll use to configure your build

Draco.Net -- How to generate a build when your source control changes (or you trigger it)

Some other interesting links I saw:

For nAnt help: NAntUsage wiki -- Some help on how to use nAnt

For Draco.Net help: Draco.Net wiki -- Some help on how to use Draco.net

Tomorrow I am going to start implementing nAnt on a fairly complex project, so I will post my findings as I go along!

UI Abstraction -- Component Based Development Part #1 -- Description and Requirements

Thu, 18 Nov 2004 05:14:36 GMT

A very common task in application development is reporting. There are many tool packages out there which do a great job, such as Crystal Reports, Active Reports and the new kid on the block, SQL Server reporting tools. However, a lot of times these are overkill, or too expensive a solution.

Using ASP.Net, generating a UI for the results using a DataGrid or DataRepeater is very easy and can look professional in minutes. However, users typically aren't happy with just pulling out all the data. They want to be able to filter the data and quickly narrow down the data they need to see.

The solution is to create a data filter. A data filter provides a UI for selecting one or more criteria and limiting the results displayed to the items selected in the filter. Sometimes, the filter takes far longer to create for a deeloper than the actual report, and from my experience not one of the 'cool' functionality to add.

Case in point: A portal-based web site I helped develop for a large bank was about 90% reporting. By implementing base pages and styles, common grid functionality and libraries, I was able to get the turnaround on a report from 2 weeks to a day or so. As I analyzed the process, I noticed the report display only took a couple of hours, but the ensuing filter could take a day or more between layout, creating the filter items and modifying the query to handle the filter.

Subsequently, I developed the FilterWizard, which is a User Control which handles compiling the filter criteria, retrieving the data and making the data available to other controls, exporting to Excel, or anything which consumes data. The beauty of this control is that filters for individual fields can be added or removed with one line of code. The layout of the filter can also be altered by changing single values.

The requirements were fairly simple: Strong encapsulation of internal logic to a few simple methods (Primarly a single point of entry for formatting the individual filters, and a single point of entry for retrieving the values to filter on when the user pushes a [Filter] button). When the filter is triggered, the FilterWizard should notify the data consumer that data has been retrieved and is available for rendering.

When formatting the individual filters, the developer should be able to change the format of a filter simply by changing an enum value which represent the available filter types. Examples of filter types might be a single-select combo box, a multi-select listbox, a date range, a single value or a range of values. In the end, I wanted it as extensible as possible so if a new filter requirement came up, I could add additional filter types as quickly and easily as possible.

Finally, the FilterWizard should also be able to clear itself and reset the individual filters as well as display a summary of the filter values should the user choose to print the page.

There are actually two versions of this control. The first version used Dynamic SQL to create the filtered data. It was written in VB.Net. While Dynamic SQL provides some flexibility not easily duplicated using parameters, it's also more susceptible to SQL Injection. The second version uses C#, and used parameterized queries. I plan on discussing both because each has it's strengths and will reach a wider audience of developers by providing source in both VB.Net and C#.

What did I come up with? A great and easy to use control which provides all that functionality. And this is the start of my series on the FilterWizard which I will write more about, and finally provide all the source for in upcoming writings!

Now there's an idea for another topic (and a brief aside): C# vs. VB.net. I am a long time VB user and fanatic, but I have to confess C# is where it's at. I will certainly discuss this at length in the future, as there are definite advantages to using C# (which may go away in VS 2005) which I think are largely overlooked in other discussions on the subject. For now, let's suffice it to say if you have a choice, don't fear C# and jump in it head first. If not, use it when you can just so you are familiar with the syntax.

What's Next?

Wed, 10 Nov 2004 04:58:13 GMT

I was thinking today that the daily tips are nice, there really isn't much I can't write about that hasn't been written about in terms of tips. So what can I write about that is not something I plan to make commercially available at some point, but can enhance the .Net community?

Today, I remembered an ASP.Net component I wrote which makes adding a complex data filter to a report as quick as a few lines of code. It's fully extendable and it demonstrates what UI abstraction can really do. I also have it already available in VB.Net and C#, and an example of building dynamic SQL as well as integration with stored procedures. It's in use for two of my large clients, and they swear by how much time it saves them, so hopefully it can save someone out there in Blog-land a bit of time too.

I'll still include my daily tips, but I think this will be a great beginning to contributing back to the ASP.Net development community which I have benefitted much from. So, stay tuned while I get the components into a nice same project using the Northwind database.

-- Daryl

Another Great tool

Tue, 09 Nov 2004 05:34:42 GMT

As a consultant, I need to be able to port a bag of tricks from one project to the next. Accessing MS Repository isn't always the easiest, although I have used it in the past for internal projects.

I ran across CodeLib for .Net by Fish, and it's a great tool, with searching, the ability to append files, notes, code (which it formats) as well as web pages (which I have yet to figure out how to work with).

Best of all, it's Freeware. So give it a try, you'll like it. Heck, once you get a library put together, maybe we can swap! ;)

Automated Testing and Bugs

Thu, 21 Oct 2004 05:51:54 GMT

With the advent of test driven and test first development, writing meaningful tests can be a bear. There are a lot of methods, such as data shunting and hardcoding values, which avoid using the database for testing. While this can test the code, it doesn't test the database CRUD. I believe I once read that 80% of all applications are database applications, so testing the database portion is critical.

Personally, if you write tests which avoid directly testing your data schema and access methods, you're asking for trouble unless your Business Object tier is very robust. Even then, schema changes might be missed in testing if they don't actually interact with the database.

I am currently using nUnit for running the automated tests, and so far I absolutely love it. However, writing meaningful tests can sometimes take longer than writing the actual code, and as enhancements occur maintaining your tests can bog down the progress of the application. Changes inevitable, expecially in XP programming with their short development iterations.

Automated testing also invites buggy code if the developer is not careful. Here's some examples:

Some developers feel this takes place of unit and integration testing. This absolutely isn't true, as automated testing typically only checks individual functional testing (unless you have a very comprensive set of test cases developed -- suddenly these tests don't seem so agile).
Automated testing for the UI is limited at best. While nUnitAsp exists, it's not quite up to par to replace real-life beating-the-hell-out-of-the-UI testing.
There's absolutely no way to predict all of the ways a user if going to use your application unless you are a UI and Process Flow God/Goddess. Most programmers aren't, so you aren't going to be able to foresee all possible combinations of testing.

Bottom line is this. Use automated testing to test functionality against expected results, but this is only about 25% of the actual testing you need to do, regardless of whether the application is internal or external.

How a tip turned into a rant, I don't know.. So I guess I am putting this under Design, and making a second tip out of it.

Error Handling

Wed, 20 Oct 2004 04:09:24 GMT

As part of an ongoing discussion with a developer (let's call him JDOAGD) I am paired with, I had the opportunity to discuss the importance of Error Handling within an application. The two sides:

Minimalist -- only at the UI layer, and only then when the code is likely to fail
Solid -- Assume errors can happen anywhere, and handle them gracefully at ALL layers of a multiple application.

There's a school of thought that when an error condition occurs, throw an error or bubble it up to the highest layer and handle it. OK, that's a strategy, but what happens when the top layer doesn't catch the error? Crash. Fortunately, I was able to demonstrate this fact to the developer today who adamantly insisted on handling it at the UI only. He forgot to handle it, and BAM!, a crash ensued.

I wish I felt this was isolated, but I have had the privledge of working with several hundred developers over the past 10 years, and I would guess error handling is one of the most overlooked aspects of an architecture. Of those hundreds of developers, I would venture error trapping and handling was considered an afterthought by 90% of them. Some examples:

Degrades performance, so why do it? (how about a dead app really performs slow)
The applicaion is for internal customers, so they are more forgiving than if we were trying to deploy for general release
What's error handling and logging?

I recall a project which I was brought into a few years ago. The 4 developers had spent a month learning the business rules involved, and were chomping at the bit to get started. When I came in, they mentioned they were ready to code. So, I asked a few obvious (or so I thought) questions so I too would know how to code with them.

What's the error handling strategy?
What's the data access strategy?
What's the physical architecture?
What type of security model are we implementing?
...and many more.

Scary thing was, they didn't have an answer for any of them. The other scary thing was they were billed as “Expert Coders” and were billing at a significantly higher rate than myself. Had I less ethics, I would have asked for more $$ instead of pushing to resolve these issues. That whole project was “interesting” to say the least and someday I might write more about those experiences.

Back to today. So, since I am on their payroll, I listened to JDOAGD's reasons for not having error handling except on the UI layer. I watched him also forget to place any at the UI level he was so adament about it. I had the hook, and he finally saw the light. What was my point?

In a multiple developer environment, you can never assume the other develper using your code will trap the error (this is an encapsulation issue, which this same developer once vehemently added encapsulation was a bad thing. In a non-web environment, crashes kill the application. The browser is very forgiving!

Finally, internal or not, as developers we are serving customers. Without them, we'd have no jobs. It's important to ALWAYS give them the best possible user experience. Anything else is simply lazy and unprofessional.

Logging is a whole other issue, which I will save for a future session. For now, I'd love to hear other opinions and experiences in this area, so please, drop me a comment!

-- Daryl