public static MemberInfo[] GetMemberInternal(this Type type, string member, MemberTypes?memberType, BindingFlags bindingFlags)
{
return(type.GetTypeInfo().GetMembersRecursive().Where(m =>
m.Name == member &&
// test type before accessibility - accessibility doesn't support some types
(memberType == null || m.MemberType() == memberType) &&
TestAccessibility(m, bindingFlags)).ToArray());
}
public static bool IsParameterMemberExpression(this Expression expression, MemberTypes?memberType = null)
{
if (expression is LambdaExpression lambdaExpression)
{
expression = lambdaExpression.Body;
}
return(expression != null && expression is MemberExpression memberExpression &&
(memberType == null || (memberExpression.Member.MemberType | memberType) != 0) &&
memberExpression.Expression is ParameterExpression);
}
public AutoCompleteItem(string displayName, string value, MemberTypes?memberType = null, Type type = null)
{
Should.NotBeNull(displayName, nameof(displayName));
Should.NotBeNull(value, nameof(value));
Type = type ?? typeof(object);
DisplayName = memberType.HasValue
? $"{displayName} ({Type.Name} - {(memberType.Value == MemberTypes.Custom ? "Attached" : memberType.Value.ToString())})"
: displayName;
Value = value;
MemberType = memberType.GetValueOrDefault(MemberTypes.Custom);
}
public AutoCompleteItem(string displayName, string value, MemberTypes?memberType = null, Type type = null)
{
Should.NotBeNull(displayName, "displayName");
Should.NotBeNull(value, "value");
Type = type ?? typeof(object);
DisplayName = memberType.HasValue
? string.Format("{0} ({1} - {2})", displayName, Type.Name,
memberType.Value == MemberTypes.Custom ? "Attached" : memberType.Value.ToString())
: displayName;
Value = value;
MemberType = memberType.GetValueOrDefault(MemberTypes.Custom);
}
private void HighlightMember(MemberTypes?memberType, int startIndex, int length)
{
if (memberType == null)
{
bindingEditor.Highlight(UnknownAttachedMemberColor, startIndex, length);
return;
}
switch (memberType.Value)
{
case MemberTypes.Event:
bindingEditor.Highlight(EventColor, startIndex, length);
break;
case MemberTypes.Field:
case MemberTypes.Property:
bindingEditor.Highlight(PropertyColor, startIndex, length);
break;
case MemberTypes.Custom:
bindingEditor.Highlight(AttachedMemberColor, startIndex, length);
break;
}
}
GetModelMembersAccessors
(
Type targetType
, bool needDefinitionAttributeProcess = false
)
{
var members = TypeHelper
.GetModelMembers
(
targetType
);
foreach (var member in members)
{
var memberName = member.Name;
Type memberType = null;
MemberTypes?memberTypes = null;
if (member is FieldInfo)
{
var fieldInfo = member as FieldInfo;
memberType = fieldInfo.FieldType;
}
else if (member is PropertyInfo)
{
var propertyInfo = member as PropertyInfo;
memberType = propertyInfo.PropertyType;
}
var accessor = new MemberAccessor()
{
Getter = DynamicExpressionTreeHelper
.CreateMemberGetter(targetType, memberName)
,
Setter = DynamicExpressionTreeHelper
.CreateMemberSetter(targetType, memberName)
,
Member = member
,
Types = memberTypes
,
Name = memberName
,
Key = memberName
,
MemberType = GetNullableUnderlyingType(memberType)
};
if (needDefinitionAttributeProcess)
{
var attribute = member
.GetCustomAttributes
(
typeof(MemberAdditionalDefinitionAttribute)
, true
)
.FirstOrDefault(); //as DataTableColumnIDAttribute;
if (attribute != null)
{
var asAttribute =
attribute as MemberAdditionalDefinitionAttribute;
if (asAttribute != null)
{
//if (asAttribute.DataTableColumnDataType != null)
//{
// accessor
// .MemberType = asAttribute
// .DataTableColumnDataType;
//}
accessor
.DefinitionAttribute = asAttribute;
if
(
!asAttribute
.DataTableColumnName
.IsNullOrEmptyOrWhiteSpace()
)
{
accessor
.Key
= asAttribute
.DataTableColumnName;
}
}
}
}
yield
return
(accessor);
}
//var properties = type.GetProperties();
//foreach (var property in properties)
//{
// if
// (
// ModelMemberTypes
// .Any
// (
// (x) =>
// {
// var r = false;
// var propertyType = property.PropertyType;
// if (x == propertyType)
// {
// r = true;
// }
// if (!r)
// {
// if
// (
// propertyType
// .IsGenericType
// &&
// propertyType
// .GetGenericTypeDefinition()
// .Equals
// (
// typeof(Nullable<>)
// )
// )
// {
// if
// (
// x
// ==
// GetNullableUnderlyingType
// (propertyType)
// )
// {
// r = true;
// }
// }
// }
// return r;
// }
// )
// )
// {
// var propertyName = property.Name;
// var propertyType = property.PropertyType;
// var accessor = new MemberAccessor()
// {
// Getter = DynamicPropertyAccessor
// .CreateGetPropertyValueFunc(type, propertyName)
// , Setter = DynamicPropertyAccessor
// .CreateSetPropertyValueAction(type, propertyName)
// , Member = property
// , Name = property.Name
// , Key = property.Name
// , MemberType = GetNullableUnderlyingType(propertyType)
// };
// if (needDefinitionAttributeProcess)
// {
// var attribute = property
// .GetCustomAttributes
// (
// typeof(MemberAdditionalDefinitionAttribute)
// , true
// )
// .FirstOrDefault(); //as DataTableColumnIDAttribute;
// if (attribute != null)
// {
// var asAttribute =
// attribute as MemberAdditionalDefinitionAttribute;
// if (asAttribute != null)
// {
// if (asAttribute.DataTableColumnDataType != null)
// {
// accessor
// .MemberType = asAttribute
// .DataTableColumnDataType;
// }
// accessor
// .DefinitionAttribute = asAttribute;
// if
// (
// !asAttribute
// .DataTableColumnName
// .IsNullOrEmptyOrWhiteSpace()
// )
// {
// accessor
// .Key
// = asAttribute
// .DataTableColumnName;
// }
// }
// }
// }
// yield
// return
// accessor;
// }
//}
//);
//return dictionary;
}
void IXmlHandler.HighlightNode(XmlExpressionNode node)
{
var commentExpressionNode = node as XmlCommentExpressionNode;
if (commentExpressionNode != null)
{
bindingEditor.Highlight(CommentColor, node);
return;
}
var expressionNode = node as XmlValueExpressionNode;
if (expressionNode == null)
{
return;
}
SortedDictionary <string, AutoCompleteItem> list = null;
XmlAttributeExpressionNode attr;
switch (expressionNode.Type)
{
case XmlValueExpressionType.ElementStartTag:
case XmlValueExpressionType.ElementStartTagEnd:
case XmlValueExpressionType.ElementEndTag:
var element = node.Parent as XmlElementExpressionNode;
if (element == null)
{
return;
}
var elementColor = element.Parent == null || _controlsDictionary.TryGetValue(element.Name, out list)
? KnownControlColor
: UnknownControlColor;
bindingEditor.Highlight(elementColor, node);
break;
case XmlValueExpressionType.AttributeName:
element = node.Parent as XmlElementExpressionNode;
if (element == null)
{
attr = node.Parent as XmlAttributeExpressionNode;
if (attr != null)
{
element = attr.Parent;
}
}
if (element == null)
{
return;
}
_controlsDictionary.TryGetValue(element.Name, out list);
if (list == null)
{
bindingEditor.Highlight(UnknownAttachedMemberColor, node);
return;
}
var memberName = node.GetValue(bindingEditor.Text);
var members = memberName.Split(DotSeparator, StringSplitOptions.None);
AutoCompleteItem member;
if (members.Length == 0 || !list.TryGetValue(members[0], out member))
{
bindingEditor.Highlight(UnknownAttachedMemberColor, node);
return;
}
HighlightMember(member.MemberType, node.Start, members[0].Length);
//Highlight for complex path.
if (members.Length > 1)
{
Type type = member.Type;
int startIndex = node.Start + members[0].Length + 1;
for (int i = 1; i < members.Length; i++)
{
var path = members[i];
MemberTypes?memberType = null;
if (type != null)
{
var bindingMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(type, path, false, false);
if (bindingMember == null)
{
type = null;
}
else
{
type = bindingMember.Type;
memberType = (bindingMember.Member as MemberInfo)?.MemberType ?? MemberTypes.Custom;
}
}
HighlightMember(memberType, startIndex, path.Length);
startIndex += path.Length + 1;
}
}
break;
case XmlValueExpressionType.AttributeEqual:
case XmlValueExpressionType.AttributeValue:
attr = node.Parent as XmlAttributeExpressionNode;
if (attr != null)
{
bindingEditor.Highlight(ValueColor, node);
}
break;
}
}
public void Reflect()
{
// Cannot happen from the constructor, but will occur
// if the type doesn't exist and fails to be deserialized
if (targetType == null)
{
if (targetTypeName != null)
{
throw new MissingMemberException(targetTypeName, name);
}
else
{
throw new MissingMemberException("Target type not found.");
}
}
_source = Source.Unknown;
_fieldInfo = null;
_propertyInfo = null;
_methodInfo = null;
_constructorInfo = null;
fieldAccessor = null;
propertyAccessor = null;
methodInvoker = null;
MemberInfo[] candidates;
try
{
candidates = targetType.GetExtendedMember(name, SupportedMemberTypes, SupportedBindingFlags);
}
catch (NotSupportedException e)
{
throw new InvalidOperationException($"An error occured when trying to reflect the member '{name}' of the type '{targetType.FullName}' in a '{GetType().Name}' unit. Supported member types: {SupportedMemberTypes}, supported binding flags: {SupportedBindingFlags}", e);
}
if (candidates.Length == 0) // Not found, check if it might have been renamed
{
var renamedMembers = RuntimeCodebase.RenamedMembers(targetType);
string newName;
if (renamedMembers.TryGetValue(name, out newName))
{
name = newName;
try
{
candidates = targetType.GetExtendedMember(name, SupportedMemberTypes, SupportedBindingFlags);
}
catch (NotSupportedException e)
{
throw new InvalidOperationException($"An error occured when trying to reflect the renamed member '{name}' of the type '{targetType.FullName}' in a '{GetType().Name}' unit. Supported member types: {SupportedMemberTypes}, supported binding flags: {SupportedBindingFlags}", e);
}
}
}
if (candidates.Length == 0) // Nope, not even, abort
{
throw new MissingMemberException($"No matching member found: '{targetType.Name}.{name}'");
}
MemberTypes?memberType = null;
foreach (var candidate in candidates)
{
if (memberType == null)
{
memberType = candidate.MemberType;
}
else if (candidate.MemberType != memberType && !candidate.IsExtensionMethod())
{
// This theoretically shouldn't happen according to the .NET specification, I believe
Debug.LogWarning($"Multiple members with the same name are of a different type: '{targetType.Name}.{name}'");
break;
}
}
switch (memberType)
{
case MemberTypes.Field:
ReflectField(candidates);
break;
case MemberTypes.Property:
ReflectProperty(candidates);
break;
case MemberTypes.Method:
ReflectMethod(candidates);
break;
case MemberTypes.Constructor:
ReflectConstructor(candidates);
break;
default:
throw new UnexpectedEnumValueException <MemberTypes>(memberType.Value);
}
isReflected = true;
}
public OutputMember(string taxonomy, string value, MemberTypes?memberType)
{
Taxonomy = taxonomy;
Value = value;
MemberType = memberType;
}
public static MemberInfo[] GetMemberInternal(this Type type, string member, MemberTypes?memberType, BindingFlags bindingFlags)
{
return(XTypes.Api.GetMemberInternal(type, member, memberType, bindingFlags));
}