internal ResolutionScope(IResolverSelector resolverSelector,
IExpressionBuilder expressionBuilder, IContainerContext containerContext)
: this(resolverSelector, expressionBuilder, containerContext,
new DelegateCache(), null)
{
this.RootScope = this;
}
private ResolutionScope(IResolverSelector resolverSelector, IExpressionBuilder expressionBuilder,
IContainerContext containerContext, IResolutionScope rootScope, IResolutionScope parent, DelegateCache delegateCache, object name = null)
: this(resolverSelector, expressionBuilder, containerContext, delegateCache, name)
{
this.RootScope = rootScope;
this.ParentScope = parent;
}
public void Setup()
{
var kernel = new StandardKernel();
kernel.Load(Assembly.GetExecutingAssembly());
expressionBuilder = kernel.Get <IExpressionBuilder>();
}
public EfReadOnlyRepository(TContext c, IExpressionBuilder expressionBuilder, ILogger <EfReadOnlyRepository <TEntity, TContext> > logger)
{
_c = c;
_c.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
_expressionBuilder = expressionBuilder;
_logger = logger;
}
public ScientificCalculator(
IInputBuffer buffer,
IOperatorLookup lookup,
IUnitConverter unitConverter,
IOperatorConverter operatorConverter,
IExpressionBuilder builder,
IExpressionParser parser,
IEvaluate evaluator,
IMemoryStorage memory
) : base(
buffer,
lookup,
unitConverter,
operatorConverter,
builder,
parser,
evaluator,
memory
)
{
}
/// <summary>
/// Serialize an object implementing IDictionary. The serialized data is similar to a regular
/// object, except that the keys of the dictionary are used instead of properties.
/// </summary>
/// <param name="data">the dictionary object</param>
/// <param name="currentPath">object's path</param>
/// <param name="serializer">the serializer instance, used to serialize keys and values</param>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
IDictionary dictionary = (IDictionary)data;
Type itemType = typeof(object);
Type genericDictionary = null;
if ((genericDictionary = dictionary.GetType().GetInterface(typeof(IDictionary <,>).Name)) != null)
{
itemType = genericDictionary.GetGenericArguments()[1];
}
ObjectExpression expression = new ObjectExpression();
foreach (DictionaryEntry pair in dictionary)
{
//may not work in all cases
object value = pair.Value;
Expression valueExpr = serializer.Serialize(value, currentPath.Append(pair.Key.ToString()));
if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), itemType))
{
valueExpr = new CastExpression(value.GetType(), valueExpr);
}
expression.Add(pair.Key.ToString(), valueExpr);
}
return(expression);
}
public EfCrudRepository(TContext c, IExpressionBuilder expressionBuilder, IUow <TEntity> uow, ILogger <EfCrudRepository <TEntity, TContext> > logger)
: base(c, expressionBuilder, logger)
{
_c = c;
_uow = uow;
c.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.TrackAll;
}
public static Expression <Func <T, bool> > BuildExpression <T>(this IExpressionBuilder <T> builder, IEnumerable <Expression> sources = null) where T : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (builder.Expression == ExpressionBuilder.True)
{
return(BuildExpressionTrue(builder));
}
if (sources == null)
{
throw new ArgumentNullException(nameof(sources));
}
var parameterValues = sources.Select(s => Expression.Convert(s, typeof(IQueryable <>).MakeGenericType(s.Type.GetGenericArguments())));
if (parameterValues.Count() < builder.Parameters.Count() - 1)
{
throw new ArgumentOutOfRangeException(nameof(parameterValues), "The element count of parameterValues should be greater than or equals to the count of builder.Parameters - 1");
}
var firstParameter = builder.Parameters.FirstOrDefault() ?? Expression.Parameter(typeof(T));
return(builder.Expression.Replace(firstParameter).Replace <T>(
builder.Parameters.Skip(1).Zip(parameterValues, (k, v) => new KeyValuePair <ParameterExpression, Expression>(k, v)),
firstParameter));
}
public static Expression <Func <T, object> > GetPropertyExpression <T>(this IExpressionBuilder expressionBuilder, string propertyName, bool ignoreCase = true)
{
expressionBuilder.CheckArgumentNull(nameof(expressionBuilder));
return((Expression <Func <T, object> >)expressionBuilder.GetPropertyExpression(typeof(T),
propertyName, typeof(T), typeof(object), ignoreCase));
}
public static Expression <Func <T, bool> > GetFilterExpression <T>(this IExpressionBuilder expressionBuilder,
Filter filter)
{
expressionBuilder.CheckArgumentNull(nameof(expressionBuilder));
return((Expression <Func <T, bool> >)expressionBuilder.GetFilterExpression(typeof(T), filter));
}
/// <summary>
/// Serialize an object implementing IDictionary. The serialized data is similar to a regular
/// object, except that the keys of the dictionary are used instead of properties.
/// </summary>
/// <param name="data">the dictionary object</param>
/// <param name="currentPath">object's path</param>
/// <param name="serializer">the serializer instance, used to serialize keys and values</param>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
IDictionary dictionary = (IDictionary)data;
Type itemType = typeof(object);
Type genericDictionary = null;
if ((genericDictionary = dictionary.GetType().GetInterface(typeof(IDictionary<,>).Name)) != null)
{
itemType = genericDictionary.GetGenericArguments()[1];
}
ObjectExpression expression = new ObjectExpression();
foreach (DictionaryEntry pair in dictionary)
{
//may not work in all cases
object value = pair.Value;
Expression valueExpr = serializer.Serialize(value, currentPath.Append(pair.Key.ToString()));
if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), itemType))
{
valueExpr = new CastExpression(value.GetType(), valueExpr);
}
expression.Add(pair.Key.ToString(), valueExpr);
}
return expression;
}
private Func <ParameterExpression, Expression> CloneListElementDelegate(IExpressionBuilder expressionBuilder, CloneExpressionContext context)
{
Type elementType = context
.SourceEntity
.Type
.GenericTypeArguments
.Single();
PropertyInfo indexProperty = typeof(IList <>)
.MakeGenericType(elementType)
.GetProperty(IndexPropertyName);
MethodInfo addMethod = typeof(ICollection <>)
.MakeGenericType(elementType)
.GetMethod(nameof(ICollection <object> .Add));
if (PrimitiveTypes.Contains(elementType))
{
return (iterator) =>
{
Expression getElementExpression = ExpressionFactory.Call(context.SourceEntity, indexProperty.GetMethod, iterator);
return ExpressionFactory.Call(context.TargetEntity, addMethod, getElementExpression);
}
}
;
else
{
return (iterator) =>
{
Expression getElementExpression = ExpressionFactory.Call(context.SourceEntity, indexProperty.GetMethod, iterator);
MethodInfo cloneMethod = CloneMethod.MakeGenericMethod(elementType);
Expression clonedElement = ExpressionFactory.Call(context.CloneFactory, cloneMethod, getElementExpression);
return ExpressionFactory.Call(context.TargetEntity, addMethod, clonedElement);
}
};
}
public RemoveAction(RemoveActionConfiguration configuration, IExpressionBuilder expressionBuilder, IMatchValueExtractor matchValueExtractor)
{
this.configuration = configuration;
this.matchValueExtractor = matchValueExtractor;
find = expressionBuilder.Build(configuration.Expression);
}
public IQueryable <T> ProcessOrderBy(IExpression expression)
{
IQueryable q;
IExpressionBuilder b = (m_query.Provider as IObjectQueryProvider).CreateExpressionBuilder();
if (expression.Desc)
{
q = ExecuteCommand(m_query, typeof(OqlOrderByDescendingCommand <,>), b.MakeMemberAccess(typeof(T), expression.Name));
}
else
{
q = ExecuteCommand(m_query, typeof(OqlOrderByCommand <,>), b.MakeMemberAccess(typeof(T), expression.Name));
}
for (IExpression x = expression.Expression; x != null; x = x.Expression)
{
if (x.Desc)
{
q = ExecuteCommand(q, typeof(OqlThenByDescendingCommand <,>), b.MakeMemberAccess(typeof(T), x.Name));
continue;
}
q = ExecuteCommand(q, typeof(OqlThenByCommand <,>), b.MakeMemberAccess(typeof(T), x.Name));
}
return(q as IQueryable <T>);
}
private void AddCloneExpressions <TEntity>(IExpressionBuilder expressionBuilder, CloneExpressionContext parameters)
{
parameters.TargetEntity = expressionBuilder.CreateObject <TEntity>(nameof(CloneExpressionContext.TargetEntity));
foreach (PropertyInfo cloneableProperty in CloneableProperties(typeof(TEntity)))
{
CloneProperty(expressionBuilder, parameters, cloneableProperty);
}
}
protected virtual Expression GetColumnExpression(DataColumn dc, JsonPath jsonPath, IExpressionBuilder serializer)
{
ObjectExpression column = new ObjectExpression();
// just DataType and column for now
column.Add("DataType", serializer.Serialize(dc.DataType, jsonPath.Append("DataType")));
column.Add("ColumnName", serializer.Serialize(dc.ColumnName, jsonPath.Append("ColumnName")));
return column;
}
public IExpressionBuilder Run(IExpressionBuilder exp, IObjectContext context)
{
var members = _runtimeDelegate(context).ToArray();
exp.RemoveMembers(members);
return(exp);
}
public IExpressionBuilder Run(IExpressionBuilder exp, IObjectContext context)
{
var next = _mapCreator.CreateUnexpandedMap(context);
exp.ExtendWith(next);
return(exp);
}
public ICloneDefinition <TEntity> Create <TEntity>(ICloneFactory cloneFactory)
where TEntity : class
{
IExpressionBuilder expressionBuilder = ExpressionBuilderFactory.Create();
CloneDelegate <TEntity> cloneDelegate = AssembleExpression <TEntity>(expressionBuilder);
return(new CloneDefinition <TEntity>(cloneFactory, cloneDelegate));
}
/// <summary>
/// Initializes a new instance of the NullArgumentMethodTestMethodSourceCodeGenerator class.
/// </summary>
/// <param name="expressionBuilder">The expression builder.</param>
/// <param name="testMethodValueProvider">The value provider.</param>
public NullArgumentMethodTestMethodSourceCodeGenerator(IExpressionBuilder expressionBuilder,
ITestMethodValueProvider testMethodValueProvider)
{
Check.NotNull(expressionBuilder, nameof(expressionBuilder));
Check.NotNull(testMethodValueProvider, nameof(testMethodValueProvider));
this.expressionBuilder = expressionBuilder;
this.testMethodValueProvider = testMethodValueProvider;
}
public ResolutionScope(IActivationContext activationContext, IServiceRegistrator serviceRegistrator,
IExpressionBuilder expressionBuilder, IResolutionScope rootScope)
{
this.activationContext = activationContext;
this.serviceRegistrator = serviceRegistrator;
this.expressionBuilder = expressionBuilder;
this.rootScope = rootScope;
}
public MathExpression(IExpressionBuilder expressionBuilder)
{
this.expressionBuilder = expressionBuilder;
elements = new List <IExpressionElement>();
deferredNumbers = new Stack <IDynamicNumber>();
deferredCommands = new Stack <ICommand>();
}
public void TestInitialize()
{
var type = typeof(ClassContructor);
var ctor = type.GetConstructors().First();
request = new ConstructorSourceCodeGenerationRequest(ctor, false, false, ctor.GetParameters().First());
expressionBuilder = MockRepository.GenerateMock<IExpressionBuilder>();
testee = new NullArgumentConstructorTestMethodSourceCodeGenerator(expressionBuilder);
}
public static IExpressionBuilder Function(this IExpressionBuilder builder, ObjectName functionName, params Action <IExpressionBuilder>[] args)
{
return(builder.Function(functionName, args.Select(x => {
var expBuilder = new ExpressionBuilder();
x(expBuilder);
return expBuilder.Build();
}).ToArray()));
}
private void AddArrayExpressions <TEntity>(IExpressionBuilder expressionBuilder, CloneExpressionContext context)
{
context.TargetEntity = expressionBuilder.CreateObject <TEntity>(
nameof(CloneExpressionContext.TargetEntity),
new[] { typeof(int) },
new[] { ExpressionFactory.Call(context.SourceEntity, ArrayLengthProperty.GetMethod) });
expressionBuilder.For(context.SourceEntity, CloneArrayElementDelegate(context));
}
public ReplaceAction(ReplaceActionConfiguration configuration, IExpressionBuilder expressionBuilder, IMatchValueExtractor matchValueExtractor)
{
this.configuration = configuration;
this.matchValueExtractor = matchValueExtractor;
find = expressionBuilder.Build(configuration.Expression);
replaceWith = new Regex("\\${(?<name>.*?)}", RegexOptions.ExplicitCapture | RegexOptions.Compiled);
}
/* ====== Constructors ====== */
private Configuration(ConfigurationOptions options)
{
options = options ?? new ConfigurationOptions();
this.AutoResolve = options.AutoResolve;
this.ConstructorSelector = options.ConstructorSelector;
this.DefaultLifecycle = options.DefaultLifecycle;
this.ExpressionBuilder = options.ExpressionBuilder;
}
public QuizzesService(
IDeletableEntityRepository <Quiz> quizRepository,
IExpressionBuilder expressionBuilder,
IRepository <Password> passwordRepository)
{
this.quizRepository = quizRepository;
this.expressionBuilder = expressionBuilder;
this.passwordRepository = passwordRepository;
}
public ResultsService(
IDeletableEntityRepository <Result> repository,
IDeletableEntityRepository <Event> eventRepository,
IExpressionBuilder expressionBuilder)
{
this.repository = repository;
this.eventRepository = eventRepository;
this.expressionBuilder = expressionBuilder;
}
public CategoriesService(
IDeletableEntityRepository <Category> categoryRepository,
IDeletableEntityRepository <Quiz> quizRepository,
IExpressionBuilder expressionBuilder)
{
this.categoryRepository = categoryRepository;
this.quizRepository = quizRepository;
this.expressionBuilder = expressionBuilder;
}
public CategoriesService(
IExpressionBuilder expressionBuilder,
IDeletableEntityRepository <Category> repository,
IDeletableEntityRepository <Quiz> quizRepository)
{
this.expressionBuilder = expressionBuilder;
this.repository = repository;
this.quizRepository = quizRepository;
}
public void TestInitialize()
{
var type = typeof(ClassContructor);
var ctor = type.GetConstructors().First();
request = new ConstructorSourceCodeGenerationRequest(ctor, false, false, ctor.GetParameters().First());
expressionBuilder = MockRepository.GenerateMock <IExpressionBuilder>();
testee = new NullArgumentConstructorTestMethodSourceCodeGenerator(expressionBuilder);
}
public void TestInitialize()
{
FooBarSignature instanceMethod = new TestAssembly.PublicClass().FooBar;
expressionBuilder = MockRepository.GenerateMock<IExpressionBuilder>();
instanceMethodRequest = new MethodSourceCodeGenerationRequest(instanceMethod.Method, false, instanceMethod.Method.GetParameters().First());
var testMethodValueProvider = MockRepository.GenerateMock<ITestMethodValueProvider>();
testee = new NullArgumentMethodTestMethodSourceCodeGenerator(expressionBuilder, testMethodValueProvider);
}
public UsersService(
IDeletableEntityRepository <ApplicationUser> userRepository,
IDeletableEntityRepository <ApplicationRole> roleRepository,
IExpressionBuilder expressionBuilder)
{
this.userRepository = userRepository;
this.roleRepository = roleRepository;
this.expressionBuilder = expressionBuilder;
}
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
DataTable table = (DataTable) data;
ObjectExpression tableExpr = new ObjectExpression();
tableExpr.Add("TableName", serializer.Serialize(table.TableName, currentPath.Append("TableName")));
tableExpr.Add("Columns", GetColumnsExpression(table, currentPath.Append("Columns"), serializer));
tableExpr.Add("Rows", GetRowsExpression(table, currentPath, serializer));
return tableExpr;
}
protected virtual Expression GetColumnsExpression(DataTable table, JsonPath currentPath, IExpressionBuilder serializer)
{
ArrayExpression columns = new ArrayExpression();
int colCount = 0;
foreach (DataColumn dc in table.Columns)
{
columns.Add(GetColumnExpression(dc, currentPath.Append(colCount), serializer));
colCount++;
}
return columns;
}
/// <summary>
/// Creates an json object expression from object data.
/// </summary>
/// <param name="data">the data to serialize</param>
/// <param name="currentPath">current path to the object</param>
/// <param name="serializer">serializer instance used to serialize key values</param>
/// <returns>json object expression</returns>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
TypeData handler = Config.GetTypeHandler(data.GetType());
ObjectExpression expression = new ObjectExpression();
foreach (IPropertyData prop in handler.Properties)
{
GenerateItemExpression(data, currentPath, serializer, expression, prop);
}
return expression;
}
protected virtual Expression GetRowsExpression(DataTable table, JsonPath currentPath, IExpressionBuilder serializer)
{
ArrayExpression rowsExpr = new ArrayExpression();
for (int i = 0; i < table.Rows.Count; i++)
{
DataRow row = table.Rows[i];
object[] values = row.ItemArray;
JsonPath rowPath = currentPath.Append(i);
ArrayExpression rowExpr = new ArrayExpression();
for (int j = 0; j < values.Length; j++)
{
rowExpr.Add(serializer.Serialize(values[j], rowPath.Append(j)));
}
rowsExpr.Add(rowExpr);
}
return rowsExpr;
}
/// <summary>
/// Generates an expression for an item and adds it to the object
/// </summary>
/// <param name="data">the item being serialized</param>
/// <param name="currentPath">the current path to the object</param>
/// <param name="serializer">serializer instance</param>
/// <param name="expression">the object expression</param>
/// <param name="prop">the property being serialized</param>
protected virtual void GenerateItemExpression(object data, JsonPath currentPath, IExpressionBuilder serializer, ObjectExpression expression, IPropertyData prop)
{
object value = prop.GetValue(data);
if (!prop.ShouldWriteValue(this.Config, value))
return;
Expression valueExpr;
if (prop.HasConverter)
{
valueExpr = serializer.Serialize(value, currentPath.Append(prop.Alias), prop.TypeConverter);
}
else
{
valueExpr = serializer.Serialize(value, currentPath.Append(prop.Alias));
}
if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), prop.PropertyType))
{
valueExpr = new CastExpression(value.GetType(), valueExpr);
}
expression.Add(prop.Alias, valueExpr);
}
/// <summary>
/// Serializes the data into a json array expression.
/// </summary>
/// <param name="data">the data to serialize</param>
/// <param name="currentPath">the current path to the data</param>
/// <param name="serializer">serializer instance to use to serialize list items</param>
/// <returns>a json array expression representation</returns>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
TypeData handler = Config.GetTypeHandler(data.GetType());
CollectionHandler collectionHandler = handler.CollectionHandler;
Type elemType = collectionHandler.GetItemType(handler.ForType);
int index = 0;
ArrayExpression expression = new ArrayExpression();
foreach (object value in collectionHandler.GetEnumerable(data))
{
Expression itemExpr = serializer.Serialize(value, currentPath.Append(index));
if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), elemType))
{
itemExpr = new CastExpression(value.GetType(), itemExpr);
}
expression.Add(itemExpr);
index++;
}
return expression;
}
public static void CreateKeySelectors(
Type outerType,
Type innerType,
IExpressionBuilder[] outerKeyCreator,
IExpressionBuilder[] innerKeyCreator,
out LambdaExpression outerKey,
out LambdaExpression innerKey)
{
// Key selector parameters
ParameterExpression outerKeyParam =
Expression.Parameter(outerType, "outer");
ParameterExpression innerKeyParam =
Expression.Parameter(innerType, "inner");
// Create key member accessor expressions
List<Expression> outerKeyMemberAccess = new List<Expression>();
List<Expression> innerKeyMemberAccess = new List<Expression>();
for (int i = 0; i < outerKeyCreator.Length; i++)
{
Expression outerAccess = outerKeyCreator[i].Build(outerKeyParam);
Expression innerAccess = innerKeyCreator[i].Build(innerKeyParam);
// KEY PART: try to unify the type of the expressions
ExpressionHelper.TryUnifyValueTypes(ref outerAccess, ref innerAccess);
outerKeyMemberAccess.Add(outerAccess);
innerKeyMemberAccess.Add(innerAccess);
}
// Build key selector lambdas
outerKey = ExpressionHelper.CreateMemberSelectorLambdaExpression(
outerKeyMemberAccess.ToArray(),
outerKeyParam);
innerKey = ExpressionHelper.CreateMemberSelectorLambdaExpression(
innerKeyMemberAccess.ToArray(),
innerKeyParam);
}
/// <summary>
/// Gets an expression for a value by first converting it with its registered type converter and then calling Serialize
/// </summary>
/// <param name="value">the value to generate an expression for</param>
/// <param name="currentPath">the current path to the value</param>
/// <param name="serializer">serializer instance</param>
/// <returns>an expression for the value</returns>
public override Expression GetExpression(object value, JsonPath currentPath, IExpressionBuilder serializer)
{
IJsonTypeConverter converter = GetConverter(value);
return GetExpression(value, converter, currentPath, serializer);
}
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
string value = ((DateTime)data).ToString(dateFormat, Culture);
return new ValueExpression(value);
}
/// <summary>
/// Initializes a new instance of the XXX class.
/// </summary>
/// <param name="expressionBuilder">The expression builder.</param>
public NullArgumentConstructorTestMethodSourceCodeGenerator(IExpressionBuilder expressionBuilder)
: base(expressionBuilder)
{
this.expressionBuilder = expressionBuilder;
}
public CustomMethodNameCodeGenerator(IExpressionBuilder expressionBuilder, ITestMethodValueProvider testMethodValueProvider)
: base(expressionBuilder, testMethodValueProvider)
{
}
/// <summary>
/// GetExpression is not valid for a CastExpression. CastExpressions should be created directly
/// during serialization whenever type information is needed.
/// </summary>
/// <param name="data">data to serialize</param>
/// <param name="currentPath">the current path to the object</param>
/// <param name="serializer">serializer instance</param>
/// <returns>expression</returns>
/// <exception cref="InvalidOperationException">This will throw an exception if called</exception>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
throw new InvalidOperationException("CastObjectHandler should not be called during Serialization");
}
/// <summary>
/// Gets an expression for a value by first converting it with a specific type converter and then calling Serialize. This
/// method can be called directly when using a Property Converter
/// </summary>
/// <param name="value">the value to generate an expression for</param>
/// <param name="converter">the type converter to use for conversion</param>
/// <param name="currentPath">the current path to the value</param>
/// <param name="serializer">serializer instance</param>
/// <returns>an expression for the value</returns>
public Expression GetExpression(object value, IJsonTypeConverter converter, JsonPath currentPath, IExpressionBuilder serializer)
{
//TODO: Cast for now to avoid breaking compatibility
object convertedObject = converter.ConvertFrom(value, (SerializationContext) Config);
// call serialize again in case the new type has a converter
Expression expr = serializer.Serialize(convertedObject, currentPath, null);
serializer.SetCanReference(value); // can't reference inside the object
return expr;
}
/// <summary> /// Take an object and convert it to an expression to be serialized. Child names/indexes should be appended to the /// currentPath before serializing child objects. /// </summary> /// <param name="data">the object to convert</param> /// <param name="CurrentPath">the current path to this object from the root, used for tracking references</param> /// <param name="serializer">serializer instance for serializing child objects</param> /// <returns>an expression which represents a json structure</returns> public abstract Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer);
/// <summary>
/// Creates a null expression
/// </summary>
/// <param name="data">the data</param>
/// <param name="currentPath">current path</param>
/// <param name="serializer">serializer instance</param>
/// <returns>NullExpression</returns>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
return new NullExpression();
}
public FluentAssertionNullArgumentConstructorTestMethodSourceCodeGenerator(IExpressionBuilder expressionBuilder)
: base(expressionBuilder)
{
}
