Type.GetType («namespace.abClassName») renvoie null

Ce code:

Type.GetType("namespace.a.b.ClassName")

retourne null.

et j'ai dans les utilisations:

using namespace.a.b;

Mettre à jour:

Le type existe, il se trouve dans une bibliothèque de classes différente, et j'ai besoin de l'obtenir par nom de chaîne.

Type.GetType("namespace.qualified.TypeName") ne fonctionne que lorsque le type se trouve dans mscorlib.dll ou l'assembly en cours d'exécution.

Si aucune de ces choses n'est vraie, vous aurez besoin d'un nom qualifié d'assembly :

Type.GetType("namespace.qualified.TypeName, Assembly.Name")

Vous pouvez également obtenir le type sans nom qualifié d'assembly mais également avec le nom de la DLL, par exemple:

Type myClassType = Type.GetType("TypeName,DllName");

J'ai eu la même situation et cela a fonctionné pour moi. J'avais besoin d'un objet de type "DataModel.QueueObject" et j'avais une référence à "DataModel" alors j'ai obtenu le type comme suit:

Type type = Type.GetType("DataModel.QueueObject,DataModel");

La deuxième chaîne après la virgule est le nom de référence (nom de la DLL).

essayez d'utiliser cette méthode

 public static Type GetType(string typeName)
        {
            var type = Type.GetType(typeName);
            if (type != null) return type;
            foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
            {
                type = a.GetType(typeName);
                if (type != null)
                    return type;
            }
            return null ;
        }

Dictionary<string, Type> typeCache;
...
public static bool TryFindType(string typeName, out Type t) {
    lock (typeCache) {
        if (!typeCache.TryGetValue(typeName, out t)) {
            foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) {
                t = a.GetType(typeName);
                if (t != null)
                    break;
            }
            typeCache[typeName] = t; // perhaps null
        }
    }
    return t != null;
}

Si l'assembly fait partie de la génération d'une application ASP.NET, vous pouvez utiliser la classe BuildManager:

using System.Web.Compilation
...
BuildManager.GetType(typeName, false);

si votre classe n'est pas en cours d'assemblage, vous devez donner qualifiéName et ce code montre comment obtenir un nom qualifié de classe

string qualifiedName = typeof(YourClass).AssemblyQualifiedName;

puis vous pouvez obtenir le type avec qualifiéName

Type elementType = Type.GetType(qualifiedName);

S'il s'agit d'un type imbriqué, vous oubliez peut-être de transformer a. à un +

Quoi qu'il en soit, typeof( T).FullNamevous dira ce que vous devriez dire

EDIT: BTW les utilisations (comme je suis sûr que vous le savez) ne sont que des directives pour le compilateur au moment de la compilation et ne peuvent donc avoir aucun impact sur le succès de l'appel d'API. (Si vous aviez des références de projet ou d'assemblage, cela pourrait potentiellement avoir une influence - par conséquent, les informations ne sont pas inutiles, il suffit d'un peu de filtrage ...)

J'ouvre les contrôles utilisateur en fonction des contrôles utilisateur auxquels l'utilisateur a accès spécifiés dans une base de données. J'ai donc utilisé cette méthode pour obtenir le TypeName ...

Dim strType As String = GetType(Namespace.ClassName).AssemblyQualifiedName.ToString
Dim obj As UserControl = Activator.CreateInstance(Type.GetType(strType))

Alors maintenant, on peut utiliser la valeur retournée dans strType pour créer une instance de cet objet.

Lorsque je n'ai que le nom de classe, j'utilise ceci:

Type obj = AppDomain.CurrentDomain.GetAssemblies().SelectMany(t => t.GetTypes()).Where(t => String.Equals(t.Name, _viewModelName, StringComparison.Ordinal)).First();

Comme Type.GetType (String) a besoin du Type.AssemblyQualifiedName, vous devez utiliser Assembly.CreateQualifiedName (String, String) .

string typeName = "MyNamespace.MyClass"; // Type.FullName
string assemblyName = "MyAssemblyName"; // MyAssembly.FullName or MyAssembly.GetName().Name
string assemblyQualifiedName = Assembly.CreateQualifiedName(assemblyName , typeName);
Type myClassType = Type.GetType(assemblyQualifiedName);

La version, la culture et le PublicKeyToken ne sont pas requis, assemblyNamec'est pourquoi vous pouvez utiliser MyAssembly.GetName (). Name.

À propos de Type.GetType (String) :

Si le type se trouve dans l'assembly en cours d'exécution ou dans Mscorlib.dll, il suffit de fournir le nom de type qualifié par son espace de noms.

Si l'assembly est référencé et la classe visible:

typeof(namespace.a.b.ClassName)

GetType renvoie null car le type est introuvable, avec typeof, le compilateur peut vous aider à trouver l'erreur.

Essayez d'utiliser le nom de type complet qui inclut les informations d'assembly, par exemple:

string typeName = @"MyCompany.MyApp.MyDomain.MyClass, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
Type myClassType = Type.GetType(typeName);

J'ai eu la même situation lorsque j'utilisais uniquement le namesspace.classname pour obtenir le type d'une classe dans un autre assembly et cela ne fonctionnerait pas. Cela n'a fonctionné que lorsque j'ai inclus les informations d'assemblage dans ma chaîne de caractères, comme indiqué ci-dessus.

Assurez-vous que la virgule se trouve directement après le nom complet

typeof(namespace.a.b.ClassName, AssemblyName)

Comme cela ne fonctionnera pas

typeof(namespace.a.b.ClassName ,AssemblyName)

J'ai été perplexe pendant quelques jours sur celui-ci

Pour moi, un "+" était la clé! Voici ma classe (elle est imbriquée):

namespace PortalServices
{
public class PortalManagement : WebService
{
    public class Merchant
    {}
}
}

et cette ligne de code a fonctionné:

Type type = Type.GetType("PortalServices.PortalManagement+Merchant");

Cette solution ci-dessus semble être la meilleure pour moi, mais cela n'a pas fonctionné pour moi, alors je l'ai fait comme suit:

AssemblyName assemblyName = AssemblyName.GetAssemblyName(HttpContext.Current.Server.MapPath("~\\Bin\\AnotherAssembly.dll"));
string typeAssemblyQualifiedName = string.Join(", ", "MyNamespace.MyType", assemblyName.FullName);

Type myType = Type.GetType(typeAssemblyQualifiedName);

La condition préalable est que vous connaissiez le chemin de l'assemblage. Dans mon cas, je le sais car il s'agit d'un assemblage construit à partir d'un autre projet interne et inclus dans le dossier bin de notre projet.

Si cela importe, j'utilise Visual Studio 2013, mon .NET cible est 4.0. Ceci est un projet ASP.NET, donc je reçois un chemin absolu via HttpContext. Cependant, le chemin absolu n'est pas une exigence comme il semble de MSDN sur AssemblyQualifiedNames

J'ai triché. Étant donné que les types que je veux créer (par nom) sont tous dans une DLL que je contrôle, je viens de mettre une méthode statique dans la DLL dans l'assembly qui prend un nom simple et appelle type.GetType à partir de ce contexte et renvoie le résultat .

Le but initial était que le type puisse être spécifié par son nom dans les données de configuration. J'ai depuis changé le code pour que l'utilisateur spécifie un format à traiter. Les classes de gestionnaire de format implémentent une interface qui détermine si le type peut analyser le format spécifié. J'utilise ensuite la réflexion pour trouver les types qui implémentent l'interface et en trouver un qui gère le format. Alors maintenant, la configuration spécifie un nom de format, pas un type spécifique. Le code de réflexion peut regarder les DLL adjacentes et les charger, donc j'ai une architecture de plug-in pour les pauvres.