camlex Wiki Rss Feed

Updated Wiki: Future improvements

sadomovalex — Wed, 17 Apr 2013 20:08:01 GMT

The following are the features which are to be implemented in the next version of Camlex.NET project:
* Reverse engineering from pure CAML queries to C#-based Camlex queries -done
* Camlex.Net for Client OM - http://camlex.codeplex.com/workitem/13989 -done

Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx, e.g. for TaxonomyFieldTypeMulti - https://camlex.codeplex.com/workitem/13998
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex

* Add conditions to existing string query - http://camlex.codeplex.com/discussions/353158 -done

Combine several string queries to one - http://camlex.codeplex.com/discussions/431325
Use strongly typed classes in queries: http://camlex.codeplex.com/discussions/438324#post1022401

Updated Wiki: Future improvements

sadomovalex — Sat, 30 Mar 2013 06:28:14 GMT

Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex

* Add conditions to existing string query - http://camlex.codeplex.com/discussions/353158 -done

Combine several string queries to one - http://camlex.codeplex.com/discussions/431325
Use strongly typed classes in queries: http://camlex.codeplex.com/discussions/438324#post1022401

Updated Wiki: Future improvements

sadomovalex — Wed, 30 Jan 2013 23:57:17 GMT

Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex

* Add conditions to existing string query - http://camlex.codeplex.com/discussions/353158 -done

Combine several string queries to one - http://camlex.codeplex.com/discussions/431325

Updated Wiki: Documentation

sadomovalex — Mon, 03 Dec 2012 16:24:51 GMT

Pages with future improvements - Future improvements

Additional Resources

Camlex Online http://camlex-online.org
Blog http://sadomovalex.blogspot.com

I. Camlex architecture and public interface
Generally Camlex – is translator from lambda expression into CAML:

It receives expression like

x => (int)x["ID"] == 1

on input and translate it to valid CAML query. The exact signature of lambda expressions depends on method call of Camlex public interface. The most important interface in Camlex.NET assembly is IQuery and its implementation – Query class:

public interface IQuery
{
    IQuery Where(Expression<Func<SPListItem, bool>> expr);
    IQuery WhereAll(IEnumerable<Expression<Func<SPListItem, bool>>> expressions);
    IQuery WhereAny(IEnumerable<Expression<Func<SPListItem, bool>>> expressions);
    IQuery OrderBy(Expression<Func<SPListItem, object>> expr);
    IQuery OrderBy(Expression<Func<SPListItem, object[]>> expr);
    IQuery OrderBy(IEnumerable<Expression<Func<SPListItem, object>>> expressions);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr);
    IQuery GroupBy(Expression<Func<SPListItem, object[]>> expr, bool? collapse, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, bool? collapse, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, bool? collapse);
    XElement[] ToCaml(bool includeQueryTag);
    string ToString();
    string ToString(bool includeQueryTag);
}

As you can see most methods returns itself – so fluent interfaces calls are available with Camlex:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["CreatedBy"]).ToString();

Also notice that it has ToCaml() method which returns valid xml in array of XElement objects. It means that it can be simply customizable – for example you can use Linq to Xml or classes from System.Xml.Linq namespace in order to modify resulting query.

II. Lambda expressions syntax
Internally Camlex uses expression trees in order to parse lambda expressions and translate it to CAML. There are 2 types of syntaxes allowed in Camlex (here and below “x” – is a parameter for lambda expression with SPListItem data type defined inMicrosoft.Sharepoint.dll):

Native syntax:

x => (int)x["ID"] == 1

I.e. you write integer rvalue and cast lvalue to int

String based syntax:

x => x["ID"] == (DataTypes.Integer)"1"

In opposite with native syntax you write integer value in string representation and cast it to DataTypes.Integer class (helper class defined in Camlex.NET.dll)
Two examples above are equivalent for Camlex. We introduced 2 types of syntaxes in order to be able to write queries with not only native .Net types (int, string, bool, DateTime), but also with Sharepoint data types (see http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spfieldtype.aspx). You can easy mix these syntaxes and composite them via logical operations (&&, ||) in the same expression.
The following schema shows how Camlex translates lambda expression with native into CAML query:

String based syntax is very similar except Camlex uses rvalue cast to DataTypes.Integer in order to determine type of value and checks that string representation contains valid value for this type.
What happens if Camlex cannot parse lambda expression? As described above there are only 2 types of syntaxes (and their combination via logical && and || operations) are valid for Camlex. If provided expression has different signature – then CamlexNET.NonSupportedExpressionException will be thrown.

III. Supported operations
The list of operations available in CAML query can be found on http://msdn.microsoft.com/en-us/library/ms467521.aspx. Camlex supports all of them. The following table shows mapping from C# operations into CAML with examples:

CAML	C#	Example
And	&&	Camlex.Query().Where(x => (string) x["Status"] == "Completed" && (int) x["ID"] == 1)
Or	\|\|	Camlex.Query().Where(x => (string)x["Status"] != "Completed" \|\| x["Status"] == null)
BeginsWith	String. StartsWith()	Camlex.Query().Where(x => ((string)x["Title"]).StartsWith("Camlex"))
Contains	String. Contains()	Camlex.Query().Where(x => ((string)x["Title "]).Contains("Camlex"))
Eq	==	Camlex.Query().Where(x => (string)x["Title"] == "Camlex")
Neq	!=	Camlex.Query().Where(x => (string)x["Status"] != "Completed")
Geq	>=	Camlex.Query().Where(x => (int)x["ID"] >= 1)
Gt	>	Camlex.Query().Where(x => (int)x["ID"] > 1)
Leq	<=	Camlex.Query().Where(x => (int)x["ID"] <= 1)
Lt	<	Camlex.Query().Where(x => (int)x["ID"] < 1)
DateRangesOverlap	Camlex.DateRangesOverlap()	Camlex.Query().Where(x => Camlex.DateRangesOverlap(x["StartField"], x["StopField"], x["RecurrenceID"], (DataTypes.DateTime)Camlex.Month))
IsNotNull	!= null	Camlex.Query().Where(x => x["Status"] != null)
IsNull	== null	Camlex.Query().Where(x => x["Title"] == null)
OrderBy	IQuery.OrderBy()	Camlex.Query().Where(x => (string)x["Status"] == "Completed").OrderBy(x => x["Modified"] as Camlex.Desc)
GroupBy	IQuery.GroupBy	Camlex.Query().Where(x => (string)x["Status"] == "Completed").GroupBy(x => new[] { x["Modified"], x["Editor"] }, true, 10)

IV. Non-constant expressions and runtime evaluation
You can specify non-constant expressions both in indexer and in rvalue:

x => (Type)x[expr1] == expr2

expr1 and expr2 are evaluated in runtime. If expr1 or expr2 is method call and it throws exception – then exception will be thrown when query will be evaluated. I.e. Camlex doesn’t catch exceptions when it evaluates expression in runtime. Notice also that expr1 (indexer’s parameter) should have string type. If expr1 cannot be casted to string then Camlex throws InvalidFieldNameForFieldRefException:

public static void Scenario()
{
    Func<object> expr1 = () => null;
    Func<object> expr2 = () => 1;

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();
}

Another interesting example – is when expr2 is null and operation is == or !=. In this case Camlex will translate <IsNull> and <IsNotNull> instead of <Eq> and <Neq> respectively:

public static void Scenario()
{
    Func<object> expr1 = () => "Title";
    Func<object> expr2 = () => null;

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();

    Console.WriteLine(caml);
}

Will be translated into <IsNull>:

<Where>
  <IsNull>
    <FieldRef Name="Title" />
  </IsNull>
</Where>

While not-null rvalue:

public static void Scenario()
{
    Func<object> expr1 = () => "Title";
    Func<object> expr2 = () => "Camlex";

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();

    Console.WriteLine(caml);
}

Will be translated into <Eq>:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">Camlex</Value>
  </Eq>
</Where>

V. Dynamic filtering conditions
This feature is added in 2.0 version. Often developers need to build CAML query based on predefined set of values. E.g. search items which have Ids contained in array {1, 2, 3} (analog of IN operator in SQL), or retrieve all items which contains one of the substrings (or all of them) in their Title { “hello”, “world” }. For this use case in version 2.0 were added 2 additional methods in IQuery interface WhereAll and WhereAny (by analogy with All and Any methods in Linq). The main difference is that WhereAll and WhereAny methods receive list of lambda expressions (or more accurate – IEnumerable) in contrast to Where method which receives single lambda expression.

By analogy with Linq WhereAll method constructs CAML query for retrieving those items which satisfy all conditions specified in argument. I.e. WhereAll method contructs CAML query using <And> logical join. WhereAny method returns CAML query which can be used to retrieve items which satisfy at least one of specified conditions – it uses <Or> logical join. The general idea is to create list of lambda expressions and pass this list into Camlex. It will composite expressions using And or Or joins – so it will have one big expression as result and pass it in old Where method from 1.0 version.

Notice that you can create various expressions – i.e. not necessary to create the same expression for each value. You can even provide different argument names in expressions – Camlex hasn't restrictions to have the same argument names for all provided expressions. For example we need to select item which have ID = 1 and which Title = “Hello world”:

<Where>
    <And>
        <Eq>
            <FieldRef Name="ID" />
            <Value Type="Integer">1</Value>
        </Eq>
        <Eq>
            <FieldRef Name="Title" />
            <Value Type="Text">Hello world</Value>
        </Eq>
    </And>
</Where>

It can be done using the following code:

var expressions = new List<Expression<Func<SPListItem, bool>>>();
expressions.Add(x => (int)x["ID"] == 1);
expressions.Add(y => (string)y["Title"] == "Hello world");

string caml = Camlex.Query().WhereAll(expressions).ToString();

I.e. Camlex may successfully translate queries with different arguments names (“x” and “y” in example above).

Updated Wiki: Documentation

sadomovalex — Mon, 03 Dec 2012 16:24:24 GMT

Pages with future improvements - Future improvements

Additional Resources

Camlex Online http://camlex-online.org
Blog http://sadomovalex.blogspot.com,http://sadomovalex.blogspot.com/search/label/Camlex.NET

I. Camlex architecture and public interface
Generally Camlex – is translator from lambda expression into CAML:

It receives expression like

x => (int)x["ID"] == 1

public interface IQuery
{
    IQuery Where(Expression<Func<SPListItem, bool>> expr);
    IQuery WhereAll(IEnumerable<Expression<Func<SPListItem, bool>>> expressions);
    IQuery WhereAny(IEnumerable<Expression<Func<SPListItem, bool>>> expressions);
    IQuery OrderBy(Expression<Func<SPListItem, object>> expr);
    IQuery OrderBy(Expression<Func<SPListItem, object[]>> expr);
    IQuery OrderBy(IEnumerable<Expression<Func<SPListItem, object>>> expressions);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr);
    IQuery GroupBy(Expression<Func<SPListItem, object[]>> expr, bool? collapse, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, bool? collapse, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, bool? collapse);
    XElement[] ToCaml(bool includeQueryTag);
    string ToString();
    string ToString(bool includeQueryTag);
}

As you can see most methods returns itself – so fluent interfaces calls are available with Camlex:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["CreatedBy"]).ToString();

Native syntax:

x => (int)x["ID"] == 1

I.e. you write integer rvalue and cast lvalue to int

String based syntax:

x => x["ID"] == (DataTypes.Integer)"1"

CAML	C#	Example
And	&&	Camlex.Query().Where(x => (string) x["Status"] == "Completed" && (int) x["ID"] == 1)
Or	\|\|	Camlex.Query().Where(x => (string)x["Status"] != "Completed" \|\| x["Status"] == null)
BeginsWith	String. StartsWith()	Camlex.Query().Where(x => ((string)x["Title"]).StartsWith("Camlex"))
Contains	String. Contains()	Camlex.Query().Where(x => ((string)x["Title "]).Contains("Camlex"))
Eq	==	Camlex.Query().Where(x => (string)x["Title"] == "Camlex")
Neq	!=	Camlex.Query().Where(x => (string)x["Status"] != "Completed")
Geq	>=	Camlex.Query().Where(x => (int)x["ID"] >= 1)
Gt	>	Camlex.Query().Where(x => (int)x["ID"] > 1)
Leq	<=	Camlex.Query().Where(x => (int)x["ID"] <= 1)
Lt	<	Camlex.Query().Where(x => (int)x["ID"] < 1)
DateRangesOverlap	Camlex.DateRangesOverlap()	Camlex.Query().Where(x => Camlex.DateRangesOverlap(x["StartField"], x["StopField"], x["RecurrenceID"], (DataTypes.DateTime)Camlex.Month))
IsNotNull	!= null	Camlex.Query().Where(x => x["Status"] != null)
IsNull	== null	Camlex.Query().Where(x => x["Title"] == null)
OrderBy	IQuery.OrderBy()	Camlex.Query().Where(x => (string)x["Status"] == "Completed").OrderBy(x => x["Modified"] as Camlex.Desc)
GroupBy	IQuery.GroupBy	Camlex.Query().Where(x => (string)x["Status"] == "Completed").GroupBy(x => new[] { x["Modified"], x["Editor"] }, true, 10)

IV. Non-constant expressions and runtime evaluation
You can specify non-constant expressions both in indexer and in rvalue:

x => (Type)x[expr1] == expr2

public static void Scenario()
{
    Func<object> expr1 = () => null;
    Func<object> expr2 = () => 1;

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();
}

Another interesting example – is when expr2 is null and operation is == or !=. In this case Camlex will translate <IsNull> and <IsNotNull> instead of <Eq> and <Neq> respectively:

public static void Scenario()
{
    Func<object> expr1 = () => "Title";
    Func<object> expr2 = () => null;

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();

    Console.WriteLine(caml);
}

Will be translated into <IsNull>:

<Where>
  <IsNull>
    <FieldRef Name="Title" />
  </IsNull>
</Where>

While not-null rvalue:

public static void Scenario()
{
    Func<object> expr1 = () => "Title";
    Func<object> expr2 = () => "Camlex";

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();

    Console.WriteLine(caml);
}

Will be translated into <Eq>:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">Camlex</Value>
  </Eq>
</Where>

<Where>
    <And>
        <Eq>
            <FieldRef Name="ID" />
            <Value Type="Integer">1</Value>
        </Eq>
        <Eq>
            <FieldRef Name="Title" />
            <Value Type="Text">Hello world</Value>
        </Eq>
    </And>
</Where>

It can be done using the following code:

var expressions = new List<Expression<Func<SPListItem, bool>>>();
expressions.Add(x => (int)x["ID"] == 1);
expressions.Add(y => (string)y["Title"] == "Hello world");

string caml = Camlex.Query().WhereAll(expressions).ToString();

I.e. Camlex may successfully translate queries with different arguments names (“x” and “y” in example above).

Updated Wiki: Documentation

sadomovalex — Mon, 03 Dec 2012 16:23:49 GMT

Pages with future improvements - Future improvements

Additional Resources

Camlex Online http://camlex-online.org
Blog http://sadomovalex.blogspot.fi/search/label/Camlex.NET

I. Camlex architecture and public interface
Generally Camlex – is translator from lambda expression into CAML:

It receives expression like

x => (int)x["ID"] == 1

public interface IQuery
{
    IQuery Where(Expression<Func<SPListItem, bool>> expr);
    IQuery WhereAll(IEnumerable<Expression<Func<SPListItem, bool>>> expressions);
    IQuery WhereAny(IEnumerable<Expression<Func<SPListItem, bool>>> expressions);
    IQuery OrderBy(Expression<Func<SPListItem, object>> expr);
    IQuery OrderBy(Expression<Func<SPListItem, object[]>> expr);
    IQuery OrderBy(IEnumerable<Expression<Func<SPListItem, object>>> expressions);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr);
    IQuery GroupBy(Expression<Func<SPListItem, object[]>> expr, bool? collapse, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, bool? collapse, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, int? groupLimit);
    IQuery GroupBy(Expression<Func<SPListItem, object>> expr, bool? collapse);
    XElement[] ToCaml(bool includeQueryTag);
    string ToString();
    string ToString(bool includeQueryTag);
}

As you can see most methods returns itself – so fluent interfaces calls are available with Camlex:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["CreatedBy"]).ToString();

Native syntax:

x => (int)x["ID"] == 1

I.e. you write integer rvalue and cast lvalue to int

String based syntax:

x => x["ID"] == (DataTypes.Integer)"1"

CAML	C#	Example
And	&&	Camlex.Query().Where(x => (string) x["Status"] == "Completed" && (int) x["ID"] == 1)
Or	\|\|	Camlex.Query().Where(x => (string)x["Status"] != "Completed" \|\| x["Status"] == null)
BeginsWith	String. StartsWith()	Camlex.Query().Where(x => ((string)x["Title"]).StartsWith("Camlex"))
Contains	String. Contains()	Camlex.Query().Where(x => ((string)x["Title "]).Contains("Camlex"))
Eq	==	Camlex.Query().Where(x => (string)x["Title"] == "Camlex")
Neq	!=	Camlex.Query().Where(x => (string)x["Status"] != "Completed")
Geq	>=	Camlex.Query().Where(x => (int)x["ID"] >= 1)
Gt	>	Camlex.Query().Where(x => (int)x["ID"] > 1)
Leq	<=	Camlex.Query().Where(x => (int)x["ID"] <= 1)
Lt	<	Camlex.Query().Where(x => (int)x["ID"] < 1)
DateRangesOverlap	Camlex.DateRangesOverlap()	Camlex.Query().Where(x => Camlex.DateRangesOverlap(x["StartField"], x["StopField"], x["RecurrenceID"], (DataTypes.DateTime)Camlex.Month))
IsNotNull	!= null	Camlex.Query().Where(x => x["Status"] != null)
IsNull	== null	Camlex.Query().Where(x => x["Title"] == null)
OrderBy	IQuery.OrderBy()	Camlex.Query().Where(x => (string)x["Status"] == "Completed").OrderBy(x => x["Modified"] as Camlex.Desc)
GroupBy	IQuery.GroupBy	Camlex.Query().Where(x => (string)x["Status"] == "Completed").GroupBy(x => new[] { x["Modified"], x["Editor"] }, true, 10)

IV. Non-constant expressions and runtime evaluation
You can specify non-constant expressions both in indexer and in rvalue:

x => (Type)x[expr1] == expr2

public static void Scenario()
{
    Func<object> expr1 = () => null;
    Func<object> expr2 = () => 1;

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();
}

Another interesting example – is when expr2 is null and operation is == or !=. In this case Camlex will translate <IsNull> and <IsNotNull> instead of <Eq> and <Neq> respectively:

public static void Scenario()
{
    Func<object> expr1 = () => "Title";
    Func<object> expr2 = () => null;

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();

    Console.WriteLine(caml);
}

Will be translated into <IsNull>:

<Where>
  <IsNull>
    <FieldRef Name="Title" />
  </IsNull>
</Where>

While not-null rvalue:

public static void Scenario()
{
    Func<object> expr1 = () => "Title";
    Func<object> expr2 = () => "Camlex";

    var caml =
        Camlex.Query()
            .Where(x => (string)x[(string)expr1()] == expr2()).ToString();

    Console.WriteLine(caml);
}

Will be translated into <Eq>:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">Camlex</Value>
  </Eq>
</Where>

<Where>
    <And>
        <Eq>
            <FieldRef Name="ID" />
            <Value Type="Integer">1</Value>
        </Eq>
        <Eq>
            <FieldRef Name="Title" />
            <Value Type="Text">Hello world</Value>
        </Eq>
    </And>
</Where>

It can be done using the following code:

var expressions = new List<Expression<Func<SPListItem, bool>>>();
expressions.Add(x => (int)x["ID"] == 1);
expressions.Add(y => (string)y["Title"] == "Hello world");

string caml = Camlex.Query().WhereAll(expressions).ToString();

I.e. Camlex may successfully translate queries with different arguments names (“x” and “y” in example above).

Updated Wiki: Future improvements

sadomovalex — Sat, 13 Oct 2012 07:58:06 GMT

Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex

* Add conditions to existing string query - http://camlex.codeplex.com/discussions/353158 -done

Updated Wiki: Home

sadomovalex — Sat, 13 Oct 2012 07:48:01 GMT

Project Description
Camlex.NET simplifies creating of CAML queries for Windows SharePoint Services by using expression trees.

If you find Camlex.NET useful, you may support its development via button on the online version http://camlex-online.org.

Client object model
Version for Client object model is also available. It can be downloaded from here: Camlex.Client.

Online version
You can convert your existing CAML queries to C# code for Camlex.NET using online service powered by Camlex: http://camlex-online.org.

Installation Instructions
In order to start working with Camlex.NET, please download and reference Camlex.NET.dll assembly in your project. After that you can create CAML queries using lambda expressions.
Starting from version 3.0 you can install NuGet package for Camlex from online packages gallery:

Install-Package Camlex.NET.dll

or Client version:

Install-Package Camlex.Client.dll

Quick Start
Camlex.NET is a new technique in Sharepoint development. It abstracts developers from syntax of CAML queries and helps them to concentrate on business tasks. With Camlex.NET developers could think about WHAT they need to do, instead of HOW to do it. It also brings the following advantages for Sharepoint developers:

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

Notice, other comparison operations like “<”, “<=”, “>”, “>=” are supported as well.

Scenario 2. Query with “and”/”or” conditions
Suppose that you need to select items which have ProductID = 1000 and IsCompleted set to false or null. Syntax of appropriate standard CAML query follows:

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

Scenario 8. Query with non-constant expressions in lvalue and rvalue
Non-constant expression gives you more control over CAML. Suppose that you need to select items depending on current locale: for English locale you need to select items which have TitleEng field set to “eng”; for non-English locale you need to select items which have Title field set to “non-eng”. I.e.:
Query for English locale:

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

Scenario 9. Dynamic filtering conditions
Starting with 2.0 version you can build dynamic filtering conditions and join them using WhereAll/WhereAny methods which use And/Or logical joins respectively.
Suppose that we need to retrieve all items which contain at least one of the values {“hello”, “greeting”, “hi”} in Title field. I.e. we need to use the following CAML query:

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();

Updated Wiki: Home

sadomovalex — Sat, 13 Oct 2012 07:03:14 GMT

Install-Package Camlex.NET.dll

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();

Updated Wiki: Home

sadomovalex — Sat, 13 Oct 2012 06:57:39 GMT

Project Description
Camlex.NET simplifies creating of CAML queries for Windows SharePoint Services by using expression trees.

If you find Camlex.NET useful, you may support its development via button on the online version http://camlex-online.org.

Client object model version
Version for Client object model is also available. It can be downloaded from here: Camlex.Client.

Online version
You can convert your existing CAML queries to C# code for Camlex.NET using online service powered by Camlex: http://camlex-online.org.

Installation Instructions
In order to start working with Camlex.NET, please download and reference Camlex.NET.dll assembly in your project. After that you can create CAML queries using lambda expressions.
Starting from version 3.0 you can install NuGet package for Camlex from online packages gallery:

Install-Package Camlex.NET.dll

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();

Updated Wiki: Home

sadomovalex — Wed, 20 Jun 2012 19:42:35 GMT

Project Description
Camlex.NET simplifies creating of CAML queries for Windows SharePoint Services by using expression trees.

If you find Camlex.NET useful, you may support its development via button on the online version http://camlex-online.org.

Online version
You can convert your existing CAML queries to C# code for Camlex.NET using online service powered by Camlex: http://camlex-online.org.

Installation Instructions
In order to start working with Camlex.NET, please download and reference Camlex.NET.dll assembly in your project. After that you can create CAML queries using lambda expressions.
Starting from version 3.0 you can install NuGet package for Camlex from online packages gallery:

Install-Package Camlex.NET.dll

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();

Updated Wiki: Home

sadomovalex — Wed, 20 Jun 2012 19:41:29 GMT

Project Description
Camlex.NET simplifies creating of CAML queries for Windows SharePoint Services by using expression trees.

If you find Camlex.NET useful, you may support its development via button on the online version http://camlex-online.org.

Online version
You can convert your existing CAML queries to C# code for Camlex.NET using online service powered by Camlex: http://camlex-online.org.
.

Installation Instructions
In order to start working with Camlex.NET, please download and reference Camlex.NET.dll assembly in your project. After that you can create CAML queries using lambda expressions.
Starting from version 3.0 you can install NuGet package for Camlex from online packages gallery:

Install-Package Camlex.NET.dll

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();

Updated Wiki: Future improvements

sadomovalex — Tue, 12 Jun 2012 22:25:29 GMT

The following are the features which are to be implemented in the next version of Camlex.NET project:
* Reverse engineering from pure CAML queries to C#-based Camlex queries -done

Camlex.Net for Client OM - http://camlex.codeplex.com/workitem/13989
Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex

* Add conditions to existing string query - http://camlex.codeplex.com/discussions/353158 -done

Updated Wiki: Future improvements

sadomovalex — Mon, 23 Apr 2012 19:07:39 GMT

The following are the features which are to be implemented in the next version of Camlex.NET project:
* Reverse engineering from pure CAML queries to C#-based Camlex queries -done

Camlex.Net for Client OM - http://camlex.codeplex.com/workitem/13989
Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex
Add conditions to existing string query - http://camlex.codeplex.com/discussions/353158

Updated Wiki: Future improvements

sadomovalex — Mon, 23 Apr 2012 19:07:02 GMT

The following are the features which are to be implemented in the next version of Camlex.NET project:
* Reverse engineering from pure CAML queries to C#-based Camlex queries -done

Camlex.Net for Client OM - http://camlex.codeplex.com/workitem/13989
Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex
Add expressions to existing string query - http://camlex.codeplex.com/discussions/353158

Updated Wiki: Future improvements

sadomovalex — Tue, 27 Mar 2012 08:06:11 GMT

The following are the features which are to be implemented in the next version of Camlex.NET project:
* Reverse engineering from pure CAML queries to C#-based Camlex queries -done

Camlex.Net for Client OM - http://camlex.codeplex.com/workitem/13989
Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815
No explicit comparisons for boolean fields: http://camlex.codeplex.com/workitem/13991?ProjectName=camlex

Updated Wiki: Future improvements

sadomovalex — Tue, 21 Feb 2012 07:27:47 GMT

The following are the features which are to be implemented in the next version of Camlex.NET project:

Reverse engineering from pure CAML queries to C#-based Camlex queries
Camlex.Net for Client OM - http://camlex.codeplex.com/workitem/13989
Support for special forms for DATETIME values: <Value Type="DateTime">[Today + 7]</Value> and <Value Type="DateTime"><Today /></Value> (http://camlex.codeplex.com/discussions/270483)

* Support for UserID in queries by user - see http://camlex.codeplex.com/discussions/264821 - done

Support for MEMBERSHIP nodes of CAML language
Support for using Camlex.NET project in Silverlight applications
Support for NULLABLE attribute of CAML language - http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.spsitedataquery.viewfields.aspx
Support for Taxonomy fields (only for SharePoint 2010) - http://msdn.microsoft.com/en-us/library/ff625182.aspx
Support for float, double and decimal native data types
Support more features available in CAML (e.g. <ProjectProperty> element inside <Value> tag)
Compiled queries for better performance - see http://camlex.codeplex.com/discussions/330815

Updated Wiki: Home

sadomovalex — Sat, 07 Jan 2012 21:44:02 GMT

Online version

You can convert your existing CAML queries to C# code for Camlex.NET using online service powered by Camlex: http://camlex-online.org

Installation Instructions
In order to start working with Camlex.NET, please download and reference Camlex.NET.dll assembly in your project. After that you can create CAML queries using lambda expressions.
Starting from version 3.0 you can install NuGet package for Camlex from online packages gallery:

Install-Package Camlex.NET.dll

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();

Updated Wiki: Home

sadomovalex — Sat, 07 Jan 2012 21:43:01 GMT

Online version

Install-Package Camlex.NET.dll

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();

Updated Wiki: Home

sadomovalex — Sat, 07 Jan 2012 21:39:03 GMT

Project Description
Camlex.NET simplifies creating of CAML queries for Windows SharePoint Services by using expression trees.

If you find Camlex.Net useful, you may support its development by clicking button on online version http://camlex-online.org.

Online version

Install-Package Camlex.NET.dll

Compile time checking of expressions
Natural and intuitive syntax using lambda expressions and fluent interfaces
Support for native .Net types (int, strings, bool, DateTime, Guid) and operations (==, !=, >, <, etc)
Support for Sharepoint-specific data types
Ability to specify non-constant expressions inside filtering conditions (variables, method calls, etc)
Fully customizable resulting query object
Ability to build dynamic filtering conditions and join them using And/Or logical joins
Search by lookup fields using LookupValue or LookupId

Now let's consider some basic scenarios:

Scenario 1. Simple query
Suppose that you need to select all items which have Status field set to Completed (following is the standard syntax of CAML):

<Where>
  <Eq>
    <FieldRef Name="Status" />
    <Value Type="Text">Completed</Value>
  </Eq>
</Where>

This query can be made with Camlex using the following syntax:

string caml =
    Camlex.Query()
        .Where(x => (string)x["Status"] == "Completed").ToString();

<Where>
  <And>
    <Eq>
      <FieldRef Name="ProductID" />
      <Value Type="Integer">1000</Value>
    </Eq>
    <Or>
      <Eq>
        <FieldRef Name="IsCompleted" />
        <Value Type="Boolean">0</Value>
      </Eq>
      <IsNull>
        <FieldRef Name="IsCompleted" />
      </IsNull>
    </Or>
  </And>
</Where>

With help of Camlex it could be converted using following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ProductID"] == 1000 && ((bool)x["IsCompleted"] == false || x["IsCompleted"] == null))
            .ToString();

Scenario 3. Query with DateTime
Lets suppose that you need to retrieve items which were modified on 01-Jan-2010:

<Where>
  <Eq>
    <FieldRef Name="Modified" />
    <Value Type="DateTime">2010-01-01T12:00:00Z</Value>
  </Eq>
</Where>

Using Camlex you can simply write:

var caml =
    Camlex.Query()
        .Where(x => (DateTime)x["Modified"] == new DateTime(2010, 01, 01)).ToString();

Scenario 4. Query with BeginsWith and Contains operations
Consider the query that should return items which Title field starts with “Task” and Project field contains “Camlex”:

<Where>
  <And>
    <BeginsWith>
      <FieldRef Name="Title" />
      <Value Type="Text">Task</Value>
    </BeginsWith>
    <Contains>
      <FieldRef Name="Project" />
      <Value Type="Text">Camlex</Value>
    </Contains>
  </And>
</Where>

You can achieve result using the following natural syntax:

var caml =
    Camlex.Query()
        .Where(x => ((string)x["Title"]).StartsWith("Task") && ((string)x["Project"]).Contains("Camlex"))
            .ToString();

Scenario 5. Query with none C# native data types
Suppose that you need to retrieve all items modified by Administrator:

<Where>
  <Eq>
    <FieldRef Name="Editor" />
    <Value Type="User">Administrator</Value>
  </Eq>
</Where>

Notice that value is of Sharepoint-specific User data type. You can easily achieve the result with alternative string-based syntax:

var caml =
    Camlex.Query()
        .Where(x => x["Editor"] == (DataTypes.User)"Administrator")
                .ToString();

Scenario 6. Query with sorting (OrderBy)
Suppose that you need to select all items which have ID >= 5 and the result should be sorted by Modified field:

<Where>
  <Geq>
    <FieldRef Name="ID" />
    <Value Type="Integer">5</Value>
  </Geq>
</Where>
<OrderBy>
  <FieldRef Name="Modified" />
</OrderBy>

You need to write the following Camlex expression in order to construct this query:

var caml =
    Camlex.Query()
        .Where(x => (int)x["ID"] >= 5)
        .OrderBy(x => x["Modified"]).ToString();

Scenario 7. Query with grouping (GroupBy)
Suppose that we need to select items having not-null Status field and result set should be grouped by Author field:

<Where>
  <IsNotNull>
    <FieldRef Name="Status" />
  </IsNotNull>
</Where>
<GroupBy>
  <FieldRef Name="Author" />
</GroupBy>

With Camlex you could simply rewrite it as:

var caml =
    Camlex.Query()
        .Where(x => x["Status"] != null)
        .GroupBy(x => x["Author"]).ToString();

<Where>
  <Eq>
    <FieldRef Name="TitleEng" />
    <Value Type="Text">eng</Value>
  </Eq>
</Where>

Query for non-English locale:

<Where>
  <Eq>
    <FieldRef Name="Title" />
    <Value Type="Text">non-eng</Value>
  </Eq>
</Where>

It is not so hard with Camlex:

bool isEng = true; // or false depending on Thread.CurrentThread.CurrentUICulture

var caml =
    Camlex.Query()
        .Where(x => (string)x[isEng ? "TitleEng" : "Title"] == (isEng ? "eng" : "non-eng")).ToString();

<Where>
  <Or>
    <Or>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">hello</Value>
      </Contains>
      <Contains>
        <FieldRef Name="Title" />
        <Value Type="Text">greeting</Value>
      </Contains>
    </Or>
    <Contains>
      <FieldRef Name="Title" />
      <Value Type="Text">hi</Value>
    </Contains>
  </Or>
</Where>

With Camlex.NET 2.0 we can create lambda expression for each condition and pass them into new WhereAny method:

// list of tokens
var tokens = new List<string> { "hello", "greeting", "hi" };
var expressions = new List<Expression<Func<SPListItem, bool>>>();

// create lambda expression for each token in list
foreach (string t in tokens)
{
    string token = t;
   expressions.Add(x => ((string)x["Title"]).Contains(token));
}

// prepare query
var caml = Camlex.Query().WhereAny(expressions).ToString();