Trovare tutti i namespace in un assembly usando Reflect (DotNET)

Question

Ho un assembly (caricato come ReflectionOnly) e voglio trovare tutti gli spazi dei nomi in questo assembly in modo che io possa convertirli in "using" ("Imports" in VB) per un modello di file di codice sorgente generato automaticamente.

Idealmente vorrei limitarmi a spazi dei nomi di primo livello solo, così invece di:

using System; 
using System.Collections; 
using System.Collections.Generic; 

che ci si ottiene solo:

using System; 

io ci notato è una proprietà Namespace sulla classe System.Type, ma esiste un modo migliore per raccogliere Namespace all'interno di un assembly che non coinvolge l'iterazione su tutti i tipi e il culling delle stringhe dei namespace duplicate?

Molto obbligato, David

Answer 1

No, non esiste una scorciatoia per questo, sebbene LINQ lo renda relativamente facile. Ad esempio, in C# il "set di spazi dei nomi" raw sarebbe:

var namespaces = assembly.GetTypes() 
         .Select(t => t.Namespace) 
         .Distinct(); 

Per ottenere lo spazio dei nomi di livello superiore, invece probabilmente si dovrebbe scrivere un metodo:

var topLevel = assembly.GetTypes() 
         .Select(t => GetTopLevelNamespace(t)) 
         .Distinct(); 

... 

static string GetTopLevelNamespace(Type t) 
{ 
    string ns = t.Namespace ?? ""; 
    int firstDot = ns.IndexOf('.'); 
    return firstDot == -1 ? ns : ns.Substring(0, firstDot); 
} 

Sono incuriosito da perché hai solo bisogno di spazi dei nomi di primo livello ... sembra un vincolo strano.

Answer 2

namespace sono in realtà solo una convenzione di denominazione in nomi di tipo, in modo che solo "esiste" come un modello che si ripete in molti nomi di tipo qualificato. Quindi devi scorrere tutti i tipi. Tuttavia, il codice per questo può probabilmente essere scritto come una singola espressione di Linq.

Answer 3

Non avrai altra scelta che iterare su tutte le classi.

Si noti che le importazioni non funzionano in modo ricorsivo. "using System" non importerà alcuna classe da subnamespace come System.Collections o System.Collections.Generic, ma dovrai includerli tutti.

Answer 4

Ecco una sorta di modo linq, in sostanza sta itterando su ogni elemento ma il codice è molto più pulito.

var nameSpaces = from type in Assembly.GetExecutingAssembly().GetTypes() 
       select type.Namespace; 
nameSpaces = nameSpaces.Distinct(); 

Anche se il codice di generazione automatica, si potrebbe essere meglio qualificare in modo completo tutto ciò, allora non dovete preoccuparvi di conflitti tra i nomi nel codice generato.

Answer 5

Un po 'di LINQ?

var qry = (from type in assembly.GetTypes() 
      where !string.IsNullOrEmpty(type.Namespace) 
      let dotIndex = type.Namespace.IndexOf('.') 
      let topLevel = dotIndex < 0 ? type.Namespace 
       : type.Namespace.Substring(0, dotIndex) 
      orderby topLevel 
      select topLevel).Distinct(); 
foreach (var ns in qry) { 
    Console.WriteLine(ns); 
} 

Answer 6

public static void Main() { 

    var assembly = ...; 

    Console.Write(CreateUsings(FilterToTopLevel(GetNamespaces(assembly)))); 
} 

private static string CreateUsings(IEnumerable<string> namespaces) { 
    return namespaces.Aggregate(String.Empty, 
           (u, n) => u + "using " + n + ";" + Environment.NewLine); 
} 

private static IEnumerable<string> FilterToTopLevel(IEnumerable<string> namespaces) { 
    return namespaces.Select(n => n.Split('.').First()).Distinct(); 
} 

private static IEnumerable<string> GetNamespaces(Assembly assembly) { 
    return (assembly.GetTypes().Select(t => t.Namespace) 
      .Where(n => !String.IsNullOrEmpty(n)) 
      .Distinct()); 
}