.NET

Enterprise Library Released

Michael Falconer — Mon, 31 Jan 2005 13:59:00 GMT

As pointed out by Roy Osherove, the new Enterprise Library for .net has been released. It basically encapsulated the application blocks that were previously released separately:

Caching Application Block
Configuration Application Block
Data Access Application Block
Cryptography Application Block
Exception Handling Application Block
Logging and Instrumentation Application Block
Security Application Block

It may only be a 'stopgap' until the launch of .net v2, but I for one am planning to make use of it. I've been making use of four of the blocks, and have been looking forward to an update that fixes many of the known issues. So I'll let you know how I get on with it.

You can download it from MSDN.

.Net helper class for SQL Server Full Text Search

Michael Falconer — Wed, 10 Nov 2004 09:42:00 GMT

I've made use of SQL Servers ability to run a full text search in a couple of projects recently and wrote a little helper class that takes a typical search phrase and creates the tsql statement that you can then pass into a CONTAINSTABLE clause. Basically it looks either for words separated by a space, or a phrase with quotes around it, or a mixture of both.

There is one limitation in this implementation; the noise words are hard coded into a string array. It would be better to read in the contents of the noise word file that SQL Server uses, but in some shared hosting arrangements you may not have access to the file.

    1 using System;

    2 using System.Collections;

    4 namespace CamelJones.Data.Utils

    5 {

    6   /// <summary>

    7   /// Helper object for converting a search string into a

    8   /// Full Text Search query, used in a CONTAINSTABLE clause.

    9   /// </summary>

   10   public class SqlFtsHelper

   11   {

   12     #region Private Members

   14     private string _searchPhrase;

   15     private string _ftsQuery;

   16     private ArrayList _ignoredWords = new ArrayList();

   17     private string[] _noiseWords = new string[] {"about","after","all","also","an","and","another","any","are","as","at","be","because","been","before","being","between","both","but","by","came","can","come","could","did","do","each","for","from","get","got","has","had","he","have","her","here","him","himself","his","how","if","in","into","is","it","like","make","many","me","might","more","most","much","must","my","never","now","of","on","only","or","other","our","out","over","said","same","see","should","since","some","still","such","take","than","that","the","their","them","then","there","these","they","this","those","through","to","too","under","up","very","was","way","we","well","were","what","where","which","while","who","with","would","you","your"};

   19     #endregion

   21     #region Constructors

   23     /// <summary>

   24     /// Constructor for the SqlFtsHelper object

   25     /// </summary>

   26     /// <param name="query">The search string that is to be used to create the Full Text Search query</param>

   27     public SqlFtsHelper(string searchPhrase)

   28     {

   29       _searchPhrase = searchPhrase;

   30       BuildFTSQuery();

   31     }

   33     #endregion

   35     #region Public Methods

   37     /// <summary>

   38     /// The query string that was passed in to be used for the Full Text Search

   39     /// </summary>

   40     public string SearchPhrase

   41     {

   42       get { return _searchPhrase; }

   43     }

   45     /// <summary>

   46     /// The T-SQL statement to be used as the contains_search_condition parameter

   47     /// of a CONTAINSTABLE query

   48     /// </summary>

   49     public string FTSQuery

   50     {

   51       get { return _ftsQuery; }

   52     }

   54     /// <summary>

   55     /// An array of any noise words that were included in the search string

   56     /// </summary>

   57     public object[] IgnoredWords

   58     {

   59       get { return _ignoredWords.ToArray(); }

   60     }

   62     #endregion

   64     #region Private Methods

   66     /// <summary>

   67     /// Builds the Full Text Search query

   68     /// </summary>

   69     private void BuildFTSQuery()

   70     {

   71       _ftsQuery = "";

   72       string cleanQuery = _searchPhrase;

   74       // Strip out comments, wildcards

   75       cleanQuery = cleanQuery.Replace("--","");

   76       cleanQuery = cleanQuery.Replace("*","");

   77       cleanQuery = cleanQuery.Replace("%","");

   79       // Rather than simply split the string, walk

   80       // through it looking for phrases or individual

   81       // words

   82       cleanQuery = cleanQuery.Trim();

   83       while(cleanQuery.Length>0)

   84       {

   85         // If this is the only word

   86         if(cleanQuery.IndexOf('"')==-1 && cleanQuery.IndexOf(' ')==-1)

   87         {

   88           if(!CheckNoiseWord(cleanQuery))

   89           {

   90             FTSAddWord(cleanQuery);

   91           }

   92           break;

   93         }

   95         // Get the next word/phrase

   96         if(!cleanQuery.StartsWith("\""))

   97         {

   98           // Get the word from the search string

   99           int end = cleanQuery.IndexOf(" ");

  100           if(end<=0){end = cleanQuery.Length;}

  101           string theWord = cleanQuery.Substring(0,end);

  103           // Check it's not a noise word

  104           if(!CheckNoiseWord(theWord))

  105           {

  106             FTSAddWord(theWord);

  107           }

  109           // Remove the word from the search string

  110           cleanQuery = cleanQuery.Remove(0,end);

  111           cleanQuery = cleanQuery.Trim();

  112           continue;

  113         }

  114         else

  115         {

  116           // A phrase

  117           int end = cleanQuery.IndexOf('"',1) + 1;

  118           if(end<=1){end = cleanQuery.Length;}

  119           FTSAddPhrase(cleanQuery.Substring(0,end));

  120           cleanQuery = cleanQuery.Remove(0,end);

  121           cleanQuery = cleanQuery.Trim();

  122           continue;

  123         }

  124       }

  125     }

  127     /// <summary>

  128     /// Checks a string for noise words and, if any exist,

  129     /// removes them from the string and adds them to the

  130     /// array of ignored words.

  131     /// </summary>

  132     /// <param name="word">the word to check</param>

  133     /// <returns>true if the word is a noise word, otherwise false</returns>

  134     private bool CheckNoiseWord(string word)

  135     {

  136       if(IsNoiseWord(word))

  137       {

  138         _ignoredWords.Add(word);

  139         return true;

  140       }

  141       return false;

  142     }

  144     /// <summary>

  145     /// Add an individual word to the query

  146     /// </summary>

  147     /// <param name="word">the word to be added</param>

  148     private void FTSAddWord(string word)

  149     {

  150       if(_ftsQuery.Length>0)

  151       {

  152         _ftsQuery = _ftsQuery + " AND ";

  153       }

  154       _ftsQuery = _ftsQuery + "FORMSOF(INFLECTIONAL, " + word + ")";

  155     }

  157     /// <summary>

  158     /// Add a phrase to the FTS query

  159     /// </summary>

  160     /// <param name="phrase">the phrase to be added</param>

  161     private void FTSAddPhrase(string phrase)

  162     {

  163       if(_ftsQuery.Length>0)

  164       {

  165         _ftsQuery = _ftsQuery + " AND ";

  166       }

  167       _ftsQuery = _ftsQuery + phrase;

  168     }

  170     /// <summary>

  171     /// Checks if the word is a noise word

  172     /// </summary>

  173     /// <param name="word">the word to check</param>

  174     /// <returns>true if it is a noise word, otherwise false</returns>

  175     private bool IsNoiseWord(string word)

  176     {

  177       // Exclude individual characters

  178       if(word.Length>1)

  179       {

  180         // Iterate through the string array of noise words,

  181         // and check the word parameter does not match

  182         foreach(string item in _noiseWords)

  183         {

  184           if(word==item)

  185           {

  186             return true;

  187           }

  188         }

  190         return false;

  191       }

  193       return true;

  194     }

  196     #endregion

  197   }

  198 }

P.S. The code snippet above was formatted using the CopySourceAsHtml VS addin by Colin Coller.

Exception handling in .net applications

Michael Falconer — Sat, 28 Aug 2004 19:20:00 GMT

One of the features of the .net CLR that I love the best is structured exception handling. Having worked largely on ASP / VBScript / VB applications prior to moving to C# / .net, the ability to catch and handle every type of error that can occur has proved invaluable.

Most of the .net applications I've worked on so far have been relatively simple, with very few interface boundaries and therefore I've not had to worry too much about catching exceptions until they bubble to the UI. The current project I'm working on, however, involves properly stuctured DAL / BLL and UI layers, plus I've been implementing provider patterns for a variety of components. One of my sources of information / inspiration has been the source code for .Text, where I noticed a number of classes the used a try...finally block without any catch. At first this looked a bit odd, until I came across this article on Ian Griffith's weblog.

So, if his closing remark (If it's news to you that your finally blocks should be outnumbering your catch blocks by a significant margin, then you're probably doing something wrong) applies to you, check it out.

Generics - List<Employee> or EmployeeList?

Michael Falconer — Wed, 25 Aug 2004 09:31:00 GMT

I was over talking to Jim last night, showing him some of the stuff I've been working on recently. One thing I pointed out was the fact that a lot of the classes I created were very similar (in particular the collection classes I had to create). I commented on the fact that they were an extremely good candidate for being a generic, so thought I'd look a bit more into it this morning.

Now, the applications I'm developing at the moment are based on v1.1 of the framework, so I've not had much time to play with v2, and certainly can't change the taget framweork version at the last minute. But when I can across this discussion on Eric Gunnersons blog, how I wished I could!!!

MSDN Lab : SQL injection protection

Michael D. Falconer — Mon, 12 Jul 2004 13:16:00 GMT

I was just reading Scott's post on Stefan Demetz's suggestion to change the default behavious of textboxes to only allow AlphaNumeric charcters by default. Personally, this is a shockingly bad idea, as I posted in my comment on the MSDN Lab site:

'This is a really bad idea. So suddenly, by default, a user cannot complete an online form if their name contains and apostrophe of a dash. No more Peter O'Toole, or Camilla Parker-Bowles. If you want this functionality, why not just create a custom validator. Or create a new inherited TextBox object that strips out unwanted characters as required and/or throws an exception.'

As Scott rightly says, a developer should be aware of these issues, and address them accordingly. To change such a fundamental feature of one of the most basic form building blocks is bound to end up causing massive headaches, particularly when there are simple steps to follow to prevent SQL injection attacks.

Accessing web services through a proxy / firewall

Michael D. Falconer — Fri, 02 Jul 2004 14:00:00 GMT

One of the projects I'm involved in at the moment has me developing some client applications (both web and windows based) that access a web service. I was just preparing an initial release when, during testing, I found that the Windows application could not always access the web service as the user had to access the internet via a proxy server. After a quick read of this article on CodeProject and this posting on .NET 247, I simply added the following code to always call the web service with the users IE proxy settings:

If Not WebProxy.GetDefaultProxy.IsBypassed(New Uri(myWS.Url)) Then
    Dim myProxy As WebProxy = WebProxy.GetDefaultProxy
    myProxy.Credentials = CredentialCache.DefaultCredentials
    myWS.Proxy = myProxy
End If

myWS is the web service whose proxy settings you need to set. Hopefully somebody might find it useful!

Visual Studio 2005 - Beta 1 Released

Michael D. Falconer — Tue, 29 Jun 2004 11:13:00 GMT

Microsoft have just announced that Visual Studio 2005 Beta 1 has been released. You can get all the details here.

Handling postbacks in composite web controls

Michael D. Falconer — Mon, 07 Jun 2004 12:20:00 GMT

I've been developing a composite web control lately to provide numeric paging for a web form. One problem I hit was how to change the structure of the child controls after handling a postback event. The typical order of events for a composite control is:

Load -> CreateChildControls -> Handle Postback -> Render

I was dynamically creating some of the child controls based on fields that could be modified by the Postback events. The problem was, as you can see from the order above, the child controls are created before the fields are set.

Thankfully I found this post on .NET 247 by Arthur Mnev. He had exactly the same problem and had found a neat solution. If you set the controls ChildControlsCerated flag to False in the event handler, the .net framework will then regenerate the child controls after the event handler has completed. It does incur a penalty as the CreateChildControls method is run twice, but it works very nicely. As he points out you do have to make sure the that the controls are created is the correct order the first tmie the code runs, but in most cases this will not be an issue.

To get round the double running of the code, he does mention that he 'changed it to redirect itself to its own page with Get Parameters instead of events'. Something else for me to take a look at soon...!

Rob Howard : Farewell and Teched slides

Michael D. Falconer — Tue, 01 Jun 2004 13:02:00 GMT

Rob Howard has announced that he's leaving Microsoft, but has thankfully posted up slides from some TechEd US presentations. I've just had a flick through the presentation titled 'Running www.asp.net', and it looks very interesting. There's certainly a nice list of recommendations to follow.

Adding a Web browser control to a windows form application : Solution #1

Michael D. Falconer — Thu, 27 May 2004 13:37:00 GMT

As I mentioned here, I've been trying to solve a problem with a web browser control embedded in a Windows Form application. I found that if you use this method to pass the HTML page as a string, when the web browser control gets focus while tabbing, it will not release it until you click on the contents. Not usually a big issue, but when the spec for the form says it must be accessible without the use of a pointnig device, it counts! This was compounded by the fact that when the web browser did get focus, it would not let you scroll the page using the Page keys.

After toiling over it, I found that you have to do four things to make it work in an acceptable fashion (not necessarily the best way):

Add an anchor to the page
Add a form elements to the page
Add some JavaScript to the page to give the form element focus
Not pass the HTML in as a string

So what I did was:

Write the HTML string to a temporary file, and load it in by calling the web browsers Navigate method
Use the following HTML page template to give the form element focus when the page is initially loaded:

<html>

<head>

INPUT { WIDTH: 8px; BORDER-TOP-STYLE: none; BORDER-RIGHT-STYLE: none; BORDER-LEFT-STYLE: none; HEIGHT: 18px; BORDER-BOTTOM-STYLE: none }

</style>

</head>

</form>

</body>

</html>

Phew. And after all that, the user can tab around the windows form, and successfully get the web page to scroll if necessary. It's not pretty, it's not ideal, but it works. The only issue with it is that when the user is tabbing around the form, when focus gets to the web browser control the first stop is invisible (I'm assuming this is when the browser control itself has focus), the second is the form element, and the third is the anchor (when this has focus you can scroll).