Come determinare e verificare se un tipo di montaggio è di tipo personalizzato o di tipo primitivo utilizzando la riflessione in .NET?

Question

E 'possibile verificare in fase di esecuzione se determinato tipo è il tipo di dati personalizzato o uno dei tipi di dati primitivi di .NET?

ho definito tipi definiti dall'utente nell'assemblaggio e quelle di tutti i tipi sono alcune strutture. Ho bisogno di chiamare i metodi di tipi definiti dall'utente di parametri whome sono quelle strutture. Quindi questo deve riempire i dati di conseguenza prima di chiamare quelle funzioni in fase di runtime usando reflection.

Ora Esiste un metodo disponibile in riflessione con la quale siamo in grado di pista che determinato tipo di dati è personalizzato o tipo di dati primitivi. So di attributo isclass, ma i miei tipi di dati definiti dall'utente mirati non sono classi, questi pubblici sono strutture.

Answer 1

Type.IsPrimitive

Answer 2

Una molto semplice, modo rudimentale di determing se un tipo è fornito dal BCL/CLR è:

var type = typeof(int); 
var isSystemType = type.Assembly.FullName.StartsWith("mscorlib"); 

Tenete a mente che l'utilizzo Type.IsPrimitive tornerà falso per System.String, quindi dipende da quale definizione di "primitivo" stai usando se è adatta o meno.

Answer 3

mi piacerebbe andare con qualcosa di simile:

static bool IsFundamental(this Type type) 
{ 
    return type.IsPrimitive || type.Equals(typeof(string)) || type.Equals(typeof(DateTime)); 
} 

La scelta di string e DateTime come aggiunte a the types for which IsPrimitive returns true, però, è una questione soggettiva in quanto non esiste un elenco assoluta ... la scelta finale è tua (si potrebbe voler includere decimal così, per esempio); e dovrebbe essere sicuramente essere documentato (almeno in un commento, preferibilmente uno XML).

Answer 4

In base alle informazioni in questo question, è possibile eseguire questa utilizzando il seguente codice:

public static class TypeExtensions 
{ 
    private static List<byte[]> tokens = new List<byte[]>() 
    { 
     new byte[] {0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89}, 
     new byte[] {0x31, 0xbf, 0x38, 0x56, 0xad, 0x36, 0x4e, 0x35}, 
     new byte[] {0xb0, 0x3f, 0x5f, 0x7f, 0x11, 0xd5, 0x0a, 0x3a} 
    }; 

    public static bool IsFrameworkType(this Type type) 
    { 
     if (type == null) { throw new ArgumentNullException("type"); } 

     byte[] publicKeyToken = type.Assembly.GetName().GetPublicKeyToken();  

     return publicKeyToken != null && publicKeyToken.Length == 8 
      && tokens.Contains(publicKeyToken, new ByteArrayEqualityComparer()); 
    } 
} 

L'insieme di token di chiave pubblica sono validi per NET 2.0 e superiori (tra cui .NET 4.0). La classe ByteArrayEqualityComparer assomiglia:

public class ByteArrayEqualityComparer : EqualityComparer<byte[]> 
{ 
    public override bool Equals(byte[] x, byte[] y) 
    { 
     return x != null && y != null 
        && x.Length == 8 && y.Length == 8 
        && x[0] == y[0] 
        && x[1] == y[1] 
        && x[2] == y[2] 
        && x[3] == y[3] 
        && x[4] == y[4] 
        && x[5] == y[5] 
        && x[6] == y[6] 
        && x[7] == y[7]; 
    } 

    public override int GetHashCode(byte[] obj) 
    { 
     return obj.GetHashCode(); 
    } 
} 

Si potrebbe quindi utilizzare questo metodo come:

Debug.WriteLine("Is type `string` a .NET Framework type? {0}", 
    typeof(string).IsFrameworkType()); 

Answer 5

Sembra che avete la necessità di distinguere tra i tipi che avete fatto voi da tutto il resto. Basta creare un attributo personalizzato che si mette su ognuno dei tipi, come questo:

[CustomAttribute] 
struct MyDataType 
{ 
.... 
} 

Un'altra opzione è quella di creare un'interfaccia che tutti i propri tipi personalizzati attrezzo. Quindi è facile vedere se è necessario fare qualcosa di speciale con quell'istanza facendo semplicemente if (x is ICustom) ....

Se è possibile inserirli tutti nello stesso spazio dei nomi o assieme, è anche facile controllarli con il riflesso.

Answer 6

Potreste essere in grado di cavarsela, controllando il nome completo del tipo o l'assemblea come sotto,

if(obj.GetType().Assembly.FullName.Contains("MyAssembly")) 
{ 
    //User-defined type 
} 
else if(obj.GetType().FullName.StartsWith("System.")) 
{ 
    //.NET type 
} 

Answer 7

Il modo più semplice che ho seguito è quello di verificare lo spazio dei nomi per capire se il suo uno dei i tuoi tipi personalizzati Ad esempio, lo spazio dei nomi potrebbe essere "YourCompany.YourDepartment" e questo può essere verificato rispetto allo spazio dei nomi del tipo.