/// <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); }