Perform a Lazy Query

// Define a lazy query
Lazy<Task<IEnumerable<Employee>>> lazyEmployees = asyncSession
    .Query<Employee>()
    .Where(x => x.FirstName == "Robert")
     // Add a call to 'LazilyAsync'
    .LazilyAsync();

IEnumerable<Employee> employees = await lazyEmployees.Value; // Query is executed here

// Define a lazy DocumentQuery
Lazy<IEnumerable<Employee>> lazyEmployees = session.Advanced
    .DocumentQuery<Employee>()
    .WhereEquals(x => x.FirstName, "Robert")
     // Add a call to 'Lazily'
    .Lazily();

IEnumerable<Employee> employees = lazyEmployees.Value; // DocumentQuery is executed here

// Define a lazy count query
Lazy<Task<int>> lazyCount = asyncSession
    .Query<Employee>()
    .Where(x => x.FirstName == "Robert")
     // Add a call to 'CountLazilyAsync'
    .CountLazilyAsync();

int count = await lazyCount.Value; // Query is executed here

// Define a lazy DocumentQuery
Lazy<int> lazyCount = session.Advanced
    .DocumentQuery<Employee>()
    .WhereEquals(x => x.FirstName, "Robert")
     // Add a call to 'CountLazily'
    .CountLazily();

int count = lazyCount.Value; // DocumentQuery is executed here

// Define a lazy suggestion query
Lazy<Task<Dictionary<string, SuggestionResult>>> lazySuggestions = asyncSession
    .Query<Employee>()
    .SuggestUsing(builder => builder.ByField("Name", "chaig"))
     // Add a call to 'ExecuteLazyAsync'
    .ExecuteLazyAsync();

Dictionary<string, SuggestionResult> suggest = await lazySuggestions.Value; // Query is executed here
List<string> suggestions = suggest["Name"].Suggestions;

// Define a lazy DocumentQuery
Lazy<Dictionary<string, SuggestionResult>> lazySuggestions = session.Advanced
    .DocumentQuery<Employee>()
    .SuggestUsing(builder => builder.ByField("Name", "chaig"))
     // Add a call to 'ExecuteLazy'
    .ExecuteLazy();

Dictionary<string, SuggestionResult> suggest = lazySuggestions.Value; // DocumentQuery is executed here
List<string> suggestions = suggest["FullName"].Suggestions;

// Define a lazy DocumentQuery
Lazy<Task<Dictionary<string,FacetResult>>> lazyFacets = asyncSession
    .Query<Product, Products_ByCategoryAndPrice>()
    .AggregateBy(facetsDefinition)
     // Add a call to 'ExecuteLazyAsync'
    .ExecuteLazyAsync();

Dictionary<string, FacetResult> facets = await lazyFacets.Value; // Query is executed here

FacetResult categoryResults = facets["Product Category"];
FacetResult priceResults = facets["Price per Unit"];

// Define a lazy DocumentQuery
Lazy<Dictionary<string, FacetResult>> lazyFacets = session.Advanced
    .DocumentQuery<Product, Products_ByCategoryAndPrice>()
    .AggregateBy(facetsDefinition)
     // Add a call to 'ExecuteLazy'
    .ExecuteLazy();

Dictionary<string, FacetResult> facets = lazyFacets.Value; //  DocumentQuery is executed here

FacetResult categoryResults = facets["Product Category"];
FacetResult priceResults = facets["Price per Unit"];

// The facets definition used in the facets query:
List<FacetBase> facetsDefinition = new List<FacetBase>
{
    new Facet
    {
        FieldName = "CategoryName",
        DisplayFieldName = "Product Category"
    },
    new RangeFacet<Product>
    {
        Ranges =
        {
            product => product.PricePerUnit < 25,
            product => product.PricePerUnit >= 25 && product.PricePerUnit < 50,
            product => product.PricePerUnit >= 50 && product.PricePerUnit < 100,
            product => product.PricePerUnit >= 100
        },
        DisplayFieldName = "Price per Unit"
    }
};

// The index definition used in the facets query:
public class Products_ByCategoryAndPrice :
    AbstractIndexCreationTask<Product, Products_ByCategoryAndPrice.IndexEntry>
{
    // The IndexEntry class defines the index-fields
    public class IndexEntry
    {
        public string CategoryName { get; set; }
        public decimal PricePerUnit { get; set; }
    }
        
    public Products_ByCategoryAndPrice()
    {
        // The 'Map' function defines the content of the index-fields
        Map = products => from product in products
            select new IndexEntry
            {
                CategoryName = LoadDocument<Category>(product.Category).Name,
                PricePerUnit = product.PricePerUnit
            };
    }
}