C# check object type against multiple types

Question

IS there a way to pass an array of types to the "is" operator?

I am trying to simplify the syntax of checking an object against multiple types.

Something like:

public static function bool IsOfType(object Obj,params Type[] Types)

This would however require the following usage:

if(X.IsOfType(typeof(int),typeof(float))
{...}

I would like to do something like:

if(X is {int,float})

or

if(X.IsOfType(int,float))

or even

public static bool ISOfType<T[]>(this object Obj){...}
if(X.ISOfType<int,float>())

I think they are all impossible.

If you're writing code that has to do a lot of type-checking like this against *basic* types, the common approach used with the CLR itself is to `switch` on [`Type.GetTypeCode`](https://msdn.microsoft.com/library/system.type.gettypecode). If you find yourself doing this a lot against non-basic types, there's probably something wrong with your code that it needs a shorthand for this in the first place. — Jeroen Mostert, Apr 13 '16 at 16:22
To further @JeroenMostert comment, this is how to [check if the type is numeric](https://stackoverflow.com/questions/1749966/c-sharp-how-to-determine-whether-a-type-is-a-number). — ryanyuyu, Apr 13 '16 at 16:23
Just create IsNumeric extension function. It's unlikely that you really need to check object against many arbitrary types. — Evk, Apr 13 '16 at 16:24

Stacklysm · Answer 1 · 2022-07-11T22:40:37.977

3

With C# 10, you can use pattern matching to test an object for multiple types.

Example:

public bool TestObject<T>(T obj)
{
    if (obj is not null and (int or float or uint))
    {
        // obj is not null and guaranteed to be an int, float or uint 
    }
}

Example 2 (in case you want to use the value):

public bool TestIntOrFloat<T>(T obj)
{
    if (obj is not (int or float))
    {
        // obj is neither int or float
    }
    else if (obj is int i)
    {
        // obj is an integer and can be used with the variable 'i'
    }
    else if (obj is float f)
    {
        // obj is a floating number and can be used with the variable 'f'
    }
}

edited Jul 11 '22 at 22:40

answered Mar 11 '22 at 20:39

Stacklysm

233
2
11

Why do you have an explicit check for null? – xKaihatsu Apr 10 '22 at 11:54
@xKaihatsu I mean, it's not necessary, but new C# projects have null checking enabled by default – Stacklysm Apr 19 '22 at 14:23

Theodoros Chatzigiannakis · Answer 2 · 2016-04-13T16:30:26.617

2

If you're okay with passing the types as generic arguments, there is a solution. Unfortunately, C# doesn't support variadic generics. You have to define the function for each generic arity.

public static bool IsOfType<T>(this object obj) => obj is T;
public static bool IsOfType<T1, T2>(this object obj) => obj is T1 || obj is T2;
public static bool IsOfType<T1, T2, T3>(this object obj) => obj is T1 || obj is T2 || obj is T3;
public static bool IsOfType<T1, T2, T3, T4>(this object obj) => obj is T1 || obj is T2 || obj is T3 || obj is T4;
public static bool IsOfType<T1, T2, T3, T4, T5>(this object obj) => obj is T1 || obj is T2 || obj is T3 || obj is T4 || obj is T5;
public static bool IsOfType<T1, T2, T3, T4, T5, T6>(this object obj) => obj is T1 || obj is T2 || obj is T3 || obj is T4 || obj is T5 || obj is T6;
public static bool IsOfType<T1, T2, T3, T4, T5, T6, T7>(this object obj) => obj is T1 || obj is T2 || obj is T3 || obj is T4 || obj is T5 || obj is T6 || obj is T7;
public static bool IsOfType<T1, T2, T3, T4, T5, T6, T7, T8>(this object obj) => obj is T1 || obj is T2 || obj is T3 || obj is T4 || obj is T5 || obj is T6 || obj is T7 || obj is T8;

I doubt you'll need more than 8 types but if you do, just define more overloads.

edited Apr 13 '16 at 16:30

answered Apr 13 '16 at 16:24

Theodoros Chatzigiannakis

28,773
8
68
104

Not what I was looking for but definitely a limited solution to the problem. – Jeff Holodnak Apr 13 '16 at 17:15
My initial solution was the following, but still yields lengthy when using it due to reuse of the typeof(): public static bool IsAnyOf(this object Obj,params Type[] Types) { foreach (Type Type in Types) if (Obj is Type) return true; return false; } – Jeff Holodnak Apr 13 '16 at 17:16
usage: ctxScript.Visible = !nSelected.IsAnyOf(typeof(TablesNode) ,typeof(ViewsNode) ,typeof(ProcedureNode) ,typeof(UserTableTypesNode) ,typeof(FunctionsNode) ,typeof(ServerNode) ,typeof(DatabaseNode)); – Jeff Holodnak Apr 13 '16 at 17:16
@JeffHolodnak: the classical solution to what you're doing would be a Visitor, giving the classes a common base with a virtual `ScriptOptionVisible` property. This allows you to add new node types without having to hunt for all the places in the code where knowledge of the new node has to be added. – Jeroen Mostert Apr 14 '16 at 10:43

DmitryG · Answer 3 · 2016-04-22T21:05:30.043

It can looks crazy, but you can use the following Fluent syntax:

object someInstance = 5.0;
if(someInstance
    .Is<int>()
    .Or<double>()) {
    // ...
}

Here the fluent-syntax is implemented as follows:

static class FluentIs {
    public static IsResult Is<T>(this object target) {
        return new IsResult(target, () => target is T);
    }
    public static IsResult Or<T>(this IsResult prev) {
        return new IsResult(prev, (v, x) => v || (x is T));
    }
    public class IsResult {
        Func<bool> value;
        object target;
        internal IsResult(IsResult r, Func<bool, object, bool> getValue) :
            this(r.target, () => getValue(r.value(), r.target)) {
        }
        internal IsResult(object target, Func<bool> value) {
            this.target = target;
            this.value = value;
        }
        // bool Operators
        public static bool operator true(IsResult r) { return r.value(); }
        public static bool operator false(IsResult r) { return !r.value(); }
    }
}

score 1 · Answer 4 · answered Apr 22 '16 at 19:52

My "chosen" solution was to use my handy "In" extension function to validate based on object type name.

    public static bool IsAnyOf(this object Obj,params string[] TypeNames)
    {
        return Obj.GetType().Name.In(TypeNames);
    }
    public static bool In(this string Needle,params string [] Haystack)
    {
        foreach (string straw in Haystack)
            if (straw == Needle)
                return true;
        return false;
    }

Usage:

    public static void CheckAll(this TreeNode Node)
    {
        foreach(TreeNode Child in Node.Nodes)
        {
            if(Child.GetType().Name.In("ChildTablesNode","ChildTableNode"))
            {
                Child.Checked = Node.Checked;
                Child.CheckAll();
            }
        }
    }

    private void ctxTree_Opening(object sender, CancelEventArgs e)
    {
        TreeNode nSelected = Tree.SelectedNode;

        ctxScript.Visible = !nSelected.IsAnyOf("TablesNode"
            , "ViewsNode"
            , "ProceduresNode"
            , "UserTableTypesNode"
            , "FunctionsNode"
            , "ServerNode"
            , "DatabaseNode"
            , "ColumnsNode"
            , "ColumnNode"
            , "TriggersNode");

        Type[] x = { typeof(int) };

    }

C# check object type against multiple types

4 Answers4