switch (object.GetType) ...

FooException fe = ex as FooException;
if (fe != null)
{
    // do something with the FooException instance...
}

Your program doesn't compile.  Fail.

Here's a version that does:

public class MyClass
{
    private delegate object Handler(object obj);
    private readonly Dictionary<Type, Handler> handlerBunch =
        new Dictionary<Type, Handler>();

    public MyClass()
    {
        handlerBunch.Add(typeof(int), DoSomethingWithInt);
        handlerBunch.Add(typeof(float), DoSomethingWithFloat);
        handlerBunch.Add(typeof(DateTime), DoSomethingWithDateTime);
        handlerBunch.Add(typeof(FileStream), DoSomethingWithFileStream);
    }

    public object DoSomething(object obj)
    {
        if (!handlerBunch.ContainsKey(obj.GetType()))
        {
            throw new ArgumentException("obj");
        }
        else
        {
            return handlerBunch[obj.GetType()](obj);
        }
    }

    public object DoSomethingWithInt(object arg)
    {
        return (int)arg + 7;
    }

    public object DoSomethingWithFloat(object arg)
    {
        return (float)arg;
    }

    public object DoSomethingWithDateTime(object arg)
    {
        return arg.ToString();
    }

    public object DoSomethingWithFileStream(object arg)
    {
        (arg as FileStream).Close();
        return null;
    }
}

There's probably a clever way to use a delegate instead of Dictionary.ContainsKey(Type) to enable F#/Haskell-style pattern matching.

Instead of ContainsKey followed by [ ] (which is a double lookup), you can use TryGetValue, like this:

public object DoSomething(object obj)
{
    if (obj == null) throw new ArgumentNullException("obj");
    Handler lHandler;
    if (handlerBunch.TryGetValue(obj.GetType(), out lHandler))
        return lHandler(obj);
    else throw new ArgumentException("The type of obj is not supported.", "obj");
}

Looks cool... but why aren't you only saving the switch that is for that given type. I mean you build up a hashtable for exactly one object, where the type is well known at the time of building the hashtable. You could make it way more efficient and only store the delegate that's appropriate for the type of the object.

Only 1 TypeSwitcher-instance is created (by the Switch-method). Each Case<T>-call adds the specified handler to the dictionary of the current instance and returns this instance.

One thing I would change: you don't have to check if the dictionary contains the type to decide whether you want to add or set the handler: handlers[t] = boxedHandler will add the item if it isn't already in the dictionary.

I was too fast

I read over the constructor that stores the type of the object. I should just acknowledge I'm getting too old, and that young geniuses like LG can make me look stupid

I would turn it around and not keep a dictionary, but just the object. Here's an implementation that's more efficient and even skips checking once it has found a case that matches. It also doesn't need a Switch-method to execute the handler.

public class TypeSwitcher
{
    readonly object fObject;
    public TypeSwitcher(object obj)
    {
        if (obj == null) throw new ArgumentNullException("obj");
        fObject = obj;
    }
    
    protected TypeSwitcher() { }
    
    public TypeSwitcher Case<T>(Action<T> action)
    {
        if (IsMatch(typeof(T)))
        {
            if (action != null) action((T)fObject);
            return IgnoreTypeSwitcher.Instance;
        }
        else return this;
    }
    
    protected virtual bool IsMatch(Type t)
    {
        return fObject.GetType() == t;
    }
    
    class IgnoreTypeSwitcher : TypeSwitcher
    {
        IgnoreTypeSwitcher() : base () { }
        
        public static IgnoreTypeSwitcher Instance = new IgnoreTypeSwitcher();
        
        protected override bool IsMatch(Type t) { return false; }
    }
}

Use it like this:

new TypeSwitcher(obj)
    .Case<string>(x => Console.WriteLine("string: {0}", x))
    .Case<int>(x => Console.WriteLine("int: {0}", x))
    .Case<DateTime>(x => Console.WriteLine("DateTime: {0}", x));