private void SetFieldOrPropValue(FieldOrProp fieldOrProp, object info, object value)
{
if (fieldOrProp == FieldOrProp.Field)
{
((FieldInfo)info).SetValue(this, value);
}
else if (fieldOrProp == FieldOrProp.Property)
{
((PropertyInfo)info).SetValue(this, value);
}
return;
}
public void SetFieldOrPropValue(string fieldOrPropName, object value)
{
FieldOrProp fieldOrProp = FieldOrProp.Unknown;
object info = null;
Type fieldOrPropType = null;
var fieldInfo = typeof(Settings).GetField(fieldOrPropName);
if (fieldInfo != null)
{
fieldOrPropType = fieldInfo.FieldType;
fieldOrProp = FieldOrProp.Field;
info = fieldInfo;
}
var propInfo = typeof(Settings).GetProperty(fieldOrPropName);
if (propInfo != null)
{
fieldOrPropType = propInfo.PropertyType;
fieldOrProp = FieldOrProp.Property;
info = propInfo;
}
if (fieldOrPropType == null)
{
return;
}
if (typeof(IEnumerable).IsAssignableFrom(fieldOrPropType))
{
//Assume all enumerable values are of string type for now
var pieces = ((string)value).Split(new string[] { "\r\n", " ", ";", "\t" }, StringSplitOptions.RemoveEmptyEntries);
var subType = fieldOrPropType.GetGenericArguments()[0];
var newList = Activator.CreateInstance(fieldOrPropType);
foreach (string p in pieces)
{
newList.GetType().GetMethod("Add").Invoke(newList, new object[] { Convert.ChangeType(p, newList.GetType().GetGenericArguments().Single()) });
}
SetFieldOrPropValue(fieldOrProp, info, newList);
}
else
{
SetFieldOrPropValue(fieldOrProp, info, Convert.ChangeType(value, fieldOrPropType));
}
}
internal static List <SerializedMember> GetSerializableMembers(Type type, TargetMember defaultTargetMembers, Func <SerializedMember, SerializationOverride> fieldFilter = null)
{
List <SerializedMember> members = new List <SerializedMember>();
var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var classConfig = type.GetCustomAttribute <MemberConfig>();
foreach (var m in type.GetFields(flags).Cast <MemberInfo>().Concat(type.GetProperties(flags)))
{
bool isPublic;
bool isField = false, isProp = false;
if (m is FieldInfo f)
{
// Skip readonly
if (f.IsInitOnly)
{
continue;
}
// Skip property backing fields
if (f.GetCustomAttribute <CompilerGeneratedAttribute>() != null)
{
continue;
}
isPublic = f.IsPublic;
isField = true;
}
else if (m is PropertyInfo p)
{
if (!p.CanRead || !p.CanWrite)
{
continue;
}
if (p.GetIndexParameters().Length != 0)
{
continue;
}
isPublic = p.GetMethod.IsPublic;
isProp = true;
}
else
{
continue;
}
var serializedMember = FieldOrProp.Create(m);
//
// 1.) Use filter if there is one
if (fieldFilter != null)
{
var filterResult = fieldFilter(serializedMember);
if (filterResult == SerializationOverride.ForceInclude)
{
members.Add(serializedMember);
continue;
}
else if (filterResult == SerializationOverride.ForceSkip)
{
continue;
}
}
//
// 2.) Use attribute
var ignore = m.GetCustomAttribute <Ignore>(true) != null;
var include = m.GetCustomAttribute <Include>(true) != null;
if (ignore && include)
{
throw new Exception($"Member '{m.Name}' on type '{type.Name}' has both [Ignore] and [Include]!");
}
if (ignore)
{
continue;
}
if (include)
{
members.Add(serializedMember);
continue;
}
//
// 3.) Use class attributes
if (classConfig != null)
{
if (IsMatch(isField, isProp, isPublic, classConfig.TargetMembers))
{
members.Add(serializedMember);
continue;
}
}
//
// 4.) Use global defaults
if (IsMatch(isField, isProp, isPublic, defaultTargetMembers))
{
members.Add(serializedMember);
continue;
}
}
members.Sort(_memberComparer);
return(members);
}
