Approach for using 'params' in a generic type definition

Question

This question got me thinking on how one could approach writing a method that would need to contain a variable list of type parameters.

One approach would be to accept params Type[] as part of the arguments, such as:

public static bool IsOneOf(this object obj, params Type[] types)
{
    return types.Contains(obj.GetType());
}

However, the use is a little verbose (e.g. obj.IsOneOf(typeof(int), typeof(bool), typeof(double))) and I am wondering about alternative approaches to defining one method taking an arbitrary amount of generic arguments. Something akin to:

public static bool IsOneOf<params TArgs[]>(this object obj)
{
    // use TArgs here
}

One solution to this would be to use the 4.0 BCL's Tuple classes (it defines a common interface ITuple as well as Tuple<T1>, Tuple<T1, T2>, etc) to define something like the following:

public static bool IsOneOf<TTypes>(this object obj) where TTypes : ITuple
{
    Type tupleType = typeof(TTypes);
    return tupleType.GetGenericArguments().Contains(obj.GetType());
}

It could then be used like this:

if (obj.IsOneOf<Tuple<int, bool, decimal>>()) { ... }

Are there performance considerations here, or are there an alternative methods to achieve this syntax?

Isn't there something already in .net framework to check for existence of an item in a list? What is the purpose of you doing this, other than extension on object? — shahkalpesh
– shahkalpesh, Commented Jul 28, 2009 at 16:23
Yes, there is List.Contains. The issue is that you cannot have params in the generic argument definition for a method. The original purpose is for an extension on object, but it could be applicable in other places. — Jason
– Jason, Commented Jul 28, 2009 at 16:30

Daniel Earwicker · Accepted Answer · 2009-07-28 16:31:38Z

1

You could possible squeeze out a little extra speed by unrolling the loop into special cases for each "arity":

static bool IsOneOf<T1>(object o)
{
    return (o.GetType() == typeof (T1));
}

static bool IsOneOf<T1, T2>(object o)
{
    return (o.GetType() == typeof(T1)) ||
           (o.GetType() == typeof(T2));
}

static bool IsOneOf<T1, T2, T3>(object o)
{
    return (o.GetType() == typeof(T1)) ||
           (o.GetType() == typeof(T2)) ||
           (o.GetType() == typeof(T3));
}

And so on.

But then, how often do you need to know if an object is one or the other of a pair of unrelated types? Let alone three or more. Seems quite an obscure need to me.

answered Jul 28, 2009 at 16:31

Daniel Earwicker

117k38 gold badges209 silver badges289 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Approach for using 'params' in a generic type definition

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related