acceso - diferencia entre private y protected c#

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

Question

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?

Answer 1

Modificadores de acceso

público

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

privado

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

protegido

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

Protegido privado (agregado en C # 7.2)

Solo se puede acceder al tipo o miembro por código en la misma clase o estructura, o en una clase derivada del mismo ensamblado, pero no desde otro ensamblado.

interno

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

protegido interno

Se puede acceder al tipo o miembro mediante cualquier código en el mismo ensamblaje, o mediante cualquier clase derivada en otro ensamblaje.

Cuando no se establece ningún modificador de acceso, 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 en una clase significa que la clase no puede ser instanciada, y que todos sus miembros son estáticos. Un miembro estático tiene una versión, independientemente de la cantidad de instancias de su tipo envolvente que se crean.

Una clase estática es básicamente lo mismo que una clase no estática, pero hay una diferencia: una clase estática no puede ser instanciada 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.

Sin embargo, existe tal cosa como un constructor estático . Cualquier clase puede tener uno de estos, incluyendo clases estáticas. No pueden llamarse directamente y no pueden tener parámetros (aparte de cualquier tipo de parámetros en la propia 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 se usan a menudo como servicios, puede usarlas así:

MyStaticClass.ServiceMethod(...);

Answer 2

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

Answer 3

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

Answer 4

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.

Answer 5

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.

Answer 6

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.

Answer 7

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.

Answer 8

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

Answer 9

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

Answer 10

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

Answer 11

Un resumen gráfico (resumen en pocas palabras)

Para los valores predeterminados si no coloca un modificador de acceso en frente, vea aquí:
¿Visibilidad predeterminada para las clases y miembros de C # (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

Answer 12

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.

Answer 13

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.

Answer 14

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.