/// <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 PropertyExportBuilder WithProperty <T, TData>(this ITypedExportBuilder <T> tc,
Expression <Func <T, TData> > property)
{
var prop = LambdaHelpers.ParsePropertyLambda(property);
ClassOrInterfaceExportBuilder tcb = tc as ClassOrInterfaceExportBuilder;
return(new PropertyExportBuilder(tcb.Blueprint, prop));
}
/// <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 field to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="field">Field to include</param>
/// <returns>Fluent</returns>
public static FieldExportBuilder WithField <T, TData>(this ITypedExportBuilder <T> tc,
Expression <Func <T, TData> > field)
{
var prop = LambdaHelpers.ParseFieldLambda(field);
ClassOrInterfaceExportBuilder tcb = tc as ClassOrInterfaceExportBuilder;
return(new FieldExportBuilder(tcb.Blueprint, prop));
}
/// <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 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>
/// <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 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 MethodExportBuilder WithMethod <T>(this ITypedExportBuilder <T> tc,
Expression <Action <T> > method)
{
var prop = LambdaHelpers.ParseMethodLambda(method);
ClassOrInterfaceExportBuilder tcb = tc as ClassOrInterfaceExportBuilder;
var methodConf = new MethodExportBuilder(tcb.Blueprint, prop);
tcb.ExtractParameters(method);
return(methodConf);
}
/// <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 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);
}
/// <summary>
/// Include specified property to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="property">Property to include</param>
/// <param name="configuration">Configuration to be applied to selected property</param>
/// <returns>Fluent</returns>
public static InterfaceConfigurationBuilder <T> WithProperty <T, TData>(this InterfaceConfigurationBuilder <T> tc,
Expression <Func <T, TData> > property, Action <PropertyExportConfiguration> configuration)
{
return(tc.WithProperties(new[] { LambdaHelpers.ParsePropertyLambda(property) }, configuration));
}
/// <summary>
/// Include specified property to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="property">Property to include</param>
/// <param name="configuration">Configuration to be applied to selected property</param>
/// <returns>Fluent</returns>
public static ClassConfigurationBuilder <T> WithField <T, TData>(this ClassConfigurationBuilder <T> tc,
Expression <Func <T, TData> > property, Action <PropertyExportConfigurationBuilder> configuration)
{
return(tc.WithFields(new[] { LambdaHelpers.ParseFieldLambda(property) }, configuration));
}
/// <summary>
/// Include specified property to resulting typing
/// </summary>
/// <param name="tc">Configuration builder</param>
/// <param name="property">Property to include</param>
/// <param name="configuration">Configuration to be applied to selected property</param>
/// <returns>Fluent</returns>
public static InterfaceConfigurationBuilder <T> WithField <T, TData>(this InterfaceConfigurationBuilder <T> tc,
Expression <Func <T, TData> > property, Action <PropertyExportConfigurationBuilder> configuration)
{
ApplyMembersConfiguration(tc, new[] { LambdaHelpers.ParseFieldLambda(property) }, configuration);
return(tc);
}
static Ts()
{
Expression <Func <object> > lambda = () => Parameter <object>(a => a.Ignore());
ParametrizedParameterMethod = LambdaHelpers.ParseMethodLambda(lambda).GetGenericMethodDefinition();
}
/// <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="method">Method to include</param>
/// <param name="configuration">configuration to be applied to method</param>
/// <returns>Fluent</returns>
public InterfaceExportBuilder <T> WithMethod <TData>(Expression <Func <T, TData> > method, Action <MethodExportBuilder> configuration)
{
this.WithMethods(new[] { LambdaHelpers.ParseMethodLambda(method) }, configuration);
ExtractParameters(method);
return(this);
}
/// <summary>
/// Include specified field to resulting typing
/// </summary>
/// <param name="field">Field to include</param>
/// <param name="configuration">Configuration to be applied to selected field</param>
/// <returns>Fluent</returns>
public ClassExportBuilder <T> WithField <TData>(Expression <Func <T, TData> > field, Action <PropertyExportBuilder> configuration)
{
ApplyMembersConfiguration(new[] { LambdaHelpers.ParseFieldLambda(field) }, configuration);
return(this);
}
/// <summary>
/// Include specified property to resulting typing
/// </summary>
/// <param name="property">Property to include</param>
/// <param name="configuration">Configuration to be applied to selected property</param>
/// <returns>Fluent</returns>
public ClassExportBuilder <T> WithProperty <TData>(Expression <Func <T, TData> > property, Action <PropertyExportBuilder> configuration)
{
WithProperties(new[] { LambdaHelpers.ParsePropertyLambda(property) }, configuration);
return(this);
}
/// <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="method">Method to include</param>
/// <param name="configuration">configuration to be applied to method</param>
/// <returns>Fluent</returns>
public ClassExportBuilder <T> WithMethod(Expression <Action <T> > method, Action <MethodExportBuilder> configuration)
{
WithMethods(new[] { LambdaHelpers.ParseMethodLambda(method) }, configuration);
ExtractParameters(method);
return(this);
}
