IQueryResultSetTData Interface

public interface IQueryResultSet<TData> : IQueryResultSet, 
	IEnumerable, IEnumerable<TData>

Public Interface IQueryResultSet(Of TData)
	Inherits IQueryResultSet, IEnumerable, IEnumerable(Of TData)

generic<typename TData>
public interface class IQueryResultSet : IQueryResultSet, 
	IEnumerable, IEnumerable<TData>

type IQueryResultSet<'TData> = 
    interface
        interface IQueryResultSet
        interface IEnumerable
        interface IEnumerable<'TData>
    end

Type Parameters

TData

[Missing <typeparam name="TData"/> documentation for "T:SanteDB.Core.Model.Query.IQueryResultSet`1"]

Implementers of this interface support yielded or late-executed queries. For example, when calling a Query() method on a persistence class, the query to the database is not executed immediately, rather the first call to a method which iterates over this collection, or calls or otherwise fetches a record results in the query being executed

This is done to reduce the amount of data which is loaded from the database, however it also means that careless use of the result set will result in many additional queries to the database. Consider:

var results = this.persistenceService.Query(o => o.StatusConceptKey == StatusKeys.Active, AuthenticationContext.Current.Principal);
var count = results.Count();
var first = results.First();
var second = results.Skip(1).First();

Would result in 3 calls to the database:

1. The Count() call results in a SQL SELECT COUNT(*)
2. The First() method results in a SQL SELECT * .... FETCH FIRST 1 ROWS ONLY call
3. The Skip(1).First() method results in a SQL SELECT * .... OFFSET 1 FETCH FIRST 1 ROWS ONLY call

If the caller wishes to make multiple calls to this interface, it is recommended that they realize the results into an IEnumerable instance, for example:

Results in only one SELECT * FROM xxx method, all results are loaded into memory and then subsequent calls are made in memory.

This may seem more efficient, however imagine a result set where only the second page is required (10 results per page), we want the COUNT of all records however only actually want to load 10 records from the database, in this case we want two SQL queries executed (one for counting and another for fetching)

This code executes two SQL queries, a SELECT COUNT(*) FROM xxxx and then another SELECT * FROM ... OFFSET 10 FETCH FIRST 10 ROWS ONLY , this greatly reduces the result set. We can also determine if we want to send queries to the database with Any, which would execute a SELECT 1 WHERE EXISTS ....

Note: You can use the AsResultSet(IEnumerable) method in order to access the delay load functions from interfaces which return IEnumerable

Reference