Protected vs protected internal (Again) in c#

http://stackoverflow.com/questions/22940317/protected-vs-protected-internal-again-in-c-sharp

protected means that you can access the member from any subtype (and of course from the declaring type itself). So regardless of where that subtype is, even if it is in another assembly, you will still have access to all protected members.

 

internal means that you can access the member from any type in the same assembly. So even a completely unrelated class that lives in the same assembly can access the member.

 

protected internal combines both, meaning that both apply separately. So you can access the member from any subtype, and you can also access the member from any type in the same assembly.

 

// Assembly 1
class A {
    protected int foo;
    internal int bar;
    protected internal int baz;
}

class B : A {} // can access: foo, bar, baz
class C {} // can access: bar, baz                  protected类型的foo无法被访问，所以protected internal访问范围比protected高

// Assembly 2
class D : A {} // can access: foo, baz              internal类型的bar无法被访问，所以protected internal访问范围比internal高
class E {} // can access neither

 

在Assembly1内部

public class A
    {
        protected int foo;
        internal int bar;
        protected internal int baz;
    }

    /// <summary>
    /// can access: foo, bar, baz
    /// </summary>
    public class B : A
    {
        void Method()
        {
            A a = new A();
            //a.foo = 1;
            //can not access protected member 'A.foo' via a qualifier of type 'A'
            //the qualifier must be of type of B(or derive from it)
            a.bar = 2;
            a.baz = 3;

            B b = new B();
            b.foo = 1;
            b.bar = 2;
            b.baz = 3;
        }
    }

    /// <summary>
    /// can access: bar, baz
    /// </summary>
    class C
    {
        void Method()
        {
            A a = new A();
            //a.foo = 1;  A.foo is inaccessible due to its protectionlevel
            a.bar = 2;
            a.baz = 3;

            B b = new B();
            //b.foo = 1;  A.foo is inaccessible due to its protectionlevel
            b.bar = 2;
            b.baz = 3;
        }
    }

 

 

 

在Assembly2内部，AssemblyB将AssemblyA添加为引用

    /// <summary>
    /// can access: foo, baz
    /// </summary>
    class D : A
    {
        void Method()
        {
            A a = new A();
            //a.foo = 1;
            //can not access protected member 'A.foo' via a qualifier of type 'A'
            //the qualifier must be of type of B(or derive from it)

            //a.bar = 2;   //A.bar is inaccessible due to its protection level

            //a.baz = 3;
            //can not access protected member 'A.foo' via a qualifier of type 'A'
            //the qualifier must be of type of B(or derive from it)

            B b = new B();
            //b.foo = 1;
            //can not access protected member 'A.foo' via a qualifier of type 'B'
            //the qualifier must be of type of D(or derive from it)

            //b.bar = 2;  //A.bar is inaccessible due to its protection level

            //b.baz = 3;  
            //can not access protected member 'A.foo' via a qualifier of type 'B'
            //the qualifier must be of type of D(or derive from it)

            D d = new D();
            d.foo = 1;
            //d.bar = 2; //A.bar is inaccessible due to its protection level
            d.baz = 3;
        }
    } 

    /// <summary>
    /// can access neither
    /// </summary>
    class E
    {
        void Method()
        {
           //什么都访问不到
        }
    }