Itay's space: General .Net

User friendly file size

Fri, 01 Feb 2008 21:07:13 GMT

Based on a utility method found in the Microsoft.SharePoint.Utilities.SPUtility class, here's a method to get a user-friendly text for a file size:

public static string FormatSize(long cbSize)
{
    double num;
    if (cbSize <= 1024L)
    {
        if (cbSize <= 0L)
        {
            return string.Format("{0} KB", "0");
        }
        return string.Format("< 1 KB");
    }
    if (cbSize <= 1048576L)
    {
        num = Math.Round((double)(Convert.ToDouble(cbSize) / 1024.0), 1);
        return string.Format("{0} KB", num);
    }
    if (cbSize <= 1073741824L)
    {
        num = Math.Round((double)(Convert.ToDouble(cbSize) / 1048576.0), 1);
        return string.Format("{0} MB", num);
    }

    if (cbSize <= 1099511627776L)
    {
        num = Math.Round((double)(Convert.ToDouble(cbSize) / 1073741824.0), 1);
        return string.Format("{0} GB", num);
    }

    num = Math.Round((double)(Convert.ToDouble(cbSize) / 1099511627776.0), 1);
    return string.Format("{0} TB", num);
}

Utility classes: Negative arrays

Tue, 29 Jan 2008 18:57:28 GMT

Playing around with Lutz Roeder's .Net Reflector, I came across a very simple implementation of a "negative" array inside the Microsoft.SharePoint.Utilities namespace: NegativeArray. This class allows you to work with a "two-way" array: Creating a NegativeArray of size 10, you will have an array, with indices ranging from -10 to 10.

Where's the class implementation:

public class NegativeArray
{
    private int[] negative;
    private int[] positive;

    public NegativeArray(int maxIndex)
    {
        this.positive = new int[maxIndex + 1];
        this.negative = new int[maxIndex];
    }

    public NegativeArray(int maxIndex, NegativeArray source)
    {
        this.positive = new int[maxIndex + 1];
        this.negative = new int[maxIndex];
        for (int i = -source.MaxIndex; i <= source.MaxIndex; i++)
            this[i] = source[i];
    }

    public int this[int index]
    {
        get
        {
            if ((index >= 0) && (index <= this.MaxIndex))
                return this.positive[index];

            if (index < -this.MaxIndex)
                throw new ArgumentOutOfRangeException();

            return this.negative[-index - 1];
        }
        set
        {
            if ((index >= 0) && (index <= this.MaxIndex))
                this.positive[index] = value;
            else
            {
                if (index < -this.MaxIndex)
                    throw new ArgumentOutOfRangeException();

                this.negative[-index - 1] = value;
            }
        }
    }

    public int MaxIndex
    {
        get
        {
            return (this.positive.Length - 1);
        }
    }
}

MIME Types and File Extensions

Tue, 29 Jan 2008 18:40:06 GMT

Whenever working with content of files, it is often useful to have a way to find the MIME type based on a file extension, or the other way around - finding the file extension from a MIME type. Below are 2 useful methods for such requirements:

public static string GetExtensionFromMime(string mimeType)
{
    try
    {
        RegistryKey key = Registry.ClassesRoot.OpenSubKey(@"Mime\Database\Content Type\" + mimeType);
        if (key == null)
            return null;

        string str = key.GetValue("Extension") as string;
        if (string.IsNullOrEmpty(str))
            return string.Empty;
        
        return str;
    }
    catch
    {
        return string.Empty;
    }
}

public static string GetMimeFromExtension(string ext)
{
    if (!ext.StartsWith("."))
        ext = "." + ext;
    RegistryKey key = Registry.ClassesRoot.OpenSubKey(ext);
    if (key == null)
        return null;

    return key.GetValue("Content Type") as string;
}

SqlCE doesn't support TRUNCATE TABLE

Mon, 01 Oct 2007 19:08:14 GMT

Not long ago, I modified a piece of code to use SqlCE as a data store. The older code was using OleDb to access an MS Access file.

As part of the modifications, our team did a general overview of much of the data access code. We did many changes, more than I can even number. Here is a partial list:

Review of table keys, indices and restrictions.
Usage of IDbCommand instead of SQL string statements.
Removed legacy object model.
Replaced consecutive DELETE and INSERT statements with UPDATE.
and so on.

A few days ago, I noticed some delay in the data layer. This was nothing new - we process a huge amount of data - but since the many improvements, what used to be fast might now appear slow compared to the optimized code. After some search I've come up to a method that clears a many tables in the database. Something along the lines of:

using (IDbCommand cmd = DAL.GetClearTableCommand(tablename))
{
    // cmd.CommandText == "DELETE FROM " + tablename
    cmd.ExecuteNonQuery();
}

This of course, is nothing fancy or special. My thought was, instead of performing a DELETE statement, why not use the TRUNCATE TABLE statement, which is faster and more efficient. To my surprise, changing the GetClearTableCommand() method to return a TRUNCATE TABLE statement results in an parsing exception.

After some research, I've found that the TRUNCATE TABLE statement is not supported/implemented in SqlCE. Much to my disappointment, I will have to leave the DELETE statement in place, until I find a faster solution.

Allowing timeout on long-running operations - possible bug - Miscellaneous Debris

Sat, 29 Sep 2007 15:09:47 GMT

Avner Kashtan writes in his blog about an interesting problem, and solution, on how to run a long-running operation, with a timeout. The solution involves, obviously, running the code in a different thread. The possible bug is an unhandled exception in the different thread, which might kill the whole application process.

The suggested solution is to catch the exception in the running thread, and "passing the exception backward". This is possible thanks to the us of an anonymous delegate.

Although this is indeed, as mentioned in the post, an ugly solution, I find myself wondering what's the penalty of doing such a thing. Is the performance degraded so much? Is it such a horrible OOP crime?

Allowing timeout on long-running operations - possible bug - Miscellaneous Debris

Design Patterns Implementation in a Storage Explorer Application

Mon, 01 Jan 2007 22:27:19 GMT

Although a bit old, I found the well-written, interesting article by Breman Sinaga, Design Patterns Implementation in a Storage Explorer Application to be an excellente piece of work, explaining about several design patterns, such as Strategy, Observer, Adapter and Template Method, and showing how to corperate them all together. The result looks like a well designed, well thought-of, tool.

DebbugerDisplayAttribute

Thu, 21 Dec 2006 09:06:28 GMT

A little late, I know, but while watching the Channel 9: Scott Nonnenberg - Visualizers in VS 2005 webcast, I've learned the beauty of the DebuggerDisplayAttribute.

For those of you not familiar with this attribute, it allow you to choose how the tooltips inside the IDE while debugging will look like, and what values they will show you. Look at the following example:

[System.Diagnostics.DebuggerDisplay("Name={Name} ({Members.Count} members)")]
public class Group
{
public string Name;
public ArrayList Members = new ArrayList();
}

Group g = new Group();
g.Name = "Administrators";
g.Members.Add("User1");
g.Members.Add("User2");
g.Members.Add("User3");

If you run your application, and have an instance of a Group, here's how it will look like when you'll place the mouse ove the instance:

Name="Aministrator" (3 members);

This is very usefull if you have instances of complex objects, and you'd like to shorten the time you spend understanding that's the data that you are currently debugging.

Isolated storage

Fri, 15 Sep 2006 23:13:51 GMT

Although not a very technical, you should read the following article by Peter Aitken: Exploring .Net's Isolated Storage. The article doesn't go very deep, isn't very technical, and to tell the truth, I didn't find it a good read. However, it does provide a basic introduction to the very important subject of Isolated Storage.