Question

我有一个有一些派生类的类。这很有效。

我想实例化＆＃34;父母＆＃34;类。到目前为止......

但是我想用一个＆＃34;孩子＆＃34;来实例化它。课程，然后可能改变那个＆＃34;孩子＆＃34;上课后。也许这里的推导是不合适的。

采用以下示例：

public class Unicorn {
    public string Horn { get; set; }
    public Unicorn(){

    }
}

public class BadUnicorn : Unicorn{
    public string Rainbow()
    {
        return "dark rainbow";
    }

}
public class GoodUnicorn : Unicorn{
    public string Rainbow()
    {
        return "light rainbow";
    }
}

我可以实例化其中一个孩子，但是如果我从＆＃34;好的＆＃34;为了＆＃34;坏＆＃34;，我将不得不重新实例化。也许这就是它的方式，如果它完全存在的话，这将是一个可以接受的答案。

我宁愿想要实例化一个Unicorn，然后能够将它从Good变为Bad以维护存储在该Unicorn上的信息，但是可以访问＆＃34; child＆＃34;的当前方法和属性。类。

当我打电话给Unicorn.Rainbow()时，它会调用＆＃34;孩子所需的方法＆＃34;类。

我对C＃有点新鲜，是否有适合此法案的模式？

Answer 1

你不能用多态来做你想做的事。您无法将类的实例从一个更改为另一个。一旦创建它，它总是相同的类型。

你可以使用合成。

以下是您需要做的事情：

public class Unicorn
{
    public string Horn { get; set; }
    public Unicorn(Rainbow rainbow)
    {
        _rainbow = rainbow;
    }

    public void SetRainbow(Rainbow rainbow)
    {
        _rainbow = rainbow;
    }

    private Rainbow _rainbow;

    public string Rainbow()
    {
        return _rainbow.Colour();
    }
}

public abstract class Rainbow
{
    public abstract string Colour();
}

public class BadRainbow : Rainbow
{
    public override string Colour()
    {
        return "dark rainbow";
    }
}

public class GoodRainbow : Rainbow
{
    public override string Colour()
    {
        return "light rainbow";
    }
}

你可以这样测试：

var unicorn = new Unicorn(new GoodRainbow());
Console.WriteLine(unicorn.Rainbow());

unicorn.SetRainbow(new BadRainbow());
Console.WriteLine(unicorn.Rainbow());

输出：

light rainbow
dark rainbow

Unicorn的实例保持不变，但您可以更改彩虹。

Answer 2

这是我对代表词典的看法。虽然使用Func而不仅仅是字符串似乎是多余的，但如果该方法具有计算或需要参数等附加功能，那么您将被Func覆盖。

public class Unicorn
{
    static Dictionary<Attitude, Func<string>> RainbowByAttitude =
        new Dictionary<Attitude, Func<string>>()
        {
            [Attitude.Bad] = new Func<string>(() => "dark rainbow"),
            [Attitude.Good] = new Func<string>(()=>"light rainbow")

        };
    public string Horn { get; set; }
    public enum Attitude
    {
        Good,Bad
    }
    public Attitude attitude;
    public Unicorn(Attitude attitude)
    {
        this.attitude = attitude;
    }

    public string Rainbow() => RainbowByAttitude[attitude].Invoke();

}

class Program
{
    static void Main(string[] args)
    {
        Unicorn unicorn;

        unicorn = new Unicorn(Unicorn.Attitude.Bad);
        Console.WriteLine(unicorn.Rainbow());
        unicorn.attitude = Unicorn.Attitude.Good;
        Console.WriteLine(unicorn.Rainbow());

    }
}

Answer 3

这对我来说似乎是一种状态模式：

public abstract class UnicornState
{
    public abstract UnicornState Change();

    public abstract string Rainbow();
}

public sealed class GoodUnicornState : UnicornState
{
    public override UnicornState Change()
    {
        return new BadUnicornState();
    }

    public override string Rainbow()
    {
        return "light rainbow";
    }
}

public sealed class BadUnicornState : UnicornState
{
    public override UnicornState Change()
    {
        return new GoodUnicornState();
    }

    public override string Rainbow()
    {
        return "dark rainbow";
    }
}

public class Unicorn
{
    public string Horn { get; set; }

    public UnicornState State { get; set; }

    public string Rainbow => State.Rainbow();
}

用法：

var u = new Unicorn();
u.State = new GoodUnicornState();
Console.WriteLine(u.Rainbow);

u.State = u.State.Change();
Console.WriteLine(u.Rainbow);

C＃用不同的＆＃34; child＆＃34;实例化类。类

3 个答案: