C# 什么是内部保护，为什么奇怪的类工作？

如果我将基类公开，它会开始抱怨：

Assets/TestScript.cs(14,14): error CS0060: Inconsistent accessibility: base class `Class1' is less accessible than class `BaseClass'

首先，我不明白为什么它会抱怨，因为afaik基类应该是您开始访问内容的那个基类

B无法访问受保护的功能，开关处于正常状态

但是什么是内部类呢

using UnityEngine;
using System.Collections;

public class TestScript : MonoBehaviour {
    BaseClass B = new BaseClass();
    Class2 A = new BaseClass(); // how can this even work and why does it work?
Class2 C = new Class2(); // Assets/TestScript.cs(7,28): error CS0144: Cannot create an instance of the abstract class or interface `Class2' // - WTH why?
    void Start(){
        B.BaseFunction(); // Base
        B.Function1(); // Assets/TestScript.cs(10,19): error CS0122: `Class1.Function1()' is inaccessible due to its protection level
        A.Function2(); // 2
    }
}

internal class BaseClass : Class1 {
    internal void BaseFunction(){
        Debug.Log("Base");
    }
}
internal abstract class Class1 : Class2{
    protected void Function1(){
        Debug.Log("1");
    }
}
public abstract class Class2{
    public void Function2(){
        Debug.Log("2");
    }
}

还是我只是做了一堆和公众一样有效的东西

但最让我感到不安的是为什么这样做：

Class2 A = new BaseClass();

如果这不起作用

Class2 C = new Class2();

---

抱歉，如果我对课程了解太少，我在编程一年后今天才开始学习这些课程。

这里是修饰符之间的一些基本区别：

受保护：

类型或成员只能由同一类或结构或派生类中的代码访问

内部：

同一程序集中的任何代码都可以访问该类型或成员，但不能从其他程序集中访问

受保护内部：

同一程序集中的任何代码或另一程序集中的任何派生类都可以访问该类型或成员

---

内部保护；只有派生类型或同一程序集中的类型才能访问该成员，因此它们必须位于同一动态链接库或可执行文件中。

以下是修饰符之间的一些基本区别：

受保护：

类型或成员只能由同一类或结构或派生类中的代码访问

内部：

同一程序集中的任何代码都可以访问该类型或成员，但不能从其他程序集中访问

受保护内部：

同一程序集中的任何代码或另一程序集中的任何派生类都可以访问该类型或成员

---

内部保护；只有派生类型或同一程序集中的类型才能访问该成员，因此它们必须位于同一动态链接库或可执行文件中。

以下是修饰符之间的一些基本区别：

受保护：

类型或成员只能由同一类或结构或派生类中的代码访问

内部：

同一程序集中的任何代码都可以访问该类型或成员，但不能从其他程序集中访问

受保护内部：

同一程序集中的任何代码或另一程序集中的任何派生类都可以访问该类型或成员

---

内部保护；只有派生类型或同一程序集中的类型才能访问该成员，因此它们必须位于同一动态链接库或可执行文件中。

以下是修饰符之间的一些基本区别：

受保护：

类型或成员只能由同一类或结构或派生类中的代码访问

内部：

同一程序集中的任何代码都可以访问该类型或成员，但不能从其他程序集中访问

受保护内部：

同一程序集中的任何代码或另一程序集中的任何派生类都可以访问该类型或成员

---

内部保护；只有派生类型或同一程序集中的类型才能访问该成员，因此它们必须位于同一动态链接库或可执行文件中。

您将所有内容命名得非常糟糕。。。这让人困惑。如果您使

基类

实际上是基类。。那么它应该更有意义：

public abstract class AbstractBase {
    public void BaseFunction(){
        Debug.Log("2");
    }
}

public class Class1 : AbstractBase {
    public void ClassOneFunction(){
        Debug.Log("Base");
    }
}
public abstract class Class2 : Class1 {
    public void ClassTwoFunction(){
        Debug.Log("1");
    }
}

现在，如果我们重新处理您的问题，您会得到如下结果：

AbstractBase A = new Class1();

您将

Class1

的一个实例表示为

AbstractBase

，这很好。您可以用继承自

AbstractBase

的任何内容替换

AbstractBase

声明。这是工作中的多态性

这里要记住的关键是，当您将

Class1

的实例表示为

AbstractBase

时。。它仅作为

AbstractBase

可见。因此，根据上述代码。。这行不通：

AbstractBase A = new Class1();
A.ClassOneFunction(); // won't work because Function2 is a function of Class1

不起作用的那个：

Class2 C = new Class2();

…是因为您代码中的

Class2

是

抽象的
。您不能简单地实例化
抽象类的实例。他们将从……那里继承。。没有实例化

不一致的可访问性错误是因为
内部
比
公共
更难访问。如果您的方法是
内部
。。那么它在程序集外部就不可见了。
你把所有东西都命名得非常糟糕。。。这让人困惑。如果您使
基类
实际上是基类。。那么它应该更有意义：

public abstract class AbstractBase {
    public void BaseFunction(){
        Debug.Log("2");
    }
}

public class Class1 : AbstractBase {
    public void ClassOneFunction(){
        Debug.Log("Base");
    }
}
public abstract class Class2 : Class1 {
    public void ClassTwoFunction(){
        Debug.Log("1");
    }
}

现在，如果我们重新处理您的问题，您会得到如下结果：

AbstractBase A = new Class1();

您将
Class1
的一个实例表示为
AbstractBase
，这很好。您可以用继承自
AbstractBase
的任何内容替换
AbstractBase
声明。这是工作中的多态性

这里要记住的关键是，当您将
Class1
的实例表示为
AbstractBase
时。。它仅作为
AbstractBase
可见。因此，根据上述代码。。这行不通：

AbstractBase A = new Class1();
A.ClassOneFunction(); // won't work because Function2 is a function of Class1

不起作用的那个：

Class2 C = new Class2();

…是因为您代码中的
Class2
是
抽象的
。您不能简单地实例化
抽象类的实例。他们将从……那里继承。。没有实例化

不一致的可访问性错误是因为
内部
比
公共
更难访问。如果您的方法是
内部
。。那么它在程序集外部就不可见了。
你把所有东西都命名得非常糟糕。。。这让人困惑。如果您使
基类
实际上是基类。。那么它应该更有意义：

public abstract class AbstractBase {
    public void BaseFunction(){
        Debug.Log("2");
    }
}

public class Class1 : AbstractBase {
    public void ClassOneFunction(){
        Debug.Log("Base");
    }
}
public abstract class Class2 : Class1 {
    public void ClassTwoFunction(){
        Debug.Log("1");
    }
}

现在，如果我们重新处理您的问题，您会得到如下结果：

AbstractBase A = new Class1();

您将
Class1
的一个实例表示为
AbstractBase
，这很好。您可以用继承自
AbstractBase
的任何内容替换
AbstractBase