Question

您可以在类型基类的C＃中将派生类和基类混合在一个通用列表中吗？我不明白为什么不......而且我没有看到明确的答案......但今天玩的是类型基类的通用列表，它也有派生类，我没有看到任何问题。但是我想知道是否存在潜在的问题，除了通常的派生/基类固有的向上/向下限制。我问的原因是：我不知道C＃的通用列表是否与以前在C ++中称为ArrayList的列表相同，也就是说，在编译期间是否会收到任何关于混合'类型'的抱怨（如此） base vs derived classes）。我今天跑了很多例子没有抱怨，但想验证是否存在问题。

Answer 1

C＃类类型是引用类型。 C ++类类型在.NET世界中称为值类型。适当的比较将是基类指针的C ++列表，您可以在其中存储指向派生类的指针而不会出现任何问题。

是的，没关系。

Answer 2

 using System;
 using System.Collections.Generic;

 namespace DoFactory.GangOfFour.Composite.Structural
{
/// <summary>
/// MainApp startup class for Structural 
/// Composite Design Pattern.  
/// </summary>
class MainApp
{
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    static void Main()
    {
        // Create a tree structure
        Composite root = new Composite("root");
        root.Add(new Leaf("Leaf A")); //1st Add for root
        root.Add(new Leaf("Leaf B")); //2nd Add for root
        Console.WriteLine(" ....");
        root.Display(1);
        Console.WriteLine("...........");
        Composite comp = new Composite("Composite X");
        comp.Add(new Leaf("Leaf XA"));
        root.Add(comp); //add comp to root //3rd Add for root

        DerivedComposite myDerivedComposite = new DerivedComposite("derived member",      1000);
        Console.WriteLine("Show the special int, string for DerivedComposite");
        myDerivedComposite.mySpecialVariablesAre();
        Console.WriteLine("........");

        root.Add(myDerivedComposite); //4th Add for root

        Composite SecondRoot = new Composite("SecondRoot");
        SecondRoot.Add(new Leaf("Leaf fA"));


        SecondRoot.Add(myDerivedComposite); //add to SecondRoot

        root.Add(SecondRoot); //add comp to root ; //5th Add for root
        //// Recursively display tree again, after adding
        root.Display(1);

        Console.WriteLine("Now get List read back");
        Console.WriteLine("show List elements for root (should be five)");
        root.DisplayList();

        Console.WriteLine("Show List elements for comp (should be one)");
        comp.DisplayList();
        Console.WriteLine("Show List ele for SecondRoot (should be 2)");
         SecondRoot.DisplayList();

        // Wait for user
        Console.ReadKey();
    }
}


/// <summary>
/// The 'Component' abstract class
/// </summary>
abstract class Component
{
    protected string name;

    // Constructor
    public Component(string name)
    {
        this.name = name;
    }

    public abstract void Add(Component c);
    public abstract void Remove(Component c);
    public abstract void Display(int depth);
    public abstract void printSpecialInt();
}

/// <summary>
/// The 'Composite' class
/// </summary>
class Composite : Component
{
    private List<Component> _children = new List<Component>(); 
    //This Generic List was potentially troublesome but it executed fine
    protected int specialbaseInt;
    // Constructor
    public Composite(string name)
        : base(name)
    {
        specialbaseInt = -1;
    }

    public override void Add(Component component)
    {
        _children.Add(component);
    }

    public override void Remove(Component component)
    {
        _children.Remove(component);
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);

        // Recursively display child nodes
        foreach (Component component in _children)
        {
            component.Display(depth + 2); //calls .Display again, is recursive
        }
    }

    public void DisplayList()
    {
        int ijk = _children.Count;
        Console.WriteLine("# elements in this List: {0}", ijk);
        foreach (Component c in _children)
        {
            int ii = c.GetHashCode();
            Type type = c.GetType();
            Console.WriteLine("GetHashCode, Type on list: {0}, {1}", ii, type.FullName);

            c.printSpecialInt();

        }
    }

    public override void printSpecialInt()
    {
        Console.WriteLine("special int (at base class): {0}", specialbaseInt);
    }
}

class DerivedComposite : Composite
{
    public string myExtraString;
    public int mySpecialInt;

    public DerivedComposite(string name,int ianint)
        : base(name)
    {
        myExtraString = name;
        mySpecialInt = ianint + 10;
        specialbaseInt = ianint;
    }

    public void mySpecialVariablesAre()
    {
        Console.WriteLine("The string, int, specialbaseInt are!- {0}, {1}, {2}", myExtraString, mySpecialInt, specialbaseInt);
    }

    public override void printSpecialInt()
    {
        Console.WriteLine("The string, int, specialbaseInt are (at derived): {0}, {1},    {2}", myExtraString, mySpecialInt, specialbaseInt);
    }

}

/// <summary>
/// The 'Leaf' class
/// </summary>
class Leaf : Component
{
    // Constructor
    public Leaf(string name)
        : base(name)
    {
    }

    public override void Add(Component c)
    {
        Console.WriteLine("Cannot add to a leaf");
    }

    public override void Remove(Component c)
    {
        Console.WriteLine("Cannot remove from a leaf");
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);
    }

    public override void printSpecialInt()
    {
        Console.WriteLine("at Leaf printSpecialInt");
    }
}

/// <summary>
/// The 'Leafail' class //try and make it fail
/// </summary>
class Leafail : Component
{
    // Constructor
    public Leafail(string name)
        : base(name)
    {
        myExtraString = "Hi, I am Leafail";
        mySpecialInt = 123;
    }

    public string myExtraString;
    public int mySpecialInt;

    public override void Add(Component c)
    {
        Console.WriteLine("Cannot add to a leafail");
    }

    public override void Remove(Component c)
    {
        Console.WriteLine("Cannot remove from a leafail");
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);
    }

    public void mySpecialVariablesAre()
    {
        Console.WriteLine("The string, int are: {0}, {1}", myExtraString,mySpecialInt);
    }
    public override void printSpecialInt()
     {
         Console.WriteLine("at Leafail printSpecialInt");
     }
}


}

您可以在类型基类的C＃中将派生类和基类混合在一个通用列表中吗？

2 个答案: