The below source code is just for future reference, since I had
problems understanding the use of access modifiers "protected" and
"protected internal" with the examples on the net.   Nothing beats
doing a demonstration program yourself however.

Actually the below example doesn't show how using "protected internal"
will allow you access of a member from outside the namespace the
member class is found in, but you get the picture.

Sorry for any line breaks, but I copied and pasted from Word.

Program shows:  how even private members of a enclosing class can be
accessed by the nested class enclosed by the enclosing class; how
protected/ protected internal works; how you can instantiate either
the nested class, the enclosing class, or both; how instantiation by
"new" overrides and/or is required by a nested class, to access the
enclosing class.

Frankly I think the access modifiers in C# are more confusing and can
lead to spagetti code quicker than C++, but that's another matter.

RL

using System;
using System.Collections.Generic;
using System.Text;

namespace nestc001
{

   /// <summary>
   /// Summary Using Nested classes with access modifier "protected
internal"
   /// </summary>
   ///
   class NestedOuterClass1
   {
       private int magic_no;
       public int magic_noPublic;
       public int[] arr_outerCl;
       public NestedInterClass0 mySeemingViolationInnerClass;
       public NestedInnerClassTWO
my2ndInnerClassThatCanAccessPrivateMembersOfOuterClass;

       public NestedOuterClass1()
       {
           magic_no = 1111111;
           magic_noPublic = 999;
           arr_outerCl = new int[3] { 111, 222, 333 };
           mySeemingViolationInnerClass = new
NestedInterClass0(69);  //works, despite being protected, since
'protected AND internal' (more expansive)
           my2ndInnerClassThatCanAccessPrivateMembersOfOuterClass =
new NestedInnerClassTWO();

       } //end of constructor for outer class

       protected int[] Function01NestedOuterClass1(NestedInterClass0
O)
       {
           arr_outerCl = new int[3];
           arr_outerCl = O.arr_innerCl;
           return arr_outerCl;
       }

       public int[] Function02NestedOuterClass2(NestedInterClass0 O)
       {

           arr_outerCl = O.arr_innerCl;
           return arr_outerCl;
       }

       public int[] interfaceFunction01NestedOuterClass1()
       {
           NestedInterClass0 Internal_ICl = new NestedInterClass0();
           // BTW:  Internal_ICl.// cannot see any outer class member
here, since 'temp' and 'local', but other inner class
mySeemingViolationInnerClass can!
           arr_outerCl = Function01NestedOuterClass1(Internal_ICl);
           return arr_outerCl;
       }

       public int[] return_the_arr_outerCl_noMatterWhatItIs()
       {
           return arr_outerCl;

       }

       public void Access_even_internal_members()
       {
           // mySeemingViolationInnerClass.//nothing from outer class
or second inner class accessible here
           //
my2ndInnerClassThatCanAccessPrivateMembersOfOuterClass.jay = 0;
       }

       // protected class NestedInterClass0 doesn't give sufficent
privileged to any class other than the enclosed class (outer class) to
run any function, even if labeled 'public', so changed to 'protected
internal'

       protected internal class NestedInterClass0
       {
           public int j;
           public int[] arr_innerCl;
           public NestedInterClass0()
           {
               arr_innerCl = new int[3] { 10, 20, 30 };
               j = 1001;

           }
           public NestedInterClass0(int i)
           {
               j = i;
               arr_innerCl = new int[3] { 55, 66, 77 };
           }

           public int NestInnerC0Function()
           {
               return 1;
           }
           public int[] change_the_arr_innerCl()
           {
               for (int i = 0; i < 3; i++)
               {
                   arr_innerCl[i] = i * i; //0,1,4

               }
               return arr_innerCl;
           }
       }

       public class NestedInnerClassTWO
//second nested inner class, this time access modifier is public, so
this class can access enclosing outer class private numbers
       {
           public int jay;
           public NestedInnerClassTWO()
           {
               jay = 1;
               // jay = NestedOuterClass1.//nothing!  cannot access
any members of outerclass
           }

           public int MyNICTWOfunction ()
           {
               NestedOuterClass1 myNOC1 = new NestedOuterClass1(); //
instantiation req'd!
              // myNOC1.magic_no = 100000; //can override private
number if you want...
               return myNOC1.magic_no; // no overriding, should get
magic_no = 1111111;

           }
           public int MyNICTWOfunction2()
           {
               NestedOuterClass1 myNOC1 = new NestedOuterClass1(); //
instantiation req'd
               return myNOC1.magic_noPublic;

           }
       }
   }

   public static class Tester
   {
       public static void MMain()
       {
           int[] TestArr = new int[3];

           NestedOuterClass1 myNestedOuterClass1 = new
NestedOuterClass1();

           NestedOuterClass1.NestedInterClass0 myNIC0 = new
NestedOuterClass1.NestedInterClass0();
           Console.WriteLine("myNIC0 reached, since 'protected
internal',NestedInterClass0, with magic #:{1}, magic# public: {2}!",
myNIC0.NestInnerC0Function(),
myNestedOuterClass1.my2ndInnerClassThatCanAccessPrivateMembersOfOuterClass.MyNICTWOfunction(),
myNestedOuterClass1.my2ndInnerClassThatCanAccessPrivateMembersOfOuterClass.MyNICTWOfunction2());

           TestArr = myNestedOuterClass1.arr_outerCl;
           int ll01 = TestArr.Length;

           for (int i = 0; i < ll01; i++)
           {
               Console.WriteLine("TestArr[{0}] is: {1}", i,
TestArr[i]);

           }

           TestArr =
myNestedOuterClass1.interfaceFunction01NestedOuterClass1();

           for (int i = 0; i < ll01; i++)
           {
               Console.WriteLine("TestArr(2)[{0}] is: {1}", i,
TestArr[i]);

           }

           myNIC0.change_the_arr_innerCl();

           myNestedOuterClass1.Function02NestedOuterClass2(myNIC0);
           TestArr =
myNestedOuterClass1.return_the_arr_outerCl_noMatterWhatItIs();

           for (int i = 0; i < ll01; i++)
           {
               Console.WriteLine("TestArr(3)[{0}] is: {1}", i,
TestArr[i]);

           }

       }
   }
}

/*
/////////// output, after running class Tester from inside of main():

myNIC0 reached, since 'protected internal',NestedInterClass0, with
magic #:11111
11, magic# public: 999!
TestArr[0] is: 111
TestArr[1] is: 222
TestArr[2] is: 333
TestArr(2)[0] is: 10
TestArr(2)[1] is: 20
TestArr(2)[2] is: 30
TestArr(3)[0] is: 0
TestArr(3)[1] is: 1
TestArr(3)[2] is: 4
Press any key to continue . . .
*/