public async Task PauseOperator()
{
pause = true;
IFilterOperator nextOperator = base.GrainFactory.GetGrain <IFilterOperator>(this.GetPrimaryKeyLong());
await nextOperator.PauseOperator();
//return Task.CompletedTask;
}
/// <summary>
/// Удалить оператор
/// </summary>
/// <param name="filterOperator">Оператор</param>
/// <exception cref="ArgumentNullException">Оператор не задан</exception>
public void Remove(IFilterOperator filterOperator)
{
if (filterOperator == null)
{
throw new ArgumentNullException(nameof(filterOperator));
}
_operators.Remove(filterOperator);
}
public async Task QuitOperator()
{
sw.Flush();
fs.Close();
IFilterOperator nextOperator = base.GrainFactory.GetGrain <IFilterOperator>(this.GetPrimaryKeyLong());
await nextOperator.QuitOperator();
//return Task.CompletedTask;
}
public void SholdSerializeOperator()
{
// Given
var entity = new FilterTestEntity {
StringField = "Abc", IntField = 5
};
// Какое-то сложное логическое выражение
var specification = new FilterSpecification <FilterTestEntity>(
b => b.Or(
c => c
.And(a => a.Or(o => o
.Null(i => i.StringField)
.Equal(i => i.StringField, string.Empty))
.Equal(i => i.IntField, 0))
.And(a => a
.NotNull(i => i.StringField)
.NotEqual(i => i.StringField, string.Empty)
.Or(o => o
.In(i => i.StringField.ToLower(), new[] { "a", "b", "c" })
.Contains(i => i.StringField.ToLower(), "abc")
.StartsWith(i => i.StringField, "1")
.EndsWith(i => i.StringField, "5"))
.Or(o => o
.And(a2 => a2
.GreaterOrEqual(i => i.IntField, 0)
.LessOrEqual(i => i.IntField, 10))
.And(a2 => a2
.Greater(i => i.IntField, 10)
.Less(i => i.IntField, 20))
.Between(i => i.IntField, 20, 30)))));
IFilterOperator operatorFromStream;
IFilterOperator operatorToStream = specification.Operator;
// When
using (var stream = new MemoryStream())
{
// Сериализация
var serializer = new NetDataContractSerializer();
serializer.Serialize(stream, operatorToStream);
stream.Position = 0;
// Десериализация
operatorFromStream = (IFilterOperator)serializer.ReadObject(stream);
}
// Then
Assert.IsNotNull(operatorFromStream);
Assert.AreEqual(operatorToStream.IsSatisfiedBy(entity), operatorFromStream.IsSatisfiedBy(entity));
}
/// <summary>
/// Добавить оператор
/// </summary>
/// <param name="filterOperator">Оператор</param>
/// <exception cref="ArgumentNullException">Оператор не задан</exception>
/// <exception cref="ArgumentException">Тип оператора не соответствует типу данного фильтра</exception>
public void Add(IFilterOperator filterOperator)
{
if (filterOperator == null)
{
throw new ArgumentNullException(nameof(filterOperator));
}
if (filterOperator.Type != Type)
{
throw new ArgumentOutOfRangeException(nameof(filterOperator));
}
_operators.Add(filterOperator);
}
/// <summary>
/// Добавить оператор
/// </summary>
/// <param name="filterOperator">Оператор</param>
/// <exception cref="ArgumentNullException">Оператор не задан</exception>
/// <exception cref="ArgumentException">Тип оператора не соответствует типу данного фильтра</exception>
public void Add(IFilterOperator filterOperator)
{
if (filterOperator == null)
{
throw new ArgumentNullException();
}
if (filterOperator.Type != Type)
{
throw new ArgumentException();
}
_operators.Add(filterOperator);
}
/// <summary>
/// Добавить оператор
/// </summary>
/// <param name="filterOperator">Оператор</param>
/// <exception cref="ArgumentNullException">Оператор не задан</exception>
/// <exception cref="ArgumentException">Тип оператора не соответствует типу данного фильтра</exception>
public void Add(IFilterOperator filterOperator)
{
if (filterOperator == null)
{
throw new ArgumentNullException();
}
if (filterOperator.Type != Type)
{
throw new ArgumentException();
}
_operators.Add(filterOperator);
}
public async Task ResumeOperator()
{
pause = false;
if (pausedRows.Count > 0)
{
await SubmitTuples(pausedRows, true);
pausedRows.Clear();
}
IFilterOperator nextOperator = base.GrainFactory.GetGrain <IFilterOperator>(this.GetPrimaryKeyLong());
await nextOperator.ResumeOperator();
//return Task.CompletedTask;
}
public NotOperator(string typeName, IFilterOperator filterOperator)
: base(typeName, filterOperator)
{
}
public NotOperator(string typeName, IFilterOperator filterOperator)
: base(typeName, filterOperator)
{
}
public static IQueryFilter <T, P> Or <T, P>(this IFilterOperator <T> query, Expression <Func <T, P> > property) => query.AddOperator(nameof(IQueryInstructions.Or), property);
public static IQueryFilter <T> Or <T>(this IFilterOperator <T> query, string property) => query.AddOperator(nameof(IQueryInstructions.Or), property);
public static IFilterOperator <T> Or <T>(this IFilterOperator <T> query, Action <IQueryCompose <T> > subQuery) => query.AddGroupExpression(nameof(IQueryInstructions.Or), subQuery);
/// <summary>
/// Удалить оператор
/// </summary>
/// <param name="filterOperator">Оператор</param>
/// <exception cref="ArgumentNullException">Оператор не задан</exception>
public void Remove(IFilterOperator filterOperator)
{
if (filterOperator == null)
{
throw new ArgumentNullException();
}
_operators.Remove(filterOperator);
}
