C#制作不同类型对象的数组

我是初学者。我试图找到一种方法，当数组中的对象不是同一类型的对象时，如何访问该对象的属性，而不总是使用“数组[0]作为类名”。不需要详细的回答。你也可以建议/引导我去哪里阅读这些东西，因为答案可能就在我面前，但我无法识别，因为我是初学者

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Vezba_9_object_ecercises
{
    class Program
    {
        static void Main(string[] args)
        {

            object[] books = new object[2];

            books[0] = new SomeBooks("Book_1", "Good", 22);
            Console.WriteLine((books[4] as SomeBooks).name); // working
           // Console.WriteLine((books[4].name); // not working, how to make it work

            books[1] = new OtherBooks("Book_2", "Bad", 2);
            Console.WriteLine((books[4] as OtherBooks ).name); // working
          //  Console.WriteLine((books[4].name); // not working, how to make it work

        }
    }
    public class SomeBooks
    {
        public SomeBooks(string _name, string _likability, int _numberOfPages)
        {
            name = _name;
            likability = _likability;
            numberOfPages = _numberOfPages;
        }

        public string name { get; set; }
        public string likability { get; set; }
        public int numberOfPages { get; set; }


    }
    public class OtherBooks
    {
        public OtherBooks(string _name, string _likability, int _numberOfAuthors)
        {
            name = _name;
            likability = _likability;
            NumberOfAuthors = _numberOfAuthors;
        }

        public string name { get; set; }
        public string likability { get; set; }
        public int NumberOfAuthors { get; set; }


    }
}

---

您可以使SomeBook和OtherBook类从

Book

基类（或接口）继承。这将允许您将它们存储在类型为

Book[]

而不是

object[]

的数组中。您可以通过这种方式访问继承的属性，例如名称和亲和力，而无需强制转换

public class Book
{
    public string Name { get; set; }
    public string Likability { get; set; }
}

public class SomeBook : Book
{
    public int NumberOfPages { get; set; }
}

public class OtherBook : Book
{
    public int NumberOfAuthors { get; set; }
}

然而，我反对这样做的必要性。问问自己，这是不是设计过度了。您可以只拥有一个Book类，该类允许其他值为null

public class Book
{
    public string Name { get; set; }
    public string Likability { get; set; }
    public int? NumberOfPages { get; set; }
    public int? NumberOfAuthors { get; set; }
}

---

您可以使SomeBook和OtherBook类从

Book

基类（或接口）继承。这将允许您将它们存储在类型为

Book[]

而不是

object[]

的数组中。您可以通过这种方式访问继承的属性，例如名称和亲和力，而无需强制转换

public class Book
{
    public string Name { get; set; }
    public string Likability { get; set; }
}

public class SomeBook : Book
{
    public int NumberOfPages { get; set; }
}

public class OtherBook : Book
{
    public int NumberOfAuthors { get; set; }
}

然而，我反对这样做的必要性。问问自己，这是不是设计过度了。您可以只拥有一个Book类，该类允许其他值为null

public class Book
{
    public string Name { get; set; }
    public string Likability { get; set; }
    public int? NumberOfPages { get; set; }
    public int? NumberOfAuthors { get; set; }
}

---

数组的类型必须是接口，每个元素的类型必须是继承接口的类

public interface IBook
{
    string Name { get; set; }
    string Likability { get; set; }
}

public class SomeBook : IBook
{
    public string Name { get; set; }
    public string Likability { get; set; }
    public int NumberOfPages { get; set; }
}

public class OtherBook : IBook
{
    public string Name { get; set; }
    public string Likability { get; set; }
    public int NumberOfAuthors { get; set; }
}

public class Books
{
    public Books()
    {
        IBook[] books = new IBook[2] {
            new SomeBook(),
            new OtherBook()
        };

        for (int i = 0; i < books.Length; i++)
        {
            switch (books[i].GetType().Name)
            {
                case "SomeBook":
                    int numberOfPages = ((SomeBook)books[i]).NumberOfPages;
                    break;

                case "OtherBook":
                    int numberOfAuthors = ((OtherBook)books[i]).NumberOfAuthors;
                    break;
            }
        }
    }
}

公共接口IBook
{
字符串名称{get；set；}
字符串相似性{get；set；}
}
公共类书籍：IBook
{
公共字符串名称{get；set；}
公共字符串相似性{get；set；}
公共int NumberOfPages{get；set；}
}
公共类其他书籍：IBook
{
公共字符串名称{get；set；}
公共字符串相似性{get；set；}
public int NumberOfAuthors{get；set；}
}
公共课用书
{
公共书籍（）
{
IBook[]图书=新IBook[2]{
new SomeBook（），
新书
};
for（int i=0；i

数组的类型必须是接口，每个元素的类型必须是继承接口的类

public interface IBook
{
    string Name { get; set; }
    string Likability { get; set; }
}

public class SomeBook : IBook
{
    public string Name { get; set; }
    public string Likability { get; set; }
    public int NumberOfPages { get; set; }
}

public class OtherBook : IBook
{
    public string Name { get; set; }
    public string Likability { get; set; }
    public int NumberOfAuthors { get; set; }
}

public class Books
{
    public Books()
    {
        IBook[] books = new IBook[2] {
            new SomeBook(),
            new OtherBook()
        };

        for (int i = 0; i < books.Length; i++)
        {
            switch (books[i].GetType().Name)
            {
                case "SomeBook":
                    int numberOfPages = ((SomeBook)books[i]).NumberOfPages;
                    break;

                case "OtherBook":
                    int numberOfAuthors = ((OtherBook)books[i]).NumberOfAuthors;
                    break;
            }
        }
    }
}

公共接口IBook
{
字符串名称{get；set；}
字符串相似性{get；set；}
}
公共类书籍：IBook
{
公共字符串名称{get；set；}
公共字符串相似性{get；set；}
公共int NumberOfPages{get；set；}
}
公共类其他书籍：IBook
{
公共字符串名称{get；set；}
公共字符串相似性{get；set；}
public int NumberOfAuthors{get；set；}
}
公共课用书
{
公共书籍（）
{
IBook[]图书=新IBook[2]{
new SomeBook（），
新书
};
for（int i=0；i

（books[4].name）

这将不起作用，因为

books[4]

是一个对象，根据合同，它没有

名称

属性。。我认为你需要学习更多。。例如，您可以使用接口数组或抽象数组来代替

对象数组。。您可以定义每个类实现的接口，然后访问公共接口的属性。注意，您的类只有一个属性不同？您应该将其中一个设置为“super”或父类，并从父类派生另一个并添加新属性。然后，您可以将它们作为父类存储在数组中，并且只有在需要子类时才将它们作为
存储。Thaks很多，很明显，在做类似的事情之前，我需要学习更多OOP/谢谢您的时间。
（books[4].name）
这将无法工作，因为
books[4]
是一个对象，根据合同，它没有
名称
属性。。我认为你需要学习更多。。例如，您可以使用接口数组或抽象数组来代替
对象数组。。您可以定义每个类实现的接口，然后访问公共接口的属性。注意，您的类只有一个属性不同？您应该将其中一个设置为“super”或父类，并从父类派生另一个并添加新属性。然后，您可以将它们作为父类存储在数组中，并且仅当您需要子类时才将它们作为
存储。Thaks很多，很明显，在执行类似操作之前，我需要学习更多OOP/谢谢您的时间。