private void FillFilterContext( FilterDescriptor filter, TDataItem item, ExpressionContext context) { CompositeFilterDescriptor filterDescriptor1 = filter as CompositeFilterDescriptor; if (filterDescriptor1 != null) { foreach (FilterDescriptor filterDescriptor2 in (Collection <FilterDescriptor>)filterDescriptor1.FilterDescriptors) { this.FillFilterContext(filterDescriptor2, item, context); } } else { object obj = this.GetFieldValue(item, filter.PropertyName); if (obj is Enum) { obj = (object)Convert.ToInt32(obj); } if (context.ContainsKey(filter.PropertyName)) { context[filter.PropertyName] = obj; } else { context.Add(filter.PropertyName, obj); } } }
public static CompositeFilterDescriptor CreateDescriptor( CompositeFilterDescriptor.DescriptorType type, string propertyName, params object[] values) { if (type == CompositeFilterDescriptor.DescriptorType.Unknown) { throw new InvalidOperationException("You cannot create undefined composite filter descriptor."); } CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor(); filterDescriptor.PropertyName = propertyName; switch (type - 1) { case CompositeFilterDescriptor.DescriptorType.Unknown: case CompositeFilterDescriptor.DescriptorType.Between: if (values != null && values.Length != 2) { throw new ArgumentException(nameof(values)); } if (values == null) { values = new object[2]; } filterDescriptor.LogicalOperator = FilterLogicalOperator.And; filterDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, values[0])); filterDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, values[1])); filterDescriptor.NotOperator = type == CompositeFilterDescriptor.DescriptorType.NotBetween; break; } return(filterDescriptor); }
public static string GetCompositeExpression( CompositeFilterDescriptor filterDescriptor, Function <FilterDescriptor, object> formatValue) { StringBuilder stringBuilder = new StringBuilder(); for (int index = 0; index < filterDescriptor.filters.Count; ++index) { FilterDescriptor filter = filterDescriptor.filters[index]; CompositeFilterDescriptor filterDescriptor1 = filter as CompositeFilterDescriptor; if (filterDescriptor1 != null || !string.IsNullOrEmpty(filter.PropertyName)) { string str1 = filterDescriptor1 != null?CompositeFilterDescriptor.GetCompositeExpression(filterDescriptor1, formatValue) : FilterDescriptor.GetExpression(filter, formatValue); stringBuilder.Append(string.Format("{0}", (object)str1)); string str2 = filterDescriptor.filters.LogicalOperator == FilterLogicalOperator.And ? "AND" : "OR"; if (index < filterDescriptor.filters.Count - 1) { stringBuilder.Append(string.Format(" {0} ", (object)str2)); } } } if (stringBuilder.Length > 0) { stringBuilder.Insert(0, filterDescriptor.NotOperator ? "NOT (" : "("); stringBuilder.Append(")"); } return(stringBuilder.ToString()); }
public static CompositeFilterDescriptor.DescriptorType GetDescriptorType( CompositeFilterDescriptor compositeDescriptor) { CompositeFilterDescriptor.DescriptorType descriptorType = CompositeFilterDescriptor.DescriptorType.Unknown; if (compositeDescriptor == null || compositeDescriptor.FilterDescriptors.Count != 2) { return(descriptorType); } FilterDescriptor filterDescriptor1 = compositeDescriptor.FilterDescriptors[0]; FilterDescriptor filterDescriptor2 = compositeDescriptor.FilterDescriptors[1]; if (filterDescriptor1 is CompositeFilterDescriptor || filterDescriptor2 is CompositeFilterDescriptor) { return(descriptorType); } if (filterDescriptor1.Operator == FilterOperator.IsGreaterThanOrEqualTo && filterDescriptor2.Operator == FilterOperator.IsLessThanOrEqualTo && compositeDescriptor.LogicalOperator == FilterLogicalOperator.And) { descriptorType = CompositeFilterDescriptor.DescriptorType.Between; } if (compositeDescriptor.NotOperator && descriptorType == CompositeFilterDescriptor.DescriptorType.Between || descriptorType == CompositeFilterDescriptor.DescriptorType.Unknown && filterDescriptor1.Operator == FilterOperator.IsLessThanOrEqualTo && (filterDescriptor2.Operator == FilterOperator.IsGreaterThanOrEqualTo && !compositeDescriptor.NotOperator) && compositeDescriptor.LogicalOperator == FilterLogicalOperator.Or) { descriptorType = CompositeFilterDescriptor.DescriptorType.NotBetween; } return(descriptorType); }
public static CompositeFilterDescriptor CreateDescriptor( CompositeFilterDescriptor.DescriptorType type, string propertyName, Type dataType, params object[] values) { if (type == CompositeFilterDescriptor.DescriptorType.Unknown) { throw new InvalidOperationException("You cannot create undefined composite filter descriptor."); } CompositeFilterDescriptor filterDescriptor1 = new CompositeFilterDescriptor(); filterDescriptor1.PropertyName = propertyName; switch (type - 1) { case CompositeFilterDescriptor.DescriptorType.Unknown: case CompositeFilterDescriptor.DescriptorType.Between: if (values != null && values.Length != 2) { throw new ArgumentException(nameof(values)); } if (values == null) { values = new object[2]; } FilterDescriptor filterDescriptor2; FilterDescriptor filterDescriptor3; if ((object)dataType == (object)typeof(DateTime)) { DateTime?nullable1 = new DateTime?(); DateTime?nullable2 = new DateTime?(); if (values[0] != null) { nullable1 = new DateTime?((DateTime)values[0]); } if (values[1] != null) { nullable2 = new DateTime?((DateTime)values[1]); } filterDescriptor2 = (FilterDescriptor) new DateFilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, nullable1); filterDescriptor3 = (FilterDescriptor) new DateFilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, nullable2); } else { filterDescriptor2 = new FilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, values[0]); filterDescriptor3 = new FilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, values[1]); } filterDescriptor1.LogicalOperator = FilterLogicalOperator.And; filterDescriptor1.FilterDescriptors.AddRange(new FilterDescriptor[2] { filterDescriptor2, filterDescriptor3 }); filterDescriptor1.NotOperator = type == CompositeFilterDescriptor.DescriptorType.NotBetween; break; } return(filterDescriptor1); }
private void RebuildFilter() { this.FilterDescriptors.BeginUpdate(); for (int index = this.FilterDescriptors.Count - 1; index >= 0; --index) { FilterDescriptor filterDescriptor = this.FilterDescriptors[index]; filterDescriptor.PropertyChanged -= new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged); this.FilterDescriptors.Remove(filterDescriptor); } this.FilterDescriptors.Clear(); FilterDescriptorCollection filterDescriptors = this.FilterDescriptors; if (this.predicates.Count > 0) { filterDescriptors.LogicalOperator = GridViewHelper.GetLogicalOperator(this.predicates[0].BinaryOperator); } List <FilterPredicate> validPredicates = this.GetValidPredicates(); for (int index = 0; index < validPredicates.Count; ++index) { object[] predicateValues = this.GetPredicateValues(validPredicates[index]); FilterOperator filterOperator = GridViewHelper.GetFilterOperator(validPredicates[index].Function); if (filterOperator != FilterOperator.None) { FilterDescriptor filterDescriptor = new FilterDescriptor(this.PropertyName, filterOperator, predicateValues[0]); filterDescriptor.PropertyChanged += new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged); filterDescriptors.Add(filterDescriptor); } else { CompositeFilterDescriptor.DescriptorType type = CompositeFilterDescriptor.DescriptorType.Between; if (this.predicates[index].Function == GridKnownFunction.NotBetween) { type = CompositeFilterDescriptor.DescriptorType.NotBetween; } CompositeFilterDescriptor descriptor = CompositeFilterDescriptor.CreateDescriptor(type, this.PropertyName, predicateValues[0], predicateValues[1]); descriptor.PropertyChanged += new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged); filterDescriptors.Add((FilterDescriptor)descriptor); } if (this.IsComposite(validPredicates.Count - index, validPredicates)) { CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor(); filterDescriptor.PropertyChanged += new PropertyChangedEventHandler(this.FilterExpression_PropertyChanged); filterDescriptor.LogicalOperator = GridViewHelper.GetLogicalOperator(validPredicates[index + 2].BinaryOperator); filterDescriptors.Add((FilterDescriptor)filterDescriptor); filterDescriptors = filterDescriptor.FilterDescriptors; } } this.FilterDescriptors.EndUpdate(); }
public override object Clone() { CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor(); filterDescriptor.PropertyName = this.PropertyName; filterDescriptor.Operator = this.Operator; filterDescriptor.Value = this.Value; filterDescriptor.IsFilterEditor = this.IsFilterEditor; filterDescriptor.notOperator = this.notOperator; filterDescriptor.LogicalOperator = this.LogicalOperator; foreach (FilterDescriptor filter in (Collection <FilterDescriptor>) this.filters) { filterDescriptor.FilterDescriptors.Add(filter.Clone() as FilterDescriptor); } return((object)filterDescriptor); }
/// <summary> /// Removes the specified property name. /// </summary> /// <param name="propertyName">Name of the property.</param> /// <param name="predicate">The predicate which determine weather the filter can be deleted.</param> /// <returns></returns> public bool Remove(string propertyName, Predicate <FilterDescriptor> predicate) { bool result = false; int index = 0; this.BeginUpdate(); while (index < this.Count) { CompositeFilterDescriptor compositeFilter = this[index] as CompositeFilterDescriptor; if (compositeFilter != null) { if (compositeFilter.FilterDescriptors.Remove(propertyName, predicate)) { result = true; } if (compositeFilter.FilterDescriptors.Count == 0) { this.RemoveAt(index); continue; } } index++; } bool notify = result; index = this.IndexOf(propertyName); bool performRemove = index >= 0; if (predicate != null && performRemove) { performRemove = predicate(this[index]); } if (performRemove) { this.RemoveAt(index); result = true; } this.EndUpdate(notify || result); return(result); }
private static CompositeFilterDescriptor ConvertDescriptor( CompositeFilterDescriptor compositeFilter, CompositeFilterDescriptor.DescriptorType type, Type dataType) { if (compositeFilter == null) { throw new ArgumentNullException(nameof(compositeFilter)); } if (type == CompositeFilterDescriptor.DescriptorType.Unknown) { throw new InvalidOperationException("You cannot convert the filter descriptor to unknown type."); } CompositeFilterDescriptor filterDescriptor1 = compositeFilter.Clone() as CompositeFilterDescriptor; while (filterDescriptor1.FilterDescriptors.Count > 2) { int index = filterDescriptor1.FilterDescriptors.Count - 1; filterDescriptor1.FilterDescriptors.RemoveAt(index); } while (filterDescriptor1.FilterDescriptors.Count < 2) { if ((object)dataType == (object)typeof(DateTime)) { filterDescriptor1.FilterDescriptors.Add((FilterDescriptor) new DateFilterDescriptor()); } else { filterDescriptor1.FilterDescriptors.Add(new FilterDescriptor()); } } if (type == CompositeFilterDescriptor.DescriptorType.Between || type == CompositeFilterDescriptor.DescriptorType.NotBetween) { filterDescriptor1.LogicalOperator = FilterLogicalOperator.And; FilterDescriptor filterDescriptor2 = filterDescriptor1.FilterDescriptors[0]; filterDescriptor2.PropertyName = filterDescriptor1.PropertyName; filterDescriptor2.Operator = FilterOperator.IsGreaterThanOrEqualTo; FilterDescriptor filterDescriptor3 = filterDescriptor1.FilterDescriptors[1]; filterDescriptor3.PropertyName = filterDescriptor1.PropertyName; filterDescriptor3.Operator = FilterOperator.IsLessThanOrEqualTo; filterDescriptor1.NotOperator = type == CompositeFilterDescriptor.DescriptorType.NotBetween; } return(filterDescriptor1); }
private static CompositeFilterDescriptor ConvertDescriptor(CompositeFilterDescriptor compositeFilter, DescriptorType type) { if (compositeFilter == null) { throw new ArgumentNullException("compositeFilter"); } if (type == DescriptorType.Unknown) { throw new InvalidOperationException("You cannot convert the filter descriptor to unknown type."); } CompositeFilterDescriptor result = compositeFilter.Clone() as CompositeFilterDescriptor; while (result.FilterDescriptors.Count > 2) { int lastIndex = result.FilterDescriptors.Count - 1; result.FilterDescriptors.RemoveAt(lastIndex); } while (result.FilterDescriptors.Count < 2) { result.FilterDescriptors.Add(new FilterDescriptor()); } if (type == DescriptorType.Between || type == DescriptorType.NotBetween) { result.LogicalOperator = FilterLogicalOperator.And; FilterDescriptor firstFilterDescriptor = result.FilterDescriptors[0]; firstFilterDescriptor.PropertyName = result.PropertyName; firstFilterDescriptor.Operator = FilterOperator.IsGreaterThanOrEqualTo; FilterDescriptor secondFilterDescriptor = result.FilterDescriptors[1]; secondFilterDescriptor.PropertyName = result.PropertyName; secondFilterDescriptor.Operator = FilterOperator.IsLessThanOrEqualTo; result.NotOperator = type == DescriptorType.NotBetween; } return(result); }
/// <summary> /// Creates the descriptor. /// </summary> /// <param name="type">The type.</param> /// <param name="propertyName"></param> /// <param name="values"></param> /// <returns></returns> public static CompositeFilterDescriptor CreateDescriptor(DescriptorType type, string propertyName, params object[] values) { if (type == DescriptorType.Unknown) { throw new InvalidOperationException("You cannot create undefined composite filter descriptor."); } //if (String.IsNullOrEmpty(propertyName)) //{ // throw new ArgumentNullException("propertyName"); //} CompositeFilterDescriptor compositeDescriptor = new CompositeFilterDescriptor(); compositeDescriptor.PropertyName = propertyName; switch (type) { case DescriptorType.NotBetween: case DescriptorType.Between: if (values != null && values.Length != 2) { throw new ArgumentException("values"); } if (values == null) { values = new object[2]; } compositeDescriptor.LogicalOperator = FilterLogicalOperator.And; compositeDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsGreaterThanOrEqualTo, values[0])); compositeDescriptor.FilterDescriptors.Add(new FilterDescriptor(propertyName, FilterOperator.IsLessThanOrEqualTo, values[1])); compositeDescriptor.NotOperator = type == DescriptorType.NotBetween; break; } return(compositeDescriptor); }
public bool Remove(string propertyName, Predicate <FilterDescriptor> predicate) { bool flag1 = false; int index1 = 0; this.BeginUpdate(); while (index1 < this.Count) { CompositeFilterDescriptor filterDescriptor = this[index1] as CompositeFilterDescriptor; if (filterDescriptor != null) { if (filterDescriptor.FilterDescriptors.Remove(propertyName, predicate)) { flag1 = true; } if (filterDescriptor.FilterDescriptors.Count == 0) { this.RemoveAt(index1); continue; } } ++index1; } bool flag2 = flag1; int index2 = this.IndexOf(propertyName); bool flag3 = index2 >= 0; if (predicate != null && flag3) { flag3 = predicate(this[index2]); } if (flag3) { this.RemoveAt(index2); flag1 = true; } this.EndUpdate(flag2 || flag1); return(flag1); }
/// <summary> /// Gets the type of the <see cref="CompositeFilterDescriptor"/>. /// </summary> /// <param name="compositeDescriptor">The filter descriptor.</param> /// <returns></returns> public static DescriptorType GetDescriptorType(CompositeFilterDescriptor compositeDescriptor) { DescriptorType type = DescriptorType.Unknown; if (compositeDescriptor == null || compositeDescriptor.FilterDescriptors.Count != 2) { return(type); } FilterDescriptor firstDescriptor = compositeDescriptor.FilterDescriptors[0]; FilterDescriptor secondDescriptor = compositeDescriptor.FilterDescriptors[1]; if (firstDescriptor is CompositeFilterDescriptor || secondDescriptor is CompositeFilterDescriptor) { return(type); } // Between Descriptor if (firstDescriptor.Operator == FilterOperator.IsGreaterThanOrEqualTo && secondDescriptor.Operator == FilterOperator.IsLessThanOrEqualTo && compositeDescriptor.LogicalOperator == FilterLogicalOperator.And) { type = DescriptorType.Between; } // NotBetween Descriptor if ((compositeDescriptor.NotOperator && type == DescriptorType.Between) || (type == DescriptorType.Unknown && firstDescriptor.Operator == FilterOperator.IsLessThanOrEqualTo && secondDescriptor.Operator == FilterOperator.IsGreaterThanOrEqualTo && !compositeDescriptor.NotOperator && compositeDescriptor.LogicalOperator == FilterLogicalOperator.Or)) { type = DescriptorType.NotBetween; } return(type); }
//private void Parse(string expression) //{ // ExpressionNode root = ExpressionParser.Parse(expression, false); // //validate name nodes // this.BeginUpdate(); // this.Clear(); // Stack<ExpressionNode> nodeStack = new Stack<ExpressionNode>(); // nodeStack.Push(root); // Stack<FilterExpressionCollection> collectionStack = new Stack<FilterExpressionCollection>(); // collectionStack.Push(this); // while (nodeStack.Count > 0) // { // ExpressionNode current = nodeStack.Pop(); // FilterExpressionCollection expressions = collectionStack.Pop(); // UnaryOpNode unaryNode = current as UnaryOpNode; // if (unaryNode != null) // { // if (unaryNode.Op == Operator.Noop) // { // nodeStack.Push(((UnaryOpNode)current).Right); // collectionStack.Push(expressions); // continue; // } // } // BinaryOpNode binaryNode = current as BinaryOpNode; // if (binaryNode != null) // { // if (this.IsPredicate(binaryNode)) // { // FilterExpression filterExpression = new FilterExpression(); // expressions.Add(filterExpression); // continue; // } // nodeStack.Push(binaryNode.Right); // FilterExpressionCollection collection = expressions; // if(!this.IsPredicate(binaryNode.Right)) // { // CompositeFilterExpression compositeExpression = new CompositeFilterExpression(); // expressions.Add(compositeExpression); // collection = compositeExpression.FilterExpressions; // } // collectionStack.Push(collection); // nodeStack.Push(binaryNode.Left); // collection = expressions; // if (!this.IsPredicate(binaryNode.Left)) // { // CompositeFilterExpression compositeExpression = new CompositeFilterExpression(); // compositeExpression.BinaryOperator = (binaryNode.Op == Operator.And) ? FilterExpression.BinaryOperation.AND : FilterExpression.BinaryOperation.OR; // expressions.Add(compositeExpression); // collection = compositeExpression.FilterExpressions; // } // collectionStack.Push(collection); // } // } // this.EndUpdate(); //} //private bool IsPredicate(ExpressionNode node) //{ // while (node is UnaryOpNode) // { // node = ((UnaryOpNode)node).Right; // } // BinaryOpNode binaryNode = node as BinaryOpNode; // if (binaryNode == null) // { // return false; // } // if (binaryNode.Left is NameNode || binaryNode.Right is NameNode) // { // return true; // } // return false; //} private void Parse(string expression) { ExpressionNode root = ExpressionParser.Parse(expression, false); //validate name nodes this.BeginUpdate(); this.Clear(); Stack <ExpressionNode> nodeStack = new Stack <ExpressionNode>(); nodeStack.Push(root); Stack <FilterDescriptorCollection> collectionStack = new Stack <FilterDescriptorCollection>(); collectionStack.Push(this); while (nodeStack.Count > 0) { ExpressionNode current = nodeStack.Pop(); FilterDescriptorCollection expressions = collectionStack.Pop(); UnaryOpNode unaryNode = current as UnaryOpNode; if (unaryNode != null) { if (unaryNode.Op == Operator.Noop) { nodeStack.Push(((UnaryOpNode)current).Right); collectionStack.Push(expressions); continue; } } BinaryOpNode binaryNode = current as BinaryOpNode; if (binaryNode != null) { if (this.IsPredicate(binaryNode)) { FilterDescriptor filterDescriptor = this.CreateFilterDescriptor(binaryNode); expressions.Add(filterDescriptor); continue; } nodeStack.Push(binaryNode.Right); FilterDescriptorCollection collection = expressions; if (!this.IsPredicate(binaryNode.Right)) { CompositeFilterDescriptor compositeExpression = new CompositeFilterDescriptor(); expressions.Add(compositeExpression); collection = compositeExpression.FilterDescriptors; } collectionStack.Push(collection); nodeStack.Push(binaryNode.Left); collection = expressions; if (!this.IsPredicate(binaryNode.Left)) { CompositeFilterDescriptor compositeExpression = new CompositeFilterDescriptor(); compositeExpression.LogicalOperator = (binaryNode.Op == Operator.And) ? FilterLogicalOperator.And : FilterLogicalOperator.Or; expressions.Add(compositeExpression); collection = compositeExpression.FilterDescriptors; } collectionStack.Push(collection); } } this.EndUpdate(); }
public static string GetCompositeExpression(CompositeFilterDescriptor filterDescriptor) { return(CompositeFilterDescriptor.GetCompositeExpression(filterDescriptor, (Function <FilterDescriptor, object>)null)); }
private void Parse(string expression) { ExpressionNode binaryNode1 = ExpressionParser.Parse(expression, false); this.BeginUpdate(); this.Clear(); Stack <ExpressionNode> expressionNodeStack = new Stack <ExpressionNode>(); expressionNodeStack.Push(binaryNode1); Stack <FilterDescriptorCollection> descriptorCollectionStack = new Stack <FilterDescriptorCollection>(); descriptorCollectionStack.Push(this); this.LogicalOperator = this.GetCompositeFilterDescriptorLogicalOperator(binaryNode1); bool flag = false; while (expressionNodeStack.Count > 0) { ExpressionNode expressionNode = expressionNodeStack.Pop(); FilterDescriptorCollection descriptorCollection1 = descriptorCollectionStack.Pop(); UnaryOpNode unaryOpNode = expressionNode as UnaryOpNode; if (unaryOpNode != null) { if (unaryOpNode.Op == Operator.Noop) { expressionNodeStack.Push(((UnaryOpNode)expressionNode).Right); descriptorCollectionStack.Push(descriptorCollection1); continue; } if (unaryOpNode.Op == Operator.Not) { expressionNodeStack.Push(((UnaryOpNode)expressionNode).Right); flag = true; descriptorCollectionStack.Push(descriptorCollection1); continue; } } BinaryOpNode binaryNode2 = expressionNode as BinaryOpNode; if (binaryNode2 != null) { if (this.IsPredicate((ExpressionNode)binaryNode2)) { FilterDescriptor filterDescriptor = this.CreateFilterDescriptor(binaryNode2); if (flag) { filterDescriptor.Operator = this.GetNegativeOperator(filterDescriptor.Operator); flag = false; } descriptorCollection1.Add(filterDescriptor); } else { expressionNodeStack.Push(binaryNode2.Right); FilterDescriptorCollection descriptorCollection2 = descriptorCollection1; if (!this.IsPredicate(binaryNode2.Right)) { CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor(); filterDescriptor.LogicalOperator = this.GetCompositeFilterDescriptorLogicalOperator(binaryNode2.Right); descriptorCollection1.Add((FilterDescriptor)filterDescriptor); descriptorCollection2 = filterDescriptor.FilterDescriptors; } descriptorCollectionStack.Push(descriptorCollection2); expressionNodeStack.Push(binaryNode2.Left); FilterDescriptorCollection descriptorCollection3 = descriptorCollection1; if (!this.IsPredicate(binaryNode2.Left)) { CompositeFilterDescriptor filterDescriptor = new CompositeFilterDescriptor(); filterDescriptor.LogicalOperator = this.GetCompositeFilterDescriptorLogicalOperator(binaryNode2.Left); descriptorCollection1.Add((FilterDescriptor)filterDescriptor); descriptorCollection3 = filterDescriptor.FilterDescriptors; } descriptorCollectionStack.Push(descriptorCollection3); } } } this.EndUpdate(); }
public CompositeFilterDescriptor ConvertTo( CompositeFilterDescriptor.DescriptorType type) { return(CompositeFilterDescriptor.ConvertDescriptor(this, type, (Type)null)); }
public CompositeFilterDescriptor ConvertTo( CompositeFilterDescriptor.DescriptorType type, Type dataType) { return(CompositeFilterDescriptor.ConvertDescriptor(this, type, dataType)); }