Filter Data with LINQ - .NET SDK

On this page

Comparison Operators

Logical Operators
String Operators
Full Text Search
Unsupported LINQ Operators

Realm is now Atlas Device SDK – Learn More

The Atlas Device SDK query engine implements standard LINQ syntax.

There are several operators available to filter an SDK collection with LINQ. Filters work by evaluating an operator expression for every object in the collection being filtered. If the expression resolves to true, the SDK includes the object in the results collection.

An expression consists of one of the following:

The name of a property of the object currently being evaluated
An operator
A value of any type used by the SDK (string, date, number, boolean, etc.)

Note

The SDK does not currently support all of the LINQ operators. Refer to the Unsupported LINQ Operators section on this page for a list of those unsupported operators.

Comparison Operators

Value comparisons

Operator	Description
`==`	Evaluates to `true` if the left-hand expression is equal to the right-hand expression.
`>`	Evaluates to `true` if the left-hand numerical or date expression is greater than the right-hand numerical or date expression. For dates, this evaluates to `true` if the left-hand date is later than the right-hand date.
`>=`	Evaluates to `true` if the left-hand numerical or date expression is greater than or equal to the right-hand numerical or date expression. For dates, this evaluates to `true` if the left-hand date is later than or the same as the right-hand date.
`<`	Evaluates to `true` if the left-hand numerical or date expression is less than the right-hand numerical or date expression. For dates, this evaluates to `true` if the left-hand date is earlier than the right-hand date.
`<=`	Evaluates to `true` if the left-hand numeric expression is less than or equal to the right-hand numeric expression. For dates, this evaluates to `true` if the left-hand date is earlier than or the same as the right-hand date.
`!=`	Evaluates to `true` if the left-hand expression is not equal to the right-hand expression.

Example

The following example uses the query engine's comparison operators to:

Find high priority tasks by comparing the value of the priority property value with a threshold number, above which priority can be considered high.
Find just-started or short-running tasks by seeing if the progressMinutes property falls within a certain range.
Find unassigned tasks by finding tasks where the assignee property is equal to null.
Find tasks assigned to specific teammates Ali or Jamie by seeing if the assignee property is in a list of names.

var highPri = items.Where(i => i.Priority > 5);
var quickItems = items.Where(i =>
    i.ProgressMinutes >= 1 &&
    i.ProgressMinutes < 15);
var unassignedItems = items.Where(i =>
    i.Assignee == null);
var AliOrJamieItems = items.Where(i =>
   i.Assignee == "Ali" ||
   i.Assignee == "Jamie");

Logical Operators

You can use the logical operators listed in the following table to make compound predicates:

Operator	Description
`&&`	Evaluates to `true` if both left-hand and right-hand expressions are `true`.
`!`	Negates the result of the given expression.
`\|\|`	Evaluates to `true` if either expression returns `true`.

Example

We can use the query language's logical operators to find all of Ali's completed tasks. That is, we find all tasks where the assignee property value is equal to 'Ali' AND the isComplete property value is true:

var completedItemsForAli = items
    .Where(i => i.Assignee == "Ali" && i.IsComplete);

String Operators

You can compare string values using the string operators listed in the following table. Regex-like wildcards allow more flexibility in search.

Operator	Description
`StartsWith`	Evaluates to `true` if the left-hand string expression begins with the right-hand string expression. This is similar to `contains`, but only matches if the left-hand string expression is found at the beginning of the right-hand string expression.
`EndsWith`	Evaluates to `true` if the left-hand string expression ends with the right-hand string expression. This is similar to `contains`, but only matches if the left-hand string expression is found at the very end of the right-hand string expression.
`Like`	Evaluates to `true` if the left-hand string expression matches the right-hand string wildcard string expression. A wildcard string expression is a string that uses normal characters with two special wildcard characters: The `*` wildcard matches zero or more of any character The `?` wildcard matches any character. For example, the wildcard string "d?g" matches "dog", "dig", and "dug", but not "ding", "dg", or "a dog".
`Equals`	Evaluates to `true` if the left-hand string is lexicographically equal to the right-hand string.
`Contains`	Evaluates to `true` if the left-hand string expression is found anywhere in the right-hand string expression.
`string.IsNullOrEmpty`	Evaluates to `true` if the left-hand string expression is null or empty. Note that `IsNullOrEmpty()` is a static method on `string`.

Example

The following examples use the query engine's string operators to find tasks:

// Note: In each of the following examples, you can replace the
// Where() method with First(), FirstOrDefault(),
// Single(), SingleOrDefault(),
// Last(), or LastOrDefault().
// Get all items where the Assignee's name starts with "E" or "e"
var ItemssStartWithE = items.Where(i => i.Assignee.StartsWith("E",
    StringComparison.OrdinalIgnoreCase));
// Get all items where the Assignee's name ends wth "is"
// (lower case only)
var endsWith = items.Where(t =>
    t.Assignee.EndsWith("is", StringComparison.Ordinal));
// Get all items where the Assignee's name contains the
// letters "ami" in any casing
var itemsContains = items.Where(i => i.Assignee.Contains("ami",
     StringComparison.OrdinalIgnoreCase));
// Get all items that have no assignee
var null_or_empty = items.Where(i => string.IsNullOrEmpty(i.Assignee));

Important

Case Comparisons

When evaluating strings, the second parameter in all functions except Like must be either StringComparison.OrdinalIgnoreCase or StringComparison.Ordinal. For the Like() method, the second parameter is a boolean value (where "true" means "case sensitive").

Full Text Search

You can use LINQ to query on properties that have enabled Full-Text Search (FTS). To query these properties, use QueryMethods.FullTextSearch. The following examples query the Person.Biography field:

// Find all people with "scientist" and "Nobel" in their biography
var scientists = realm.All<Person>()
    .Where(p => QueryMethods.FullTextSearch(p.Biography, "scientist Nobel"));
// Find all people with "scientist" in their biography, but not "physics"
var scientistsButNotPhysicists = realm.All<Person>()
    .Where(p => QueryMethods.FullTextSearch(p.Biography, "scientist -physics"));

Unsupported LINQ Operators

The following LINQ operators are not currently supported by the SDK:

Category	Unsupported Operators
Concatenation	`Concat` `Join`. While `Join` is not supported, it is not needed with the SDK. Instead of using keys in a Join statement, as you would in a traditional relational database, you can reference another type as a property. For more information, refer to Model Relationships. `GroupJoin`
Grouping	`GroupBy`
Partitioning	`Take` `Skip` `TakeWhile` `SkipWhile`
Projection	`SelectMany` `Select`, with one exception: when used with the query syntax, `Select` is supported as long as you select the Realm object itself and not a derivative: `var tasks = from t in realm.All<Task>() where t.Assignee == "Caleb" select t;`
Sets	`Distinct` `Union` `Intersect` `Except`

← Fluent Interface (Java SDK)

Type-Safe and NSPredicate Queries (Swift SDK) →