public static IReflectionTableBuilder AddEventAttributes(this IReflectionTableBuilder builder, Type type, string eventName, IEnumerable <Attribute> attributes)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type), $"{nameof(type)} is null.");
}
if (string.IsNullOrEmpty(eventName))
{
throw new ArgumentException($"{nameof(eventName)} is null or empty.", nameof(eventName));
}
if (attributes == null)
{
throw new ArgumentNullException(nameof(attributes), $"{nameof(attributes)} is null.");
}
EventInfo eventInfo = type.GetTypeInfo().GetEvent(eventName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);
if (eventInfo == null)
{
throw new ArgumentException($"The type {type.FullName} does not declare an event named \"{eventName}\".");
}
return(builder.AddMemberAttributes(eventInfo, attributes));
}
public static IReflectionTableBuilder AddMemberAttributes <T>(this IReflectionTableBuilder builder, Expression <Action <T> > expression, IEnumerable <Attribute> attributes)
{
var member = Reflect.GetMember <T>(expression);
if (!member.DeclaringType.Equals(typeof(T)))
{
throw new ArgumentException($"The type '{typeof(T).FullName}' does not declare a member '{member.Name}'.");
}
return(builder.AddMemberAttributes(member, attributes));
}
private static IReflectionTableBuilder AddParameterAttributes(IReflectionTableBuilder builder, LambdaExpression expression)
{
MethodCallExpression methodCallExpression = expression.Body as MethodCallExpression;
if (methodCallExpression == null)
{
throw new ArgumentException("Expression is not a single method call expression.");
}
MethodInfo targetMethod = (MethodInfo)Reflect.GetMemberInternal(methodCallExpression, true);
var parameters = targetMethod.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var argCall = GetMethodCallExpression(methodCallExpression.Arguments[i]);
if (argCall != null)
{
if (argCall.Method.IsGenericMethod && (s_decorateEnumerableMethodInfo.Equals(argCall.Method.GetGenericMethodDefinition())))
{
Expression attrArg = argCall.Arguments[0];
var argLamb = Expression.Lambda <Func <IEnumerable <Attribute> > >(attrArg).Compile();
var attributes = argLamb();
builder.AddParameterAttributes(parameter, attributes);
}
else if (s_decorateParamsMethodInfo.Equals(argCall.Method.GetGenericMethodDefinition()))
{
Expression attrArg = argCall.Arguments[0];
var argLamb = Expression.Lambda <Func <Attribute[]> >(attrArg).Compile();
var attributes = argLamb();
builder.AddParameterAttributes(parameter, attributes);
}
}
}
return(builder);
}
public static IReflectionTableBuilder AddEventAttributes <T>(this IReflectionTableBuilder builder, string eventName, params Attribute[] attributes)
{
return(AddEventAttributes(builder, typeof(T), eventName, attributes));
}
public static IReflectionTableBuilder AddPropertyAttributes <T>(this IReflectionTableBuilder builder, Type type, string propertyName, params Attribute[] attributes)
{
return(AddPropertyAttributes(builder, type, propertyName, attributes.AsEnumerable()));
}
/// <summary>Used to return a builder that will add attributes to the type specified by <paramref name="implementationType"/>, but allows
/// strong typing using the type <typeparamref name="TInterface"/>. Usable when you want to add attributes to a concrete type, but you
/// only have compile time access to an interface of that type.</summary>
/// <exception cref="NotSupportedException">Thrown when the requested operation is not supported.</exception>
/// <typeparam name="TInterface">Type of the interface.</typeparam>
/// <param name="builder">The builder to act on.</param>
/// <param name="implementationType">The implementation type to actually add the attributes to.</param>
public static IMappedTypedReflectionTableBuilder <TInterface> ForType <TInterface>(this IReflectionTableBuilder builder, Type implementationType)
{
if (!typeof(TInterface).IsAssignableFrom(implementationType))
{
throw new NotSupportedException($"The {nameof(implementationType)} must derive from- or implement the type {typeof(TInterface).FullName} to be used in the reflection table builder.");
}
return(new MappedTypedReflectionTableBuilder <TInterface>(builder, implementationType));
}
public static ITypedReflectionTableBuilder <T> ForType <T>(this IReflectionTableBuilder builder)
{
return(new TypedReflectionTableBuilder <T>(builder));
}
public static IReflectionTableBuilder AddTypeAttributes <T>(this IReflectionTableBuilder builder, IEnumerable <Attribute> attributes)
{
return(builder.AddMemberAttributes(typeof(T), attributes));
}
public TypedReflectionTableBuilder(IReflectionTableBuilder builder)
{
m_builder = builder;
}
public static IReflectionTableBuilder AddMemberAttributes <T>(this IReflectionTableBuilder builder, Expression <Action <T> > expression, params Attribute[] attributes)
{
return(AddMemberAttributes(builder, expression, attributes.AsEnumerable()));
}
public static IReflectionTableBuilder AddMemberAttributes(this IReflectionTableBuilder builder, Expression <Action> expression, IEnumerable <Attribute> attributes)
{
var member = Reflect.GetMember(expression);
return(builder.AddMemberAttributes(member, attributes));
}
public static IReflectionTableBuilder AddReturnParameterAttributes(this IReflectionTableBuilder builder, Expression <Action> expression, IEnumerable <Attribute> attributes)
{
var method = Reflect.GetMethod(expression);
return(builder.AddParameterAttributes(method.ReturnParameter, attributes));
}
public static IReflectionTableBuilder AddParameterAttributes <T>(this IReflectionTableBuilder builder, Expression <Action <T> > expression)
{
return(AddParameterAttributes(builder, (LambdaExpression)expression));
}
public static IReflectionTableBuilder AddPropertyAttributes <T>(this IReflectionTableBuilder builder, string propertyName, params Attribute[] attributes)
{
return(AddPropertyAttributes(builder, typeof(T), propertyName, attributes));
}
public static IReflectionTableBuilder AddTypeAttributes(this IReflectionTableBuilder builder, Type type, params Attribute[] attributes)
{
return(builder.AddMemberAttributes(type, attributes.AsEnumerable()));
}
public static IReflectionTableBuilder AddEventAttributes(this IReflectionTableBuilder builder, Type type, string eventName, params Attribute[] attributes)
{
return(AddEventAttributes(builder, type, eventName, attributes.AsEnumerable()));
}
public static IReflectionTableBuilder AddTypeAttributes <T>(this IReflectionTableBuilder builder, params Attribute[] attributes)
{
return(AddTypeAttributes <T>(builder, attributes.AsEnumerable()));
}
public MappedTypedReflectionTableBuilder(IReflectionTableBuilder builder, Type concreteType)
{
m_concreteType = concreteType;
m_builder = builder;
}
public static IReflectionTableBuilder AddFieldAttributes <T>(this IReflectionTableBuilder builder, string fieldName, params Attribute[] attributes)
{
return(AddFieldAttributes(builder, typeof(T), fieldName, attributes));
}
