Pregunta ¿Cuál es la diferencia entre público, privado, protegido y que no tiene ningún modificador de acceso?


Todos mis años universitarios que he estado usando public, y me gustaría saber la diferencia entre public, privatey protected?

También lo que hace static hacer en lugar de no tener nada?


620
2018-03-05 13:48


origen


Respuestas:


Modificadores de acceso

público

Se puede acceder al tipo o miembro mediante cualquier otro código en el mismo conjunto u otro conjunto que lo haga referencia.

privado

El tipo o miembro solo se puede acceder por código en la misma clase o estructura.

protegido

Solo se puede acceder al tipo o miembro mediante código en la misma clase o estructura, o en una clase derivada.

interno

Se puede acceder al tipo o miembro mediante cualquier código en el mismo ensamblaje, pero no desde otro ensamblado.

protegido interno

Se puede acceder al tipo o miembro mediante cualquier código en el mismo conjunto o por cualquier clase derivada en otro ensamblado.

Cuando sin modificador de acceso se establece, se utiliza un modificador de acceso predeterminado. Por lo tanto, siempre hay algún tipo de modificador de acceso, incluso si no está configurado.

Estático

El modificador estático de una clase significa que no se puede crear una instancia de la clase y que todos sus miembros son estáticos. Un miembro estático tiene una versión independientemente de cuántas instancias de su tipo adjunto se creen.

Una clase estática es básicamente la misma que una clase no estática, pero hay una diferencia: una clase estática no se puede instanciar externamente. En otras palabras, no puede usar la nueva palabra clave para crear una variable del tipo de clase. Como no hay una variable de instancia, puede acceder a los miembros de una clase estática utilizando el nombre de la clase en sí.

Sin embargo, existe algo así como constructor estático. Cualquier clase puede tener uno de estos, incluidas las clases estáticas. No se pueden llamar directamente y no pueden tener parámetros (que no sean parámetros de tipo en la clase). Se llama automáticamente a un constructor estático para inicializar la clase antes de que se cree la primera instancia o se haga referencia a cualquier miembro estático. Se ve como esto:

static class Foo()
{
    static Foo()
    {
        Bar = "fubar";
    }

    public static string Bar { get; set; }
}

Las clases estáticas a menudo se usan como servicios, puede usarlas de la siguiente manera:

MyStaticClass.ServiceMethod(...);

882
2018-03-05 13:55



Público - Si puedes ver la clase, entonces puedes ver el método

Privado - Si usted es parte de la clase, entonces puedes ver el método, de lo contrario no.

Protegido - Igual que Privado, más todo descendientes también puede ver el método.

Estático (clase) - ¿Recuerdas la distinción entre "Clase" y "Objeto"? Olvida todo eso. Son lo mismo con "estático" ... la clase es la única instancia de sí mismo.

Estático (método) - Siempre que utilice este método, tendrá un marco de referencia independiente de la instancia real de la clase de la que forma parte.


143
2018-03-05 14:26



Una descripción gráfica (resumen en pocas palabras)

Visibility

Para los valores predeterminados si no pones ningún modificador de acceso en el frente, mira aquí:
Visibilidad predeterminada para clases C # y miembros (campos, métodos, etc.)

No anidado

enum                              public
non-nested classes / structs      internal
interfaces                        internal
delegates in namespace            internal
class/struct member(s)            private
delegates nested in class/struct  private

Anidado:

nested enum      public
nested interface public
nested class     private
nested struct    private

129
2018-04-11 08:00



En cuanto a la pregunta de Nada

  • Los tipos de espacio de nombres son internos por defecto
  • Cualquier miembro de tipo, incluidos los tipos anidados, son privados de forma predeterminada

22
2018-03-05 17:27



enter image description here

using System;

namespace ClassLibrary1
{
    public class SameAssemblyBaseClass
    {
        public string publicVariable = "public";
        protected string protectedVariable = "protected";
        protected internal string protected_InternalVariable = "protected internal";
        internal string internalVariable = "internal";
        private string privateVariable = "private";
        public void test()
        {
            // OK
            Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(publicVariable);

            // OK
            Console.WriteLine(protectedVariable);

            // OK
            Console.WriteLine(internalVariable);

            // OK
            Console.WriteLine(protected_InternalVariable);
        }
    }

    public class SameAssemblyDerivedClass : SameAssemblyBaseClass
    {
        public void test()
        {
            SameAssemblyDerivedClass p = new SameAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }

    public class SameAssemblyDifferentClass
    {
        public SameAssemblyDifferentClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // NOT OK
            // Console.WriteLine(privateVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            //Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }
}

 using System;
        using ClassLibrary1;
        namespace ConsoleApplication4

{
    class DifferentAssemblyClass
    {
        public DifferentAssemblyClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            // Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protectedVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protected_InternalVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protected_InternalVariable);
        }
    }

    class DifferentAssemblyDerivedClass : SameAssemblyBaseClass
    {
        static void Main(string[] args)
        {
            DifferentAssemblyDerivedClass p = new DifferentAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            //Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);

            SameAssemblyDerivedClass dd = new SameAssemblyDerivedClass();
            dd.test();
        }
    }
}

16
2018-05-24 07:19



Hmm.

Mira aquí: Modificadores de acceso.

En una palabra:

Public da el método o escribe visibilidad completa desde otros tipos / clases.

Privado solo permite el tipo que contiene el método privado / acceso variable al método / variable privado (tenga en cuenta que las clases anidadas también tienen acceso a las clases privadas que contienen las variables / métodos).

Protected es similar a private, excepto que las clases derivadas también pueden acceder a métodos protegidos.

"Nothing" es el equivalente de VB.NET a null. Aunque si te refieres a "nada" que significa "sin modificador de acceso", entonces depende, aunque una regla empírica (por cierto en C #) es que si no especificas explícitamente un modificador de acceso, el método / variable declaración es usualmente como restringido como puede ser es decir

public class MyClass
{
    string s = "";
}

es efectivamente lo mismo que:

public class MyClass
{
    private string s = "";
}

El artículo enlazado de MSDN ofrecerá una descripción completa cuando no haya un modificador de acceso explícitamente especificado.


11
2018-03-05 13:53



público - puede ser accesible por cualquier persona en cualquier lugar.
privado - solo se puede acceder desde dentro de la clase de la que forma parte.
protegido - solo se puede acceder desde dentro de la clase o cualquier objeto que herede fuera de la clase.

Nada es como nulo, pero en VB.
Estático significa que tiene una instancia de ese objeto, método para cada instancia de esa clase.


8
2018-03-05 13:55