C# Language => Zugriffsmodifizierer

Bemerkungen

Wenn der Zugriffsmodifizierer weggelassen wird,

Klassen sind standardmäßig internal
Methoden sind von doult private
Getter und Setter erben den Modifizierer der Eigenschaft, standardmäßig ist dies private

Zugriffsmodifizierer für Setter oder Eigenschaften von Eigenschaften können den Zugriff nur einschränken, nicht erweitern: public string someProperty {get; private set;}

Öffentlichkeit

Das Schlüsselwort public stellt jedem Verbraucher eine Klasse (einschließlich verschachtelter Klassen), Eigenschaften, Methoden oder Felder zur Verfügung:

public class Foo()
{
    public string SomeProperty { get; set; }

    public class Baz
    {
        public int Value { get; set; }
    }
}

public class Bar()
{
    public Bar()
    {
        var myInstance = new Foo();
        var someValue = foo.SomeProperty;
        var myNestedInstance = new Foo.Baz();
        var otherValue = myNestedInstance.Value;
    }        
}

Privatgelände

Das private Schlüsselwort kennzeichnet Eigenschaften, Methoden, Felder und verschachtelte Klassen, die nur innerhalb der Klasse verwendet werden können:

public class Foo()
{
    private string someProperty { get; set; }

    private class Baz
    {
        public string Value { get; set; }
    }

    public void Do()
    {
        var baz = new Baz { Value = 42 };
    }
}

public class Bar()
{
    public Bar()
    {
        var myInstance = new Foo();

        // Compile Error - not accessible due to private modifier
        var someValue = foo.someProperty;
        // Compile Error - not accessible due to private modifier
        var baz = new Foo.Baz();
    }
}

intern

Das interne Schlüsselwort macht eine Klasse (einschließlich verschachtelter Klassen), eine Eigenschaft, eine Methode oder ein Feld für jeden Benutzer in derselben Assembly verfügbar:

internal class Foo
{
    internal string SomeProperty {get; set;}
}

internal class Bar
{
    var myInstance = new Foo();
    internal string SomeField = foo.SomeProperty;

    internal class Baz
    {
        private string blah;
        public int N { get; set; }
    }
}

Dies kann unterbrochen werden, damit eine Test-Assembly durch Hinzufügen von Code zur AssemblyInfo.cs-Datei auf den Code zugreifen kann:

using System.Runtime.CompilerServices;

[assembly:InternalsVisibleTo("MyTests")]

geschützt

Das Feld für das protected Schlüsselwort kennzeichnet die Methodeneigenschaften und die verschachtelten Klassen, die nur innerhalb derselben Klasse und derselben abgeleiteten Klassen verwendet werden:

public class Foo()
{
    protected void SomeFooMethod()
    {
        //do something
    }

    protected class Thing
    {
        private string blah;
        public int N { get; set; }
    }
}

public class Bar() : Foo
{
    private void someBarMethod()
    {
        SomeFooMethod(); // inside derived class
        var thing = new Thing(); // can use nested class
    }
}

public class Baz()
{
    private void someBazMethod()
    {
        var foo = new Foo();
        foo.SomeFooMethod(); //not accessible due to protected modifier
    }
}

intern geschützt

Das protected internal Schlüsselwort kennzeichnet Feld, Methoden, Eigenschaften und verschachtelte Klassen zur Verwendung in derselben Assembly oder abgeleiteten Klassen in einer anderen Assembly:

Montage 1

public class Foo
{
    public string MyPublicProperty { get; set; }
    protected internal string MyProtectedInternalProperty  { get; set; }

    protected internal class MyProtectedInternalNestedClass
    {
        private string blah;
        public int N { get; set; }
    }
}

public class Bar
{
    void MyMethod1()
    {
        Foo foo = new Foo();
        var myPublicProperty = foo.MyPublicProperty;
        var myProtectedInternalProperty = foo.MyProtectedInternalProperty;
        var myProtectedInternalNestedInstance =
            new Foo.MyProtectedInternalNestedClass();
    }
}

Montage 2

public class Baz : Foo
{
    void MyMethod1()
    {
        var myPublicProperty = MyPublicProperty;
        var myProtectedInternalProperty = MyProtectedInternalProperty;
        var thing = new MyProtectedInternalNestedClass();
    }

    void MyMethod2()
    {
        Foo foo = new Foo();
        var myPublicProperty = foo.MyPublicProperty;

        // Compile Error
        var myProtectedInternalProperty = foo.MyProtectedInternalProperty;
        // Compile Error
        var myProtectedInternalNestedInstance =
            new Foo.MyProtectedInternalNestedClass();
    }

}

public class Qux
{
    void MyMethod1()
    {
        Baz baz = new Baz();
        var myPublicProperty = baz.MyPublicProperty;

        // Compile Error
        var myProtectedInternalProperty = baz.MyProtectedInternalProperty;
        // Compile Error
        var myProtectedInternalNestedInstance =
            new Baz.MyProtectedInternalNestedClass();
    }

    void MyMethod2()
    {
        Foo foo = new Foo();
        var myPublicProperty = foo.MyPublicProperty;

        //Compile Error
        var myProtectedInternalProperty = foo.MyProtectedInternalProperty;
        // Compile Error
        var myProtectedInternalNestedInstance =
            new Foo.MyProtectedInternalNestedClass();
    }
}