¿Cómo probar si un tipo es anónimo?

Tengo el siguiente método que serializa un objeto a una etiqueta HTML. Solo quiero hacer esto aunque el tipo no sea Anónimo.

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

¿Puede alguien mostrarme cómo lograr esto?

Gracias

De: 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 & TypeAttributes.NotPublic) == TypeAttributes.NotPublic; } 

HTH.

EDITAR:
Otro enlace con el método de extensión: determinar si un tipo es un tipo anónimo

Rápido y sucio:

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

Solo puede verificar si el espacio de nombres es nulo.

 public static bool IsAnonymousType(this object instance) { if (instance==null) return false; return instance.GetType().Namespace == null; } 

Bueno, hoy compiier genera tipos anónimos como clases genéricas Y selladas. Una combinación paradójica ya que la especialización de una clase genérica es un tipo de herencia, ¿no es así? Entonces puede verificar esto: 1. ¿Es este un tipo genérico? Sí => 2) ¿está su definición sellada && no es pública? Sí => 3) ¿su definición tiene el atributo CompilerGeneratedAttribute? Supongo que si estos 3 criterios son ciertos, tenemos un tipo anónimo … Bueno … Existe un problema con CUALQUIERA de los métodos descritos: son aspectos de uso que pueden cambiar en las próximas versiones de .NET y será hasta que Microsoft agregue la propiedad booleana IsAnonymous a la clase Type. Espero que suceda antes de que todos muramos … Hasta ese día, se puede verificar así:

 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(this T instance) { return IsAnonymous(instance.GetType()); } } 

Compruebe si CompilerGeneratedAttribute and DebuggerDisplayAttribute.Type

aquí está el código generado por el comstackdor para un tipo anónimo

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