Comment tester si un type est anonyme ?

Question

J'ai la méthode suivante qui sérialise un objet dans une balise HTML. Je ne veux cependant le faire que si le type n'est pas anonyme.

private void MergeTypeDataToTag(object typeData)
{
    if (typeData != null)
    {
        Type elementType = typeData.GetType();

        if (/* elementType != AnonymousType */)
        {
            _tag.Attributes.Add("class", elementType.Name);    
        }

        // do some more stuff
    }
}

Quelqu'un peut-il me montrer comment y parvenir ?

Merci

Answer 1

Desde http://www.liensberger.it/web/blog/?p=191 :

private static bool CheckIfAnonymousType(Type type)
{
    if (type == null)
        throw new ArgumentNullException("type");

    // HACK: The only way to detect anonymous types right now.
    return Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute), false)
        && type.IsGenericType && type.Name.Contains("AnonymousType")
        && (type.Name.StartsWith("<>") || type.Name.StartsWith("VB$"))
        && type.Attributes.HasFlag(TypeAttributes.NotPublic);
}

EDIT :
Un autre lien avec la méthode d'extension : Déterminer si un type est un type anonyme

Answer 2

Rapide et sale :

if(obj.GetType().Name.Contains("AnonymousType"))

Answer 3

Vous pouvez simplement vérifier si l'espace de nom est nul.

public static bool IsAnonymousType(this object instance)
{

    if (instance==null)
        return false;

    return instance.GetType().Namespace == null;
}

Answer 4

Eh bien, aujourd'hui compiier génère des types anonymes comme des classes génériques ET scellées. Une combinaison paradoxale puisque la spécialisation d'une classe générique est une sorte d'héritage, n'est-ce pas ? Vous pouvez donc vérifier cela : 1. Est-ce un type générique ? Oui => 2) sa définition est-elle scellée && non publique ? Oui => 3) sa définition possède-t-elle l'attribut CompilerGeneratedAttribute ? Je suppose que si ces 3 critères sont vrais ensemble, nous avons un type anonyme... Et bien... Il y a un problème avec TOUTES les méthodes décrites - ce sont des aspects d'utilisation qui peuvent changer dans les prochaines versions de .NET et il en sera ainsi jusqu'à ce que Microsoft ajoute la propriété booléenne IsAnonymous à la classe Type. J'espère que cela arrivera avant que nous mourions tous... Jusqu'à ce jour, il peut être vérifié comme suit :

using System.Runtime.CompilerServices;
using System.Reflection;

public static class AnonymousTypesSupport
{
    public static bool IsAnonymous(this Type type)
    {
        if (type.IsGenericType)
        {
            var d = type.GetGenericTypeDefinition();
            if (d.IsClass && d.IsSealed && d.Attributes.HasFlag(TypeAttributes.NotPublic))
            {
                var attributes = d.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false);
                if (attributes != null && attributes.Length > 0)
                {
                    //WOW! We have an anonymous type!!!
                    return true;
                }
            }
        }
        return false;
    }

    public static bool IsAnonymousType<T>(this T instance)
    {
        return IsAnonymous(instance.GetType());
    }
}

Answer 5

Vérifiez si CompilerGeneratedAttribute y DebuggerDisplayAttribute.Type

voici le code généré par le compilateur pour un type anormal

[CompilerGenerated, DebuggerDisplay(@"\{ a = {a} }", Type="<Anonymous Type>")]
internal sealed class <>f__AnonymousType0<<a>j__TPar>
{
...
}