Explicación detallada de las palabras clave internas en C#

1. Interno
Todos conocemos los tres tipos/modificadores de miembros public, protected y private, y también entendemos los significados que representan. Internal también es un modificador de tipo/miembro (el tipo o miembro modificado se denomina tipo o miembro interno) , pero solo se puede acceder a la clase que modifica en el mismo ensamblado, y el mismo ensamblado significa el mismo ensamblado dll o el mismo ensamblado exe. Un proyecto en vs generará un archivo dll, por lo que este dll o este proyecto también es un ensamblaje.
Por ejemplo, hay un ensamblado con:

namespace Common
{
    internal class A
    {
        public void aa()
        {
        }
    }
    public class B
    {
        public void bb()
        {
            //这样是正确的
            A a = new A();
            a.aa();
        }
    }
} 

Si otro proyecto TestWeb hace referencia a este dll, common.dll, es decir

using Common;
namespace TestWeb
{
    public class Test
    {
        public void test_1()
        {
            //这样是出错的
            A a = new A();
            a.aa();
 
            //这样是正确的
            B b = new B();
            b.bb();
        }
    }
}

El acceso interno se usa a menudo en el desarrollo basado en componentes porque permite que un conjunto de componentes cooperen de manera privada sin tener que estar expuestos al resto del código de la aplicación. Por ejemplo, un marco para generar interfaces gráficas de usuario podría proporcionar clases de Control y Formulario que cooperen mediante el uso de miembros con derechos de acceso internos. Dado que estos miembros son internos, no están expuestos al código que usa el marco.
2. Protected internal
En general, un miembro o tipo solo puede tener un modificador de acceso, excepto cuando se usa una combinación protected internal, su acceso está limitado al ensamblado actual o al tipo derivado de la clase que lo contiene. Es decir, podemos acceder a él en este ensamblaje y también podemos heredar el acceso en otros ensamblajes.
como sigue:
 

namespace Common
{
    protected internal class C
    {
        public void cc()
        {
        }
    }
} 
 
namespace TestWeb
{
    public class TestA
    {
        public void test_1()
        {
            //这样是出错的
            Common.C c = new Common.C();
            c.cc();
        }
    }
    public class TestB : Common.C
    {
        public void test_2()
        {
            //这样是正确的
            C c = new C();
            c.cc();
        }
    }
}

Además, se adjuntan las características del conjunto:

1. Un ensamblado es el componente básico de cualquier aplicación de .NET Framework. Por ejemplo, al compilar una aplicación C# simple, Visual Studio crea un ensamblaje en forma de un solo archivo ejecutable portátil (PE), específicamente un EXE o DLL.
2. Contiene metadatos que describen su propio número de compilación y detalles de todos los tipos de datos y objetos que contienen.
3. Cargue solo cuando sea necesario. Si no se utiliza el conjunto, no se cargará. Esto significa que los ensamblajes pueden ser una forma efectiva de administrar recursos en proyectos grandes.
4. Puede contener uno o más módulos. Por ejemplo, al planificar un proyecto más grande, puede hacer que varios desarrolladores individuales trabajen en módulos individuales y creen un solo ensamblaje combinando todos estos módulos.