切换到对象实例

Question

编辑

这是一个不同版本的代码,使我更清楚我要做的事情:

class Program
{
    static void Main(string[] args)
    {
        RepairCar(Car.Ferrari);
    }

    public static void RepairCar(Car BrokenCar)
    {
        switch (BrokenCar)
        {
            case Car.Ferrari:
                Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;

            case Car.BMW:
                Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;

            case Car.Audi:
                Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;

            default:
                Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;
        }
    }

    public static double CalculateInsurance(Car BrokenCar)
    {
        return (BrokenCar.Price / 10);
    }

}

public class Car
{
    public double Price;
    public int MaxSpeed;
    public int MinSpeed;

    public Car(double Price, int MaxSpeed, int MinSpeed)
    {
        this.Price = Price;
        this.MaxSpeed = MaxSpeed;
        this.MinSpeed = MinSpeed;
    }

    public static Car Ferrari = new Car(100000, 250, 10);
    public static Car Audi = new Car(50000, 120, 30);
    public static Car BMW = new Car(35000, 80, 75);
}

如上所述,这将无法编译,因为它不会让我在RepairCar方法中切换BrokenCar.有什么建议？

原帖

我正在尝试创建一个可以存储静态属性的对象,更重要的是能够切换 - 这是一个例子 -

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(GetMaxSpeed(Car.Ferrari));
        Console.ReadLine();
    }

    public static int GetMaxSpeed(Car ModelType)
    {
        switch (ModelType)
        {
            case Car.Ferrari:
                return Car.Ferrari.MaxSpeed;

            case Car.VW:
                return Car.VW.MaxSpeed;

            case Car.AstonMartin:
                return Car.AstonMartin.MaxSpeed;
        }
    }

    public class Car
    {
        public int MinSpeed;
        public int MaxSpeed;

        public Car(int MinSpeed, int MaxSpeed)
        {
            this.MinSpeed = MinSpeed;
            this.MaxSpeed = MaxSpeed;
        }

        public static Car Ferrari = new Car(30, 240);
        public static Car VW = new Car(10, 50);
        public static Car AstonMartin = new Car(75, 180);
    }

}

有没有人有任何想法？

提前致谢!

威廉

编辑

此示例描述了一个更大,更复杂的系统.为了说明为什么我需要这样做,请参阅以下更新:

    public static void OnCarSale(Car CarSold)
    {
        double LuxuryTax = 75;

        switch (CarSold)
        {
            case Car.Ferrari:
                Console.WriteLine("Total Price: {0}", Car.Ferrari.Price + LuxuryTax);
                break;

            case Car.VW:
                Console.WriteLine("Total Price: {0}", Car.VW);
                break;

            case Car.AstonMartin:
                Console.WriteLine("Total Price: {0}", Car.Ferrari.Price + LuxuryTax);
                break;
        }
    }

这将由本课外的事件调用 -

Answer 1

从 C# 7.0 开始，您可以使用模式匹配：

       public static void RepairCar(Car BrokenCar)
    {
        switch (BrokenCar)
        {
            case var car when car == Car.Ferrari:
                Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;

            case var car when car == Car.BMW:
                System.Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;

            case var car when car == Car.Audi:
                Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;

            default:
                Console.WriteLine("${0} of Insurance Needed", CalculateInsurance(BrokenCar));
                // 
                // Repair Algorithm Here
                //
                break;
        }
    }

Answer 2

要直接回答您的问题，请将ModelType设为枚举并关闭该值。在下面的示例中，让Car类型具有一个名为“ Model”的ModelType属性。

public enum ModelType
{
    Ferrari = 0,
    AstonMartin = 1
}

public int GetMaxSpeed( Car car )
{
    switch( car.Model )
    {
        case Ferrari:
           return 300;
        case AstonMartin:
           return 250;
        default:
           return 100;
    }
}

但是更好的问题是，为什么不使用多态呢？您可以将Car设为基本类型，并从其继承不同的模型。基本的Car类型应具有MaxSpeed属性。无论您从Car继承了什么子类，都可以引用MaxSpeed来获取该特定模型的属性值。这可能会使您的示例过于复杂（家庭作业？），但这会使您的代码更加面向对象。

public class Car
{
    private int _maxSpeed = 200;
    public int MaxSpeed
    {
        get { return _maxSpeed; }
        protected set { _maxSpeed = value; }
    }
}

public class Ferrari : Car
{
    public Ferrari()
    {
        // Constructor 
        this.MaxSpeed = 250;
    }
}

// client code
public void DoStuff()
{
   Car ferrari = new Ferrari();
   Console.WriteLine( ferrari.MaxSpeed );
}

如果您想使用带有汽车列表的Garage类，则外观如下所示。请记住，这是非常原始的代码，但是它可以在注释中显示您在谈论什么。

public class Garage
{
    private List<Car> Cars { get; set; }

    public Garage()
    {
       this.LoadCars();
    }

    private void LoadCars()
    {
       this.Cars = new List<Car>();
       this.Cars.Add( new Ferrari() );
       this.Cars.Add( new AstonMartin() );
    }

    public int GetMaxSpeedOfAllCars()
    {
        int maxSpeed = 0;

        foreach( Car car in this.Cars )
        {
            if( car.MaxSpeed > maxSpeed )
            {
                maxSpeed = car.MaxSpeed;
            }
        }

        return maxSpeed;
    }

}

Answer 3

这取决于你想用它做什么.如果"开关"是给汽车额外的行为,那就把它放在班级本身.例如,在你的情况下你已经有了相应的字段(ick,public fields,但是......)你可以使用:

public static int GetMaxSpeed(Car car)
{
    return car.MaxSpeed;
}

在其他情况下,您可以为类型提供方法,并且可以使用嵌套类根据不同的值以不同方式实现方法.为"base"类提供私有构造函数和抽象方法,然后将派生类创建为嵌套类,以便它们仍然可以使用私有构造函数并公开特定值.我将这些类型称为"智能枚举".

如果要将每个值映射到另一个值,请使用Dictionary<Car,string>(或其他).如果要将每个值映射到某个操作,请使用Dictionary<Car, Action>.

基本上你将无法使用开关,除非你有一个枚举或一些整体类型......这通常会很痛苦.使用字典通常是一种更简单的方法.

如果你能提供一个不那么容易解决的更现实的例子,我们可以帮助更多......