C# Language => 액세스 수정 자

비고

액세스 한정자가 생략되면,

클래스는 기본적으로 internal 클래스입니다.
메소드는 deault에 의해 private
getter 및 setter는 속성의 수정자를 상속받습니다. 기본적으로이 속성은 private

setter 또는 속성 getter의 액세스 한정자는 액세스를 제한하고 넓히지 않을 수 있습니다. public string someProperty {get; private set;}

공공의

public 키워드는 모든 소비자가 사용할 수있는 클래스 (중첩 클래스 포함), 속성, 메서드 또는 필드를 만듭니다.

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

은밀한

private 키워드는 클래스 내에서만 사용할 속성, 메서드, 필드 및 중첩 클래스를 표시합니다.

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

내부의

internal 키워드는 동일한 어셈블리의 모든 소비자가 사용할 수있는 클래스 (중첩 클래스 포함), 속성, 메서드 또는 필드를 만듭니다.

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

테스트 어셈블리가 AssemblyInfo.cs 파일에 코드를 추가하여 코드에 액세스 할 수 있도록하려면 다음과 같이하십시오.

using System.Runtime.CompilerServices;

[assembly:InternalsVisibleTo("MyTests")]

보호 된

protected 키워드는 fields, methods 속성 및 중첩 클래스를 동일한 클래스 및 파생 클래스 내에서만 사용하도록 표시합니다.

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
    }
}

보호 된 내부

protected internal 키워드는 다른 어셈블리의 동일한 어셈블리 또는 파생 클래스 내에서 사용할 필드, 메서드, 속성 및 중첩 클래스를 표시합니다.

어셈블리 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();
    }
}

어셈블리 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();
    }
}