public static string GetExpression(DateFilterDescriptor dateTimeFilterDescriptor)
{
if (!dateTimeFilterDescriptor.IgnoreTimePart)
{
return(FilterDescriptor.GetExpression((FilterDescriptor)dateTimeFilterDescriptor));
}
if (string.IsNullOrEmpty(dateTimeFilterDescriptor.PropertyName) || dateTimeFilterDescriptor.Operator == FilterOperator.None || dateTimeFilterDescriptor.Operator != FilterOperator.IsNotNull && dateTimeFilterDescriptor.Operator != FilterOperator.IsNull && !dateTimeFilterDescriptor.Value.HasValue)
{
return(string.Empty);
}
string str1 = (string)null;
string str2 = (string)null;
string str3 = DataStorageHelper.EscapeName(dateTimeFilterDescriptor.PropertyName);
if (dateTimeFilterDescriptor.Value.HasValue)
{
str1 = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "#{0}#", (object)dateTimeFilterDescriptor.Value.Value.Date);
str2 = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "#{0}#", (object)dateTimeFilterDescriptor.Value.Value.Date.AddDays(1.0));
}
switch (dateTimeFilterDescriptor.Operator)
{
case FilterOperator.None:
return(string.Empty);
case FilterOperator.IsLike:
case FilterOperator.IsEqualTo:
return(string.Format("{0} >= {1} AND {0} < {2}", (object)str3, (object)str1, (object)str2));
case FilterOperator.IsNotLike:
case FilterOperator.IsNotEqualTo:
return(string.Format("{0} < {1} OR {0} >= {2}", (object)str3, (object)str1, (object)str2));
case FilterOperator.IsLessThan:
return(string.Format("{0} < {1}", (object)str3, (object)str1));
case FilterOperator.IsLessThanOrEqualTo:
return(string.Format("{0} < {1}", (object)str3, (object)str2));
case FilterOperator.IsGreaterThanOrEqualTo:
return(string.Format("{0} >= {1}", (object)str3, (object)str1));
case FilterOperator.IsGreaterThan:
return(string.Format("{0} >= {1}", (object)str3, (object)str2));
case FilterOperator.IsNull:
return(string.Format("{0} IS NULL", (object)str3));
case FilterOperator.IsNotNull:
return(string.Format("NOT ({0} IS NULL)", (object)str3));
default:
return(string.Empty);
}
}
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 bool FilterEvaluate(FilterDescriptor filterDescriptor, TDataItem item)
{
if (filterDescriptor == null || string.IsNullOrEmpty(filterDescriptor.Expression))
{
return(true);
}
ExpressionContext context = new ExpressionContext();
context.CaseSensitive = this.CaseSensitive;
this.FillFilterContext(filterDescriptor, item, context);
object obj = ExpressionParser.ParseNoCache(filterDescriptor.Expression, this.CaseSensitive).Eval((object)null, (object)context);
if (obj is bool)
{
return((bool)obj);
}
return(true);
}
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);
}
private static object GetExpressionValue(
FilterDescriptor filterDescriptor,
Function <FilterDescriptor, object> formatValue)
{
object obj1 = filterDescriptor.Value;
if (!(obj1 is string) && obj1 is IEnumerable)
{
IEnumerable enumerable = obj1 as IEnumerable;
List <object> objectList = new List <object>();
foreach (object obj2 in enumerable)
{
FilterDescriptor filterDescriptor1 = filterDescriptor.Clone() as FilterDescriptor;
filterDescriptor1.Value = obj2;
object expressionValue = FilterDescriptor.GetExpressionValue(filterDescriptor1, formatValue);
objectList.Add(expressionValue);
}
return((object)objectList.ToArray());
}
object obj3 = formatValue != null?formatValue(filterDescriptor) : filterDescriptor.Value;
object obj4;
if (obj3 is string || obj3 is char || (obj3 is Guid || obj3 is TimeSpan))
{
obj4 = (object)("'" + DataStorageHelper.EscapeValue(Convert.ToString(obj3)) + "'");
}
else if (obj3 is Enum)
{
obj4 = (object)Convert.ToInt32(obj3);
}
else if (obj3 is DateTime)
{
obj4 = (object)string.Format((IFormatProvider)CultureInfo.InvariantCulture, "#{0}#", obj3);
}
else
{
obj4 = !(obj3 is double) ? (!(obj3 is Color) ? (obj3 is short || obj3 is int || (obj3 is long || obj3 is Decimal) || (obj3 is float || obj3 is double || obj3 is bool) ? (object)Convert.ToString(filterDescriptor.Value, (IFormatProvider)CultureInfo.InvariantCulture) : (object)("'" + DataStorageHelper.EscapeValue(Convert.ToString(filterDescriptor.Value, (IFormatProvider)CultureInfo.InvariantCulture)) + "'")) : (object)((Color)obj3).ToArgb()) : (object)((double)obj3).ToString("G17", (IFormatProvider)CultureInfo.InvariantCulture);
}
return(obj4);
}
/// <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);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="dateTimeFilterDescriptor">The filter descriptor.</param>
/// <returns></returns>
public static string GetExpression(DateFilterDescriptor dateTimeFilterDescriptor)
{
if (dateTimeFilterDescriptor.IgnoreTimePart)
{
if (String.IsNullOrEmpty(dateTimeFilterDescriptor.PropertyName) ||
dateTimeFilterDescriptor.Operator == FilterOperator.None)
{
return(string.Empty);
}
if ((dateTimeFilterDescriptor.Operator != FilterOperator.IsNotNull && dateTimeFilterDescriptor.Operator != FilterOperator.IsNull) &&
dateTimeFilterDescriptor.Value == null)
{
return(string.Empty);
}
string dateBegin = null;
string dateEnd = null;
string propertyName = DataStorageHelper.EscapeName(dateTimeFilterDescriptor.PropertyName);
if (dateTimeFilterDescriptor.Value != null)
{
dateBegin = String.Format(CultureInfo.InvariantCulture, "#{0}#", dateTimeFilterDescriptor.Value.Value.Date);
dateEnd = String.Format(CultureInfo.InvariantCulture, "#{0}#", dateTimeFilterDescriptor.Value.Value.Date.AddDays(1));
}
switch (dateTimeFilterDescriptor.Operator)
{
case FilterOperator.None:
return(String.Empty);
case FilterOperator.IsNull:
return(string.Format("{0} IS NULL", propertyName));
case FilterOperator.IsNotNull:
return(string.Format("NOT ({0} IS NULL)", propertyName));
case FilterOperator.IsLessThan:
return(string.Format("{0} < {1}", propertyName, dateBegin));
case FilterOperator.IsLessThanOrEqualTo:
return(string.Format("{0} < {1}", propertyName, dateEnd));
case FilterOperator.IsLike:
case FilterOperator.IsEqualTo:
return(string.Format("{0} >= {1} AND {0} < {2}", propertyName, dateBegin, dateEnd));
case FilterOperator.IsNotLike:
case FilterOperator.IsNotEqualTo:
return(string.Format("{0} < {1} OR {0} >= {2}", propertyName, dateBegin, dateEnd));
case FilterOperator.IsGreaterThanOrEqualTo:
return(string.Format("{0} >= {1}", propertyName, dateBegin));
case FilterOperator.IsGreaterThan:
return(string.Format("{0} >= {1}", propertyName, dateEnd));
case FilterOperator.StartsWith:
case FilterOperator.EndsWith:
case FilterOperator.Contains:
case FilterOperator.NotContains:
case FilterOperator.IsContainedIn:
case FilterOperator.IsNotContainedIn:
default:
return(String.Empty);
}
}
else
{
return(FilterDescriptor.GetExpression(dateTimeFilterDescriptor));
}
}
/// <summary>
/// Returns a <see cref="System.String"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String"/> that represents this instance.
/// </returns>
public override string ToString()
{
return(FilterDescriptor.GetExpression(this));
}
public static string GetExpression(FilterDescriptor filterDescriptor)
{
return(FilterDescriptor.GetExpression(filterDescriptor, (Function <FilterDescriptor, object>)null));
}
public static string GetExpression(
FilterDescriptor filterDescriptor,
Function <FilterDescriptor, object> formatValue)
{
if (string.IsNullOrEmpty(filterDescriptor.PropertyName) || filterDescriptor.filterOperator == FilterOperator.None || filterDescriptor.Operator != FilterOperator.IsNotNull && filterDescriptor.Operator != FilterOperator.IsNull && (filterDescriptor.Operator != FilterOperator.IsEqualTo && filterDescriptor.Operator != FilterOperator.IsNotEqualTo) && filterDescriptor.value == null)
{
return(string.Empty);
}
FilterOperator filterOperator = filterDescriptor.Operator;
object obj = FilterDescriptor.GetExpressionValue(filterDescriptor, formatValue);
if (filterDescriptor.value == null || filterDescriptor.value == DBNull.Value)
{
if (filterOperator == FilterOperator.IsEqualTo)
{
filterOperator = FilterOperator.IsNull;
}
if (filterOperator == FilterOperator.IsNotEqualTo)
{
filterOperator = FilterOperator.IsNotNull;
}
}
if (filterOperator == FilterOperator.IsContainedIn || filterOperator == FilterOperator.IsNotContainedIn)
{
IEnumerable enumebrable = obj as IEnumerable;
if (enumebrable != null && obj is string)
{
enumebrable = (IEnumerable)obj.ToString().Trim('\'').Split(new char[2]
{
',',
' '
}, StringSplitOptions.RemoveEmptyEntries);
obj = (object)DataStorageHelper.ParseEnumerbale(enumebrable);
}
if (!(obj is string) && enumebrable != null)
{
obj = (object)DataStorageHelper.ParseEnumerbale(enumebrable);
}
}
string empty = string.Empty;
string str1 = DataStorageHelper.EscapeName(filterDescriptor.PropertyName);
switch (filterOperator)
{
case FilterOperator.IsLike:
return(string.Format("{0} LIKE {1}", (object)str1, obj));
case FilterOperator.IsNotLike:
return(string.Format("{0} NOT LIKE {1}", (object)str1, obj));
case FilterOperator.IsLessThan:
return(string.Format("{0} < {1}", (object)str1, obj));
case FilterOperator.IsLessThanOrEqualTo:
return(string.Format("{0} <= {1}", (object)str1, obj));
case FilterOperator.IsEqualTo:
return(string.Format("{0} = {1}", (object)str1, obj));
case FilterOperator.IsNotEqualTo:
return(string.Format("{0} <> {1}", (object)str1, obj));
case FilterOperator.IsGreaterThanOrEqualTo:
return(string.Format("{0} >= {1}", (object)str1, obj));
case FilterOperator.IsGreaterThan:
return(string.Format("{0} > {1}", (object)str1, obj));
case FilterOperator.StartsWith:
string str2 = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, (IFormatProvider)CultureInfo.InvariantCulture));
return(string.Format("{0} LIKE '{1}%'", (object)str1, (object)str2));
case FilterOperator.EndsWith:
string str3 = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, (IFormatProvider)CultureInfo.InvariantCulture));
return(string.Format("{0} LIKE '%{1}'", (object)str1, (object)str3));
case FilterOperator.Contains:
string str4 = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, (IFormatProvider)CultureInfo.InvariantCulture));
return(string.Format("{0} LIKE '%{1}%'", (object)str1, (object)str4));
case FilterOperator.NotContains:
string str5 = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, (IFormatProvider)CultureInfo.InvariantCulture));
return(string.Format("{0} NOT LIKE '%{1}%'", (object)str1, (object)str5));
case FilterOperator.IsNull:
return(string.Format("{0} IS NULL", (object)str1));
case FilterOperator.IsNotNull:
return(string.Format("NOT ({0} IS NULL)", (object)str1));
case FilterOperator.IsContainedIn:
return(string.Format("{0} IN ({1})", (object)str1, obj));
case FilterOperator.IsNotContainedIn:
return(string.Format("{0} NOT IN ({1})", (object)str1, obj));
default:
return(string.Empty);
}
}
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 virtual object Clone()
{
FilterDescriptor filterDescriptor = new FilterDescriptor(this.propertyName, this.filterOperator, this.value);
return(filterDescriptor);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="filterDescriptor">The filter descriptor.</param>
/// <returns></returns>
public static string GetExpression(FilterDescriptor filterDescriptor)
{
if (string.IsNullOrEmpty(filterDescriptor.PropertyName) ||
filterDescriptor.filterOperator == FilterOperator.None)
{
return(string.Empty);
}
if ((filterDescriptor.Operator != FilterOperator.IsNotNull && filterDescriptor.Operator != FilterOperator.IsNull) &&
filterDescriptor.value == null)
{
return(string.Empty);
}
object value = filterDescriptor.Value;
if (value is string || value is char)
{
value = "'" + DataStorageHelper.EscapeValue(Convert.ToString(value)) + "'";
}
else if (value is Enum)
{
value = Convert.ToInt32(value);
}
else if (value is DateTime)
{
value = String.Format(CultureInfo.InvariantCulture, "#{0}#", value);
}
else if (value is double)
{
value = ((double)value).ToString("R", CultureInfo.InvariantCulture);
}
else
{
value = Convert.ToString(filterDescriptor.Value, CultureInfo.InvariantCulture);
}
string likeValue = String.Empty;
string name = DataStorageHelper.EscapeName(filterDescriptor.PropertyName);
switch (filterDescriptor.Operator)
{
case FilterOperator.IsLike:
return(string.Format("{0} LIKE {1}", name, value));
case FilterOperator.IsNotLike:
return(string.Format("{0} NOT LIKE {1}", name, value));
case FilterOperator.StartsWith:
likeValue = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, CultureInfo.InvariantCulture));
return(string.Format("{0} LIKE '{1}%'", name, likeValue));
case FilterOperator.EndsWith:
likeValue = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, CultureInfo.InvariantCulture));
return(string.Format("{0} LIKE '%{1}'", name, likeValue));
case FilterOperator.Contains:
likeValue = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, CultureInfo.InvariantCulture));
return(string.Format("{0} LIKE '%{1}%'", name, likeValue));
case FilterOperator.NotContains:
likeValue = DataStorageHelper.EscapeLikeValue(Convert.ToString(filterDescriptor.Value, CultureInfo.InvariantCulture));
return(string.Format("{0} NOT LIKE '%{1}%'", name, likeValue));
case FilterOperator.IsEqualTo:
return(string.Format("{0} = {1}", name, value));
case FilterOperator.IsLessThan:
return(string.Format("{0} < {1}", name, value));
case FilterOperator.IsLessThanOrEqualTo:
return(string.Format("{0} <= {1}", name, value));
case FilterOperator.IsGreaterThan:
return(string.Format("{0} > {1}", name, value));
case FilterOperator.IsGreaterThanOrEqualTo:
return(string.Format("{0} >= {1}", name, value));
case FilterOperator.IsNotEqualTo:
return(string.Format("{0} <> {1}", name, value));
case FilterOperator.IsNull:
return(string.Format("{0} IS NULL", name));
case FilterOperator.IsNotNull:
return(string.Format("NOT ({0} IS NULL)", name));
case FilterOperator.IsContainedIn:
return(string.Format("{0} IN ({1})", name, value));
case FilterOperator.IsNotContainedIn:
return(string.Format("{0} NOT IN ({1})", name, value));
}
return(string.Empty);
}
