c# - que - ¿Cómo usar la reflexión para determinar si una clase es interna?

propiedades get c#

Question

Como dice el título, ¿cómo usa la reflexión para verificar si una definición de clase se define como interna? "typeof (...)" devuelve ciertas propiedades que se muestran a continuación, pero no si una clase se define como interna. Lo busqué en Google, pero todo lo que pude encontrar fueron muchos artículos sobre cómo ejecutar métodos internos o protegidos utilizando la reflexión. No me interesan los métodos en este caso, sino la definición de clase.

var type = typeof(Customer);
Assert.IsTrue(type.IsClass);
Assert.That(type.IsAbstract, Is.EqualTo(isAbstract));
Assert.That(type.IsPublic, Is.EqualTo(isPublic));
Assert.That(type.IsPublic, Is.EqualTo(isPublic));
Assert.That(type.IsSealed, Is.EqualTo(isSealed));
Assert.That(type.IsSerializable, Is.EqualTo(isSerializable));

Answer 1

¿El método IsVisible da el valor que está buscando?

Answer 2

Ehh, no estoy muy seguro, pero por ejemplo

Public Function PublicFriendOrPrivate(t As Type) As String
    If t.IsPublic Then
        Return "Public"
    Else
        If t.IsNotPublic AndAlso t.IsNested Then
            Return "Private"
        Else
            Return "Friend"
        End If
    End If
End Function

''Nota'' Amigo ''es igual a'' Interno ''en C #.

Answer 3

Estas son algunas de las funciones que garantizan la visibilidad correcta del tipo (probablemente una implementación excesiva):

bool isPublic(Type t) {
    return
        t.IsVisible
        && t.IsPublic
        && !t.IsNotPublic
        && !t.IsNested
        && !t.IsNestedPublic
        && !t.IsNestedFamily
        && !t.IsNestedPrivate
        && !t.IsNestedAssembly
        && !t.IsNestedFamORAssem
        && !t.IsNestedFamANDAssem;
}

bool isInternal(Type t) {
    return
        !t.IsVisible
        && !t.IsPublic
        && t.IsNotPublic
        && !t.IsNested
        && !t.IsNestedPublic
        && !t.IsNestedFamily
        && !t.IsNestedPrivate
        && !t.IsNestedAssembly
        && !t.IsNestedFamORAssem
        && !t.IsNestedFamANDAssem;
}

// only nested types can be declared "protected"
bool isProtected(Type t) {
    return
        !t.IsVisible
        && !t.IsPublic
        && !t.IsNotPublic
        && t.IsNested
        && !t.IsNestedPublic
        && t.IsNestedFamily
        && !t.IsNestedPrivate
        && !t.IsNestedAssembly
        && !t.IsNestedFamORAssem
        && !t.IsNestedFamANDAssem;
}

// only nested types can be declared "private"
bool isPrivate(Type t) {
    return
        !t.IsVisible
        && !t.IsPublic
        && !t.IsNotPublic
        && t.IsNested
        && !t.IsNestedPublic
        && !t.IsNestedFamily
        && t.IsNestedPrivate
        && !t.IsNestedAssembly
        && !t.IsNestedFamORAssem
        && !t.IsNestedFamANDAssem;
}

Answer 4

Este es un problema clásico. Desde MSDN :

Las palabras clave C # protected e internal no tienen significado en IL y no se utilizan en las API de Reflection. Los términos correspondientes en IL son Family y Assembly . Para identificar un método internal utilizando Reflection, use la propiedad IsAssembly . Para identificar un método protected internal , use el IsFamilyOrAssembly .

La reflexión no expone una forma en la verificación de Type si es internal , protected o protected internal .