C# C“用variable”实例化类；“儿童”；班

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

我想实例化“parent”类。走了那么远

但是我想用一个“child”类来实例化它，然后可能会在以后更改这个“child”类。也许这里的推导是不合适的

以以下为例：

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";
    }
}

我可以实例化其中一个孩子，但是如果我把一个从“好”改为“坏”，我就必须重新实例化。也许事情就是这样，如果这就是问题的全部，那将是一个可以接受的答案

我更希望实例化一个Unicorn，然后能够将它从好变坏，以维护存储在该Unicorn上的信息，但可以访问“child”类的当前方法和属性

这样，当我调用

Unicorn.Rainbow（）

时，它会调用所需的“child”类方法

---

我对C#有点陌生，有适合这项要求的模式吗

多态性不能满足您的需要。不能将类的实例从一个更改为另一个。创建后，它始终是相同的类型

不过你可以用构图

以下是您需要做的：

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());

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();
}

这将产生：

light rainbow dark rainbow 彩虹 暗虹

---

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

你不能用多态性做你想做的事。不能将类的实例从一个更改为另一个。创建后，它始终是相同的类型

不过你可以用构图

以下是您需要做的：

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());

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();
}

这将产生：

light rainbow dark rainbow 彩虹 暗虹

---

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

以下是我对代理字典的理解。虽然使用Func而不仅仅是string似乎是多余的，但如果该方法具有计算等附加功能或需要参数，则可以使用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());

    }
}

公共级独角兽
{
静态字典彩虹姿态=
新字典（）
{
[Attitude.Bad]=新函数（（）=>“暗彩虹”），
[态度.好]=新功能（（）=>“光彩虹”）
};
公共字符串Horn{get；set；}
公众的态度
{
好的，坏的
}
公众态度；
公共独角兽（态度）
{
这个态度=态度；
}
公共字符串Rainbow（）=>RainbowByAttitude[attitude].Invoke（）；
}
班级计划
{
静态void Main（字符串[]参数）
{
独角兽；
独角兽=新独角兽（独角兽。态度。坏）；
Console.WriteLine（unicorn.Rainbow（））；
unicorn.attitude=unicorn.attitude.Good；
Console.WriteLine（unicorn.Rainbow（））；
}
}

这是我对委托词典的看法。虽然使用Func而不仅仅是string似乎是多余的，但如果该方法具有计算等附加功能或需要参数，则可以使用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());

    }
}

公共级独角兽
{
静态字典彩虹姿态=
新字典（）
{
[Attitude.Bad]=新函数（（）=>“暗彩虹”），
[态度.好]=新功能（（）=>“光彩虹”）
};
公共字符串Horn{get；set；}
公众的态度
{
好的，坏的
}
公众态度；
公共独角兽（态度）
{
这个态度=态度；
}
公共字符串Rainbow（）=>RainbowByAttitude[attitude].Invoke（）；
}
班级计划
{
静态void Main（字符串[]参数）
{
独角兽；
独角兽=新独角兽（独角兽。态度。坏）；
Console.WriteLine（unicorn.Rainbow（））；
unicorn.attitude=unicorn.attitude.Good；
Console.WriteLine（unicorn.Rainbow（））；
}
}

在我看来，这似乎是一种状态模式，如下所示：

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

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

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);    

---

在我看来，这似乎是一种状态模式：

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

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

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);    

---

不能将类的实例从一个更改为另一个。一旦它被创建，它总是相同的类型。它看起来好像多态性可能就是我要寻找的。。。仔细研究一下，如果我完成了我想要的任务，我会在这里发帖子，而不是让GoodUnicorn和BadUnicorn成为不同的类，而是让它们成为Unicorn中的枚举属性。然后当你呼叫彩虹时，使用pattern@Martheen请将此作为答案发布。这很好，这个例子正是我的思路。@Martheen-你能解释一下使用

enum

与委托字典模式的关系吗？你不能将类的实例从一个更改为另一个。一旦它被创建，它总是相同的类型。它看起来好像多态性可能就是我要寻找的。。。仔细研究一下，如果我完成了我想要的任务，我会在这里发帖子，而不是让GoodUnicorn和BadUnicorn成为不同的类，而是让它们成为Unicorn中的枚举属性。然后当你呼叫彩虹时，使用pattern@Martheen请将此作为答案发布。这很好，这个例子正是我的思路。@Martheen-你能解释一下使用

enum

与委托字典模式的关系吗？这也很好。我将不得不使用此方法和委托字典方法，看看哪种方法在我的情况下效果最好，但现在它们看起来都不错。非常有用，非常感谢！这也很好。我将不得不使用此方法和委托字典方法，看看哪种方法在我的情况下效果最好，但现在它们看起来都不错。非常有用，非常感谢！