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()
        {
           //什么都访问不到
        }
    } 

 

What is the difference between 'protected' and 'protected internal'?

- Update answer 2019 -

You can find the difference in below table based accessibility is yes,

 

Google Bard的解答

The main difference between protected and protected internal is that protected internal members can be accessed from code in the same assembly, or from code in a derived class in another assembly. Protected members can only be accessed from code in the same assembly, or from code in a derived class in the same assembly.

For example, let's say we have a class called Shape that has a protected member called area. We can then create a derived class called Circle that inherits from Shape. The Circle class can then access the area member, because it is a derived class of Shape.

However, a class that is not related to Shape cannot access the area member, unless it is in the same assembly. For example, the following code will not compile:

Code snippet

class OtherClass {
  void doSomething() {
    Shape shape;
    shape.area = 10; // This will not compile.
  }
}

Use code with caution. Learn more

 

This is because the OtherClass class is not related to the Shape class. It is not a derived class of Shape, and it is not in the same assembly as Shape.

However, the following code will compile:

Code snippet

class OtherClass {
  void doSomething() {
    Circle circle;
    circle.area = 10; // This will compile.
  }
}

Use code with caution. Learn more

 

This is because the OtherClass class is in the same assembly as Circle, and Circle is a derived class of Shape.

In general, you should use protected internal members when you want to allow code in other assemblies to access the member, but only if the code is derived from the class that declares the member. You should use protected members when you only want to allow code in the same assembly to access the member, or code in a derived class in the same assembly.

 

 

作者:Chuck Lu    GitHub