|
public static FromMemberInfo ( |
||
| member | ||
| return | ||
internal void AddTypeName(string typeName, Assembly assem)
{
// lock is held when this is called
Assert.NotNull(typeName, assem);
Debug.Assert(typeName.IndexOf('.') == -1); // This is the simple name, not the full name
if (!_typeNames.ContainsKey(assem))
{
_typeNames[assem] = new TypeNames(assem, _fullName);
}
_typeNames[assem].AddTypeName(typeName);
string normalizedTypeName = ReflectionUtils.GetNormalizedTypeName(typeName);
if (_dict.ContainsKey(normalizedTypeName))
{
// A similarly named type, namespace, or module already exists.
Type newType = LoadType(assem, GetFullChildName(typeName));
if (newType != null)
{
object existingValue = _dict[normalizedTypeName];
TypeTracker existingTypeEntity = existingValue as TypeTracker;
if (existingTypeEntity == null)
{
// Replace the existing namespace or module with the new type
Debug.Assert(existingValue is NamespaceTracker);
_dict[normalizedTypeName] = MemberTracker.FromMemberInfo(newType.GetTypeInfo());
}
else
{
// Unify the new type with the existing type
_dict[normalizedTypeName] = TypeGroup.UpdateTypeEntity(existingTypeEntity, TypeTracker.GetTypeTracker(newType));
}
}
}
}
public override Expression GetValue(ActionBinder binder, Type type)
{
if (!IsStatic || GetIndexParameters().Length > 0)
{
// need to bind to a value or parameters to get the value.
return(binder.ReturnMemberTracker(type, this));
}
MethodInfo getter = ResolveGetter();
if (getter == null || getter.ContainsGenericParameters)
{
// no usable getter
return(null);
}
if (getter.IsPublic && getter.DeclaringType.IsPublic)
{
return(binder.MakeCallExpression(getter));
}
// private binding is just a call to the getter method...
return(MemberTracker.FromMemberInfo(getter).Call(binder));
}
public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type instanceType)
{
if (!IsStatic || GetIndexParameters().Length > 0)
{
// need to bind to a value or parameters to get the value.
return(binder.ReturnMemberTracker(instanceType, this));
}
MethodInfo getter = ResolveGetter(instanceType, binder.PrivateBinding);
if (getter == null || getter.ContainsGenericParameters)
{
// no usable getter
return(null);
}
if (getter.IsPublic && getter.DeclaringType.IsPublic())
{
return(binder.MakeCallExpression(resolverFactory, getter));
}
// private binding is just a call to the getter method...
return(MemberTracker.FromMemberInfo(getter).Call(resolverFactory, binder));
}
/// <summary>
/// Gets the extension members of the given name from the provided type. Subclasses of the
/// type and their extension members are not searched.
/// </summary>
public MemberGroup GetExtensionMembers(Type declaringType, string name)
{
IList <Type> extTypes = GetExtensionTypes(declaringType);
List <MemberTracker> members = new List <MemberTracker>();
foreach (Type ext in extTypes)
{
foreach (MemberInfo mi in ext.GetMember(name, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
{
MemberInfo newMember = mi;
if (PrivateBinding || (newMember = CompilerHelpers.TryGetVisibleMember(mi)) != null)
{
if (ext != declaringType)
{
members.Add(MemberTracker.FromMemberInfo(newMember, declaringType));
}
else
{
members.Add(MemberTracker.FromMemberInfo(newMember));
}
}
}
// TODO: Support indexed getters/setters w/ multiple methods
MethodInfo getter = null, setter = null, deleter = null;
foreach (MemberInfo mi in ext.GetMember("Get" + name, MemberTypes.Method, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(getter == null);
getter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Set" + name, MemberTypes.Method, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(setter == null);
setter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Delete" + name, MemberTypes.Method, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(deleter == null);
deleter = (MethodInfo)mi;
}
if (getter != null || setter != null || deleter != null)
{
members.Add(new ExtensionPropertyTracker(name, getter, setter, deleter, declaringType));
}
}
if (members.Count != 0)
{
return(MemberGroup.CreateInternal(members.ToArray()));
}
return(MemberGroup.EmptyGroup);
}
public MemberGroup GetExtensionMembers(Type type, string name)
{
Type curType = type;
do
{
IList <Type> extTypes = GetExtensionTypes(curType);
List <MemberTracker> members = new List <MemberTracker>();
foreach (Type ext in extTypes)
{
foreach (MemberInfo mi in ext.GetMember(name))
{
members.Add(MemberTracker.FromMemberInfo(mi, true));
}
// TODO: Support indexed getters/setters w/ multiple methods
MethodInfo getter = null, setter = null, deleter = null;
foreach (MemberInfo mi in ext.GetMember("Get" + name))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(getter == null);
getter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Set" + name))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(setter == null);
setter = (MethodInfo)mi;
}
foreach (MemberInfo mi in ext.GetMember("Delete" + name))
{
if (!mi.IsDefined(typeof(PropertyMethodAttribute), false))
{
continue;
}
Debug.Assert(deleter == null);
deleter = (MethodInfo)mi;
}
#if FULL
if (getter != null || setter != null || deleter != null)
{
members.Add(new ExtensionPropertyTracker(name, getter, setter, deleter, curType));
}
#endif
}
if (members.Count != 0)
{
return(MemberGroup.CreateInternal(members.ToArray()));
}
curType = curType.BaseType;
} while (curType != null);
return(MemberGroup.EmptyGroup);
}
