/// <summary>
/// Include specified field to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="field">Field to include</param>
/// <returns>Fluent</returns>
public static PropertyExportConfigurationBuilder WithField <T, TData>(this TypeConfigurationBuilder <T> tc,
Expression <Func <T, TData> > field)
{
var prop = LambdaHelpers.ParseFieldLambda(field);
ITypeConfigurationBuilder tcb = tc;
return(new PropertyExportConfigurationBuilder(prop, tc._blueprint));
}
/// <summary>
/// Include specified method to resulting typing.
/// User <see cref="Ts.Parameter{T}()" /> to mock up method parameters or specify configuration for perticular method
/// parameter
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="method">Method to include</param>
/// <param name="configuration">Configuration to be applied to method</param>
/// <returns>Fluent</returns>
public static ClassConfigurationBuilder <T> WithMethod <T>(this ClassConfigurationBuilder <T> tc,
Expression <Action <T> > method, Action <MethodExportConfiguration> configuration)
{
tc.WithMethods(new[] { LambdaHelpers.ParseMethodLambda(method) }, configuration);
ITypeConfigurationBuilder tcb = tc;
ExtractParameters(tcb, method);
return(tc);
}
/// <summary>
/// Include specified method to resulting typing.
/// User <see cref="Ts.Parameter{T}()" /> to mock up method parameters or specify configuration for perticular method
/// parameter
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="method">Method to include</param>
/// <param name="configuration">configuration to be applied to method</param>
/// <returns>Fluent</returns>
public static InterfaceConfigurationBuilder <T> WithMethod <T, TData>(this InterfaceConfigurationBuilder <T> tc,
Expression <Func <T, TData> > method, Action <MethodConfigurationBuilder> configuration)
{
tc.WithMethods(new[] { LambdaHelpers.ParseMethodLambda(method) }, configuration);
ITypeConfigurationBuilder tcb = tc;
ExtractParameters(tcb, method);
return(tc);
}
/// <summary>
/// Include specified field to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="field">Field to include</param>
/// <returns>Fluent</returns>
public static PropertyExportConfigurationBuilder WithField <T, TData>(this TypeConfigurationBuilder <T> tc,
Expression <Func <T, TData> > field)
{
var prop = LambdaHelpers.ParseFieldLambda(field);
ITypeConfigurationBuilder tcb = tc;
return
((PropertyExportConfigurationBuilder)
tcb.MembersConfiguration.GetOrCreate(prop, () => new PropertyExportConfigurationBuilder(prop)));
}
/// <summary>
/// Include specified property to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="property">Property to include</param>
/// <returns>Fluent</returns>
public static PropertyExportConfiguration WithProperty <T, TData>(this TypeConfigurationBuilder <T> tc,
Expression <Func <T, TData> > property)
{
var prop = LambdaHelpers.ParsePropertyLambda(property);
ITypeConfigurationBuilder tcb = tc;
return
((PropertyExportConfiguration)
tcb.MembersConfiguration.GetOrCreate(prop, () => new PropertyExportConfiguration()));
}
/// <summary>
/// Include specified method to resulting typing.
/// User <see cref="Ts.Parameter{T}()" /> to mock up method parameters or specify configuration for perticular method
/// parameter
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="method">Method to include</param>
/// <returns>Fluent</returns>
public static MethodConfigurationBuilder WithMethod <T>(this TypeConfigurationBuilder <T> tc,
Expression <Action <T> > method)
{
var prop = LambdaHelpers.ParseMethodLambda(method);
ITypeConfigurationBuilder tcb = tc;
var methodConf = new MethodConfigurationBuilder(prop, tc._blueprint);
ExtractParameters(tcb, method);
return(methodConf);
}
/// <summary>
/// Include specified field to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="fieldName">Name of field to include</param>
/// <param name="configuration">Configuration to be applied to selected field</param>
/// <returns>Fluent</returns>
public static ITypeConfigurationBuilder WithField(this ITypeConfigurationBuilder tc, string fieldName,
Action <PropertyExportConfigurationBuilder> configuration)
{
var field = tc.Type._GetField(fieldName);
if (field == null)
{
ErrorMessages.RTE0013_InvalidField.Throw(fieldName, tc.Type.FullName);
}
return(tc.WithFields(new[] { field }, configuration));
}
/// <summary>
/// Include specified property to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="propertyName">Name of property to include</param>
/// <param name="configuration">Configuration to be applied to selected property</param>
/// <returns>Fluent</returns>
public static ITypeConfigurationBuilder WithProperty(this ITypeConfigurationBuilder tc, string propertyName,
Action <PropertyExportConfigurationBuilder> configuration)
{
var prop = tc.Type._GetProperty(propertyName);
if (prop == null)
{
ErrorMessages.RTE0014_InvalidProperty.Throw(propertyName, tc.Type.FullName);
}
return(tc.WithProperties(new[] { prop }, configuration));
}
/// <summary>
/// Include specified method to resulting typing.
/// User <see cref="Ts.Parameter{T}()" /> to mock up method parameters or specify configuration for perticular method
/// parameter
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="method">Method to include</param>
/// <returns>Fluent</returns>
public static MethodExportConfiguration WithMethod <T>(this TypeConfigurationBuilder <T> tc,
Expression <Action <T> > method)
{
var prop = LambdaHelpers.ParseMethodLambda(method);
ITypeConfigurationBuilder tcb = tc;
var methodConf =
(MethodExportConfiguration)
tcb.MembersConfiguration.GetOrCreate(prop, () => new MethodExportConfiguration());
ExtractParameters(tcb, method);
return(methodConf);
}
private static void ExtractParameters(ITypeConfigurationBuilder conf, LambdaExpression methodLambda)
{
var mex = methodLambda.Body as MethodCallExpression;
if (mex == null)
{
throw new Exception(
"MethodCallExpression should be provided for .WithMethod call. Please use only lamba expressions in this place.");
}
var mi = mex.Method;
var methodParameters = mi.GetParameters();
if (methodParameters.Length == 0)
{
return;
}
var i = 0;
foreach (var expression in mex.Arguments)
{
var pi = methodParameters[i];
i++;
var call = expression as MethodCallExpression;
if (call != null)
{
if (call.Method.IsGenericMethod &&
call.Method.GetGenericMethodDefinition() == Ts.ParametrizedParameterMethod)
{
var pcb =
(ParameterConfigurationBuilder)
conf.ParametersConfiguration.GetOrCreate(pi, () => new ParameterConfigurationBuilder());
var parsed = false;
var arg = call.Arguments[0] as LambdaExpression;
if (arg != null)
{
var delg = arg.Compile();
delg.DynamicInvoke(pcb);
parsed = true;
}
var uarg = call.Arguments[0] as UnaryExpression; // convert expression
if (uarg != null)
{
var operand = uarg.Operand as MethodCallExpression;
if (operand != null)
{
var actionArg = operand.Object as ConstantExpression;
if (actionArg != null)
{
var value = actionArg.Value as MethodInfo;
if (value != null)
{
var param = Expression.Parameter(typeof(ParameterConfigurationBuilder));
var newCall = Expression.Call(value, param);
var newLambda = Expression.Lambda(newCall, param);
var delg = newLambda.Compile();
delg.DynamicInvoke(pcb);
parsed = true;
}
}
}
if (!parsed)
{
throw new Exception(
string.Format(
"Sorry, but {0} is not very good idea for parameter configuration. Try using simple lambda expression.",
call.Arguments[0]));
}
}
}
}
}
}
private static void ExtractParameters(ITypeConfigurationBuilder conf, LambdaExpression methodLambda)
{
var mex = methodLambda.Body as MethodCallExpression;
if (mex == null)
{
ErrorMessages.RTE0008_FluentWithMethodError.Throw();
}
var mi = mex.Method;
var methodParameters = mi.GetParameters();
if (methodParameters.Length == 0)
{
return;
}
var i = 0;
foreach (var expression in mex.Arguments)
{
var pi = methodParameters[i];
i++;
var call = expression as MethodCallExpression;
if (call != null)
{
if (call.Method.IsGenericMethod &&
call.Method.GetGenericMethodDefinition() == Ts.ParametrizedParameterMethod)
{
var pcb =
(ParameterConfigurationBuilder)
conf.ParametersConfiguration.GetOrCreate(pi, () => new ParameterConfigurationBuilder(pi));
var parsed = false;
var arg = call.Arguments[0] as LambdaExpression;
if (arg != null)
{
var delg = arg.Compile();
delg.DynamicInvoke(pcb);
parsed = true;
}
var uarg = call.Arguments[0] as UnaryExpression; // convert expression
if (uarg != null)
{
var operand = uarg.Operand as MethodCallExpression;
if (operand != null)
{
var actionArg = operand.Object as ConstantExpression;
if (actionArg != null)
{
var value = actionArg.Value as MethodInfo;
if (value != null)
{
var param = Expression.Parameter(typeof(ParameterConfigurationBuilder));
var newCall = Expression.Call(value, param);
var newLambda = Expression.Lambda(newCall, param);
var delg = newLambda.Compile();
delg.DynamicInvoke(pcb);
parsed = true;
}
}
}
if (!parsed)
{
ErrorMessages.RTE0009_FluentWithMethodCouldNotParse.Throw(call.Arguments[0]);
}
}
}
}
}
}
