static object GetMemberValue(MemberInfo mi, object inst)
{
if (mi.MemberType == MemberTypes.Property)
{
return(mi.As <PropertyInfo>().GetValue(inst));
}
return(mi.As <FieldInfo>().GetValue(inst));
}
public static bool IsReadonly(this MemberInfo member)
{
switch (member.MemberType)
{
case MemberTypes.Field: return(member.As <FieldInfo>().IsInitOnly);
case MemberTypes.Property: return(!member.As <PropertyInfo>().CanWrite);
default: return(true);
}
}
public static Type GetPropertyOrFieldType(this MemberInfo member)
{
switch (member.MemberType)
{
case MemberTypes.Field: return(member.As <FieldInfo>().FieldType);
case MemberTypes.Property: return(member.As <PropertyInfo>().PropertyType);
default: throw new OnlyPropertiesAndFieldsSupportedException();
}
}
public static Type GetMemberType(this MemberInfo member)
{
switch (member.MemberType)
{
case MemberTypes.Field:
return(member.As <FieldInfo>().FieldType);
case MemberTypes.Property:
return(member.As <PropertyInfo>().PropertyType);
}
return(null);
}
public static void Set(this MemberInfo member, object source, object value)
{
switch (member.MemberType)
{
case MemberTypes.Field:
member.As <FieldInfo>().SetValue(source, value);
break;
case MemberTypes.Property:
member.As <PropertyInfo>().SetValue(source, value, null);
break;
}
}
public static Type GetMemberType(this MemberInfo member)
{
if (member is FieldInfo)
{
return(member.As <FieldInfo>().FieldType);
}
if (member is PropertyInfo)
{
return(member.As <PropertyInfo>().PropertyType);
}
throw new NotSupportedException();
}
/// <summary>
/// Gets the public or private member using reflection.
/// </summary>
/// <param name="obj">The source target.</param>
/// <param name="memberName">Name of the field or property.</param>
/// <returns>the value of member</returns>
public static object GetMemberValue(this object obj, string memberName)
{
MemberInfo memInf = GetMemberInfo(obj, memberName);
if (memInf == null)
{
throw new Exception("memberName");
}
return(memInf switch
{
PropertyInfo => memInf.As <PropertyInfo>().GetValue(obj, null),
FieldInfo => memInf.As <FieldInfo>().GetValue(obj),
_ => throw new Exception()
});
public static Type GetRawMemberType(this MemberInfo member)
{
Type rawType = null;
if (member is FieldInfo)
{
rawType = member.As <FieldInfo>().FieldType;
}
if (member is PropertyInfo)
{
rawType = member.As <PropertyInfo>().PropertyType;
}
return(rawType);
}
public static object Get(this MemberInfo member, object source)
{
switch (member.MemberType)
{
case MemberTypes.Field:
member.As <FieldInfo>().GetValue(source);
break;
case MemberTypes.Property:
member.As <PropertyInfo>().GetValue(source, null);
break;
}
return(null);
}
public static Type GetMemberType(this MemberInfo member)
{
Type rawType = null;
if (member is FieldInfo)
{
rawType = member.As <FieldInfo>().FieldType;
}
if (member is PropertyInfo)
{
rawType = member.As <PropertyInfo>().PropertyType;
}
return(rawType.IsNullable() ? rawType.GetInnerTypeFromNullable() : rawType);
}
public LambdaExpression ToSetterLambda(Type concreteType, ParameterExpression target)
{
var lambdaType = typeof(Action <, ,>).MakeGenericType(typeof(IBuildSession), typeof(IContext), concreteType);
var method = _member.As <PropertyInfo>().GetSetMethod();
var callSetMethod = Expression.Call(target, method,
AssignedValue.ToExpression(Parameters.Session, Parameters.Context));
return(Expression.Lambda(lambdaType, callSetMethod, Parameters.Session, Parameters.Context, target));
}
public long GetVersion(T aggregate)
{
if (VersionMember is PropertyInfo prop)
{
return(Convert.ToInt64(prop.GetValue(aggregate)));
}
return(Convert.ToInt64(VersionMember.As <FieldInfo>().GetValue(aggregate)));
}
/// <summary>
/// Gets the public or private member using reflection.
/// </summary>
/// <param name="obj">The source target.</param>
/// <param name="memberName">Name of the field or property.</param>
/// <returns>the value of member</returns>
public static object GetMemberValue(this object obj, string memberName)
{
MemberInfo memberInfo = GetMemberInfo(obj, memberName);
if (memberInfo == null)
{
throw new Exception("memberName");
}
if (memberInfo is PropertyInfo)
{
return(memberInfo.As <PropertyInfo>().GetValue(obj, null));
}
if (memberInfo is FieldInfo)
{
return(memberInfo.As <FieldInfo>().GetValue(obj));
}
throw new Exception();
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
var prop = base.CreateProperty(member, memberSerialization);
if (prop.Writable)
{
return(prop);
}
prop.Writable = member.As <PropertyInfo> ()?.GetSetMethod(true) != null;
return(prop);
}
public static bool IsPublicPropertyOrField(this MemberInfo member)
{
switch (member.MemberType)
{
case MemberTypes.Field: return(member.As <FieldInfo>().IsPublic);
case MemberTypes.Property:
var property = (PropertyInfo)member;
return((property.CanRead && property.GetGetMethod(true).IsPublic) ||
(property.CanWrite && property.GetSetMethod(true).IsPublic));
default: return(false);
}
}
public static bool IsIndexer(this MemberInfo member)
{
return(member.MemberType == MemberTypes.Property &&
member.As <PropertyInfo>().GetIndexParameters().Length > 0);
}
public static Action <TTarget, TMember> Setter <TTarget, TMember>(MemberInfo member)
{
return(member is PropertyInfo
? SetProperty <TTarget, TMember>(member.As <PropertyInfo>())
: SetField <TTarget, TMember>(member.As <FieldInfo>()));
}
public static Func <TTarget, TMember> Getter <TTarget, TMember>(MemberInfo member)
{
return(member is PropertyInfo
? GetProperty <TTarget, TMember>(member.As <PropertyInfo>())
: GetField <TTarget, TMember>(member.As <FieldInfo>()));
}
/// <summary>
/// Returns the expected name for a member element in the XML
/// documentation file. The general format is, using the example of a
/// method,'M:Namespace.Class.Method'.
/// </summary>
/// <param name="member">The reflected member.</param>
/// <returns>The name of the member element.</returns>
private static string GetMemberElementName(MemberInfo member)
{
string memberName;
if (member is Type)
{
memberName = member.As <Type>().FullName;
}
else
{
// member belongs to a Type
memberName = member.DeclaringType.FullName + "." + member.Name;
}
char prefixCode;
switch (member.MemberType)
{
case MemberTypes.Constructor:
// XML documentation uses slightly different constructor names
memberName = memberName.Replace(".ctor", "#ctor");
goto case MemberTypes.Method;
case MemberTypes.Method:
prefixCode = 'M';
// parameters are listed according to their type, not their name
string paramTypesList = String.Join(
",",
((MethodBase)member).GetParameters()
.Cast <ParameterInfo>()
.Select(x => x.ParameterType.GetGenericTypeName(true)
).ToArray()
);
if (!String.IsNullOrEmpty(paramTypesList))
{
memberName += "(" + paramTypesList + ")";
}
break;
case MemberTypes.Event:
prefixCode = 'E';
break;
case MemberTypes.Field:
prefixCode = 'F';
break;
case MemberTypes.NestedType:
// XML documentation uses slightly different nested type names
memberName = memberName.Replace('+', '.');
goto case MemberTypes.TypeInfo;
case MemberTypes.TypeInfo:
prefixCode = 'T';
break;
case MemberTypes.Property:
prefixCode = 'P';
break;
default:
throw new ArgumentException("Unknown member type", "member");
}
return(String.Format("{0}:{1}", prefixCode, memberName));
}