What are "good" use cases for using "is" keyword in C#?

Question

We had a discussion today on the job where we were talking about use case where you have code similar to this:

using System;

namespace test
{
    class Program
    {
        public class A
        {
            public void Foo()
            {
                Console.WriteLine("This is A.");
            }
        }

        public class B
        {
            public void Foo()
            {
                Console.WriteLine("This is B");
            }
        }

        public static void Test(object obj)
        {
            if (obj is A a)
            {
                a.Foo();
            }
            else if (obj is B b)
            {
                b.Foo();
            }
        }

        static void Main(string[] args)
        {
            Test(new A());
        }
    }
}

Then we discussed how the "is" keyword can be removed by abstracting the behavior like this (or with an interface, depending on which works best in the context):

using System;

namespace test
{
    class Program
    {
        public abstract class Base
        {
            public abstract void Foo();
        }

        public class A : Base
        {
            public override void Foo()
            {
                Console.WriteLine("This is A.");
            }
        }

        public class B : Base
        {
            public override void Foo()
            {
                Console.WriteLine("This is B");
            }
        }

        public static void Test(Base obj)
        {
            obj.Foo();
        }

        static void Main(string[] args)
        {
            Test(new A());
        }
    }
}

So, from there, we were a bunch of people trying to figure out which would be the scenarios where the use of the "is" keyword would really be justified. All the examples we could come up with were ruled out as they resulted from other code smells..

I did some research on the web for an answer but most websites would only provide definitions and how to use the keyword but I couldn't find any source that I could cite for "good practices" related to the keyword.

In summary, my question is, what are (if any) scenarios where the use of the "is" keyword is justified (necessary/more elegant)?

Edit: More information to clarify. For a lot, if not most keywords/statements/directives, there are context where it makes sense to use it and other contexts where the use is unjustified.

For example, try, catch, throw are great when you need to have a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero. However, most programmers would agree that using them for control flow is a bad idea.

In that same regards, goto can be used in switches or in nested loops and this is generally accepted usage. However, if you start using goto to jump around in the code, this is, again, considered to be a bad idea by most programmers.

Therefore, I want to identify what use cases for is would be accepted and what others would be rejected by most programmer?

Answer 1

Everything is a code smell to someone, some are more-so than others.

is (C# Reference)

Checks if an object is compatible with a given type, or (starting with C# 7.0) tests an expression against a pattern.

Asking for legitimate uses of is is like asking for legitimate uses of water. It's never ending and all can be debated all day. If you have someone hell-bent on proving everything is a smell, then you will never win.

However, what we know is, if you need to Check if an object is compatible with a given type then you have a legitimate use-case, end of story.

Think about events and the sender parameter.

Think about lists of base types.

<insert oodles of more list items here>

BCL Example

public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source)
{
   if (source == null) throw Error.ArgumentNull("source");
   return OfTypeIterator<TResult>(source);
}

static IEnumerable<TResult> OfTypeIterator<TResult>(IEnumerable source)
{
   foreach (object obj in source)
   {
      if (obj is TResult) yield return (TResult)obj;
   }
}