private TCecil GetMemberItemFromCache <TCecil, TReflector>(object item, Dictionary <TReflector, TCecil> cache, FindMatchingMember <TCecil, TReflector> finder) where TReflector : RC.IMemberReference
{
if (!(item is TReflector))
{
throw new ArgumentException(typeof(TReflector).Name);
}
TReflector memberdec = (TReflector)item;
TCecil result = default(TCecil);
if ((memberdec != null) && (!cache.ContainsKey(memberdec)))
{
ITypeDeclaration classdec = (ITypeDeclaration)memberdec.DeclaringType;
TypeDefinition typedef = ReflectorHelper.FindMatchingType(AssemblyDefinition, classdec);
if (typedef != null)
{
result = finder(typedef, memberdec);
if (result != null)
{
// add result to cache
cache.Add(memberdec, result);
}
}
}
else
{
// Definition is already cached
result = cache[memberdec];
}
return(result);
}
public EventDefinition GetEventDefinition(IEventDeclaration item)
{
return(TryGetOrAdd(_eventcache, item, edef =>
{
var tdef = GetTypeDefinition(item.DeclaringType as ITypeDeclaration);
return tdef == null ? null : ReflectorHelper.FindMatchingEvent(tdef, edef);
}));
}
public PropertyDefinition GetPropertyDefinition(IPropertyDeclaration item)
{
return(TryGetOrAdd(_propertycache, item, pdef =>
{
var tdef = GetTypeDefinition(item.DeclaringType as ITypeDeclaration);
return tdef == null ? null : ReflectorHelper.FindMatchingProperty(tdef, pdef);
}));
}
public FieldDefinition GetFieldDefinition(IFieldDeclaration item)
{
return(TryGetOrAdd(_fieldcache, item, fdef =>
{
var tdef = GetTypeDefinition(item.DeclaringType as ITypeDeclaration);
return tdef == null ? null : ReflectorHelper.FindMatchingField(tdef, fdef);
}));
}
public MethodDefinition GetMethodDefinition(IMethodDeclaration item)
{
return(TryGetOrAdd(_methodcache, item, mdef =>
{
var tdef = GetTypeDefinition(item.DeclaringType as ITypeDeclaration);
return tdef == null ? null : ReflectorHelper.FindMatchingMethod(tdef, mdef);
}));
}
public Resource GetResource(IResource item)
{
// Fix for in-memory resource in embedded resource
var parent = item.GetType().GetProperty("Parent", typeof(IEmbeddedResource));
if (parent != null)
{
item = parent.GetValue(item, null) as IEmbeddedResource;
}
return(TryGetOrAdd(_resourcecache, item, res => ReflectorHelper.FindMatchingResource(AssemblyDefinition, res)));
}
public AssemblyNameReference GetAssemblyNameReference(IAssemblyReference item)
{
//fix: use toString() instead of object himself (getHashcode seems to be overriden)
AssemblyNameReference result;
var key = item.ToString();
if (_assemblynamereferencecache.TryGetValue(key, out result))
{
return(result);
}
result = ReflectorHelper.FindMatchingAssemblyReference(AssemblyDefinition, item);
if (result == null)
{
return(null);
}
_assemblynamereferencecache.Add(key, result);
return(result);
}
/// <summary>
/// Retrieve an Embedded Resource from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Embedded Resource</returns>
public override EmbeddedResource GetEmbeddedResource(object item)
{
IResource res = item as IResource;
return((EmbeddedResource)ReflectorHelper.ReflectorResourceToCecilResource(res));
}
public TypeDefinition GetTypeDefinition(ITypeDeclaration item)
{
return(TryGetOrAdd(_typecache, item, tdef => ReflectorHelper.FindMatchingType(AssemblyDefinition, tdef)));
}
/// <summary>
/// Retrieve a Linked Resource from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Linked Resource</returns>
public override LinkedResource GetLinkedResource(object item)
{
var res = item as IResource;
return((LinkedResource)ReflectorHelper.ReflectorResourceToCecilResource(res));
}
/// <summary>
/// Retrieve a Type Definition from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Type Definition</returns>
public override TypeDefinition GetTypeDefinition(object item)
{
ITypeDeclaration tdec = item as ITypeDeclaration;
return(ReflectorHelper.ReflectorTypeToCecilType(tdec));
}
/// <summary>
/// Retrieve a Field Definition from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Field Definition</returns>
public override FieldDefinition GetFieldDefinition(object item)
{
IFieldDeclaration fdec = item as IFieldDeclaration;
return(ReflectorHelper.ReflectorFieldToCecilField(fdec));
}
/// <summary>
/// Retrieve an Event Definition from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Event Definition</returns>
public override EventDefinition GetEventDefinition(object item)
{
IEventDeclaration edec = item as IEventDeclaration;
return(ReflectorHelper.ReflectorEventToCecilEvent(edec));
}
/// <summary>
/// Retrieve a Property Definition from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Property Definition</returns>
public override PropertyDefinition GetPropertyDefinition(object item)
{
IPropertyDeclaration pdec = (IPropertyDeclaration)item;
return(ReflectorHelper.ReflectorPropertyToCecilProperty(pdec));
}
/// <summary>
/// Retrieve an Assembly Definition from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Assembly Definition</returns>
public override AssemblyDefinition GetAssemblyDefinition(object item)
{
IAssemblyLocation aloc = item as IAssemblyLocation;
return(ReflectorHelper.ReflectorAssemblyLocationToCecilAssemblyDefinition(aloc));
}
/// <summary>
/// Retrieve an Assembly Name Reference from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Assembly Name Reference</returns>
public override AssemblyNameReference GetAssemblyNameReference(object item)
{
IAssemblyReference aref = item as IAssemblyReference;
return(ReflectorHelper.ReflectorAssemblyReferenceToCecilAssemblyNameReference(aref));
}
/// <summary>
/// Retrieve a Method Definition from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching Method Definition</returns>
public override MethodDefinition GetMethodDefinition(object item)
{
IMethodDeclaration mdec = (IMethodDeclaration)item;
return(ReflectorHelper.ReflectorMethodToCecilMethod(mdec));
}
/// <summary>
/// Retrieve an Assembly Linked Resource from the object
/// </summary>
/// <param name="item">the object</param>
/// <returns>The matching A.L. Resource</returns>
public override AssemblyLinkedResource GetAssemblyLinkedResource(object item)
{
IResource res = item as IResource;
return((AssemblyLinkedResource)ReflectorHelper.ReflectorResourceToCecilResource(res));
}
