Comment utiliser la réflexion pour déterminer si une classe est interne?

Comme le titre l'indique, comment utilisez-vous reflection pour vérifier si une définition de classe est définie comme interne? "typeof(...) "renvoie certaines propriétés indiquées ci-dessous mais pas si une classe est définie comme interne. Regardé sur Google, mais tout ce que j'ai pu trouver était beaucoup d'articles sur l'exécution de méthodes internes ou protégées en utilisant la réflexion. Ce ne sont pas les méthodes qui m'intéressent dans ce cas, mais la définition de classe.

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));
23
demandé sur Paul Hadfield 2011-02-11 19:00:30

4 réponses

C'est un problème classique. De MSDN :

Les mots-clés C # protected et internal n'ont aucune signification dans IL et ne sont pas utilisés dans les API de réflexion. Les termes correspondants dans IL sont Family et Assembly. Pour identifier une méthode internal à L'aide de la réflexion, utilisez la propriété IsAssembly. Pour identifier une méthode protected internal, Utilisez la IsFamilyOrAssembly.

Réflexion n'expose pas de manière sur Type vérifier si il est internal, protected ou protected internal.

26
répondu jason 2011-02-11 16:39:56

La méthode IsVisible Vous donne-t-elle la valeur que vous recherchez?

8
répondu John Koerner 2011-02-11 16:09:08

Voici quelques fonctions garanties pour donner la visibilité correcte du type (probablement une implémentation exagérée): 

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;
}
3
répondu gnumaru 2017-09-23 17:12:47

Ehh, Je ne suis pas tout à fait sûr, mais par exemple 

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

'Note 'Friend' est égal à 'Internal' en C#.

0
répondu Jens 2012-10-19 18:01:05