What is the C# equivalent to Java's isInstance()?

Java's isInstance() method determines if a specified object is assignment-compatible with the object represented by a class. In C#, there are several equivalent approaches to achieve the same functionality for type checking and instance validation.

C# Equivalents to Java's isInstance()

The most common C# equivalents are the is operator, IsAssignableFrom() method, and IsInstanceOfType() method. Each serves different use cases depending on whether you're working with objects, types, or need runtime type checking.

Using the 'is' Operator

The simplest and most commonly used equivalent is the is operator −

bool result = (object is ClassName);

Example

using System;

class Animal { }
class Dog : Animal { }
class Cat : Animal { }

class Program {
   public static void Main() {
      Animal animal = new Dog();
      Dog specificDog = new Dog();
      Cat cat = new Cat();
      
      Console.WriteLine("animal is Animal: " + (animal is Animal));
      Console.WriteLine("animal is Dog: " + (animal is Dog));
      Console.WriteLine("animal is Cat: " + (animal is Cat));
      Console.WriteLine("specificDog is Animal: " + (specificDog is Animal));
      Console.WriteLine("cat is Dog: " + (cat is Dog));
   }
}

The output of the above code is −

animal is Animal: True
animal is Dog: True
animal is Cat: False
specificDog is Animal: True
cat is Dog: False

Using Type.IsAssignableFrom()

The IsAssignableFrom() method checks if instances of a specified type can be assigned to the current type −

bool result = targetType.IsAssignableFrom(sourceType);

Example

using System;

class Vehicle { }
class Car : Vehicle { }
class Truck : Vehicle { }

class Program {
   public static void Main() {
      Type vehicleType = typeof(Vehicle);
      Type carType = typeof(Car);
      Type truckType = typeof(Truck);
      
      Console.WriteLine("Vehicle.IsAssignableFrom(Car): " + vehicleType.IsAssignableFrom(carType));
      Console.WriteLine("Vehicle.IsAssignableFrom(Truck): " + vehicleType.IsAssignableFrom(truckType));
      Console.WriteLine("Car.IsAssignableFrom(Vehicle): " + carType.IsAssignableFrom(vehicleType));
      Console.WriteLine("Car.IsAssignableFrom(Truck): " + carType.IsAssignableFrom(truckType));
   }
}

The output of the above code is −

Vehicle.IsAssignableFrom(Car): True
Vehicle.IsAssignableFrom(Truck): True
Car.IsAssignableFrom(Vehicle): False
Car.IsAssignableFrom(Truck): False

Using Type.IsInstanceOfType()

The IsInstanceOfType() method determines whether the specified object is an instance of the current type −

bool result = type.IsInstanceOfType(objectInstance);

Example

using System;

class Shape { }
class Circle : Shape { }
class Rectangle : Shape { }

class Program {
   public static void Main() {
      Shape shape = new Circle();
      Circle circle = new Circle();
      Rectangle rectangle = new Rectangle();
      
      Type shapeType = typeof(Shape);
      Type circleType = typeof(Circle);
      
      Console.WriteLine("Shape type - shape instance: " + shapeType.IsInstanceOfType(shape));
      Console.WriteLine("Shape type - circle instance: " + shapeType.IsInstanceOfType(circle));
      Console.WriteLine("Circle type - shape instance: " + circleType.IsInstanceOfType(shape));
      Console.WriteLine("Circle type - rectangle instance: " + circleType.IsInstanceOfType(rectangle));
   }
}

The output of the above code is −

Shape type - shape instance: True
Shape type - circle instance: True
Circle type - shape instance: True
Circle type - rectangle instance: False

Comparison of Approaches

Conclusion

C# provides multiple equivalents to Java's isInstance() method. The is operator is the most efficient for direct type checking, while IsAssignableFrom() and IsInstanceOfType() offer more flexibility for complex type validation scenarios involving reflection and runtime type checking.