private void ResolveDateFormat(AccessorMember member)
{
if (DataType == DataType.Date || DataType == DataType.DateTime)
{
DateFormat = member.TryGetAttribute(out DisplayFormatAttribute displayFormat)
? displayFormat.DataFormatString
: "MM/dd/yyyy";
}
}
public static Action <object, object> OpenDelegateBindSet <TTarget>(AccessorMember member)
where TTarget : class
{
if (member.Type.IsValueType)
{
throw new NotImplementedException();
}
switch (member.MemberInfo)
{
case PropertyInfo property:
{
var setProperty = property.GetSetMethod();
Action <TTarget, object> setter;
var type = typeof(TTarget);
var parameters = setProperty.GetParameters();
switch (parameters.Length)
{
case 0:
{
var action = Delegate.CreateDelegate(
typeof(Action <,>).MakeGenericType(type, parameters[0].ParameterType), setProperty);
setter = (Action <TTarget, object>)CallSetWithValue
.MakeGenericMethod(type, parameters[0].ParameterType)
.Invoke(null, new object[] { action });
break;
}
case 1:
{
var action = Delegate.CreateDelegate(
typeof(Action <,>).MakeGenericType(type, parameters[0].ParameterType), setProperty);
setter = (Action <TTarget, object>)CallSetWithValue
.MakeGenericMethod(type, parameters[0].ParameterType)
.Invoke(null, new object[] { action });
break;
}
default:
throw new NotImplementedException();
}
return((t, v) => setter.Invoke((TTarget)t, v));
}
case FieldInfo field:
{
var setField =
(Action <FieldInfo, TTarget, object>)Delegate.CreateDelegate(
typeof(Action <FieldInfo, TTarget, object>), FieldSetValue);
return((t, v) => setField.Invoke(field, (TTarget)t, v));
}
default:
throw new ArgumentNullException();
}
}
public static Func <object, object> OpenDelegateBindGet <TTarget>(AccessorMember member) where TTarget : class
{
if (member.Type.IsValueType)
{
throw new NotImplementedException();
}
switch (member.MemberInfo)
{
case PropertyInfo property:
{
var getProperty = property.GetGetMethod();
Func <TTarget, object, object> getter;
var type = typeof(TTarget);
var parameters = getProperty.GetParameters();
switch (parameters.Length)
{
case 0:
{
var func = Delegate.CreateDelegate(
typeof(Func <,>).MakeGenericType(type, getProperty.ReturnType), getProperty);
getter = (Func <TTarget, object, object>)CallGetWithNoArguments
.MakeGenericMethod(type, getProperty.ReturnType).Invoke(null, new object[] { func });
break;
}
case 1:
{
var func = Delegate.CreateDelegate(
typeof(Func <, ,>).MakeGenericType(type, parameters[0].ParameterType,
getProperty.ReturnType), getProperty);
getter = (Func <TTarget, object, object>)CallGetWithOneArgument
.MakeGenericMethod(type, parameters[0].ParameterType, getProperty.ReturnType)
.Invoke(null, new object[] { func });
break;
}
default:
throw new NotImplementedException();
}
return(o => getter.Invoke((TTarget)o, null));
}
case FieldInfo field:
{
var getField =
(Func <FieldInfo, TTarget, object>)Delegate.CreateDelegate(
typeof(Func <FieldInfo, TTarget, object>), FieldGetValue);
return(t => getField.Invoke(field, (TTarget)t));
}
default:
throw new ArgumentNullException();
}
}
public static Func <object, object> CallSiteBindGet(AccessorMember member)
{
var args = new List <CSharpArgumentInfo> {
CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
};
var binder = Binder.GetMember(CSharpBinderFlags.None, member.Name, member.MemberInfo.DeclaringType, args);
var callsite = CallSite <Func <CallSite, object, object> > .Create(binder);
return(t => callsite.Target(callsite, t));
}
private void ResolveReadOnly(AccessorMember member)
{
if (member.TryGetAttribute(out ReadOnlyAttribute readOnly))
{
IsReadOnly = readOnly.IsReadOnly;
}
else if (!member.CanWrite)
{
IsReadOnly = true;
}
}
private static AccessorMember MaybeUseMetadata(AccessorMember member, string profile)
{
if (member.DeclaringType != null)
{
member = MaybeSwapMetadataMember(member.DeclaringType, member, profile);
}
member = MaybeSwapMetadataMember(member.MemberInfo, member, profile);
return(member);
}
public AccessorMemberDisplay(AccessorMember member, string profile)
{
member = MaybeUseMetadata(member, profile);
ResolveName(member);
ResolvePrompt(member);
ResolveDataType(member);
ResolveDateFormat(member);
ResolveReadOnly(member);
ResolveVisible(member);
}
private void ResolveDataType(AccessorMember member)
{
if (!member.TryGetAttribute(out DataTypeAttribute dataType))
{
DataType = DataType.Text;
return;
}
DataType = dataType.DataType;
if (DataType == DataType.Custom)
{
CustomDataType = dataType.CustomDataType;
}
}
public static Action <object, object> DynamicMethodBindSet(AccessorMember member)
{
var skipVisibility = member.Type.IsNotPublic;
var dm = new DynamicMethod($"{member.Name}", typeof(void), new[] { typeof(object), typeof(object) },
skipVisibility);
var il = dm.GetILGenerator();
Type memberType;
switch (member.MemberInfo)
{
case PropertyInfo property:
memberType = property.PropertyType;
break;
case FieldInfo field:
memberType = field.FieldType;
break;
default:
throw new ArgumentOutOfRangeException(nameof(member));
}
var declaringType = member.MemberInfo.DeclaringType;
il.Emit(OpCodes.Ldarg_0); // target
il.Emit(OpCodes.Castclass, declaringType); // (Type)target
il.Emit(OpCodes.Ldarg_1); // value
il.Emit(OpCodes.Castclass, memberType); // ({member.Type}) value
switch (member.MemberInfo)
{
case PropertyInfo property:
var setMethod = property.GetSetMethod(true);
il.Emit(setMethod.IsFinal || !setMethod.IsVirtual ? OpCodes.Call : OpCodes.Callvirt, setMethod);
break;
case FieldInfo field:
il.Emit(OpCodes.Stfld, field);
break;
default:
throw new ArgumentOutOfRangeException(nameof(member));
}
il.Emit(OpCodes.Ret);
return((Action <object, object>)dm.CreateDelegate(typeof(Action <object, object>)));
}
public static Func <object, object> DynamicMethodBindGet(AccessorMember member)
{
var skipVisibility = member.Type.IsNotPublic;
var dm = new DynamicMethod($"{member.Name}", typeof(object), new[] { typeof(object) }, skipVisibility);
var il = dm.GetILGenerator();
switch (member.MemberInfo)
{
case PropertyInfo property:
{
var getMethod = property.GetGetMethod(true);
if (getMethod == null)
{
throw new ArgumentNullException();
}
il.Emit(OpCodes.Ldarg_0);
il.Emit(getMethod.IsFinal || !getMethod.IsVirtual ? OpCodes.Call : OpCodes.Callvirt, getMethod);
if (property.PropertyType.IsValueType)
{
il.Emit(OpCodes.Box, property.PropertyType);
}
break;
}
case FieldInfo field:
if (field.IsStatic)
{
il.Emit(OpCodes.Ldsfld, field);
}
else
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, field);
}
if (field.FieldType.IsValueType)
{
il.Emit(OpCodes.Box, field.FieldType);
}
break;
}
il.Emit(OpCodes.Ret);
return((Func <object, object>)dm.CreateDelegate(typeof(Func <object, object>)));
}
private void ResolveVisible(AccessorMember member)
{
if (member.TryGetAttribute(out BrowsableAttribute browsable))
{
IsVisible = browsable.Browsable;
}
else if (member.TryGetAttribute(out DesignTimeVisibleAttribute visible))
{
IsVisible = visible.Visible;
}
else if (!member.CanRead)
{
IsVisible = false;
}
else
{
IsVisible = true;
}
}
public static Action <object, object> ExpressionBindSet(AccessorMember member)
{
var declaringType = member.MemberInfo.DeclaringType;
if (declaringType == null)
{
throw new ArgumentNullException();
}
switch (member.MemberInfo)
{
case PropertyInfo property:
{
var setMethod = property.GetSetMethod();
if (setMethod == null)
{
throw new ArgumentNullException();
}
var targetParam = Expression.Parameter(typeof(object), "target");
var valueParam = Expression.Parameter(typeof(object), "value");
var call = Expression.Call(Expression.Convert(targetParam, declaringType), setMethod,
Expression.Convert(valueParam, property.PropertyType));
var lambda = Expression.Lambda <Action <object, object> >(call, targetParam, valueParam);
return(lambda.Compile());
}
case FieldInfo field:
{
var targetParam = Expression.Parameter(typeof(object), "target");
var valueParam = Expression.Parameter(typeof(object), "value");
var setField = Expression.Field(Expression.Convert(targetParam, declaringType), field);
var lambda = Expression.Lambda <Action <object, object> >(
Expression.Convert(Expression.Assign(setField, Expression.Convert(valueParam, field.FieldType)),
typeof(object)), targetParam, valueParam);
return(lambda.Compile());
}
default:
throw new ArgumentException();
}
}
public static Action <object, object> MethodInvokeBindSet(AccessorMember member)
{
switch (member.MemberInfo)
{
case PropertyInfo property:
{
var setMethod = property.GetSetMethod();
if (setMethod == null)
{
throw new ArgumentNullException();
}
return((o, v) => setMethod.Invoke(o, new[] { v }));
}
case FieldInfo field:
return((o, v) => field.SetValue(o, v));
default:
throw new ArgumentException();
}
}
private void ResolveName(AccessorMember member)
{
if (member.TryGetAttribute(out DisplayAttribute display))
{
Name = display.GetName() ?? display.GetShortName();
if (Name != null)
{
return;
}
}
if (member.TryGetAttribute(out DisplayNameAttribute displayName))
{
Name = displayName.DisplayName;
if (Name != null)
{
return;
}
}
Name = member.Name;
}
public static Func <object, object> MethodInvokeBindGet(AccessorMember member)
{
switch (member.MemberInfo)
{
case PropertyInfo property:
{
var getMethod = property.GetGetMethod();
if (getMethod == null)
{
throw new ArgumentNullException();
}
return(o => getMethod.Invoke(o, null));
}
case FieldInfo field:
{
return(o => field.GetValue(o));
}
default:
throw new ArgumentException();
}
}
private static MethodInfo GetOrSwapPropertySetter(PropertyInfo property,
Dictionary <AccessorMember, MethodInfo> callSwaps, AccessorMember member)
{
var setMethod = property.GetSetMethod(true);
if (setMethod == null)
{
setMethod = callSwaps[member];
}
return(setMethod);
}
public static Func <object, object[], object> DynamicMethodBindCall(AccessorMember member)
{
return(DynamicMethodBindCall((MethodInfo)member.MemberInfo));
}
private void ResolvePrompt(AccessorMember member)
{
Prompt = member.TryGetAttribute(out DisplayAttribute display) ? display.GetPrompt() : string.Empty;
}
private static AccessorMember MaybeSwapMetadataMember(ICustomAttributeProvider authority, AccessorMember member,
string profile)
{
foreach (var attribute in authority.GetAttributes <MetadataTypeAttribute>())
{
if (attribute.Profile != profile)
{
continue;
}
var types = AccessorMemberTypes.None;
types |= member.MemberType switch
{
AccessorMemberType.Field => AccessorMemberTypes.Fields,
AccessorMemberType.Property => AccessorMemberTypes.Properties,
AccessorMemberType.Method => AccessorMemberTypes.Methods,
_ => throw new ArgumentOutOfRangeException()
};
var members = AccessorMembers.Create(attribute.MetadataType, types, member.Scope);
foreach (var m in members)
{
if (m.Name != member.Name)
{
continue;
}
member = m;
break;
}
}
return(member);
}
