protected SPModelQuery ApplyFilters()
{
CamlExpression expression = originalExpression;
if (expression == Caml.False || expressionForCTFilter == Caml.False)
{
return(this);
}
foreach (ISPModelQueryFilter filter in filters)
{
if (filter.ShouldTransformExpression(this))
{
ISPModelQueryFilter clone = (ISPModelQueryFilter)filter.Clone();
expression = clone.TransformExpression(this, expression);
if (expression == Caml.False)
{
break;
}
}
}
if (expression != this.Expression)
{
SPModelQuery result = (SPModelQuery)MemberwiseClone();
result.originalExpression = expression;
result.expression = null;
return(result);
}
return(this);
}
public CamlExpression GetExpression(Func <SPModelQueryFieldInfo, CamlExpression> expressionFactory, bool checkOrderable)
{
CommonHelper.AccessNotNull(expressionFactory, "expressionFactory");
if (this.FieldAssociations == null)
{
CommonHelper.AccessNotNull(this.Field.FieldRef, "FieldRef");
return(expressionFactory(this.Field));
}
if (!this.FieldAssociations.Queryable)
{
throw new Exception(String.Format("Member '{0}' must have exactly one SPFieldAttribute with IncludeInQuery set to true", this.Member.Name));
}
if (this.FieldAssociations.Fields.Count > 1 && checkOrderable)
{
throw new Exception(String.Format("Member '{0}' cannot be used in ordering", this.Member.Name));
}
CamlExpression expression = Caml.False;
foreach (SPModelFieldAssociation association in this.FieldAssociations)
{
SPModelQueryFieldInfo fieldInfo = new SPModelQueryFieldInfo(visitor.Manager.Site, association);
if (this.FieldAssociations.Fields.Count == 1)
{
return(expressionFactory(fieldInfo));
}
expression |= (association.Descriptor.GetContentTypeExpression(visitor.Manager.Descriptor) + expressionFactory(fieldInfo));
}
return(expression);
}
/// <summary>
/// Gets all variation labels in a site collection. This method is safe when called in console.
/// </summary>
/// <param name="publishingSite">Site collection.</param>
/// <param name="includePending">Whether to return pending variation labels.</param>
/// <returns>A read-only collection of all variation labels.</returns>
public static ReadOnlyCollection <VariationLabel> GetVariationLabels(this PublishingSite publishingSite, bool includePending)
{
if (GetVariationLabelMethod == null)
{
throw new MissingMethodException("GetVariationLabel");
}
List <VariationLabel> collection = new List <VariationLabel>();
publishingSite.Site.WithElevatedPrivileges(elevatedSite => {
string variationsListId = (string)elevatedSite.RootWeb.AllProperties["_VarLabelsListId"];
if (!String.IsNullOrEmpty(variationsListId))
{
SPList variationsList = elevatedSite.RootWeb.Lists[new Guid(variationsListId)];
CamlExpression queryExpr = Caml.IsNotNull(SPBuiltInFieldName.Title);
if (!includePending)
{
queryExpr &= Caml.IsNotNull("Top_x0020_Web_x0020_URL");
}
SPQuery query = new SPQuery {
Query = queryExpr.ToString()
};
foreach (SPListItem listItem in variationsList.GetItems(query))
{
VariationLabel label = GetVariationLabelMethod.Invoke <VariationLabel>(null, listItem);
collection.Add(label);
}
}
});
return(collection.AsReadOnly());
}
public SPListItem GetItem(SPList list, CamlExpression expr)
{
SPListItemCollection items = this.Query(list,expr,1);
if (items.Count > 0)
return items[0];
else
return null;
}
public void Reset()
{
this.Expression = null;
this.Field = default(SPModelQueryFieldInfo);
this.FieldAssociations = null;
this.Member = null;
this.MemberType = null;
this.ParameterName = null;
}
public void Reset()
{
this.Expression = null;
this.Field = default(SPModelQueryFieldInfo);
this.FieldAssociations = null;
this.Member = null;
this.MemberType = null;
this.IsValueDefined = false;
definedValue = null;
}
public SPModelQuery(ISPModelManagerInternal manager, Type modelType, CamlExpression expression, int limit, int startRow)
{
CommonHelper.ConfirmNotNull(manager, "manager");
CommonHelper.ConfirmNotNull(modelType, "modelType");
this.Manager = manager;
this.Descriptor = SPModelDescriptor.Resolve(modelType);
this.ContentTypeFilterExpression = manager.Descriptor.GetContentTypeExpression(this.descriptor);
this.Expression = expression;
this.Offset = startRow;
this.Limit = limit;
}
/// <summary>
/// Creates a <see cref="KeywordQuery"/> instance with query text and certain properties set in regards of the specified CAML expression, with values to be binded on parameters.
/// </summary>
/// <param name="site">A site collection object.</param>
/// <param name="expression">A CAML expression.</param>
/// <param name="bindings">A collection of parameter values.</param>
/// <returns>A prepared <see cref="KeywordQuery"/> instance.</returns>
public static KeywordQuery CreateKeywordQueryFromCaml(SPSite site, CamlExpression expression, Hashtable bindings)
{
CommonHelper.ConfirmNotNull(site, "site");
CommonHelper.ConfirmNotNull(expression, "expression");
CommonHelper.ConfirmNotNull(bindings, "bindings");
KeywordQuery query = new KeywordQuery(site);
KeywordQueryCamlVisitor visitor = new KeywordQueryCamlVisitor(query, bindings);
visitor.Visit(expression);
return(query);
}
private CamlExpression UpdateExpression(CamlExpression expression, CamlParameterBindingFieldRef field, bool equals)
{
ICollection <int> ids = GetDeletedTermIDs();
if (ids.Count == 0)
{
return(expression);
}
CamlExpression constraint = Caml.LookupIdEqualsAny(field, ids);
return(equals ? expression | constraint : expression& ~constraint);
}
/// <summary>
/// Called when visiting a <Query/> expression.
/// </summary>
/// <param name="expression">An instance of the <see cref="CamlQueryExpression"/> class representing the <Query/> expression.</param>
/// <returns>When overriden, returns an expression to replace the expression given in arguments.</returns>
protected virtual CamlExpression VisitQueryExpression(CamlQueryExpression expression)
{
CommonHelper.ConfirmNotNull(expression, "expression");
CamlExpression x = VisitChecked(expression.Where, CamlExpressionType.Where);
CamlExpression y = VisitChecked(expression.OrderBy, CamlExpressionType.OrderBy);
CamlExpression z = VisitChecked(expression.GroupBy, CamlExpressionType.GroupBy);
if (x != expression.Where || y != expression.OrderBy || z != expression.GroupBy)
{
return(new CamlQueryExpression(x as ICamlQueryComponent <CamlWhereExpression>, y as ICamlQueryComponent <CamlOrderByExpression>, z as ICamlQueryComponent <CamlGroupByExpression>));
}
return(expression);
}
public CamlExpression GetContentTypeExpression(SPModelDescriptor other)
{
CommonHelper.ConfirmNotNull(other, "other");
CamlExpression expression = Caml.False;
foreach (SPContentTypeId contentTypeId in this.ContentTypeIds)
{
if (other == this || other.ContentTypeIds.Any(v => v.IsParentOf(contentTypeId)))
{
expression |= Caml.OfContentType(contentTypeId);
}
}
return(expression);
}
/// <summary>
/// Called when visiting a CAML expression with binded values.
/// </summary>
/// <param name="expression">An instance of the <see cref="CamlBindedExpression"/> class representing the value-binded expression.</param>
/// <returns>When overriden, returns an expression to replace the expression given in arguments.</returns>
protected virtual CamlExpression VisitBindedExpression(CamlBindedExpression expression)
{
Hashtable previous = this.Bindings;
try {
this.Bindings = expression.Bindings;
CamlExpression result = Visit(expression.Expression);
if (result != expression.Expression)
{
return(new CamlBindedExpression(result, this.Bindings));
}
return(expression);
} finally {
this.Bindings = previous;
}
}
/// <summary>
/// Called when visiting a sub-expression.
/// </summary>
/// <param name="expression">An instance of the <see cref="CamlExpression"/> class representing the visiting expression.</param>
/// <returns>When overriden, returns an expression to replace the expression given in arguments.</returns>
protected virtual CamlExpression Visit(CamlExpression expression)
{
CommonHelper.ConfirmNotNull(expression, "expression");
switch (expression.Type)
{
case CamlExpressionType.Binded:
return(VisitBindedExpression((CamlBindedExpression)expression));
case CamlExpressionType.GroupBy:
return(VisitGroupByExpression((CamlGroupByExpression)expression));
case CamlExpressionType.GroupByFieldRef:
return(VisitGroupByFieldRefExpression((CamlGroupByFieldRefExpression)expression));
case CamlExpressionType.OrderBy:
return(VisitOrderByExpression((CamlOrderByExpression)expression));
case CamlExpressionType.OrderByFieldRef:
return(VisitOrderByFieldRefExpression((CamlOrderByFieldRefExpression)expression));
case CamlExpressionType.Query:
return(VisitQueryExpression((CamlQueryExpression)expression));
case CamlExpressionType.ViewFields:
return(VisitViewFieldsExpression((CamlViewFieldsExpression)expression));
case CamlExpressionType.ViewFieldsFieldRef:
return(VisitViewFieldsFieldRefExpression((CamlViewFieldsFieldRefExpression)expression));
case CamlExpressionType.Where:
return(VisitWhereExpression((CamlWhereExpression)expression));
case CamlExpressionType.WhereBinaryComparison:
return(VisitWhereBinaryComparisonExpression((CamlWhereBinaryComparisonExpression)expression));
case CamlExpressionType.WhereLogical:
return(VisitWhereLogicalExpression((CamlWhereLogicalExpression)expression));
case CamlExpressionType.WhereUnaryComparison:
return(VisitWhereUnaryComparisonExpression((CamlWhereUnaryComparisonExpression)expression));
}
return(expression);
}
private CamlExpression VisitChecked(CamlExpression expression, CamlExpressionType expressionType)
{
if (expression != null)
{
CamlExpression result = Visit(expression);
if (result != expression)
{
if (result == null)
{
throw new InvalidOperationException(String.Format("Expected an expression of compatiable type to {0} but NULL returned.", expressionType));
}
if (result.Type != CamlExpressionType.Empty && result.Type != expression.Type)
{
Type expectedType = null;
switch (expressionType)
{
case CamlExpressionType.Where:
expectedType = typeof(ICamlQueryComponent <CamlWhereExpression>);
break;
case CamlExpressionType.GroupBy:
expectedType = typeof(ICamlQueryComponent <CamlWhereExpression>);
break;
case CamlExpressionType.OrderBy:
expectedType = typeof(ICamlQueryComponent <CamlWhereExpression>);
break;
case CamlExpressionType.ViewFields:
expectedType = typeof(CamlViewFieldsExpression);
break;
}
if (!result.GetType().IsOf(expectedType))
{
throw new InvalidOperationException(String.Format("Expected an expression of compatiable type to {0} but expression of type {1} returned.", expressionType, result.Type));
}
}
}
return(result);
}
return(null);
}
private CamlExpression VisitExpressionList <T>(CamlExpressionList <T> expression) where T : CamlExpression
{
CamlExpression[] src = expression.Expressions;
CamlExpression[] dst = new CamlExpression[src.Length];
Type expectedType = null;
switch (expression.Type)
{
case CamlExpressionType.GroupBy:
expectedType = typeof(CamlGroupByExpression);
break;
case CamlExpressionType.OrderBy:
expectedType = typeof(CamlOrderByExpression);
break;
case CamlExpressionType.ViewFields:
expectedType = typeof(CamlViewFieldsExpression);
break;
}
for (int i = 0; i < src.Length; i++)
{
dst[i] = VisitChecked(src[i], expression.Type);
}
if (!src.SequenceEqual(dst))
{
IEnumerable <CamlFieldRefExpression> fields = dst.OfType <ICamlFieldRefComponent>().SelectMany(v => v.EnumerateFieldRefExpression());
switch (expression.Type)
{
case CamlExpressionType.GroupBy:
return(new CamlGroupByExpression(fields.OfType <CamlGroupByFieldRefExpression>(), ((CamlGroupByExpression)(object)expression).Collapse));
case CamlExpressionType.OrderBy:
return(new CamlOrderByExpression(fields.OfType <CamlOrderByFieldRefExpression>()));
case CamlExpressionType.ViewFields:
return(new CamlViewFieldsExpression(fields.OfType <CamlViewFieldsFieldRefExpression>()));
}
}
return(expression);
}
private CamlExpression HandleNullExpression(SPModelQueryFieldInfo field, bool negate)
{
CamlExpression expression = Caml.IsNull(field.FieldRef);
if (field.FieldTypeAsString == "TaxonomyFieldType" || field.FieldTypeAsString == "TaxonomyFieldTypeMulti")
{
SPList taxonomyHiddenList = SPExtensionHelper.GetTaxonomyHiddenList(manager.Site);
foreach (SPListItem item in taxonomyHiddenList.GetItems("IdForTerm"))
{
if (manager.TermStore.GetTerm(new Guid((string)item["IdForTerm"])) == null)
{
expression |= Caml.LookupIdEquals(field.FieldRef, item.ID);
}
}
}
if (negate)
{
return(~expression);
}
return(expression);
}
/// <summary>
/// Called when visiting a <Where/> expression.
/// </summary>
/// <param name="expression">An instance of the <see cref="CamlWhereExpression"/> class representing the <Where/> expression.</param>
/// <returns>When overriden, returns an expression to replace the expression given in arguments.</returns>
protected virtual CamlExpression VisitWhereExpression(CamlWhereExpression expression)
{
CommonHelper.ConfirmNotNull(expression, "expression");
CamlExpression bodyExpression = VisitChecked(expression.Body, CamlExpressionType.Where);
if (bodyExpression != expression.Body)
{
switch (bodyExpression.Type)
{
case CamlExpressionType.WhereUnaryComparison:
case CamlExpressionType.WhereBinaryComparison:
case CamlExpressionType.WhereLogical:
return(new CamlWhereExpression((CamlWhereComparisonExpression)bodyExpression));
case CamlExpressionType.Where:
case CamlExpressionType.Empty:
return(bodyExpression);
}
throw new InvalidOperationException();
}
return(expression);
}
/// <summary>
/// Creates a <see cref="KeywordQuery"/> instance with query text and certain properties set in regards of the specified CAML expression.
/// </summary>
/// <param name="site">A site collection object.</param>
/// <param name="query">A CAML expression.</param>
/// <param name="limit">Number of rows to be returned.</param>
/// <param name="startRow">Number of rows to be skipped.</param>
/// <param name="keywords">A list of keywords to be passed in query text.</param>
/// <param name="inclusion">Whether to match all or any keywords supplied.</param>
/// <param name="selectProperties">A list of managed properties to be returned.</param>
/// <returns>A prepared <see cref="KeywordQuery"/> instance.</returns>
public static KeywordQuery CreateQuery(SPSite site, CamlExpression query, int limit, int startRow, string[] keywords, KeywordInclusion inclusion, string[] selectProperties)
{
CommonHelper.ConfirmNotNull(site, "site");
KeywordQuery keywordQuery = SearchServiceHelper.CreateKeywordQueryFromCaml(site, query);
if (keywords != null)
{
keywordQuery.QueryText = String.Concat(String.Join(" ", keywords), " ", keywordQuery.QueryText);
}
keywordQuery.SelectProperties.AddRange(SPModel.RequiredSearchProperties);
if (selectProperties != null)
{
keywordQuery.SelectProperties.AddRange(selectProperties);
}
keywordQuery.KeywordInclusion = inclusion;
keywordQuery.ResultsProvider = SearchProvider.Default;
keywordQuery.TrimDuplicates = true;
keywordQuery.TrimDuplicatesOnProperty = BuiltInManagedPropertyName.UniqueID;
keywordQuery.StartRow = startRow;
keywordQuery.RowLimit = limit;
keywordQuery.RowsPerPage = limit;
return(keywordQuery);
}
/// <summary>
/// Called when visiting a logical comparison expression inside a <Where/> element.
/// </summary>
/// <param name="expression">An instance of the <see cref="CamlWhereLogicalExpression"/> class representing the logical comparison expression.</param>
/// <returns>When overriden, returns an expression to replace the expression given in arguments.</returns>
protected virtual CamlExpression VisitWhereLogicalExpression(CamlWhereLogicalExpression expression)
{
CommonHelper.ConfirmNotNull(expression, "expression");
CamlExpression l = VisitChecked(expression.Left, CamlExpressionType.Where);
CamlExpression r = VisitChecked(expression.Right, CamlExpressionType.Where);
if (l != expression.Left || r != expression.Right)
{
switch (expression.Operator)
{
case CamlLogicalOperator.And:
return(Caml.And(l, r));
case CamlLogicalOperator.Or:
return(Caml.Or(l, r));
case CamlLogicalOperator.Not:
return(Caml.Not(l));
}
throw new InvalidOperationException();
}
return(expression);
}
public SPListItem GetItem(SPList list, CamlExpression expr)
{
SPListItem item = null;
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite site = new SPSite(SPContext.Current.Site.ID))
{
using (SPWeb web = site.OpenWeb(this._web.ID))
{
SPList list2 = web.Lists[list.ID];
SharePointService svr = new SharePointService(web);
item = svr.GetItem(list2, expr);
}
}
});
return item;
}
public DataTable QueryDataTable(SPList list, CamlExpression expr, int rowLimit , params OrderPair[] orders)
{
SPListItemCollection items = this.Query(list,expr,rowLimit,orders);
DataTable t = items.GetDataTable();
if (t != null)
{
foreach (DataColumn col in t.Columns)
{
SPField f = list.Fields.GetFieldByInternalName(col.ColumnName);
if (f.ReadOnlyField) continue;
col.ColumnName = f.Title;
}
}
return t ;
}
//public SPListItemCollection Query(SPList list, string expr, int rowLimit , bool rec )
//{
// SPQuery q = new SPQuery();
// if (!string.IsNullOrEmpty(expr))
// q.Query = expr;
// if (rowLimit >= 0)
// q.RowLimit = (uint)rowLimit;
// SPListItemCollection items = list.GetItems(q);
// return items;
//}
public SPListItemCollection Query(SPList list, CamlExpression expr, int rowLimit, params OrderPair[] orders)
{
IList<OrderPair> dic = new List<OrderPair>();
if (orders != null)
{
foreach (OrderPair p in orders)
dic.Add(p);
}
SPQuery q = new SPQuery();
//if (expr != null)
q.Query = CamlBuilder.Where(list, expr,dic);
if (rowLimit >= 0)
q.RowLimit = (uint)rowLimit;
SPListItemCollection items = list.GetItems(q);
return items;
}
/// <summary>
/// Performs a keyword search against the items of the associated content type(s) and returns the number of items.
/// </summary>
/// <typeparam name="TItem">Item type.</typeparam>
/// <param name="query">CAML query expression.</param>
/// <param name="keywords">A list of keywords to be searched against.</param>
/// <param name="refiners">A list of <see cref="SearchRefiner"/> instances. Refinement results are populated to the supplied instances.</param>
/// <param name="keywordInclusion">See <see cref="KeywordInclusion"/>.</param>
/// <returns>Number of items.</returns>
public new int GetCount <TItem>(CamlExpression query, string[] keywords, SearchRefiner[] refiners, KeywordInclusion keywordInclusion)
{
return(base.GetCount <TItem>(query, keywords, refiners, keywordInclusion));
}
/// <summary>
/// Performs a keyword search against the items of the associated content type(s) and returns the number of items.
/// </summary>
/// <param name="query">CAML query expression.</param>
/// <param name="keywords">A list of keywords to be searched against.</param>
/// <param name="keywordInclusion">See <see cref="KeywordInclusion"/>.</param>
/// <returns>Number of items.</returns>
public int GetCount(CamlExpression query, string[] keywords, KeywordInclusion keywordInclusion)
{
return(base.GetCount <T>(query, keywords, keywordInclusion));
}
/// <summary>
/// Performs a keyword search against the items of the associated content type(s).
/// </summary>
/// <typeparam name="TItem">Item type.</typeparam>
/// <param name="query">CAML query expression.</param>
/// <param name="limit">Maximum number of items to be returned.</param>
/// <param name="startRow">Number of items to skip from start.</param>
/// <param name="keywords">A list of keywords to be searched against.</param>
/// <param name="refiners">A list of <see cref="SearchRefiner"/> instances. Refinement results are populated to the supplied instances.</param>
/// <param name="keywordInclusion">See <see cref="KeywordInclusion"/>.</param>
/// <param name="totalCount">Total number of items.</param>
/// <returns>A collection containing the returned items.</returns>
public new SPModelCollection <TItem> GetItems <TItem>(CamlExpression query, uint limit, uint startRow, string[] keywords, SearchRefiner[] refiners, KeywordInclusion keywordInclusion, out int totalCount)
{
return(base.GetItems <TItem>(query, limit, startRow, keywords, refiners, keywordInclusion, out totalCount));
}
CamlExpression ISPModelQueryFilter.TransformExpression(SPModelQuery query, CamlExpression expression)
{
Initialize(query);
return(base.Visit(expression));
}
/// <summary>
/// Performs a keyword search against the items of the associated content type(s).
/// </summary>
/// <typeparam name="TItem">Item type.</typeparam>
/// <param name="query">CAML query expression.</param>
/// <param name="limit">Maximum number of items to be returned.</param>
/// <param name="keywords">A list of keywords to be searched against.</param>
/// <param name="keywordInclusion">See <see cref="KeywordInclusion"/>.</param>
/// <returns>A collection containing the returned items.</returns>
public new SPModelCollection <TItem> GetItems <TItem>(CamlExpression query, uint limit, string[] keywords, KeywordInclusion keywordInclusion)
{
return(base.GetItems <TItem>(query, limit, keywords, keywordInclusion));
}
public static CamlExpression LinkAnd(CamlExpression expr1, CamlExpression expr2)
{
if (expr1 == null)
return expr2;
else
return expr1 && expr2;
}
private CamlExpression LinkAnd(CamlExpression expr1, CamlExpression expr2)
{
if (expr1 == null)
return expr2;
else
return expr1 && expr2;
}
/// <summary>
/// Visits a CAML expression.
/// </summary>
/// <param name="expression">A CAML expression.</param>
public void Visit(CamlExpression expression)
{
expression.VisitInternal(this);
}
/// <summary> /// Called when visiting a <Where/> expression. /// </summary> /// <param name="expression">Subexpression contained.</param> protected internal abstract void VisitWhereExpression(CamlExpression expression);
public DataTable QueryDataTable(SPList list, CamlExpression expr, int rowLimit , params OrderPair[] orders)
{
DataTable data = null;
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite site = new SPSite(SPContext.Current.Site.ID))
{
using (SPWeb web = site.OpenWeb(this._web.ID))
{
SPList list2 = web.Lists[list.ID];
SharePointService svr = new SharePointService(web);
data = svr.QueryDataTable(list2, expr, rowLimit, orders);
}
}
});
return data;
}
/// <summary>
/// Gets the number of items of the associated content type(s) that satisfy the condition.
/// </summary>
/// <typeparam name="TItem">Item type.</typeparam>
/// <param name="query">CAML query expression.</param>with the associated content type(s)
/// <returns>Number of items.</returns>
public new int GetCount <TItem>(CamlExpression query)
{
return(base.GetCount <TItem>(query));
}
/// <summary> /// Called when visiting a logical comparison expression inside a <Where/> element. /// </summary> /// <param name="operatorValue">Type of logical operator.</param> /// <param name="leftExpression">Left expression.</param> /// <param name="rightExpression">Right expression.</param> protected internal abstract void VisitWhereLogicalExpression(CamlLogicalOperator operatorValue, CamlExpression leftExpression, CamlExpression rightExpression);
/// <summary>
/// Gets items of the associated content type(s) that satisfy the condition.
/// </summary>
/// <typeparam name="TItem">Item type.</typeparam>
/// <param name="query">CAML query expression.</param>
/// <param name="limit">Maximum number of items to be returned.</param>
/// <param name="startRow">Number of items to skip from start.</param>
/// <returns>A collection containing the returned items.</returns>
public new SPModelCollection <TItem> GetItems <TItem>(CamlExpression query, uint limit, uint startRow)
{
return(base.GetItems <TItem>(query, limit, startRow));
}
private CamlExpression LinkOr(CamlExpression expr1, CamlExpression expr2)
{
if (expr1 == null)
return expr2;
else
return expr1 || expr2;
}
/// <summary>
/// Gets the number of items of the associated content type(s) that satisfy the condition.
/// </summary>
/// <param name="query">CAML query expression.</param>with the associated content type(s)
/// <returns>Number of items.</returns>
public int GetCount(CamlExpression query)
{
return(base.GetCount <T>(query));
}
public static CamlExpression LinkOr(CamlExpression expr1, CamlExpression expr2)
{
if (expr1 == null)
return expr2;
else
return expr1 || expr2;
}
public new void Visit(CamlExpression expression)
{
base.Visit(expression);
}
