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

Public - Si puedes ver la clase, entonces puedes ver el método

Private - Si eres parte de la clase, entonces puedes ver el método, de lo contrario no.

Protected - Igual que Private, más todos los descendientes también pueden ver el método.

Static (class) - ¿Recuerda la distinción entre" Class "y" Object"? Olvida todo eso. Son lo mismo con "estática"... la clase es la única instancia de sí mismo.

Static (method) - Cada vez que use este método, tendrá un marco de referencia independiente de la instancia real de la clase de la que forma parte.

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

Para los valores predeterminados si no pone ningún modificador de acceso delante, 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

Respecto a la cuestión de Nada

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

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

Hmm.

Vea aquí: Modificadores de acceso.

En pocas palabras:

Public da al método o tipo visibilidad completa de otros tipos/clases.

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

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

"Nada" es VB.NET es equivalente a null. Aunque si se refiere a "nada" que significa "no modificador de acceso", entonces depende, aunque una regla general muy aproximada (ciertamente en C#) es que si no especifica explícitamente un modificador de acceso, la declaración de método/variable suele ser restricted 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 acceso modificador especificado explícitamente.

Public - puede ser accedido por cualquier persona en cualquier lugar.
private - solo se puede acceder desde con en la clase de la que forma parte.
protected - solo se puede acceder desde con en la clase o cualquier objeto que hereda fuera de la clase.

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

Reposting the awesome diagrams from this answer.

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

private:

private protected: - añadido en C# 7.2

internal:

protected:

protected internal:

public:

Mmm...

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

Se puede acceder directamente desde la definición de la clase.

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

"de la tabla anterior podemos ver la deferencia entre privado y protegido... estoy creo que ambos son iguales.... así que lo que la necesidad de que dos comandos separados"

Compruebe MSDN enlace para más información

Esos modificadores de acceso especifican dónde están visibles sus miembros. Probablemente deberías 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.

Tenga cuidado con la accesibilidad de sus clases. Las clases y métodos públicos y protegidos son accesibles por defecto para todos.

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

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

C # tiene en total 6 modificadores de acceso:

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

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 de la asamblea que contiene este miembro, no es visible para ninguna asamblea fuera de la asamblea que contiene. es decir, el acceso está limitado a contener solo el ensamblado.

Interno protegido: El miembro declarado con este la accesibilidad puede ser visible dentro de los tipos derivados del tipo que contiene dentro o fuera del ensamblaje que contiene, también es visible para cualquier tipo dentro del ensamblaje que contiene. es decir, el acceso se limita a contener tipos ensamblados o derivados.

Public: El miembro declarado con esta accesibilidad puede ser visible dentro de la asamblea que contiene a este miembro, o cualquier otra asamblea que haga referencia a la asamblea que contiene. es decir, el acceso no está limitado.

C # 7.2 es añadir un nuevo nivel de accesibilidad:

Private protected: El miembro declarado con esta accesibilidad puede ser visible dentro de los tipos derivados de este tipo contenedor dentro del ensamblado contenedor. No es visible para ningún tipo no derivado del tipo que contiene, o fuera del conjunto que contiene. es decir, el acceso está limitado a tipos derivados dentro del ensamblado que contiene.

Fuente incluyendo un código de ejemplo del nuevo acceso protegido privado modificador