The updated version of the original JavaScript Querystring class.

   1: // 

   2: //    ------------------------------------------------------------------------

   3: //    Modified by Danie Bruwer  2008/08/26

   4: //    http://dotnet.org.za/danieb

   5: //    New in Version 1.4

   6: //    * Chainable

   7: //    ------------------------------------------------------------------------

   8: //    Original File :

   9: //    http://adamv.com/dev/javascript/querystring

  10: //    Client-side access to querystring name=value pairs

  11: //      Version 1.3

  12: //       28 May 2008    

  13: //      License (Simplified BSD):

  14: //      http://adamv.com/dev/javascript/qslicense.txt    

  15:  

  16: function $Querystring(qs) {

  17:     return new Querystring(qs);

  18: }

  19: function Querystring(qs) { // optionally pass a querystring to parse

  20:     this.params = {};

  21:     this.keys = new Array();

  22:     this.path = (qs && qs.indexOf('?') > 0) ? qs.split('?')[0] : location.protocol +location.host + location.pathname;

  23:     

  24:     if (qs == null) qs = location.search.substring(1, location.search.length);

  25:     if (qs.length == 0) return;

  26:     if (qs.indexOf('?') > 0)

  27:         qs = qs.split('?')[1];

  28:  

  29:     // Turn <plus> back to <space>

  30:     // See: http://www.w3.org/TR/REC-html40/interact/forms.html#h-17.13.4.1

  31:     qs = qs.replace(/\+/g, ' ');

  32:     var args = qs.split('&'); // parse out name/value pairs separated via &

  33:     

  34:     // split out each name=value pair

  35:     for (var i = 0; i < args.length; i++) {

  36:         var pair = args.split('=');

  37:         var name = decodeURIComponent(pair[0]);

  38:         

  39:         var value = (pair.length==2)

  40:             ? decodeURIComponent(pair[1])

  41:             : name;

  42:             

  43:         this.keys = name;

  44:         this.params[name] = value;

  45:     }        

  46: }

  47:  

  48: Querystring.prototype.get = function(key, default_) {

  49:     var value = this.params[key];

  50:     return (value != null) ? value : default_;

  51: }

  52: Querystring.prototype.set = function(key, value) {

  53:     value = encodeURI(value);

  54:     this.params[key] = value;

  55:     var index = this.indexOfKey(key);

  56:     if (index < 0)

  57:         this.keys[this.keys.length] = key;

  58:  

  59:     return this;

  60: }

  61: Querystring.prototype.indexOfKey = function(key) {

  62:     for (var i = 0; i < this.keys.length; i++) 

  63:     {

  64:         if(this.keys == key)

  65:             return i;

  66:     }

  67:     return -1;

  68: }

  69: Querystring.prototype.remove = function(key) {

  70:     var index = this.indexOfKey(key);

  71:     if (index >= 0) {

  72:         this.params[key] = null;

  73:         this.keys.splice(index, 1);

  74:     }

  75:     return this;

  76: }

  77: Querystring.prototype.toString = function() {

  78:     var ret = "";

  79:     for (var i = 0; i < this.keys.length; i++) 

  80:     {

  81:         if(this.keys)

  82:             ret += ((i == 0) ? "?" : "&") + this.keys + "=" + this.params[this.keys];

  83:     }

  84:     return ret;

  85: }

  86: Querystring.prototype.getAbsolutePath = function() {

  87:     return this.path;

  88: }

  89: Querystring.prototype.toAbsoluteUrl = function() {

  90:    return this.path + this.toString();

  91: }

  92: Querystring.prototype.contains = function(key) {

  93:     var value = this.params[key];

  94:     return (value != null);

  95: }

New in Version 1.4. Chainable :

   1: alert($Querystring().set("search", "changed").toString());

   2: alert($Querystring().set("search", "changed").set("page", "1").indexOfKey("page"));

   3: alert($Querystring().set("search", "changed").set("page", "1").set("search", "changed again").toAbsoluteUrl());

   4: alert($Querystring("http://www.test.com?search=searchtext&page=1").set("search", "changed").set("page", "2").toAbsoluteUrl());

Download the source.

I have always found it difficult to manipulate querystring client side. So i searched for a javascript querystring helper class and found this class by Adam Vandenberg.

I added a couple methods that you may find usefull.

Here's a couple examples on how to use the enhanced class.

var qs = new Querystring();
qs.set("search", "changed");
alert(qs.get("search"));       
alert(qs.toString());
alert(qs.indexOfKey("search"));
alert(qs.toAbsoluteUrl());
alert("Removed search : " + qs.remove("search"));
alert("Removed search : " + qs.remove("search"));
qs.set("search", "search added with some empty spaces");
alert(qs.toAbsoluteUrl());

var qs2 = new Querystring("http://www.test.com?search=searchtext&page=1")
alert(qs2.toString());

Here's a example that uses extension methods, lambda expressions and anonymous methods to synchronize values from a ListItemCollection to a EntityList (Linq to SQL).

/// <summary>
/// This is used to easily bind a CheckBoxList to a EntitySet
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="items">List of items to Sync </param>
/// <param name="list">EntitySet to Remove from</param>
/// <param name="selected">Method to Find</param>
/// <param name="create">Method to Create a New Instance of T from a ListItem</param>
/// <param name="delete">Method to Delete T</param>
public static void SyncToList<T>(this ListItemCollection items
    , EntitySet<T> list
    , Func<T, ListItem, bool> selected
    , Func<ListItem, T> create
    , Func<T, bool> delete)
   where T : class, new()
{
    foreach (ListItem item in items)
    {
        T litem = list.FirstOrDefault(p => selected.Invoke(p, item));
        if (item.Selected && litem == null)
        {
            litem = create.Invoke(item);
            list.Add(litem);                   
        }
        else if(!item.Selected && litem != null)
        {
            if(delete != null)
                delete.Invoke(litem);
            list.Remove(litem);     
        }
    }
}

Example (Linq to SQL):

this.chkl_Clients.Items.SyncToList<UserClient>(this.User.UsersClients,                                    
delegate(UserClient u, ListItem i)
{//Selected
    return u.ClientId == int.Parse(i.Value); },           
delegate(ListItem l)
{//Create
    UserClient u = new UserClient();
    u.UserId = this.User.UserId;
    u.ClientId = int.Parse(l.Value);
    return u;
}
,delegate(UserClient u)
{//Delete
    Factory.DataContext.UsersClients.DeleteOnSubmit(u);
    return true;
}
);           
DataContext.SubmitChanges();

I found a very easy way to select items in a ListItemCollection 
using Extension Methods, Anonymous Methods and Lambda Expressions.

 /// <summary>
 /// This will select the items in a ChekboxList, ListBox
 /// </summary>
 /// <typeparam name="T">Type of items</typeparam>
 /// <param name="items">Source</param>
 /// <param name="selectionList">Selected items</param>
 /// <param name="property">Expression to select items</param>
 public static void SelectByValue<T>(this ListItemCollection items
                                    ,IEnumerable<T> selectionList
                                    , Func<T, string> property)
     where T : class, new()
 {
     foreach(ListItem i = items)
           i.Selected = selectionList.FirstOrDefault(
              p => property.Invoke(p) == i.Value) != null;                 
 }
 /// <summary>
 /// This will select the items in a ChekboxList, ListBox
 /// </summary>
 /// <typeparam name="T">Type of items</typeparam>
 /// <param name="items">Source</param>
 /// <param name="selectionList">Selected items</param>
 /// <param name="property">Expression to select items</param>
 public static void SelectByText<T>(this ListItemCollection items
                                    , IEnumerable<T> selectionList
                                    , Func<T, string> property)
     where T : class, new()
 {
      foreach(ListItem i = items)
           i.Selected = selectionList.FirstOrDefault(
                      p => property.Invoke(p) == i.Text) != null;  
 }

Here's an example :

chkl_Roles.Items.SelectByValue<Role>(this.User.Roles,
 delegate(Role r) { return r.RoleId.ToString(); });

I do support on a SharePoint Portal (2003, Framework 1.1). Last week after we deployed some new functionality we started to get very strange errors. The portal would just break at random arbitrary functions. I traced the root cause to the following warning in the System Event Log:

After investigating the application log for hours, days I found nothing but errors caused by the chain reaction of error in the application log. However we would receive this error quite often.

Then eventually it logged an error that basically said that it’s failing to compile a temporary file.

Thinking I had found the problem I delete the windows temp and the Asp.net temp directories. However a couple hours later the error was back, but not logging the Compile issue, only the warning in the system event log.  Googling the errors, didn’t return anything that made any sense.

Eventually we figured out (after reading this article) that when I added an extra Web Method to an existing web service, the generated Web Service had too many local variables.  I don’t know what the exact number is for .net 1.1 but for 2.0 its 32767, which is really a lot.

See .net declares a local variable for each method and parameter in your web service and compiles this class.

So we resolved the issue by removing some of the web methods, but if this is not an option there's a hotfix available to raise that limit to 4 million.

}

}

I have uploaded a demo of some custom AJAX controls we've pieced together.

• DropDownList with paging
• ImageDropdown with paging
• Holiday support for the Calendar Control

Check out the sample and download the source code.

I found a way to trick word in publishing code with the correct format and spacing.

You can do a find replace on:

• "^p" (paragraph) with "^l" (newline)
• " " (4 spaces) with "^t" (tab)

I don't know if there is a better way but this works quite well check the beautiful formatting here and here

I must say the yield keyword new in 2.0 is one of my favourites.
How I would best explain it best is that it iterates on demand.
Here is a very cool enumerator I wrote for our Exception Handler class.
Download the sourcecode here
/// <summary>
/// Enumerate the exception and the inner exceptions
/// </summary>
/// <param name="ex"></param>
/// <returns></returns>
public static IEnumerable<Exception> GetEnumerator(Exception ex)
{
    Exception tmp = ex;
    while (tmp != null)
    {
        Exception toYield = tmp;
        tmp = tmp.InnerException;
        yield return toYield;
    }
}

This made searching for specific exception type or formatting our exceptions much more elegant and faster in theory
(I say in theory since I don't think iterating thru exceptions is very CPU intensive!).
This small console app just illustrates the iteration on demand:
class Program
{
    public static IEnumerable<int> GetEnumerator()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("yield for :" + i);
            yield return i;
        }
    }
    public static List<int> GetItems()
    {
        List<int> ret = new List<int>();
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("for :" + i);
            ret.Add(i);
        }
        return ret;
    }
    static void Main(string[] args)
    {
        foreach (int j in GetEnumerator())
        {
            Console.WriteLine("yield foreach :" + j);
        }
        Console.ReadLine();
        foreach (int j in GetItems())
        {
            Console.WriteLine("foreach :" + j);
        }
        Console.ReadLine();
    }
}
Here is just an example on how to traverse a tree using yield:
public class TreeNode<T> : IComparable where T : IComparable
{
public TreeNode(){ }
public TreeNode(T data) : this(){this.data = data;}
private T data;
public T Data
{
    get { return data; }
    set { data = value; }
}
private TreeNode<T> parent;
public TreeNode<T> Parent
{
    get { return parent; }
    set { parent = value; }
}        
private TreeNodeCollection<T> nodes;
public TreeNodeCollection<T> Nodes
{
    get
    {
        if (nodes == null){nodes = new TreeNodeCollection<T>(this);}
        return nodes;
    }
    set { nodes = value; }
}
public IEnumerable<TreeNode<T>> GetAncestors()
{
    return GetAncestors(this);
}
public static IEnumerable<TreeNode<T>> GetAncestors(TreeNode<T> node)
{
    if ((node != null) && (node.Parent != null))
    {
        yield return node.Parent;
        foreach (TreeNode<T> n in GetAncestors(node.Parent))
            yield return n;
    }
}
public IEnumerable<TreeNode<T>> GetDescendents()
{
    return GetDescendents(this);
}
public static IEnumerable<TreeNode<T>> GetDescendents(TreeNode<T> node)
{
    foreach (TreeNode<T> child in node.Nodes)
    {
        yield return child;
        foreach (TreeNode<T> de in GetDescendents(child))
        {
            yield return de;
        }                
    }
}

Download the sourcecode here

I found this custom class I pieced together quite useful. It's essentially just a wrapper for List<T>, but with some added functionality.

So I added the following events that also supports "Cancel" *
BeforeAdd *
ItemAdded
BeforeItemInsert *
ItemInserted
BeforeRemove *
ItemRemoved
BeforeRemoveAt *
ItemRemovedAt
BeforeClear *

DistinctList<T>
The cancel events allowed me to create "DistinctList<T>" which is quite handy.
Notice that T has to implement IComparable since the Contains evaluates the "CompareTo" on T to determine if it's contained in the list. (This is crucial for custom objects)
/// <summary>
/// A Disctinct list of items
/// The list will automatically check that no duplicates are added to the collection
/// </summary>
/// <typeparam name="T"></typeparam>
public class DistinctList<T> : GenericList<T>
where T : IComparable
{
    protected override bool OnBeforeItemInsert(int index, T item)
    {
        if (!this.Contains(item))
        {
            return base.OnBeforeItemInsert(index, item);
        }
        return true;
    }
    protected override bool OnBeforeAdd(T item)
    {
        if (!this.Contains(item))
        {
            return base.OnBeforeAdd(item);
        }
        return true;
    }
    
}
Aggregation
I know Linq will make this obsolete since it supports aggregation but in 2.0 how many times have you written similar code?
List<int> list = new List<int>(new int[] { 70, 20 });
int total = 0;
foreach (int i in list)
    total += i;
Assert.AreEqual(((double)total) / ((double)list.Count), 45.0);
Is this not much easier?
GenericList<int> list = new GenericList<int>(new int[] { 70, 20 });
Assert.AreEqual(list.Average(), 45.0);
Or on Complex types like person:
class Person : IComparable
{
    public Person(string name, int age) { this.Name = name; this.Age = age; }
    public string Name;
    public int Age;

    public int CompareTo(object obj)
    {
        return this.Name.CompareTo(((Person)obj).Name);
    }        
}

We can simply do this:
GenericList<Person> list = new GenericList<Person>(new Person[]{
new Person("Old Guy",70)
,new Person("Young Guy",20)});
Assert.AreEqual(list.Average("Age"), 45.0);
So how does it work? I have pieced together an Aggregation helper that uses the (+) and (-) operators.
public static T Aggregate<T>(Aggregators aggregator, IEnumerable list, string propertyName)
    where T : IComparable
{
T ret = default(T);
    int count = 0;
    foreach (object item in list)
    {
        T value = AggregationHelper.GetValue<T>(item, propertyName);
        switch (aggregator)
        {
            case Aggregators.avg:
            case Aggregators.sum:
                ret = GenericWrapper<T>.Sum(ret, value);
                break;
            case Aggregators.max:
                if (ret.CompareTo(value) > 0)
                    ret = value;
                break;
            case Aggregators.min:
                if (ret.CompareTo(value) < 0)
                    ret = value;
                break;
            default:
                throw new NotImplementedException(
                 string.Format("Aggregator '{0}' not implemented"
                 , aggregator.ToString()));
        }
        count++;
    }
    if (aggregator == Aggregators.avg)
    {
        if (ret is IConvertible)
        {
            double total = (double)System.Convert.ChangeType(ret, typeof(double));
            double avg = total / (double)count;
            ret = (T)System.Convert.ChangeType(avg, typeof(T));
        }
        else
        {
            throw new
NotImplementedException("Type should be IConvertable when using average");
        }
    }
    return ret;
}
The GetValue<T> will either simply return the value or use reflection for complex types to get the value i.e. Person.Age.

For the GenericWrapper<T> I used Lightweight Code Generation (LCG) for operator overloading as shown in this example by Keith Farmer.
Basically what this does it is allows me to call the +,- operators on any type without having to cast.
class GenericWrapper<T> : IComparable, IComparable<T>
    where T : IComparable
{
    public GenericWrapper(T value) { _value = value; }
    private T _value;
    public T Value
    {
        get { return _value; }
        set { _value = value; }
    }

    #region Opperators        
    /// <summary>
    /// cached copy of the Add<T,T> delegate
    /// </summary>
    private static BinaryOperator<T, T, T> addTT;

    /// <summary>
    /// cached copy of the Subtract<T,T> delegate
    /// </summary>
    private static BinaryOperator<T, T, T> subTT;

    /// <summary>
    /// overloaded addition operator
    /// This will use GenericOperatorFactory to create the Add<T,T> delegate
    /// </summary>
    /// <param name="p1"></param>
    /// <param name="p2"></param>
    /// <returns></returns>
    public static GenericWrapper<T> operator +(GenericWrapper<T> p1, GenericWrapper<T> p2)
    {
        // use addTT to cache the delegate locally
        if (addTT == null)
        {
            addTT = GenericOperatorFactory<T, T, T, GenericWrapper<T>>.Add;
        }
        return new GenericWrapper<T>(addTT(p1.Value, p2.Value));
    }

    /// <summary>
    /// overloaded subtraction operator
    /// This will use GenericOperatorFactory to create the Subtract<T,T> delegate
    /// </summary>
    /// <param name="p1"></param>
    /// <param name="p2"></param>
    /// <returns></returns>
    public static GenericWrapper<T> operator -(GenericWrapper<T> p1, GenericWrapper<T> p2)
    {
        // use subTT to cache the delegate locally
        if (subTT == null)
        {
            subTT = GenericOperatorFactory<T, T, T, GenericWrapper<T>>.Subtract;
        }
        return new GenericWrapper<T>(subTT(p1.Value, p2.Value));
    }
    #endregion

    public virtual int CompareTo(object other)
    {
        return this.Value.CompareTo((T)(other));
    }
    
    public virtual int CompareTo(T other)
    {
        return this.Value.CompareTo(other);
    }
    
    #region Sum
    public static T Sum(T x, T y)
    {
        GenericWrapper<T> tmp = (new GenericWrapper<T>(x) + new GenericWrapper<T>(y));
        return tmp.Value;
    }        
    #endregion
}

Transcode DiVX, XViD, and MPEG files with .AVI extensions to zune! See how to?

I struggled a bit with a range validator for dates. So hopefully this can help someone.

I tried:

RangeValidator val = new RangeValidator();
val.MinimumValue = DateTime.Today.ToString();
val.MaximumValue = DateTime.MaxValue.ToString();

I but finally got it to work:

RangeValidator val = new RangeValidator();
val.MinimumValue = DateTime.Today.ToString("d");
val.MaximumValue = DateTime.MaxValue.ToString("d");