内部受保护的属性仍然可以从不同的程序集访问

Question

I'm setting up some demo code for a beginner session on accessibility and I found that I am able to access an internal protected property from a derived class. What am I missing?

Assembly 1

namespace Accessibility
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass c = new ExampleClass();
            c.Go();
            //c.Prop1 = 10;
        }
    }

    class ExampleClass : DerivedClass
    {
        public void Go()
        {
            this.Prop1 = 10;
            this.Prop2 = 10;
            //this.Prop3 = 10; //Doesn't work
            //this.Prop4 = 10; //Doesn't work
            this.Prop5 = 10; //why does this work?!

            this.DoSomething();
        }
    }
}

Assembly 2

namespace Accessibility.Models
{
    public class BaseClass
    {
        public int Prop1 { get; set; }
        protected int Prop2 { get; set; }
        private int Prop3 { get; set; }

        internal int Prop4 { get; set; }
        internal protected int Prop5 { get; set; }
        //internal public int Prop6 { get; set; } //Invalid 
        //internal private int Prop7 { get; set; } //Invalid

        public BaseClass()
        {
            this.Prop3 = 27;
        }
    }

    public class DerivedClass : BaseClass
    {
        public void DoSomething()
        {
            this.Prop1 = 10;
            this.Prop2 = 10;
            //this.Prop3 = 10; //Doesn't work
            this.Prop4 = 10;
            this.Prop5 = 10;

            PropertyInfo Prop3pi = typeof(DerivedClass).GetProperty("Prop3", BindingFlags.Instance | BindingFlags.NonPublic);
            int value = (int)Prop3pi.GetValue(this, null);
        }
    }
}

Notice in ExampleClass.Go I can set a value to Prop5. Why? It's marked as internal protected but I can't set a value on Prop4 (marked as internal)

Answer 1

internal protected means "internal to the assembly OR an inherited class". So yes, if you have a public class with an protected internal member, another class that inherits that type in a different assembly can still access it because of the protected modifier:

protected internal

The type or member can be accessed by any code in the assembly in which it is declared, or from within a derived class in another assembly. Access from another assembly must take place within a class declaration that derives from the class in which the protected internal element is declared, and it must take place through an instance of the derived class type.

Reference: http://msdn.microsoft.com/en-us/library/ms173121.aspx

This is a limitation of the C# language. The CLR supports the "Internal AND Protected" notion. There is evidence of this with the MethodAttributes.FamANDAssem enumeration if you were emitting your own IL. If you really wanted this feature, you could do some IL post processing with something like Mono.Cecil. Why the C# language does not expose this is only a guess: little need for it.

Answer 2

Because it's how internal protected is intended to work. Access is given for either children in inheritance tree ( protected part) or for the same assembly ( internal part) - see Access Modifiers on MSDN .

And your ExampleClass is in the inheritance tree of BaseClass , which defines Prop5 . So the access is thanks to protected part.

Answer 3

By combining the protected and internal keywords, a class member can be marked protected internal — only derived types or types within the same assembly can access that member.

This MSDN article answers all your questions.

Answer 4

It looks like protected internal means protected or internal .

Answer 5

Basically, it doesn't seem to work like that.

See - http://msdn.microsoft.com/en-us/library/ba0a1yw2(VS.80).aspx

protected internal acts as an OR - access is restricted to derived classes or to the current assembly.

Answer 6

The protected keyword is a member access modifier. A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.

http://msdn.microsoft.com/en-us/library/bcd5672a(v=vs.71).aspx

By combining the protected and internal keywords, a class member can be marked protected internal — only derived types or types within the same assembly can access that member.

http://msdn.microsoft.com/en-us/library/ms173121(v=vs.80).aspx

Answer 7

Protected means that it is shared only with descendant classes, only private means that it can't be accessed by anyone else.

Edit: Hans comment makes your question a little more clear. When you combine modifiers like that, they combine inclusively not exclusively. It is accesse in all the ways internal or protected can be.

Answer 8

Late answer but I got caught with the same issue. Eventualy I came up with a partial solution.

    internal Int MyInt
    {
        get;
        protected set;
    }

It is still visible within the assembly but at least only inherithing classes can actualy change it. It is enough for what I wanted.