How do I "test" an Exception type? - C# Discussion Boards

Re: Dictionary where the key is a combination of values?

20-Nov-07 5:54

How so?

PIEBALDconsult20-Nov-07 17:44

Re: Dictionary where the key is a combination of values?

20-Nov-07 17:44

I like a good programming exercise. What I've been concentrating on is the "max flexibility" part, but with a lack of type safety Frown | :(

I don't see how both can be achieved.

This is just a little test program that uses the class I'm working on.

namespace Test
{
    class Test
    {
        [System.STAThreadAttribute]
        static void
        Main
        (
            string[] args
        )
        {
            PIEBALD.Types.Hierarchary store = new PIEBALD.Types.Hierarchary
            (
                typeof(int)
            ,
                typeof(int)
            ,
                typeof(string)
            ) ;
 
            store [ 1234 , 1 , "Property1" ] = "1234 1 1" ;
            store [ 1234 , 1 , "Property2" ] = "1234 1 2" ;
 
            store [ 1234 , 2 , "Property1" ] = "1234 2 1" ;
            store [ 1234 , 2 , "Property2" ] = "1234 2 2" ;
 
            store [ 1237 , 1 , "Property1" ] = "1237 1 1" ;
            store [ 1237 , 1 , "Property2" ] = "1237 1 2" ;
 
            System.Console.WriteLine 
            ( "ProductId (key)   InventId (key)   Property1 (value)    Property2 (value)" ) ;
 
            foreach ( object k1 in store.Keys() )
            {
                foreach ( object k2 in store.Keys ( k1 ) )
                {
                    System.Console.WriteLine
                    (
                        "{0,-17} {1,-16} {2,-20} {3,-20}"
                    ,
                        k1
                    ,
                        k2
                    ,
                        store [ k1 , k2 , "Property1" ]
                    ,
                        store [ k1 , k2 , "Property2" ]
                    ) ;
                }
            }
 
            return ;
        }
    }
}

Rune Baess21-Nov-07 10:15

Rune Baess

21-Nov-07 10:15

Clever, but you don't avoid the unfortunate cast to and from object without the use of generics...

I've been working on a generic KeyedList, a kind of "brother" to the KeyedCollection, but for use with multible keys.

It's used like this

<code>

KeyedList<string, int, MyObject> keyedlist = new KeyedList<string, int, MyObject>();

keyedlist.Add(new MyObject("kvalue1",123, "actual content"));
keyedlist.Add(new MyObject("kvalue2",123, "actual content"));
// etc...

string key1 = "kvalue1";
int key2 = 123;

if(keyedlist.Contains(key1, key2);
{
MyObject obj = keyedlist[key1, key2];
// etc..
}

</code>

but I had make a new class for each number of keytypes for a coollection...
For 1, 2 and 3 keys the outcome was:

<code>
class KeyedList<TKey1, TObject>
{
}

class KeyedList<TKey1, TKey2, TObject>
{
}

class KeyedList<TKey1, TKey2, TKey3, TObject>
{
}

// etc...

</code>

I was hoping to avoid that ...
My dreams was that you could declare n-number of TKey types in a generic class....
Something like this:
<code>
class KeyedList<TKey[], TObject>
{
void Somemethod()
{
foreach(TKey keytype in TKey[])
{
// etc...
}
}
}

// so you could use it like this

KeyedList<int, int, Guid, MyObject> list = new ...

// or

KeyedList<string, MyObject> list = new ...

// with out having to make new class declare for each ....

</code>

Maybe in the next C# version...

Re: Dictionary where the key is a combination of values?

PIEBALDconsult21-Nov-07 12:11

Re: Dictionary where the key is a combination of values?

21-Nov-07 12:11

I don't think the key types matter as much as the value type, generally they go in but don't come out.

Because I was aiming for max flexibility I didn't provide the ability to specify the value type, but it could be done.

PIEBALDconsult23-Nov-07 7:25

How do I "test" an Exception type?

23-Nov-07 7:25

I added the ability to specify the value type and the key type when desired.

namespace Test
{
    class Test
    {
        [System.STAThreadAttribute]
        static void
        Main
        (
            string[] args
        )
        {
            try
            {
                PIEBALD.Types.Hierarchary<string> store = 
                new PIEBALD.Types.Hierarchary<string>
                (
                    typeof(int)
                ,
                    typeof(int)
                ,
                    typeof(string)
                ) ;

                store [ 1234 , 1 , "Property1" ] = "1234 1 1" ;
                store [ 1234 , 1 , "Property2" ] = "1234 1 2" ;

                store [ 1234 , 2 , "Property1" ] = "1234 2 1" ;
                store [ 1234 , 2 , "Property2" ] = "1234 2 2" ;

                store [ 1237 , 1 , "Property1" ] = "1237 1 1" ;
                store [ 1237 , 1 , "Property2" ] = "1237 1 2" ;

                System.Console.WriteLine ( "ProductId (key)   InventId (key)   Property1 (value)    Property2 (value)" ) ;

                foreach ( int k1 in store.Keys<int>() )
                {
                    foreach ( int k2 in store.Keys<int> ( k1 ) )
                    {
                        System.Console.WriteLine
                        (
                            "{0,-17} {1,-16} {2,-20} {3,-20}"
                        ,
                            k1
                        ,
                            k2
                        ,
                            store [ k1 , k2 , "Property1" ]
                        ,
                            store [ k1 , k2 , "Property2" ]
                        ) ;
                    }
                }
            }
            catch ( System.Exception err )
            {
                System.Console.WriteLine ( err.Message ) ;
            }

            return ;
        }
    }
}

JoeRip18-Nov-07 21:37

18-Nov-07 21:37

I have a method which is passed an Exception.

I'd like to find out which Exception it is (ie, was it ArgumentNullException, was it a COM Exception, etc).

How do I address this? I don't have control of the original Try/Catch statement in this method, it just receives an Exception which is passed, not thrown.

laserbaronen18-Nov-07 21:39

laserbaronen

18-Nov-07 21:39

if(ex is ArgumentNullException)
{
MessageBox.Show("Thau shall not nullify");
}

fafafa, ringakta icke sådant som bringa ack så naggande högönsklig välmåga å baronens ära.

JoeRip18-Nov-07 21:42

18-Nov-07 21:42

Thanks, that was exactly what I was looking for - what comparator to use. I was trying "==" and getting nowhere. Sounds like "is" is the way to go.

I was also just casting from the general exception to the specific exception and seeing what happened. I was not getting much info there Smile | :)

JoeRip18-Nov-07 21:50

18-Nov-07 21:50

How can I access the specific fields and properties?

public string GetErrorCode(Exception ex)<br />
{<br />
     if (ex is COMException)<br />
     {<br />
          return ex.ErrorCode.ToString();<br />
     }<br />
     else<br />
     {<br />
          return "";<br />
     }<br />
}

This doesn't work, the compiler complains that System.Exception doesn't contain a definition for ErrorCode.

I tried casting ex using

ex = (COMException)ex

but it fails the same way.

Martin#18-Nov-07 21:53

Martin#

18-Nov-07 21:53

Hello,

You have to cast it to the Type!

if (ex is COMException)
{
    COMException comEx = ex as COMException
    return comEx.ErrorCode.ToString();
}

COMException comEx = ex as COMException
if(comEx !=null)
{
   return comEx.ErrorCode.ToString();
}

All the best,

Martin

JoeRip18-Nov-07 22:01

18-Nov-07 22:01

Interesting, I used a direct cast (as in my example posted further down) instead of "as", and it appears to work fine. Any caveats there I should know about?

I'm not that familiar with "is" and "as", clearly. Perhaps I should be...

Martin#18-Nov-07 22:06

Martin#

18-Nov-07 22:06

Hello,

In you example you instanciated a object of COMException bevore casting,
which is not needed at all!

The advantage of using "is" or/and "as" is the check of the complete inheritance tree!

Additionaly you have the possibility (like I showed in the second example) to use "as" without doing the TypeCheck bevor, and not have to have the "fear" of an Exception thrown because of invalid type.

All the best,

Martin

PIEBALDconsult19-Nov-07 4:23

19-Nov-07 4:23

Right, I would write that first example as:

if (ex is COMException)
{    
    return ((COMException)ex).ErrorCode.ToString();
}

"Omit needless local variables." -- (To modernize Strunk)

JoeRip18-Nov-07 21:58

18-Nov-07 21:58

Got it.

I had to create a new COMException, and cast into that.

COMException COMex = new COMException();<br />
<br />
COMex = (COMException)ex;

then I was fine.

J4amieC18-Nov-07 22:33

J4amieC

18-Nov-07 22:33

JoeRip wrote:
I had to create a new COMException

No, you didn't. this would have worked just fine:

COMException COMex = (COMException)ex;

The reason it failed initially is that you tried to reuse the ex variable which was already defined as Exception:

//wont work<br />
ex = (COMException)ex;

You should definately read up on the C# is and as keywords as they are better suited to what you are trying to do.

JoeRip18-Nov-07 22:35