Danie Bruwer

Javascript Querystring Class Version 1.4

2008-08-26T09:58:00Z

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

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

//      Version 1.3

//       28 May 2008    

//      License (Simplified BSD):

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

  

function $Querystring(qs) {

    return new Querystring(qs);

}

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

    this.params = {};

    this.keys = new Array();

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

    

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

    if (qs.length == 0) return;

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

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

  

    // Turn <plus> back to <space>

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

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

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

    

    // split out each name=value pair

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

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

        var name = decodeURIComponent(pair[0]);

        

        var value = (pair.length==2)

            ? decodeURIComponent(pair[1])

            : name;

            

        this.keys = name;

        this.params[name] = value;

    }        

}

  

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

    var value = this.params[key];

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

}

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

    value = encodeURI(value);

    this.params[key] = value;

    var index = this.indexOfKey(key);

    if (index < 0)

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

  

    return this;

}

Querystring.prototype.indexOfKey = function(key) {

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

    {

        if(this.keys == key)

            return i;

    }

    return -1;

}

Querystring.prototype.remove = function(key) {

    var index = this.indexOfKey(key);

    if (index >= 0) {

        this.params[key] = null;

        this.keys.splice(index, 1);

    }

    return this;

}

Querystring.prototype.toString = function() {

    var ret = "";

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

    {

        if(this.keys)

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

    }

    return ret;

}

Querystring.prototype.getAbsolutePath = function() {

    return this.path;

}

Querystring.prototype.toAbsoluteUrl = function() {

   return this.path + this.toString();

}

Querystring.prototype.contains = function(key) {

    var value = this.params[key];

    return (value != null);

}

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.

Javascript Querystring Class

2008-08-06T12:45:00Z

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

ListItemCollection.SyncToList

2008-01-10T00:16:00Z

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

ListItemCollection.SelectByValue, SelectByText

2008-01-09T23:42:00Z

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(); });

The Worst Bug Ever

2007-11-26T06:24:00Z

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:

A process serving application pool 'X' suffered a fatal communication error with the World Wide Web Publishing Service. The process id was 'X'. The data field contains the error number.

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.

Common Language Runtime detected an invalid program.

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

Cannot execute a program. The command being executed was "c:\windows\microsoft.net\framework\v1.1.4322\csc.exe" /noconfig @"C:\WINDOWS\TEMP\lannijk8.cmdline".

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.

Using Generics, Anonymous Methods and Delegates to join.

2007-11-20T16:54:00Z

/// <summary>
/// Delegate used to in Join
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public delegate object JoinDelegate<T>(T obj);
/// <summary>
/// Anonymous Method Delegate Join
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="items"></param>
/// <param name="join"></param>
/// <param name="delimiter"></param>
/// <returns></returns>
public static string Join<T>(IEnumerable items, JoinDelegate<T> join, string delimiter)
{
    StringWriter sw = new StringWriter();
    bool firstTime = true;
    foreach (T t in items)
    {
        if (firstTime)
            firstTime = false;
        else
            sw.Write(delimiter);
         sw.Write(join.Invoke(t));
    }
    return sw.ToString();

}

public struct StructTest
{
    public StructTest(string ID){this.id = ID;}
    public string id;
}[TestMethod]
public void Test_GenericJoin()
{
    StructTest[] items = new StructTest[] { new StructTest("1"),
                                           new StructTest("2") };
    string result = StringHelper.Join<StructTest>(items,
                              delegate (StructTest item) { return item.id;});
    Assert.AreEqual("1,2", result);

}

Custom Ajax Controls

2007-06-11T10:30:00Z

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.

Publishing Code from Word 2007

2007-06-06T17:59:24Z

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

To yield, or not to yield

2007-06-06T16:43:00Z

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;
        }
    }
}