Prüfen, ob ein Typ zu einem Namespace ohne hardcoded Strings gehört

Question

Ist es möglich, zu überprüfen, ob ein Typ Teil eines Namespace ist, ohne harcodierte Strings zu verwenden?

Ich versuche, so etwas wie zu tun:

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

oder

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

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

Diese Beispiele kompilieren nicht zu vermeiden, aber sollte eine Vorstellung davon geben, was Ich versuche es zu erreichen.

Ich kann nameof(System.Data) nicht verwenden, weil es nur "Data" zurückgibt.

Ich würde gerne einen Weg finden, um zu überprüfen, ob eine Klasse, wenn Teil eines Namespace ohne den Namespace in einer Zeichenfolge haben.

Answer 1

Sie können th definieren im Namensraum ist, wo Sie die Prüfung durchführen möchten:

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

Zum Beispiel:

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

Zwei Arten als Testfälle:

namespace My 
{ 
    class SomeTypeA { } 
} 

namespace My.Inner 
{ 
    class SomeTypeB { } 
} 

Hier ist die Nutzung:

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

Answer 2

Sie sollten in der Lage sein, so etwas zu tun:

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 
} 

Auch mit der Idee von @Theodoros Chatzigiannakis, könnten Sie dies weiter verallgemeinern:

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; 
    } 
} 

und dann verwenden, wie:

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