.NET

Evolving Web Forms

Kevin — Fri, 30 Nov 2007 15:51:00 GMT

I found the recent article “What's Ailing ASP.NET WEB Forms” by Rick Strahl to be very interesting. I still agree that the ASP.NET server side has a strong advantage over alternate technologies, but the client needs to be richer. Web Forms are too simple and people are not ready to fully except Silverlight (and the control set is not there yet). Integrating a client side framework like ExtJS seems like the best approach... for now.

WPF/E?

Kevin — Wed, 26 Jul 2006 10:34:00 GMT

WPF/E?

(Where WPF = Windows Presentation Foundation and E stands for "Everywhere")

What is this? It’s the supposed Flash killer. A plugin/extension for all browsers on all platforms that knows how to render XAML and has a mini CLR running on the client.

http://channel9.msdn.com/showpost.aspx?postid=193367

Some day maybe the client will not matter…

Quail - Query and Tail Support for Large Logfiles.

Kevin — Fri, 27 Jan 2006 13:25:00 GMT

Quail is a real-time log viewing program that I wrote to support large files with color highlighting and search functionality. Quail also provides a front end to LogParser enabling SQL query support for your logs.

Update (2/25/2006): Fixed bugs around display issues, key handling, and file reload on log rollover.

Update (5/22/2006): Enhanced highlight feature and added load from non-working directory.

Update (10/1/2006): Launch external commands, and window positioning added.

The Simple Way to Read Config Options for Your App

Kevin — Fri, 27 Jan 2006 11:25:00 GMT

Usually you want to control settings in your application via MetaData instead of hard coding values that may change. With C# serialization this is so easy that you will gladly place settings in a config file. Take the following example that I have recently been working on:

XML Config File:

<?xml version="1.0" encoding="utf-8"?>
<Options xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <Option>
    <DefaultLogLocation>c:\temp\mtlog.txt</DefaultLogLocation>
    <AutoLoadLog>false</AutoLoadLog>
    <TailTimeout>1000</TailTimeout>
    <MaxBytesToLoad>100000000</MaxBytesToLoad>
    <BackgroundColor>WhiteSmoke</BackgroundColor>
    <FilterColor>Teal</FilterColor>
    <DefaultColor>Black</DefaultColor>
  </Option>
  <HighlightItem>
    <ContainsString>[DEBUG</ContainsString>
    <HighlightColor>Black</HighlightColor>
  </HighlightItem>
  <HighlightItem>
    <ContainsString>[INFO</ContainsString>
    <HighlightColor>Navy</HighlightColor>
  </HighlightItem>
  <HighlightItem>
    <ContainsString>[WARNING</ContainsString>
    <HighlightColor>Orange</HighlightColor>
  </HighlightItem>
  <HighlightItem>
    <ContainsString>[ERROR</ContainsString>
    <HighlightColor>DarkRed</HighlightColor>
  </HighlightItem>
  <HighlightItem>
    <ContainsString>[FATAL</ContainsString>
    <HighlightColor>Red</HighlightColor>
  </HighlightItem>
  <HighlightItem>
    <ContainsString>***</ContainsString>
    <HighlightColor>DarkRed</HighlightColor>
  </HighlightItem>
</Options>

C# Class to Read and Save:

using System;
using System.Collections;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
namespace Quail
{
  /// <summary>
  /// Options class which will be serialized.
  /// </summary>
  [XmlRoot("Options")]
  public class MyOptions
  {
    [XmlElement("Option")]
    public Option option;
    private ArrayList mHighlightItems;
    public MyOptions() 
    {
      option = new Option();
      mHighlightItems = new ArrayList();
    }
    [XmlElement("HighlightItem")]
    public HighlightItem[] HighlightItems 
    {
      get 
      {
        HighlightItem[] items = new HighlightItem[ mHighlightItems.Count ];
        mHighlightItems.CopyTo( items );
        return items;
      }
      set 
      {
        if( value == null ) return;
        HighlightItem[] items = (HighlightItem[])value;
        mHighlightItems.Clear();
        foreach( HighlightItem item in items )
          mHighlightItems.Add( item );
      }
    }
    public int AddItem(HighlightItem item) 
    {
      return mHighlightItems.Add( item );
    }
    public bool Save()
    {
      // Serialization
      XmlSerializer s = new XmlSerializer( typeof( MyOptions ) );
      TextWriter w = new StreamWriter( @"options.xml" );
      s.Serialize( w, this );
      w.Close();
      return true;
    }
    public static MyOptions Load()
    {
      // Deserialization
      XmlSerializer s = new XmlSerializer( typeof( MyOptions ) );
      MyOptions opt;
      TextReader r = new StreamReader( @"options.xml" );
      opt = (MyOptions)s.Deserialize( r );
      r.Close();
      return opt;
    }
  }
  public class HighlightItem 
  {
    [XmlElement("ContainsString")] 
    public string ContainsString;
    [XmlElement("HighlightColor")]
    public string HiglightColor;
    public HighlightItem() 
    {
    }
    public HighlightItem(string containsString, string color) 
    {
      ContainsString = containsString;
      HiglightColor = color;
    }
  }
  // Option
  public class Option 
  {
    [XmlElement("DefaultLogLocation")] 
    public string DefaultLogLocation = @"c:\temp\mtlog.txt";
    [XmlElement("AutoLoadLog")] 
    public bool AutoLoadLog = false;
    [XmlElement("TailTimeout")] 
    public int TailTimeout = 1000;
    [XmlElement("MaxBytesToLoad")] 
    public long MaxBytesToLoad = 100000000;
    [XmlElement("BackgroundColor")] 
    public string BackgroundColor = "WhiteSmoke";
    [XmlElement("FilterColor")] 
    public string FilterColor = "Teal";
    [XmlElement("DefaultColor")] 
    public string DefaultColor = "Black";
  
    [XmlElement("BorderColor")] 
    public string BorderColor = "WhiteSmoke";
    public Option() 
    {
    }
  }
}

LINQ (Language Integrated Query)

Kevin — Sun, 25 Sep 2005 10:24:00 GMT

Data lives in many different places and the middle layer is always struggling to get it together for the clients. LINQ will allow developers to treat data in a standard way whether it is in memory or not. Query set operations become first class citizens in the programming language allowing you to query against objects (that support IEnumerable), relational databases, or XML. LINQ allows you to join in memory data with data in the database.

See: The LINQ Project

Why AJAX?

Kevin — Wed, 06 Jul 2005 20:20:00 GMT

AJAX or Asynchronous JavaScript and XML is by no means a new technology. I have been using this technique to prevent page refreshes and create dynamic pages for 5 years now. However, it seems that tossing a new acronym at technology makes people believe it will save the world. No wait that is XML. Alas, I'm not sure Microsoft has the right idea with the Atlas project (and they are a bit late). To me it seems the user is still stuck in an environment that was not created for a rich end user experience. I have written an article (Putting Performance into Your ASP.NET Application with Managed Client Side Controls) that proposes a work around to this problem for now. In the end, I do think Avalon's Express Applications may be the real answer (as long as we don't leave Firefox behind). I'm not crazy about another markup language like XAML, but often creating a specific language can be the best way to solve a discrete problem.

There is obviously still a place for AJAX in simple web applications that require an interactive dynamic element to improve usability.

Locality Caching

Kevin — Tue, 10 May 2005 13:11:00 GMT

A new technique I have for caching items on a web page is to use what I call Locality Caching. Locality Caching determines on it's own when to free your cached items and when to keep them around. Unlike traditional caching techniques such as file dependency, key dependency, or the guessing game of time expiration; Locality Caching knows what the user is doing. Locality Caching keeps the items of a web page cached until those pages are no longer used. This works much like a garbage collector. If a page is in scope/being used then the age of this page remains 1. If the user clicks on another page the age of the first page goes up to 2 and the new page is added to a list of pages to be freed with an age of 1. This technique insures that items that are currently being used remain cached in memory, while older pages (deemed such by the collector) are freed. The nice thing about Locality Caching is you don't have to predict what a user will do or what they will need cached. The fact that they are using a page ensures the items they will need will be cached.

Improving Web Service Performance

Kevin — Mon, 14 Mar 2005 12:55:00 GMT

Improve your web service performance by supporting zip compression.

Improving Web Service Perfomance Article

Reverse a char array in C# with XOR

Kevin — Thu, 27 Jan 2005 22:00:00 GMT

Here's a neat trick. Use XOR operations to reverse a char array without using a temporary variable.

public void ReverseIt(ref char[] c)
{
int l = c.Length - 1;

for(int i=0; i<l; i++, l--)
{
    c[i] ^= c[l]; // xor trick
    c[l] ^= c[i];
    c[i] ^= c[l];
}
}

Top 10 things to be thankful for in .NET

Kevin — Fri, 03 Dec 2004 23:22:00 GMT

I came across the top 10 things to be thankful for in .NET. It's pretty funny. Check it out.