什么是像Class这样的参数化类型的等效C＃ <? extends Throwable> 在Java中？

Question

I wrote this blog: http://tri-katch.blogspot.com and implemented the pahakia-fault library: https://github.com/pahakia/lib .

I'd like to convert the pahakia-fault library to C#. But how to translate the following into C#?

public CodeBlockWorker<T> ignore(Class<? extends Throwable> clazz,
        @SuppressWarnings("unchecked") Class<? extends Throwable>... classes) {
    String[] codes = new String[classes.length];
    for (int i = 0; i < codes.length; i++) {
        Class<? extends Throwable> clz = classes[i];
        codes[i] = clz.getName();
    }
    handlers.add(new KatchHandler<T>(clazz.getName(), codes));
    return this;
}

I know C# has Type as the equivalent of Class in Java but Type is not parameterized.

So how to represent a parameterized type in C# if I want to use the type itself instead of an instance of it?

Thanks.

Answer 1

My java is a bit rusty, but I think what you are trying to accomplish can be done by using the GetType method to get the type of the passed parameters:

public CodeBlockWorker<T> Ignore(
      Exception clazz, params Exception[] classes)
{

    handlers.add(
       new KatchHandler<T>(
           //You can use FullName if you want to include the namespace
           clazz.GetType().Name, 
           classes.Select(t => t.GetType().Name)
           /* might need to call .ToArray() if your Constructor expects an array */);

    return this;
}

Right so a bit about what's going on. As any "throwable" exception (ie one that can be used in a try/catch) in .Net must inherit from Exception you can set your method parameters to use Exception . The params keyword is just a hint to the compiler that allows multiple method parameters to be automatically passed as an array.

Object in .net has the method GetType which will return the Type for that instance. You can that get either just the class name via Name or the class name and namespace via FullName . You can also use the keyword typeof to get the Type of a generic parameter.

Finally a bit of linq goodness with the .Select method, which performs a transformation / projection over an enumerable (ie array), in this case returning an enumerable of every name in classes .

Update

If you are trying to work on Types instead of instances of exceptions you could also try and write your method using generic type parameters and the typeof keyword to get the type of the type parameters:

 public CodeBlockWorker<T> Ignore<TClazz, TClasses>()
    where TCLazz : Exception
    where TClasses : Exception
 {
     var typename = typeof(TClazz).Name;
 }

The where clauses force the caller to pass in an exception class:

 Ignore<NullReferenceException, ArgumentException>();

If you wanted to allow the caller to put multiple TClasses you'd have to create additional method overloads for each additional type (which is how this is done for Action :

 Ignore<TClazz, T1, T2>(){}
 Ignore<TClazz, T1, T2, T3>(){}

However, you could have each of these overrides feed into the same method:

 private CodeBlockWorker<T> DoWork(Type TClazz, params Type[] TClasses){}
 public CodeBlockWorker<T> Ignore<TClazz, T1, T2, T3>()
 {
     return DoWork(typeof(TClazz), typeof(T1), typeof(T2), typeof(T3));
 }

Or you could write it such that the caller has to pass in types, but there isn't a way to restrict the values passed in at compile time; just as you can't create a method that has an integer parameter that restricts the value to '5' and '42'; you can only do this at run time.

Ignore(Type clazz, params Type[] classes){

    var typename = clazz.Name;
}

This would be called as:

Ignore(
    typeof(NullReferenceException), 
    typeof(ArgumentException), 
    typeof(DivideByZeroException));