Obtiene el tipo de GUID

Question

Por varias razones, necesito implementar un mecanismo de caché de tipo en C#. Afortunadamente, CLR proporciona Type.GUID para identificar de forma única un tipo. Lamentablemente, no encuentro ninguna forma de buscar un tipo basado en este GUID. Hay Type.GetTypeFromCLSID() pero según mi comprensión de la documentación (y experimentos) que hace algo muy, muy diferente.

¿Hay alguna manera de obtener un tipo basado en su GUID menos de bucle a través de todos los tipos cargados y en comparación con sus GUID?

EDIT: Olvidé mencionar que realmente me gustaría una "huella dactilar tipográfica" de ancho fijo, es por eso que el GUID es tan atractivo para mí. En un caso general, por supuesto, el nombre completo del tipo funcionaría.

Answer 1

No bucle para comparar. Llene un Dictionary<Type> y use el método Contains.

Dictionary<Type> types = new Dictionary<Types>(); 
... //populate 

if (types.Contains(someObject.GetType())) 
    //do something 

Esto sin duda le dará una entrada de tamaño fijo, ya que todos ellos habrá referencias a objetos (instancias de Tipo siendo esencialmente objetos de fábrica).

Answer 2

¿por qué no utilizar la propiedad designada para eso, es decir. AssemblyQualifiedName? Esta propiedad está documentada como "puede persistir y luego usarse para cargar el Tipo".

El GUID es para interoperabilidad COM.

Answer 3

Si usted está en control de estas clases yo recomendaría:

public interface ICachable 
{ 
    Guid ClassId { get; } 
} 

public class Person : ICachable 
{ 
    public Guid ClassId 
    { 
     get { return new Guid("DF9DD4A9-1396-4ddb-98D4-F8F143692C45"); } 
    } 
} 

puede generar su GUID utilizando Visual Studio, Herramientas-> Crear GUID.

Answer 4

¿Qué pasa (de Generating Deterministic GUIDs):

private Guid GetDeterministicGuid(string input) 
{ 
    // use MD5 hash to get a 16-byte hash of the string: 
    MD5CryptoServiceProvider provider = new MD5CryptoServiceProvider(); 
    byte[] inputBytes = Encoding.Default.GetBytes(input); 
    byte[] hashBytes = provider.ComputeHash(inputBytes); 

    // generate a guid from the hash: 
    Guid hashGuid = new Guid(hashBytes); 
    return hashGuid; 
} 

Y tirar en ese typeof().AssemblyQualifiedName. Podría almacenar estos datos dentro de una colección Dictionary<string, Guid> (o, lo que sea, un <Guid, string>).

De esta forma siempre tendrá el mismo GUID para un tipo determinado (advertencia: colisión es posible).

Answer 5

La documentación de Mono informa que un módulo tiene un Metadata heap of guids.

¿Quizás Cecil podría ayudarlo a buscar un tipo basado en su guía? Aunque no estoy seguro, hay una clase GuidHeap, parece que está generando las guías, pero ¿quizás esto sea suficiente para que funcione la caché?

Answer 6

Esto puede ser solo un resumen de las respuestas ya publicadas, pero no creo que haya una forma de hacerlo sin antes crear un mapa de Guid-> Tipo.

Hacemos esto en nuestro marco de inicialización:

static TypeManager() 
    { 
     AppDomain.CurrentDomain.AssemblyLoad += (s, e) => 
     { 
      _ScanAssembly(e.LoadedAssembly); 
     }; 

     foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) 
     { 
      _ScanAssembly(a); 
     } 
    } 

    private static void _ScanAssembly(Assembly a) 
    { 
     foreach (Type t in a.GetTypes()) 
     { 
      //optional check to filter types (by interface or attribute, etc.) 
      //Add type to type map 
     } 
    } 

controlar el evento AssemblyLoad se encarga de ensamblajes de carga dinámica.

Por lo que entiendo, Type.GUID utiliza la versión de ensamblaje del tipo como parte del algoritmo de generación de Guid.Esto puede ocasionar problemas si incrementa los números de versión de su ensamblaje. Usar el método GetDeterministicGuid descrito en otra respuesta probablemente sea aconsejable, dependiendo de su aplicación.

Answer 7

me gustaría utilizar el typeof (clase) .GUID para encontrar la instancia en el diccionario caché:

private Dictionary<Guid, class> cacheDictionary { get; set; } 

y me gustaría tener un método para devolver el diccionario y el GUID como parámetro del método para buscar para la clase en el diccionario.

public T Getclass<T>() 
    { 
     var key = typeof(T).GUID; 
     var foundClass= cacheDictionary.FirstOrDefault(x => x.Key == key); 
     T item; 
     if (foundClass.Equals(default(KeyValuePair<Guid, T>))) 
     { 
      item = new T() 
      cacheDictionary.Add(key, item); 
     } 
     else 
      item = result.Value; 

     return item; 
    } 

y me gustaría utilizar un patrón Singleton para la caché,

y la llamada sería algo así como el código de abajo:.

var cachedObject = Cache.Instance.Getclass<class>();