c# modificadores ¿Cuál es la diferencia entre público, privado, protegido y sin modificador de acceso?




modificadores de acceso java (12)

Todos mis años universitarios he estado utilizando el public y me gustaría saber la diferencia entre public , private y protected .

También, ¿qué hace la static en lugar de no tener nada?


Creo que está relacionado con un buen diseño OOP. Si usted es un desarrollador de una biblioteca, desea ocultar el funcionamiento interno de su biblioteca. De esa manera, puede modificar el funcionamiento interno de su biblioteca más adelante. Así que coloca a sus miembros y sus métodos de ayuda como privados, y solo los métodos de interfaz son públicos. Los métodos que deben sobrescribirse deben estar protegidos.


Público - puede ser accedido por cualquier persona en cualquier lugar.
Privado : solo se puede acceder desde con la clase de la que forma parte.
protegido : solo se puede acceder desde dentro de la clase o cualquier objeto que se herede de la clase.

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


Hmm

Vea aquí: Modificadores de acceso .

En una palabra:

Público da el método o tipo de visibilidad completa de otros tipos / clases.

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

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

"Nada" es el equivalente de VB.NET a nulo. Aunque si se refiere a "nada" que significa "sin modificador de acceso", entonces depende, aunque una regla de oro muy aproximada (ciertamente en C #) es que si no especifica explícitamente un modificador de acceso, el método / variable La declaración es generalmente tan restringida como puede ser. es decir

public class MyClass
{
    string s = "";
}

es efectivamente lo mismo que:

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

El artículo de MSDN vinculado ofrecerá una descripción completa cuando no se especifique explícitamente un modificador de acceso.


Público : si puedes ver la clase, puedes ver el método

Privado : si eres parte de la clase, entonces puedes ver el método, de lo contrario no.

Protegido : igual que Privado, más todos los descendientes también pueden ver el método.

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

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.


Esos modificadores de acceso especifican dónde están visibles sus miembros. Probablemente debería leer esto. Tome el enlace dado por IainMH como punto de partida.

Los miembros estáticos son uno por clase y no uno por instancia.


C # tiene en total 6 modificadores de acceso:

privado : el miembro declarado con esta accesibilidad puede ser visible dentro del tipo que contiene, no es visible para ningún tipo derivado, otros tipos en el mismo conjunto o tipos fuera del conjunto que contiene. es decir, el acceso está limitado solo al tipo que contiene.

protegido : el miembro declarado con esta accesibilidad puede ser visible dentro de los tipos derivados del tipo que contiene dentro del conjunto que contiene, y los tipos derivados del tipo que contiene fuera del conjunto que contiene. es decir, el acceso está limitado a los tipos derivados del tipo que contiene.

interno : el miembro declarado con esta accesibilidad puede ser visible dentro del ensamblaje que contiene este miembro, no es visible para ningún ensamblaje fuera del ensamblaje que lo contiene. Es decir, el acceso está limitado a contener solo el ensamblaje.

protegido interno : el miembro declarado con esta accesibilidad puede ser visible dentro de los tipos derivados del tipo que contiene dentro o fuera del conjunto que contiene, también es visible para cualquier tipo dentro del conjunto que contiene Es decir, el acceso está limitado a contener ensamblajes o tipos derivados.

público : el miembro declarado con esta accesibilidad puede ser visible dentro del conjunto que contiene este miembro, o cualquier otro conjunto que haga referencia al conjunto que contiene. Es decir, el acceso no está limitado.

C # 7.2 está agregando un nuevo nivel de accesibilidad:

protegido privado : el miembro declarado con esta accesibilidad puede ser visible dentro de los tipos derivados de este tipo que contiene dentro del ensamblaje que contiene. No es visible para ningún tipo que no se derive del tipo que contiene, o fuera del conjunto que contiene. es decir, el acceso está limitado a los tipos derivados dentro del ensamblaje que contiene.

Fuente que incluye un código de muestra del nuevo modificador de acceso protegido privado


mmm ...

Estático significa que puede acceder a esa función sin tener una instancia de la clase.

Puedes acceder directamente desde la definición de la clase.


Cuida tu accesibilidad de tus clases. Las clases y los métodos públicos y protegidos son, por defecto, accesibles para todos.

Además, Microsoft no es muy explícito en mostrar modificadores de acceso (palabras clave públicas, protegidas, etc.) cuando se crean nuevas clases en Visual Studio. Por lo tanto, tenga mucho cuidado y piense acerca de la accesibilidad de su clase porque es la puerta a sus implementos internos.


Repostando los diagramas impresionantes de esta respuesta .

Aquí están todos los modificadores de acceso en los diagramas de Venn, desde más limitantes hasta más promiscuos:

private

private protected : - agregada en C # 7.2

internal :

protected

protected internal :

public


Un estado de Privado indica que solo los objetos de la misma clase pueden acceder a las variables. El estado protegido extiende ese acceso para incluir también a los descendientes de la clase.

"en la tabla anterior podemos ver la deferencia entre privado y protegido ... creo que ambos son iguales ... entonces, ¿cuál es la necesidad de ese comando separado"

Compruebe el enlace de MSDN para más información


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();
        }
    }
}

Sobre la cuestión de la Nada.

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




access-modifiers