Verificare se un tipo appartiene a uno spazio dei nomi senza stringhe codificate

Question

È possibile verificare se un tipo fa parte di uno spazio dei nomi senza utilizzare stringhe harcoded?

sto cercando di fare qualcosa di simile:

Type type = typeof(System.Data.Constraint); 
if(type.Namespace == System.Data.ToString()) 
{...} 

o

Type type = typeof(System.Data.Constraint); 
if(type.Namespace == System.Data) 
{...} 

per evitare

Type type = typeof(System.Data.Constraint); 
if(type.Namespace == "System.Data") 
{...} 

Questi esempi non si compila, ma dovrebbe dare un'idea di ciò che Sto cercando di ottenere.

Non riesco a utilizzare nameof(System.Data) perché restituisce solo "Data".

Vorrei trovare un modo per verificare se una classe se parte di uno spazio dei nomi senza la necessità di avere tale spazio dei nomi in una stringa.

Answer 1

È possibile definire è nello spazio dei nomi in cui si desidera eseguire il controllo:

static class Namespace 
{ 
    public static bool Contains<T>() 
     => typeof (T).Namespace == typeof (Namespace).Namespace; 
}  

Ad esempio:

namespace My.Inner 
{ 
    static class Namespace 
    { 
     public static bool Contains<T>() 
      => typeof (T).Namespace == typeof (Namespace).Namespace; 
    }  
} 

Due tipi come casi di test:

namespace My 
{ 
    class SomeTypeA { } 
} 

namespace My.Inner 
{ 
    class SomeTypeB { } 
} 

Qui è l'utilizzo:

Console.WriteLine(My.Inner.Namespace.Contains<SomeTypeA>()); // False 
Console.WriteLine(My.Inner.Namespace.Contains<SomeTypeB>()); // True 

Answer 2

Si dovrebbe essere in grado di fare qualcosa di simile:

static class Namespaces 
{ 
    //You would then need to add a prop for each namespace you want 
    static string Data = typeof(System.Data.Constrains).Namespace; 
} 

var namespaceA = typeof(System.Data.DataTable).Namespace 
if (namespaceA == Namespaces.Data) //true 
{ 
    //do something 
} 

Inoltre, utilizzando l'idea da @Theodoros Chatzigiannakis, si potrebbe ulteriormente generalizzare questo:

static class Namespace 
{ 
    //generic 
    static bool Contains<T1, T2>() 
    { 
     return typeof(T1).Namespace == typeof(T2).Namespace; 
    } 
    //Non-generic 
    static bool Contains(Type type1, Type type2) 
    { 
     return type1.Namespace == type2.Namespace; 
    } 
} 

e poi usarlo Mi piace:

bool generic = Namespace.Contains<System.Data.CLASS1, System.Data.CLASS2>(); 
bool nonGeneric = Namespace.Contains(typeof(System.Data.CLASS1), typeof(System.Data.CLASS2));