Dot Net Technologies -- MS Tech talk and more - ASP.Net

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: An extension method to HTML encode a string

Daryl — Thu, 05 Aug 2010 01:39:30 GMT

Ever need to HTML Encode a string? This useful extension method will do it for you:

 ///
<summary> ///
Extension method to HTML encode any string characters with ASCII > 127 ///
</summary> ///
<param name="str">string to be encoded</param> ///
<returns>Encoded string</returns> public static string ToHtml(this string str)
{ return string.Join("",
str.ToCharArray().Select(c => (int)c
> 127 ? "&#" + (int)c + ";" :
c.ToString()).ToArray()); }

Tip of the Day: Manipulating ASP.Net validators client side

Tue, 02 Mar 2010 04:29:40 GMT

This tip will show how to get a reference to a validator using client-side script, check the valid state of the validator control, and set a validator control active state client-side as well.

I ran across a situation today to validate two dates (txtStartDate, txtEndDate) with the following criteria:

txtStartDate is required (use RequiredFieldValidator)
txtEndDate is required (use RequiredFieldValidator)
txtStartDate must be a valid date (use RegularExpressionValidator)
txtEndDate must be a valid date (use RegularExpressionValidator)
txtStartDate must occur before txtEndDate (use CompareValidator)

Granted, I could write client script for doing this in one fell swoop, but I inherited this page and these validators were already there, and I was just there to fix a bug.

The QA person logged an issue like this:

txtStateDate value – 11/1/2009

txtEndDate value – 11/31/2009 (invalid date)

The “bug” was that in this case txtEndDate is not a valid date. The RegularExpression Validator correctly caught this, but the Compare Validator still fired, indicating a second error. The QA person felt that we should only display an “invalid date” error.

My options were to strip out the RegularExpressionValidator and CompareValidator and use a CustomValidator and write some javascript. But really all I needed to do is disable the CompareValidator if the txtBeginDate or txtEndDate is not a valid date.

It took some doing, but I came up with a simple solution. I added a CustomValidator, and called a client side function called ControlEndDateValidators(). You need one for each date input.

<asp:CustomValidator ID="valEndDateCheck" runat="server" ControlToValidate="txEndDate" ClientValidationFunction="ControlEndDateValidators" />

The function obtains a reference to the validators, and the compare validator is only made active if the data is valid per the RegularExpressionValidators. To check and see if a validator is valid client-side, check the isvalid property for true/false.

function ControlEndDateValidators(source, arguments)

{

var regExpValidatorEndDate = document.getElementById("<%=valEndDate.ClientID %>");

var regExpValidatorBeginDate = document.getElementById("<%=valStartDate.ClientID %>");

var compareValidator = document.getElementById("<%=valDate.ClientID %>");

ValidationEnable(compareValidator, (regExpValidatorBeginDate.isvalid) && (regExpValidatorEndDate.isvalid));

}

function ValidationEnable(val, enable)

{

val.enabled = (enable != false);

ValidatorValidate(val);

ValidatorUpdateIsValid();

}

</script>

Again, we could write client-script code perform all this validation, but sometimes time is of the essence. Using the functions above, we have shown how to get a reference to a validator client-side, check whether it is valid, and finally enable a validator on the client-side.

Tip of the Day: How to register class based user controls in a web project

Wed, 06 Jan 2010 03:52:06 GMT

The latest project I am working on is a web site project, which differs significantly from a web application project. If you need a little background on the difference, here's some links:

http://www.codersbarn.com/post/2008/06/ASPNET-Web-Site-versus-Web-Application-Project.aspx

http://reddnet.net/code/aspnet-web-site-vs-web-application/

We wanted to create some base controls, such as for the GridView so that common functionality could be consistant across the web site. It's simple to create a user control to do this (e.g. an .ascx file), but in this case we wanted to do it as a class.

In the web application, that's no problem because we know what the assembly name is. In a web site template, we don't, so how do we register the control for use? It took a few minutes of digging around and trying a few things, but I finally got it, and I decided to share it for the next person looking.

Let's say I define my base GridView class like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI.WebControls;

namespace BaseControls
{
/// <summary>
/// Summary description for BaseGrid
/// </summary>
public class BaseGrid : GridView
{
   public BaseGrid()
   {
      //
      // TODO: Add constructor logic here
      //
   }

   public string SomeMethod(string someString)
   {
      return someString;
   }

}
}

Note the namespace. By default the web project may not have it, so you'll need to create one.

In order to reference it on the page, you'll actually leave the assembly blank. Your register tag will look something like this:

<%@ Register Namespace="BaseControls" TagPrefix="wf" %>

Now, to use the control, all you need to do is put this on the aspx page.

<wf:BaseGridID="grdReport"runat="server"Width="95%"…. (use it like a normal GridView)

In code, you can then use the properties/methods like this:

grdReport.SomeMethod("test");

Tip of the Day: Eliminating unused "using" statements and sorting them

Tue, 29 Dec 2009 04:43:28 GMT

I am a big fan of Resharper, but right now I am at a client who doesn't use it. Today, I accidentally reset my toolbar, so I was going through and adding my settings (yes, I could have restored an old one..)

As I was doing it, I ran across two items I relied on Resharper to handle.

One will remove unused "using" statements, and the other will sort them in your class by namespace.

Here's what they look like:

They can be found in the Edit Menu items.

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: Opening a process and (optionally) waiting

Thu, 29 Oct 2009 04:12:31 GMT

Every once in a while, you need to open another application from your WinForm application. Today’s snippet is a wrapper which will give you the ability to start a new process (application). It takes two parameters:
filename – string - the name full path of the application to open
waitToFinish – bool - True/False – setting to true will cause your program to stop until the opened application finishes processing.

        private static void OpenApplication(string fileName, bool waitToFinish)

        {

            OpenApplication(fileName, String.Empty,
waitToFinish);

        }

        private static void OpenApplication(string fileName, string arguments, bool waitToFinish)

        {

            using (System.Diagnostics.Process prc
= new System.Diagnostics.Process())

            {

                prc.StartInfo.FileName
= fileName;

                if (arguments.Trim().Length
> 0)

prc.StartInfo.Arguments = arguments;

                prc.Start();

                if (waitToFinish)

                {

prc.WaitForExit();

prc.Close();

                }

            }

        }

To use them, here’s an example usage:

        private void button1_Click(object sender, EventArgs e)

        {

            OpenApplication(@"c:\windows\notepad.exe", false);

            MessageBox.Show("Alert
that processing has continued!", "Processing..", MessageBoxButtons.OK, MessageBoxIcon.Information);

        }

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: 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.

Catching up is hard to do...

Tue, 29 Sep 2009 04:23:27 GMT

So much is going on, where to begin. First, I'll start with WebSpark. I've had my issues with Microsoft programs in the past, but this one does make up some ground. First, I'll lead you to the place where I first heard of the program, Scott Guthrie's site.

The gist of the program is if you are a small company (less than 10 developers) and you are designing web sites for other companies, they'll give you development software for 3 years for $100 (and server software). If you decide to keep it, you'll pay $999, and even that is a bargain. You get upgrades (hint --> VS2010) as well. This is a huge deal with a very easy qualification.

On a personal front, I was bidding on some things on eBay, and needed to pay for them via PayPal. I haven't used either in years, primarily in that I got taken on eBay, and PayPal refused to help on my dispute. The advised me that they hoped I used my credit card so I can dispute that, as they were unable to help. Doesn't PayPal prefer our checking accounts?

The issue came about because I ordered a very expensive GPS system which had near realtime traffic updates. The listing described the GPS as in "mint, like new" condition (the words from the ad). The problem was, the seller decided to make a little extra money and sell the traffic antenna (costs $200 to replace) and not mention that in their description of "mint". When I contacted PayPal to dispute the issue (after the seller told me I was screwed), they were not helpful and refused my claim agreeing with the seller. Apparently mint does not mean complete. Never again. Score one more victory (lost customer) for foreign customer service! I say that because the emails had some of the worst English I have ever seen. Ever. I should dig them out and post them kind of bad.

But alas, there are certain things you can only find on eBay, and PayPal is the only way to pay sometimes. I signed up for my account, and connected my credit card to it this time. However, as part of their verification process, they process a $1.95 charge, then you have to enter the code. At the bottom is a disclaimer, which seemed written by a 5 year old. To paraphrase, it went something like this:

"If you contact your credit card company to get this transaction information, and your credit card company complains to PayPal, your account may be cancelled." -- Nice...

Tip of the Day: Redirecting page trace output to a file

Fri, 25 Sep 2009 05:11:05 GMT

If you'd like to redirect your page trace infomation to a file (which can be useful when you are trying to run down a problem and don't want the world to see your trace information during testing), it's as simple as this:

Add this to your web.config:

< trace enabled="true" traceMode="SortByTime" pageOutput="false" localOnly="false" />>

The key is the pageOutput="false" which tells the framework to redirect the trace info to the trace.axd file. To view the trace information, you just need to load the page in the browser, such as:

http://localhost:4774/trace.axd

This will allow you to see the trace history of any browsed files since the trace was started, as well as clearing the trace history. Just remember to remove this before you deploy (or make sure you compile in release mode!).

Tip of the Day: Get values from DataRows safely

Sat, 29 Aug 2009 18:32:59 GMT

The following code snippets make retrieving values from DataRows safely, and properly casts them to the desired values.

        /// <summary>

        /// Gets
the int value from data row.

        /// </summary>

        /// <param
name="fieldName">Name of the field.</param>

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

        /// <returns></returns>

        public static int GetIntValueFromDataRow(string fieldName, DataRow dr)

        {

            return (dr[fieldName]
== DBNull.Value ? 0 : Convert.ToInt32(dr[fieldName].ToString()));

        }

        /// <summary>

        /// Gets
the int value from data row.

        /// </summary>

        /// <param
name="fieldName">Name of the field.</param>

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

        /// <param
name="defaultValue">The default value.</param>

        /// <returns></returns>

        public static int GetIntValueFromDataRow(string fieldName, DataRow dr, int defaultValue)

        {

            return (dr[fieldName]
== DBNull.Value ? defaultValue : Convert.ToInt32(dr[fieldName].ToString()));

        }

        /// <summary>

        /// Gets
the string value from data row.

        /// </summary>

        /// <param
name="fieldName">Name of the field.</param>

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

        /// <returns></returns>

        public static string GetStringValueFromDataRow(string fieldName, DataRow dr)

        {

            return (dr[fieldName]
== DBNull.Value ? String.Empty
: dr[fieldName].ToString());

        }

        /// <summary>

        /// Gets
the string value from data row.

        /// </summary>

        /// <param
name="fieldName">Name of the field.</param>

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

        /// <param
name="defaultValue">The default value.</param>

        /// <returns></returns>

        public static string GetStringValueFromDataRow(string fieldName, DataRow dr, string defaultValue)

        {

            return (dr[fieldName]
== DBNull.Value ? defaultValue : dr[fieldName].ToString());

        }

        /// <summary>

        /// Gets
the bool value from data row.

        /// </summary>

        /// <param
name="fieldName">Name of the field.</param>

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

        /// <returns></returns>

        public static bool GetBoolValueFromDataRow(string fieldName, DataRow dr)

        {

            return (dr[fieldName]
== DBNull.Value ? false : Convert.ToBoolean(dr[fieldName].ToString()));

        }

        /// <summary>

        /// Gets
the decimal value from data row.

        /// </summary>

        /// <param
name="fieldName">Name of the field.</param>

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

        /// <returns></returns>

        public static decimal GetDecimalValueFromDataRow(string fieldName, DataRow dr)

        {

            return (dr[fieldName]
== DBNull.Value ? 0 : Convert.ToDecimal(dr[fieldName].ToString()));

        }

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).

Tip of the day: Interview Question: What are some of the ways of maintaining state in an asp.net application?

Wed, 19 Aug 2009 19:34:53 GMT

Question: What are the various ways of maintaining state in an ASP.Net application?

A lot of people answer this with the different time of Session providers, but it’s not the same things. The key of this question is two-fold, do you know the object, and do you know when/how to properly use them (which leads to follow-up questions to gauge whether the person memorized the answer, or truly understands the concept).

· Session

· ViewState

· Application

· Cache

· Cookies

· Hidden Fields

· Query Strings

· Profile Settings

The big ones I look for are Session, ViewState, Application and Cache. If they answer that, I drill down a bit for understanding. For example, I might ask:

Question: How does application and cache differ?

Answer: They are both globally available to an application, but with cache, the server can free this up if it needs resources. Additionally, you can expire it after a predefined time, or is a file changes, etc.

Question: What are the dangers/concerns of using viewstate?

Answer: Page size, performance, security, etc..

The bottom line is that this question is fundamental to ASP.Net development, and it’s important you fully understand the implications of each. Failure to answer this question and any follow-ups is definitely damaging when I perform interviews.

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.

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!

WinCV v2 revisited

Wed, 22 Mar 2006 15:44:55 GMT

I found some details on WinCV for VS2005 (or the lack thereof). As near as I can ascertain, if you have VS2005 only, and place WinCV on that system it will work for the .Net 2.0 libraries. I don't know how that works as it seems the information is hardcoded into WinCV.

So, it was such a great utility, and I think it lends itself to some great enhancements, so I think I am going to write a version which is VS2005+ compliant. Some features I want to add:

Quick linking to the help topic for a class/method
Ability to easily add external assemblies WITHOUT having to use the command line

I plan on keeping the same basic interface though, as it was simple and effective. Not sure how much I willl get to work on this, or how long it will take, but I will post it here and probably CodeProject when I get it finished.

Web Service Issues Part II: The Underlying Connection was closed

Thu, 16 Mar 2006 05:19:42 GMT

Previously, I discussed how I worked around a firewall issue where the HTTPS port was re-mapped, and the return URL was different than the request URL as a result of that remapping. So I trudged on, and hit a real stumper. Here’s the new issue:

The underlying connection was closed: Could not establish secure channel for SSL/TLS. Inner Exception: The function completed successfully, but must be called again to complete the context

I ran across Jan Tielen’s blog post (http://weblogs.asp.net/jan/archive/2004/05/08/128394.aspx) where he provided a code snippet to override the GetWebRequest method in the Reference.cs file. I implemented it, and it worked great --- on my development machine! However, when rolled out to the same test environment, the problem remained. However, I modified it futher, and got it to work..

/// <summary>

/// Set web request properties here

/// </summary>

/// <param name="uri">uri </param>

/// <returns></returns>

protected override System.Net.WebRequest GetWebRequest(System.Uri uri)

{

System.Net.HttpWebRequest webRequest = (System.Net.HttpWebRequest)WebRequest.Create(uri);

webRequest.AllowWriteStreamBuffering = true;

webRequest.KeepAlive = false;

return webRequest;

}

Sort of. When I tried to use DIME with the above code, it gave me an error “Client found response content type of '', but expected 'text/xml'”. That was not going to work. I found some more code, and it seemed to work great once again, until I tried to make a DIME call. Here was that attempt.

protected override System.Net.WebRequest GetWebRequest(System.Uri uri)

{

WebRequest request = base.GetWebRequest(uri); ;

if (requestPropertyInfo==null)

requestPropertyInfo = request.GetType().GetProperty("Request");

HttpWebRequest webRequest = (HttpWebRequest)requestPropertyInfo.GetValue(request,null);

webRequest.KeepAlive = false;

webRequest.ProtocolVersion = System.Net.HttpVersion.Version10;

return request;

}

Once again, it worked fine during my WSE calls, but failed when trying to use DIME attachments with the following error: found response content 'application/dime', but expected 'text/xml'

To save any readers some time, I will go through everything I tried to resolve the problem, and finally, how I ended up resolving it. Here’s the items which didn’t work:

-- tried setting the SoapActor

-- tried turning off the Document protocol

-- tried setting the request and return URI

-- tried overding the GetWebRequest function a few different ways

-- tried using wsdl instead of asmx in setting up the Web Reference

-- tried setting the URI target/destination seperately

-- moved web service to the same machine as the calling web site (but still had to make an external call)

-- turned on tracing input and output and analyzed the logs created by WSE 2.0

So what finally worked? I ended up abandoning DIME, and encoded the file as a string, and passed it as an element of my XML. Here’s the code to encode the file as a string.

/// <summary>

/// Encodes the file in a Base64 string format.

/// </summary>

/// <param name="file">Name of the file.</param>

/// <returns></returns>

private string EncodeFile(HtmlInputFile file)

{

try

{

if (file.PostedFile.ContentLength > 0)

{

byte[] fsBytes = new byte[file.PostedFile.ContentLength];

System.IO.Stream fileStream = file.PostedFile.InputStream;

fileStream.Read(fsBytes, 0, file.PostedFile.ContentLength);

return Convert.ToBase64String(fsBytes);

}

else

return String.Empty;

}

catch (Exception ex)

{

//Handle the Error

return String.Empty;

}

What a trip it was to get there, but the resulting service has performed well, and I don’t have the issues I had with DIME. Don’t get me wrong, DIME worked great. But deployment of the web service in a secure environment proved to be quite a challenge. If you need more detail in resolving your issue, feel free to leave a comment or shoot me an email, and I will be glad to save you some of the pain I had to go through!

Web Service Adventures - The <To> header must match the value of an incoming message's HTTP Request Url if the soap receiver does not have an actor name.

Thu, 09 Mar 2006 16:12:20 GMT

At my current client, security is taken to a whole new level, which is a good thing. But as a result, sometimes there is more of a challenge to resolve issues you may not normally encounter. For example, I was tasked with writing a web service which would facilitate file transfers of documents and images from a web page (and Windows client), store them on a secured server, and serve them up to an authenticated user on the internet. To do so, we have to deal with proxy server issues and firewall issues.

After writing and testing the web service locally, I deployed it to our production server. Locally, it all worked fine. However, when I deployed the web portion of the application to our test server outside our intranet, the real fun began. The next several posts I will discuss the problems I encountered, and how I ultimately resolved the issue. Hopefully this will help any readers out there who have a similar issue, as well as become documentation for the process I used so I can later reference it.

The first issue I saw was the following error:

The <To> header must match the value of an incoming message's HTTP Request Url if the soap receiver does not have an actor name.

I'd love to give the person I found the solution at credit, but it's been such a long time I can't find the original document I used. I modified the solution to make it a little more "generic" so that the web service can be moved without requiring a recompile of the application.

First, you'll need to locate the Reference.cs file for the web service reference(for C# users. Reference.vb is the similar file for VB.Net, but all code here will be in C#). In this file, add the following reference:

using Microsoft.Web.Services2.Addressing;

Next, locate the consructor for the WSE portion of the Reference.cs. In this case, mine will be FileServiceWse(). Here's the code you'll need to replace the this.Url reference already in there.

public FileServiceWse() 

        {

            //these
two setting are the <TO> and Response URLs. For example, in our case the response
was

            //coming
back with the redirected port appended to the url.

            //The
Web service <TO> looked like https://mycompany.com/FileService/FileService.asmx

            //but
the response was https://mycompany.com:1234/FileService/FileService.asmx

            //The
endpointreference call to the Destination tells the application to expect the return
url to look differently than the

            //<TO>
reference

            string urlSetting
= System.Configuration.ConfigurationSettings.AppSettings["FileService"];

            string urlReturnSetting
= System.Configuration.ConfigurationSettings.AppSettings["FileService.ReturnURL"];

            if ((urlSetting
!= null) && (urlReturnSetting != null)) 

            {

                Uri sourceUri
= new Uri(urlSetting);

                Uri returnUri
= new Uri(urlReturnSetting);

 

                this.Destination
= new EndpointReference(sourceUri, returnUri);

            }

            else 

            {

                if ((urlSetting
!= null)) 

                {

                    this.Url
= string.Concat(urlSetting, "");

                }

                else 

                {

                    //this
is the default URL of the file service if all else fails.

                    this.Url
= "https://mycompany.com/FileService/FileService.asmx";

                }

            }

 

        }

What this code does is set the Destination property (if the FileService and FileService.ReturnURL settings are placed in the web.config file) to expect a different response than the requested web service URL. In our case, since our request was going through a firewall which remapped the ports, we had a port attached to the url for our web service which triggered this error.

The code also has failover. If I forget to make the settings, it will try the original URL reference. In my case the call won't work, but I believe in at least attempting to code some failover when human error can take place in moving files, etc.

But this only solved one of the many challenges I encountered in deploying this web service. Stay tuned for the next resolution to tricky WSE issues!

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.

Bizarre error, bizarre solution...

Tue, 20 Sep 2005 22:50:34 GMT

Once again I have disappeared from blogging. Let's face it, I rarely get to do it. I also need to upgrade this DasBlog but I have been so busy I haven't been able to do that, even though someone kindly wrote me and told me it would solve my spam comment problem. Maybe this weekend...

But I wanted to blog because I found a weird problem, with a weirder solution. I wrote a Windows service in C# which periodically loads some data, based on the time since the last load. So dates are a bit important in this process.

First, the cryptic message: “Internal Query Processor Error: The query processor could not produce a query plan. Contact your primary support provider for more information”. A Google search turned up several solutions, but most of them relied on a service patch. What's wierder is that the error was intermittant. The procs would run fine in Query Analyzer, but not from C#.

Finally, I tried the unlikely. Instead of passing in my parameters as DateTime values, I passed them in as SqlDbType.Varchar, and in the proc made sure and converted them to DateTime values. Lo and behold, the problem went away.....Go figure!

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!

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..

Tip of the day: Using Web Services in a Windows environment

Sat, 23 Apr 2005 20:36:27 GMT

If you are using DIME attachments, and you want to use them in a Windows client, this tip will save you some time. I created a File Upload/Download web service for a client I am currently working with, and until this week is was used solely on a web front end. However, there was a request for a Windows client, so I set out to create one using the same code.

All seemed well, until I went to compile. My Web Service is called FileService (for the purposes of this discussion), and in order the use DIME attachments after setting a web reference, you need to use the FileServiceWse version of the web reference (the wse class). The problem was, one wasn't generated in the proxy. I debated using the proxy for the web application, but then decided to try something a little different.

I removed the existing Web Reference, added a reference to System.Web to my project, then added the Web Reference again. Viola! My wse version was available now, and my code compiles! I decided to post this to save someone else a bit of time, as well as a reminder to myself in the future.

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 - My errors aren't showing up in the task list..???

Mon, 04 Apr 2005 18:28:35 GMT

I have a large ASP.Net project I am working on, and the solution contains about 6 projects. Periodically, it won't compile, but when I look in the Task List there are no errors listed. After a lot of trial and error, I finally found a solution which restores the missing error notations, so that I can fix the problem and move on.

Right-click in the “Task” screen, and select the “Show Tasks/Comments” option. Try compiling, and of course it will fail again. Then, right-click on the “Task” screen again, and select the “Build Errors” option, and they should appear. It seems to work fairly consistantly so I think this “workaround” may actually work.

As an alternative (although not as easy to work with), you can just look at the output window, and filter through the text output. Take your pick, you should be able to see what the problem is!

ADDENDUM: It happened again, and these steps didn't work exactly. To make it work, try to compile again between “right-clicks” and they should appear.

Tip of the Day: Testing WSE2 (SOAP) DIME Attachments and the 'ResponseSoapContext.Current is null' issue

Fri, 18 Mar 2005 21:15:58 GMT

I am so irritated at how poor the documentation for WSE2 and DIME attachment processing is. So today's tip will save someone new to the process countless amount of time. Here's the scenario: You want to process a file download using DIME attachments. You write your web service, and want to test it. You run the web service, pop up the Visual Studio test page for the web service, and it doesn't download your file as expected.

So, you start debugging, and it turns out the ResponseSoapContext.Current is null. WTF? It *should* work. So you grab all your books and online articles you can find, and a few people are having this problem, but no one seems to post how they solved it. Well, after spending a few hours trying to solve the problem, I run across a blurb that states you can't test your DIME downloading from the web page which is created by the Visual Studio IDE, you *have* to create a separate client (those weren't the exact words, but that's the gist of it).

Arrggh!!! Wasted time! But if I can save someone else from the same frustration, I will.

Good luck!

Tip of the day: Renaming files with a time date stamp

Wed, 16 Mar 2005 15:26:57 GMT

Sometimes as a developer you need to rename a file with a date time aspect so you can do something like guarantee uniqueness, track submission information, etc. There's always a ton of ways to do this, but I decided to write a couple of routines to do this using the FileInfo class. First, the code:

/// <summary>

/// Gets a string you
can append in a file name to supply uniqueness

/// </summary>

/// <returns>a
string which looks similar to 2232005_090812 which is a date time</returns>

public static string GetUniqueFileNameIdentifier()

{

    return DateTime.Now.Month.ToString()
+ DateTime.Now.Day.ToString() + DateTime.Now.Year.ToString()+ "_" + DateTime.Now.Hour.ToString()
+ DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString();

}

/// <summary>

/// Renames a file with
a unique identifier in it

/// </summary>

/// <param
name="fileName">file name to rename..</param>

/// <returns>unique
name of file with datetime identifier in the name. e.g. MyFile.txt renamed to MyFile_2232005_090812.txt </returns>

public static string FormatUniqueFileName(string fileName)

{

    FileInfo fi = new FileInfo(fileName);

    return fi.Name.Replace(fi.Extension,"")
+ "_" + GetUniqueFileNameIdentifier() + fi.Extension;

}

First, the FormatUniqueFileName funtion takes a file name (like test.txt), and inserts the date time info (in the current format, it does this as fileprefix_mmddyyyy_hhmmss.fileextension, so in our example, we might get test_03162005_071525.txt.

Not a real complex function by any means, but one that's reused a lot in development, and I decided to get this out just in case some developer wanted to save 5 minutes!

Enjoy!

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

Tip of the Day: Determining which control caused the Postback

Mon, 27 Dec 2004 22:19:36 GMT

While not 100%, you can look at the following to see what control caused the postback on a form:

Request.Form("__EVENTTARGET")

It works because ASP.Net uses javascript to handle the postback functionality, and the __EVENTTARGET query string value can contain the name of the control which caused the postback.

Want to know what arguments are being passed during the postback? Take a look at the Request.Form(”__EVENTARGUMENT”) value!

Tip of the Day: Debugging Javascript in ASP.Net

Tue, 21 Dec 2004 21:26:19 GMT

I don't think you can be a real effective ASP.Net programmer (personal opinion alert) unless you can do SOME javascript. Postbacks not only increase your server load, they can also detract from your user's experience on your ASP.Net site.

The downside is that working with javascript is that it's always been tough to debug (if not impossible), as well as untyped, but that part's an aside. Well, it's tough no more. Here's today's tip(s). First, enabling debugging:

Open your browser, open the Tools menu, and select the Internet Options menu item.
On the Advanced tab, locate the Browser section, and uncheck “Disable Script Debugging“ (see image below).
When you fire up the ASP.Net debugger (either manually or by default), make sure the “Client Script“ option is selected.
Trigger the javascript.

Image 1: Browser Options

Image 2: Setting the script debugging in the Process Debugging command in .Net

OK, you're all set for debugging. So what! Well, the thing I learned today was how to break into the script (without an error, which causes it to trigger debugging automatically) is to add the following script where you want to break:

debugger;

Your web page will break right there, and you'll be able to step through it just like you would your normal ASP.Net page, with local variable browsing and everything!

Tip of the day - Javascript - Getting the control which called a function

Sat, 18 Dec 2004 21:55:17 GMT

One of the things I use this blog for is to keep track of tips which I may need while out at the client site. I have a fairly extensive CodeLib library I use, but for some reason, I didn't have this in my library.

If you're new to javascript, which I am definitely still in the learning stages of, at some point you are going to access the control which called a function. I did a few searches, and it turns out, unless you know what you are looking for, it's tough to do a search like “javascript determining control which called a function” and similar searches. So here goes, and hopefully this simple tip will save another developer a little time. It IS a basic function, I will be the first to admit, but it is also useful to know for an ASP.Net developer. And the code is:

document.activeElement

There you go! Simple, but for some reason, it's assumed you should know it, which to a degree, I agree with. But I would also have to say online there seems to be an assumption that everyone already knows the DOM!

Skipping over a routine automatically in the debugger, and other neat debugger tricks..

Wed, 15 Dec 2004 20:15:13 GMT

Do you have a routine which you know works, and you don't want to have to step into when you're debugging? Granted, you could you the hotkeys to do it, but why bother? The System.Diagnostics namespace provides some neat functionality for helping you in your debugging process. Here's some examples:

//This attribute prevents the debugger from entering, as well as no breakpoints within

<System.Diagnostics.DebuggerStepThrough()>

private string MyRoutine()

{

//Don't step through this

}

I am actually not sure what the difference between that and the DebuggerHidden() attribute is though. The description in the help is the same. Anyone know?

Some great free tools for ASP.Net

Fri, 10 Dec 2004 02:30:27 GMT

I was out late last night in my first “real” poker tournament, so I am a bit too tired to whip out some good code. (I did OK at the tournament, and hit my target, just as an FYI). So tonight's tip is going to be about a great set of free components I use occasionally in ASP.Net. And at least for this one, you can get the source at a very reasonable price. Check these out:

Excentrics World

They have a great collapsible panel, masked textbox, breadcrumb tracker and a popup calendar, plus a few others. Definitely worth looking, and throw him a bone and buy the source!

More cool tools I have found if I can stay awake!

-- Daryl

Tip of the Day: Dynamically boxing a type in C#

Wed, 08 Dec 2004 14:49:20 GMT

Here's a quick tip for casting to a particular type if you have the name of the type. Once again, it may be obvious to some, but if you've never done it, it's tough to find a quick example of it, so here goes.

I was implementing a custom ViewState for an UserControl I was creating, and came across a situation where I needed to dynamically box a type, when all I know is the type which I have stored in a string. I am creating a special container control which can host any other type of control, and for restoring ViewState, I needed to cast it correctly when restored. Fortunately, I followed a hunch, and came across the answer -- System.Type.GetType.

string testType = “System.Int32“;

Type myType1 = Type.GetType(testType);

Not Earth shattering, but then again, you have to know where to look!

Castastrophic Error -- What to do when you see this when trying to debug..

Mon, 06 Dec 2004 04:44:29 GMT

OK, so you're looking at some really obscure code, so it's time to step in and see exactly what it's doing, and the best way to do it is use the debugger. Actually, if I have to give you a reason to use the debugger, you probably shouldn't be reading this in the first place. You fire up the VS IDE, hit F5, and viola! You see the following scary message:

What the heck? “Error when typing to run project: Unable to start debugging on the web server. Catastrophic failure.”

Likely you won't see this unless you don't have Admin privledges on the box. Right now, I am doing a project for a large bank, and trying to get rights to do anything is like trying to pry a “Magic” card from a freshman engineering student. My rights are so messed up, I actually have to do the following steps at the start of every day I plan on debugging. If you see this message, here's the steps you can try to get rid of it and get on with your debugging.

First, you're going to need to change one of the local security policies. Open up your admin folder, and select Local Security Policies. You should see something similar to the image below. Next, select User Rights Assignment.

Locate Impersonate a client after authentication, and double click on it. You should get a dialog similar to the following. What you'll need to do is add the IWAM_ (and I add the ASP.Net worker thread just for good measure to the policy) like below. For the record, I believe only IWAM_ is required.

OK, you've taken the first step to fixing the problem, but that's not it. You've got to get IIS and the rest of the system to recognize the new policy. So, first, open up the “Run “ command from the Start menu) or command prompt, and type the following:

Type

secedit /refreshpolicy machine_policy /enforce

This will refresh the security policy for the local machine. Next, type this command to restart IIS now that everything is set.

iisreset

That's it! Assuming the IIS application workspace is set to allow debugging, and everything else is good on the machine, hopefully you'll be debugging like the Orkin man!

-- Daryl

Tip of the Day: Converting an integer to a Roman Numeral in C#

Sat, 27 Nov 2004 04:25:01 GMT

Not sure where I got this, so my apologies to the original author, but it's been a pretty useful function. Of course, you might want to wrap this with some error handling and validation code, but here's a good start for you...

private string GetRomanNumber(int number)

    string[]
ArabicNums = new string[] {"1", "4", "5", "9", "10", "40", "50", "90", "100", "400", "500", "900", "1000"};

    string[]
RomanNums = new string[] {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};

    int ArabicUpper
= ArabicNums.GetUpperBound(0);

    int ArabicLower
= ArabicNums.GetLowerBound(0);

    string Output
= "";

    for (int i
= ArabicUpper; i >= ArabicLower; i--)

        while (number
>= Convert.ToInt32(ArabicNums[i]))

            number -= Convert.ToInt32(ArabicNums[i]);

            Output += RomanNums[i];

    return Output;

Enjoy!

Reading, Reading, Reading....

Thu, 25 Nov 2004 05:51:47 GMT

I seem to go in spurts in honing my technical skills by reading. Lately, I have been on an uber-quest to learn new things through reading, so I thought I'd write a bit on one I have finished, and the next likely target. My .Net and SQL Server library is pretty stocked, with about 60+ current books on a variety of subjects from graphics to SQL optimization to network programming to UI ideas. Most just end up being references, but a few (like Rocky Lohtka's CSLA books) get the full study and learn act.

I just finished Open Source .NET Development : Programming with NAnt, NUnit, NDoc, and More By Brian Nantz. It's a good intro book if you want to get a real high level look at the open source tools for automating builds and automated testing. It's a little confusing if you're trying to learn what some of the tools do and which are best for which scenario, but it does give a good glance on nAnt in particular. I would recommend this book for someone wanting to understand what tools are available, but don't look for this book to get you results in really complex situations. Sort of a road map, but you'll still be looking for topos when you figure out where you want to go.

Looking ahead, I had just purchased Seeing Data : Designing User Interfaces for Database Systems Using .NET by Rebecca M. Riordan. It came in this afternoon, and I was very excited to get it on a long weekend where I can try to pump through it. I am a little dis-enchanted though, as it appears to be oriented towards Rich Clients. I do rich client apps, but I was looking more forward to ASP.Net suggestions. I haven't given up hope on that yet, but if there is limited information on web applications in the book, I would certainly wish they would put "rich client" in the book description. I'll give it a read and put an update here once I know for sure.

It's important to me primarily because I can make a program do twists through hoops with no problem. I can also make a program very usable in terms of functionality. But making it look pretty, it takes me a lot of time, and I never am happy with it. Note there is a huge difference between pretty and usability, although the two can work together quite well and create a symbiotic relationship.

That's it for now. I plan on posting a few more tips this weekend, and eating some good home-cooked food. So, all those so celebrating, have a Happy Thanksgiving!

-- Daryl

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.

using log4net database storage -- review and database configuration correction

Sun, 21 Nov 2004 16:05:01 GMT

If you are looking to add logging to your application, whether for error logging or debugging or tracing, one decent option is the open source log4net. I give it a “decent” only in that there seems to be some bugs, and I am still not totally sold on the open source concept for a variety of reasons. But given that, some good thought has been placed into log4net, so that you have a good variety of options on where and in what format your logging information will be output. Note that I looked at v2, since it's the one which allows you to output to the database.

I am a huge proponent of logging error information to a database because you can check on errors real-time, as well as give yourself some powerful searching mechanisms. The client I was working for was logging to a file using an older version of log4net, so I decided to check out the log4net database functionality. Here's where you can find all the information you may want to know, including how to download log4net: http://logging.apache.org/log4net/

What I found was mixed. On the upside, you can (to a degree) use log4net with an existing database error log to a certain degree (I say to a certain degree because without going in an changing the source -- which is a plus for open source). A lot of thought has been placed into the design with regards to flexibility and performance.

On the downside, the code seemed buggy and the documentation is pretty bad. In order to get v2 database logging to work, I had to resort to stepping into the code to determine what the correct configuration settings would be. So as a bonus today, I will save the reader any heartache and post my file, along with a description of what the reader will need to change to use it!

First, I created a database (called test) in SQL Server 2000, and created a table called Log. Here's the fields, and I will leave the size out so you can make your own decisions about that, but given the amount of detail in the Message parameter of an error message, you might want to make some big varchars in there.

Column	Type
ErrorId	Identity (int)
Date	datetime
Thread	varchar
Level	int
Logger	varchar
Message	varchar
Exception	varchar

Create the table, then configure the log4net configuration file. Here's what mine looked like with the table structure above:

<?xml version="1.0" encoding="utf-8" ?>

<log4net debug="false">

<appender name="ADONetAppender" type="log4net.Appender.ADONetAppender">

<param name="BufferSize" value="1" />

<param name="ConnectionType" value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />

<param name="ConnectionString" value="server=localhost;uid=test;pwd=test;database=test" />

<param name="CommandText" value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message],[Exception]) VALUES (@log_date, @thread, @log_level, @logger, @message, @exception)" />

<param name="Parameter">

<param name="ParameterName"&#0;value="@log_date" />

<param name="DbType" value="DateTime" />

<param name="Layout" type="log4net.Layout.RawTimeStampLayout" />

</param>

<param name="Parameter">

<param name="ParameterName"&#0;value="@thread" />

<param name="DbType" value="String" />

<param name="Size" value="255" />

<param name="Layout" type="log4net.Layout.PatternLayout">

<param name="ConversionPattern" value="%t" />

</param>

</param>

<param name="Parameter">

<param name="ParameterName"&#0;value="@log_level" />

<param name="DbType" value="String" />

<param name="Size" value="50" />

<param name="Layout" type="log4net.Layout.PatternLayout">

<param name="ConversionPattern" value="%p" />

</param>

</param>

<param name="Parameter">

<param name="ParameterName"&#0;value="@logger" />

<param name="DbType" value="String" />

<param name="Size" value="255" />

<param name="Layout" type="log4net.Layout.PatternLayout">

<param name="ConversionPattern" value="%c" />

</param>

</param>

<param name="Parameter">

<param name="ParameterName"&#0;value="@message" />

<param name="DbType" value="String" />

<param name="Size" value="4000" />

<param name="Layout" type="log4net.Layout.PatternLayout">

<param name="ConversionPattern" value="%m" />

</param>

</param>

<param name="Parameter">

<param name="ParameterName"&#0;value="@exception" />

<param name="DbType" value="String" />

<param name="Size" value="2000" />

<param name="Layout" type="log4net.Layout.ExceptionLayout" />

</param>

</appender>

<root>

<level value="DEBUG" />

<appender-ref ref="ADONetAppender" /

</root>

</log4net>

config.log4net (2.32 KB)

Of course, first thing you'll want to do is change the ConnectionString value to your situation. Now, some weird things I found. It doesn't seem to use the stored procedure it says it does. I stepped through the source, and it looks like it just tries to execute a SQL statement, which can be found in the CommandText parameter in the configuration file. So really, you could likely strip out all the parameters listed above. I have to confess it has been some months since I looked at log4net, so there might be a reason I left them in, such as a different part of the code that uses them and without it, it fails. So, take a few minutes and strip them out, and see what you get. But the saving you get from my slogging through the code should more than justify looking at this configuration file.

My final review is this: If you're creating a production app, here's your two options: roll your own solution or use log4net. If you plan on using log4net, download the source, learn it, and be prepared to spend some time (possibly considerable) debugging it. As a consultant, unless you need to ability to switch logging types (e.g. database to file to application log) dynamically, I would recommend rolling your own logging system, and write it such you can use it in multiple applications. Use log4net to get some ideas on the best way to accomplish it. Why? I think it tries to be too much to everyone, and it's not quite yet complete, and the documentation is lacking. In the end, KISS wins (keep it simple, stupid).

Making a page expire

Fri, 19 Nov 2004 14:40:51 GMT

We had a situation where the page wasn't expiring, and we were getting faulty results. So today's tip is a quick and dirty -- make the page expire!

private void EnsurePageExpires()

{

Response.Expires = -1;

Response.ExpiresAbsolute = DateTime.Now;

Response.CacheControl = "no-cache";

}

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.

Debugging in .Net

Wed, 17 Nov 2004 15:29:26 GMT

I am actually amazed that this should be considered a tip, but since .Net came out, I have been at 3+ client sites working with other developers, and in every case, they didn't know how to set the debugger to break exactly where the error occurs. So, just to get back in the swing of things, I decided to post a quick tip on effectively using the .Net debugger.

So let's say you do your due diligence, and you have robust error handling in your application (I have actually heard the argument that's why you DON'T put error handling in, so you know exactly where the error occurs...but then again, so does your customer!). An error pops up, and your error trapping doesn't provide you with sufficient information (another difficult thing to do, considering the error object actually gives you the line number). The solution? Set the debugger to stop exactly on the line the error occurs.

To do it, open the Dubug menu, and select the Exceptions menu item as shown below.

You should then see the following dialog. Select Common Language Runtime Exceptions, and select the When the Exception Is Thrown/Break into the Debugger option, as shown below.

That's it! One thing you may find is only turning it on when you reach the page you want to debug, or you may be hitting a lot more than you want. Typically, in ASP.Net, I will set a break in the Page_Load, and turn it on, and reproduce the error.

Another interesting thing about the power of this utility is the ability to select individual exception types to break on, as shown below. Happy debugging!

How to set style properties using javascript (and ASP.Net)

Thu, 11 Nov 2004 05:05:03 GMT

I ran across a situation recently where I needed to dynamically hide or show items based on whether or not a checkbox was checked. Simple enough if you know what items need to be hidden or not, but an easier and cleaner way was to set the appropriate CSSClass for the controls, then actually manipulate the style to do the work.

So how to change the properties of a style dynamically? Here's a snippet from a CodeBehind function, which was rendered in the Page_PreRender. The javascript was built in a StringWriter (sw), then rendered out onto the page.

        sw.WriteLine(@"if (document.all.chkMatch.checked)
");

        sw.WriteLine(@"document.styleSheets['Identical'].addRule
('.Identical', 'display:" + myStr + "block" + myStr
+ "'); ");

        sw.WriteLine(@"else");

        sw.WriteLine(@"document.styleSheets['Identical'].addRule
('.Identical', 'display:" + myStr + "none" + myStr + "');");

Here's the explanation. chkMatch is a server control checkbox (this is old code. it would have been better to use chkMatch's ClientId property when building this). When chkMatch is checked, the CSS class 'Identical' block attribute is set to 'block mode'. When unchecked, the style class is set to 'none', which has the effect of hiding any objects with the CSSClass property set to 'Identical'.

On a related topic, let's look at rendering scipt in include files vs. ASPX pages vs. CodeBehind. First, let's eliminate ASPX pages, since that means the code may be repeated, and we lose reuse. I suppose there's little difference between an include file and the code behind, because you can place common functions in both. However, from an encapsulation and organizational standpoint, I like CodeBehind because then I only add the exact scripts I need, instead of using include files which might contain a lot of extraneous functions. This is especially the case when I create User controls (which I do a lot of in my upcoming series on Component Based Development).

Feel free to write if you need further explanation. It's a powerful UI ability to be able to manipulate style properties dynamically from client side code!

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

WinCV -- Great .Net search tool

Wed, 10 Nov 2004 04:47:53 GMT

When you install the .Net framework, you also get a ton of utilities with it. For a complete listing, follow this link:

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

One of these utilities is insanely useful if you want to find something fast, and you don't feel like going through the overhead and all the excess listings of the MSDN. This miracle utility is the Windows Class Viewer, also known as WinCV.exe.

To run it, use the .Net DOS prompt, and type in WinCV. You'll be able to enter a serach string (or partial string), and it will list the namespace it was found in, as well as the definitions of the accessible methods.

Now, the neat thing which isn't really mentioned is that you can include 3rd party searches by placing an entry in the WinCV config file. For example, I tested this by using the Infragistics libraries. Once I placed them in the config file, I was able to search them like any other Microsoft assembly. One caveat though -- it only works for assemblies registered in the GAC. I won't tell you exactly how to edit the config file, because if you can't look at it and figure it out, you probably shouldn't be editing that file.

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! ;)

Setting a control to ReadOnly using javascript

Mon, 08 Nov 2004 04:47:19 GMT

Have you ever wanted to make a server control appear normal, but be read only? If you simply set it to disabled, it's also greyed out, which can be a real pain display wise. So here's a couple of functions which will apply client-side javascript to the TextBox and DropDownList controls to prevent the user from being able to change the entries. Feel free to extend them to other controls (and forward them on! :))

    public static void SetControlReadOnly(DropDownList
ddlTemp)

        ddlTemp.Attributes.Add("onFocus","window.focus()");

        ddlTemp.Attributes.Add("ondblclick","window.focus()");

        ddlTemp.Attributes.Add("onClick","window.focus()");

    public static void SetControlReadOnly(TextBox
txtTemp)

        txtTemp.Attributes.Add("onFocus","window.focus()");

        txtTemp.Attributes.Add("ondblclick","window.focus()");

        txtTemp.Attributes.Add("onClick","window.focus()");

Changing the EncType of an ASP.Net form

Mon, 08 Nov 2004 04:40:15 GMT

On the project I am currently working on, the entire department uses the same Portal for hosting the different applications. That's great in that it promotes reusability, a common look and feel, quicker development and a central place for users to get all related information. I could go on and on, but I won't because there's one downside: flexibility.

We had a request from a user to allow uploading some files. Simple enough task, except our web pages all inherit from the same base web page, and there's no flexibility allowed in what we can do with that page. So, I had a dilemma. I had to give the user's the ability to upload files, but I couldn't change the base page that I HAD to use.

Simple enough, I would do a search for the form tag, and change the EncType dynamically! And here's how I did it...

Once again, I passed in the Page reference, because this sits in a common library. If you don't want to do that, just use the current Page reference. The other thing you might want to do is change the “form1“ reference as a parameter to make it more flexibility. At the time I wrote this, I knew it would never change, so I just left it..

    public static void ChangePortalEncType(Page
page)

        HtmlForm form1;

        if (page.FindControl("form1")
!= null)

            form1 = (HtmlForm) page.FindControl("form1");

            if (form1.Attributes["enctype"]
!= null)

                if (form1.Attributes["enctype"]
!= "multipart/form-data")

                    form1.Attributes["enctype"]
= "multipart/form-data";

            else

                form1.Attributes.Add("enctype","multipart/form-data");