C# - Кастинг 'объектного' параметра в тип того объекта?

Правильный способ сделать это:

public interface ICanMove
{
   void Move();
}

реализовано как Cat, так и Pigeon:

public class Cat : ICanMove
{
   public void Move() { /* do something */ }
}

public class Pigeon : ICanMove
{
   public void Move() { /* do something */ }
}

А затем назвать это так:

public void Move(ICanMove objectThatMoves)
{
   objectThatMoves.Move();
}

Вы получите несколько вещей:

1. Вы можете вызвать Move (ICanMove objectThatMoves) только для объекта, реализующего интерфейс. Если вы попытаетесь передать другой объект, ваша программа не будет компилироваться.
2. Вы потеряете условный оператор. Если вы решите добавить в вашу программу Dog , который реализует ICanMove , метод Move будет отлично работать без каких-либо изменений. В вашей версии вам придется изменить метод.

Представьте, сколько работы вы бы сделали, если бы в вашей программе были операторы is ?

Один небольшой момент ... Правильнее не использовать as и is вместе, поскольку подразумеваемая проверка второго типа является избыточной. Либо используйте as следующим образом:

Cat catObject = objectToMove as Cat;
if(catObject!=null)
    catObject.Walk();
else 
{
    Pigeon pigeonObject = objectToMove as Pigeon;        
    if(pigeonObject!=null)
        pigeonObject.Fly();    
}

Или выполните прямое приведение, если вы уверены, что оно будет успешным; это и более эффективно, и более понятно: -

if(objectToMove is Cat)    
{        
     Cat catObject = (Cat)objectToMove;        
     catObject.Walk();    
}    
else if(objectToMove is Pigeon)    
{        
     Pigeon pigeonObject = (Pigeon)objectToMove;        
     pigeonObject.Fly();    
}

Используя прямое приведение, вы получаете исключение в случае неудачи, а не нулевое значение. Люди, читающие код, узнают без контекста: «Мы не просто пытаемся понять, можно ли рассматривать как что-то, мы уверены, что мы»

Другое решение вместо использования интерфейса - иметь базовый класс и переопределить метод Move () в каждом производном классе.

    abstract class Animal
    {
        public abstract void Move();
    }

    public class Cat : Animal
    {
        public override void Move()
        {
            //Cat specific behavior
        }
    }

    public class Bird : Animal
    {
        public override void Move()
        {
            //Bird specific behavior
        }
    }

Я думаю, что использование базового класса лучше, если у вас есть свойства или методы, общие для всех ваших «животных». Таким образом, вам не нужно дублировать код в каждом классе, реализующем описанный выше интерфейс «IAnimal».

Конечно, если нет общих элементов, интерфейс работает нормально.

Вы можете использовать оператор "is", чтобы проверить, является ли объект реализацией определенного класса.

if (objectToMove is Cat)

Немного измените свой, и готово.

Move( new Cat() );
Move( new Pigeon() );

public void Move(object objectToMove)
{
    if(objectToMove is Cat)
    {
        Cat catObject = objectToMove as Cat;
        catObject.Walk();
    }
    else if(objectToMove is Pigeon)
    {
        Rat pigeonObject = objectToMove as Pigeon;
        pigeonObject.Fly();
    }
}

Я бы сделал следующее:

interface IAnimal
{
    void Move();
}

Интерфейс

Затем мой кот и моя птица:

class Cat : IAnimal
{
    public void Move()
    {
        //a cat moves by walking
        this.Walk();
    }

    public void Walk()
    {
        //do logic
    }
}

class Bird : IAnimal
{
    public void Move()
    {
        this.Fly();
    }

    public void Fly()
    {
        //do fly logic
    }
}

Итак, когда вы закончите, вы получите следующее:

public void Move(IAnimal animal)
{
    animal.Move();
}

И должны вы хотите проверить тип вашего животного, вы можете сделать это:

public void PrintType(IAnimal animal)
{   
    Console.WriteLine(typeof(animal));
    //or
    Console.WriteLine(animal.GetType());
}