Quelle est la différence entre "privé" et "protégé interne"?

• Un protected internal membre est visible à tout le code dans l'actuelle assemblée ou dans une classe dérivée d'une autre assemblée. En termes techniques, c'est la disjonction logique de protected et internal.
• Un private membre est visible uniquement code dans la même classe.

protected internal est en fait le deuxième plus permissif modificateur d'accès après public.

Il est intéressant de noter que protected est sans doute plus permissive que internalcar il permet l'accès à partir du code que vous n'avez aucun contrôle sur (c'est à dire d'autres assemblées). Alors que internal permet l'accès à partir tous du code dans l'assemblée, ce code est le vôtre et que vous avez le contrôle!

Pour paraphraser, protected (et protected internal) les membres font partie de l'API publique de votre assemblée (et doit donc être documentée). internal membres ne le sont pas.

private est seulement visible par les propres membres de la classe, alors que protected internal est visible à l'enfant des classes ainsi que à d'autres classes à l'intérieur de l'espace de noms de la collection.

Je pense que les protégés interne signifie que seules les classes qui en héritent et sont dans la même assemblée peut voir que la propriété. Ceux qui dérivent de la classe et de différents assemblée, ne peut pas la voir.

LE: lire Mattias Buelens commentaire pour cette.

J'essayais de comprendre les différences entre les protégés interne et interne .NET contexte par la lecture de la description fournie différents forums et blogs. J'ai vraiment pas compris alors j'ai créé a créé 2 assemblée distincte à l'aide de VS2015. Probablement maintenant, j'ai une compréhension de base. Je voudrais partager avec vous, il pourrait être utile à quelqu'un. J'ai essayé d'utiliser les champs déclarés dans une assemblée à partir d'une autre assemblée. Aussi j'ai essayé dérivée d'une classe qui a été déclarée dans une autre assemblée.
Voici le code pour class1.cs de l'assemblée 1

namespace Z_Dll_1
{
    public class PublicBaseClassAssemblyOne
    {
        internal int _myinternal = 200;
        protected internal int _protectedinternal = 100;
        protected int _myProtected = 123;
        private int _myPrivate = 2;
        public int _myPublic = 45;
    }

    public class DerivedClassAssemblyOne : PublicBaseClassAssemblyOne
    {
        protected internal int intM = 10;
    }

    internal class MyInternalClass
    {
        public void MyMethod()
        {
            Console.WriteLine("Method one with internal class");
            PublicBaseClassAssemblyOne cl1 = new PublicBaseClassAssemblyOne();
            cl1._myinternal = 1000; //Internal type is available since it is in same assembly
            cl1._protectedinternal = 10; //protected internal is available
            cl1._myPublic = 2;  //Public OK
            //cl1.myPrivate = ?? //nor available since it is private

            DerivedClassAssemblyOne drOne = new DerivedClassAssemblyOne();
            drOne._myinternal = 30; //Internal and available from derived class
            drOne._myPublic = 1; //Public 
            drOne._protectedinternal = 2; //Able to be accessed from same assembly or derived class from other assembly
        }
    }
}

Voici le code à partir d'une autre assemblée, class2.cs
à l'aide de Z_Dll_1;

namespace Z_Dll_2
{
    public class ClassAssembly2
    {
        public ClassAssembly2()
        {
            PublicBaseClassAssemblyOne classfromOtherAssembly = new PublicBaseClassAssemblyOne();
            classfromOtherAssembly._myPublic = 0; //Only public is available
        }
    }

    public class ClassDerivedFromOtherAssemblyClass : PublicBaseClassAssemblyOne
    {
        public ClassDerivedFromOtherAssemblyClass()
        {
        }
        void ClassDerivedFromOtherAssemblyClassTestMethod()
        {
            //_myinternal = 200; //can't access since it was internal to other assembly
            _protectedinternal = 100; //this can be accessed as it is  derived class from other class that has protected internal 
            _myProtected = 123; //Ordinary protected data accessed from derived class
            //_myPrivate = 2; //Private member can't be accessed from  derived class
            _myPublic = 45; //Public can be accessed anyway

            //Try to create an instance of internal class
            //MyInternalClass intClass = new MyInternalClass(); //Not accessible from this assembly
        }
    }
}