private IEnumerable <MemberInfo> Filter(IReflect type) =>
type
.GetMembers(BindingFlags.Instance
| BindingFlags.FlattenHierarchy
| BindingFlags.Public)
.Where(IncludeFields)
.Where(IgnoredMembers);
/// <summary>
/// Extracts the inspectables.
/// </summary>
/// <returns>The inspectables.</returns>
/// <param name="type">Type.</param>
private static IEnumerable <MemberWithAttr> ExtractTargetMembers(IReflect type)
{
var members = type.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance);
foreach (var member in members)
{
var attrs = member.GetCustomAttributes(true);
foreach (var attr in attrs)
{
var a = attr as GetSheetAttribute;
if (a == null)
{
continue;
}
yield return(new MemberWithAttr
{
member = member,
attr = a,
});
}
}
}
/// <summary>
/// extract all non-readonly fields and properties. als check Ignore attribute
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static List <MemberInfo> GetMembers(IReflect type)
{
return(type.GetMembers(BindingFlags.Public | BindingFlags.Instance)
.Where(mi => (mi.MemberType == MemberTypes.Field || mi.MemberType == MemberTypes.Property) &&
!mi.GetCustomAttributes <Transform>().Any(a => a.Ignore) &&
!IsReadonlyMember(mi)).ToList());
}
private Tuple <MethodInfo, MemberInfo?>?FindCommandPair([NotNull] IReflect targetType, out bool finded)
{
finded = false;
var methods =
targetType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
var main = (from method in methods
let attr = method.GetCustomAttribute <CommandTargetAttribute>()
where attr != null && attr.ProvideMemberName(method) == Name
select new { Method = method, IsSync = attr.Synchronize }).FirstOrDefault();
if (main == null)
{
Debug.Print($"CommandBinder: No Command-Method Found: {Name}");
return(null);
}
finded = true;
_isSync = main.IsSync;
var mainAttr = main.Method.GetCustomAttribute <CommandTargetAttribute>();
MemberInfo?second = null;
foreach (var m in targetType.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
var attr = m.GetCustomAttribute <CommandTargetAttribute>();
if (attr == null)
{
continue;
}
var name = attr.ProvideMemberName(m);
if (mainAttr?.CanExecuteMember != null)
{
if (mainAttr.CanExecuteMember != name)
{
continue;
}
}
else
{
if (Name != name && m == main.Method)
{
continue;
}
if ("Can" + Name != name)
{
continue;
}
}
second = m;
break;
}
return(Tuple.Create(main.Method, second));
}
private static IEnumerable <MemberInfo> GetAllColumnsForType(this IReflect sourceType)
{
return(sourceType.GetMembers(BindingFlags.GetField |
BindingFlags.GetProperty |
BindingFlags.Instance |
BindingFlags.Public)
.Where(m => m.MemberType == MemberTypes.Field || m.MemberType == MemberTypes.Property)
.Where(p => p.CustomAttributes.All(a => a.AttributeType.Name != "NotMappedAttribute")));
}
/// <summary>
/// Extracts the inspectables.
/// </summary>
/// <returns>The inspectables.</returns>
/// <param name="type">Type.</param>
static IEnumerable <MemberInfo> ExtractInspectableMembers(IReflect type)
{
var members = type.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (var member in members)
{
var attrs = member.GetCustomAttributes(true);
if (attrs.Any(a => a.GetType() == InspectableType))
{
yield return(member);
}
}
}
public void UpdateAvailableFormatingParts(IReflect type)
{
if (type is null)
{
return;
}
AvailableFormatingPartsGroupList = type
.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Select(members => members.GetCustomAttributes <FormattedFieldAttribute>())
.SelectMany();
foreach (FormattedFieldAttribute attr in AvailableFormatingPartsGroupList)
{
foreach (String linkedName in attr.LinkedNames)
{
if (String.IsNullOrEmpty(linkedName))
{
continue;
}
AvailableFormatingParts.Add(linkedName);
if (attr.Uniqueness)
{
UniqueFormatingParts.Add(linkedName);
}
foreach (String attribute in attr.Attributes)
{
String str = linkedName + ":" + attribute;
AvailableFormatingParts.Add(str);
if (attr.Uniqueness)
{
UniqueFormatingParts.Add(str);
}
}
}
}
}
System.Reflection.MemberInfo[] IReflect.GetMembers(System.Reflection.BindingFlags bindingAttr)
{
return(typeIReflectImplementation.GetMembers(bindingAttr));
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr) => publicIReflect.GetMembers(bindingAttr);
private static object[] GetProperties(IReflect type)
{
SortedList<string, List<EditorProperty>> folders = new SortedList<string, List<EditorProperty>>();
// Get all public and not so public fields and properties with EditorProperty
// attribute.
var members =
type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.Where(member => member.ContainsAttribute<EditorPropertyAttribute>());
foreach (MemberInfo member in members)
{
EditorPropertyAttribute attribute = member.GetAttribute<EditorPropertyAttribute>();
// Validate the type.
EditorPropertyType propType = Entity.GetEditorType(member.GetAssociatedType(), attribute.Type);
// Use default folder, if it is not specified.
string folderName = attribute.Folder ?? "Default";
// Register new folder, if there is a need for that.
if (!folders.ContainsKey(folderName))
{
folders.Add(folderName, new List<EditorProperty>());
}
// Add the property to the folder.
folders[folderName].Add
(
new EditorProperty
(
attribute.Name ?? member.Name,
attribute.Description,
attribute.DefaultValue ?? new Func<string>
(
delegate
{
switch (propType)
{
case EditorPropertyType.Bool:
return "false";
case EditorPropertyType.Int:
case EditorPropertyType.Float:
return "0";
case EditorPropertyType.Vector3:
case EditorPropertyType.Color:
return "0,0,0";
default:
return "";
}
}
).Invoke(),
propType,
new EditorPropertyLimits
{
Min = attribute.Min,
Max = attribute.Max
},
attribute.Flags
)
);
}
// Now lets create the array of properties.
List<object> properties = new List<object>();
foreach (KeyValuePair<string, List<EditorProperty>> folder in folders)
{
if (folder.Key == "Default")
{
properties.AddRange(folder.Value.Cast<object>());
}
else
{
properties.Add(new EditorProperty(folder.Key, "", "", EditorPropertyType.FolderBegin));
properties.AddRange(folder.Value.Cast<object>());
properties.Add(new EditorProperty(folder.Key, "", "", EditorPropertyType.FolderEnd));
}
}
return properties.ToArray();
}
private static IEnumerable <MemberInfo> GetInterfaceMembers(IReflect type)
{
return(type.GetMembers(BindingFlags.Public | BindingFlags.Instance)
.Where(mi => mi.MemberType == MemberTypes.Field || mi.MemberType == MemberTypes.Property));
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr)
{
var ret = typeIReflectImplementation.GetMembers(bindingAttr);
return(ret);
}
private static object[] GetProperties(IReflect type)
{
SortedList <string, List <EditorProperty> > folders = new SortedList <string, List <EditorProperty> >();
// Get all public and not so public fields and properties with EditorProperty
// attribute.
var members =
type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.Where(member => member.ContainsAttribute <EditorPropertyAttribute>());
foreach (MemberInfo member in members)
{
EditorPropertyAttribute attribute = member.GetAttribute <EditorPropertyAttribute>();
// Validate the type.
EditorPropertyType propType = Entity.GetEditorType(member.GetAssociatedType(), attribute.Type);
// Use default folder, if it is not specified.
string folderName = attribute.Folder ?? "Default";
// Register new folder, if there is a need for that.
if (!folders.ContainsKey(folderName))
{
folders.Add(folderName, new List <EditorProperty>());
}
// Add the property to the folder.
folders[folderName].Add
(
new EditorProperty
(
attribute.Name ?? member.Name,
attribute.Description,
attribute.DefaultValue ?? new Func <string>
(
delegate
{
switch (propType)
{
case EditorPropertyType.Bool:
return("false");
case EditorPropertyType.Int:
case EditorPropertyType.Float:
return("0");
case EditorPropertyType.Vector3:
case EditorPropertyType.Color:
return("0,0,0");
default:
return("");
}
}
).Invoke(),
propType,
new EditorPropertyLimits
{
Min = attribute.Min,
Max = attribute.Max
},
attribute.Flags
)
);
}
// Now lets create the array of properties.
List <object> properties = new List <object>();
foreach (KeyValuePair <string, List <EditorProperty> > folder in folders)
{
if (folder.Key == "Default")
{
properties.AddRange(folder.Value.Cast <object>());
}
else
{
properties.Add(new EditorProperty(folder.Key, "", "", EditorPropertyType.FolderBegin));
properties.AddRange(folder.Value.Cast <object>());
properties.Add(new EditorProperty(folder.Key, "", "", EditorPropertyType.FolderEnd));
}
}
return(properties.ToArray());
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr)
{
return(_typeIReflectImplementation.GetMembers(bindingAttr));
}
MemberInfo[] IReflect.GetMembers(BindingFlags bindingAttr)
{
return(publicIReflect.GetMembers(bindingAttr));
}