New to Telerik UI for Blazor? Download free 30-day trial

Telerik DataSource Package

The Telerik DataSource NuGet package is a set of classes and extension methods that help with remote (server-side) sorting, paging, grouping and filtering data collections.

In this article:

Basics

The Telerik.DataSource package is distributed through the Telerik Private NuGet Feed and is available to both trial and commercial licenses. It is also available as a resource in the offline installer and resources archive of Telerik UI for Blazor and some other Telerik suites, such as UI for ASP.NET Core.

The Telerik.DataSource package targets netstandard2.1.

This package lets you get or generate a request to the data source that describes various settings such as filters, paging, sorting, grouping, and, through extension methods, provides you with a resulting data set according to those settings.

If you are using an EntityFramework backend that provides an IQueryable collection, using the Telerik DataSource extension methods on it will execute the queries (operations) at the database level, which can improve performance compared to fetching all the data to the C# code and only then implementing operations on it.

Key Classes and Extensions Methods

The following classes and extension methods are the key components to the package:

  • The ToDataSourceResult(DataSourceRequest request) extension method - this method is in the Telerik.DataSource.Extensions namespace, and is available for IQueryable, IEnumerable and DataTable. It receives a DataSourceRequest argument and returns a DataSourceResult object. It also has an async version (with the standard Async suffix to the method name). This is the method that facilitates the data operations itself so you don't have to implement them.

  • DataSourceRequest - the class that describes the request for data - what page index, page size, filters and sorts, groups and aggregates are required by the client. You can receive it from Telerik components (such as the Blazor grid in its manual data operations mode), or over the wire and deserialize it (such as for requests coming from widgets like the UI for ASP.NET Core Grid with remote data). You can even create a new instance of the object and populate its fields according to some other business logic (like an OData querystring or some other case). This object is in the Telerik.DataSource namespace.

  • DataSourceResult - the resulting data set from the operations on the data source. It will contain the current page of data, for its appropriate index, according to the designated filters, sorts, groups; and it will also contain the total number of items in the data source. It will also contain aggregate data. This is what you would normally serialize over the wire to send back to the client (or pass by reference in case of C#-only services). This object is in the Telerik.DataSource namespace.

Examples

The general usage is as simple as defining (or receiving) a DataSourceRequest object, passing it to the ToDataSourceResult extension method, and consuming the DataSourceResult object that comes out of it.

You can find more complex use cases and examples, such as serializing grouped data and using custom serializers (such as Newtonsoft.Json) in the following sample projects (note: they are written in Blazor, but the backend services they simulate are standard .NET Core code): Use Telerik DataSourceRequest and DataSourceResult on the server.

Basic Console example for using a DataSourceRequest and DataSourceResult. Note: it expects that you have referenced the Telerik.DataSource NuGet package

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Telerik.DataSource;
using Telerik.DataSource.Extensions;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var data = GetData(); // simulate a real data source

            // create or receive a DataSourceRequest
            DataSourceRequest request = new DataSourceRequest
            {
                Page = 1, // start from the first page so you can track the operation more easily
                PageSize = 5, // page size is 5
                Filters = new List<IFilterDescriptor>() // some sample filtering
                {
                    // Items from Team 3 that have an ID bigger than 10
                    new FilterDescriptor() { Member = "Id", Operator = FilterOperator.IsGreaterThan, Value = 10, MemberType = typeof(int) },
                    new FilterDescriptor() { Member = "Team", Operator = FilterOperator.Contains, Value = "3", MemberType = typeof(string) },
                }
            };

            // get the DataSourceResult
            DataSourceResult result = data.ToDataSourceResult(request);

            Console.WriteLine(result.Total); // Takes into account the filters. OUTPUT: 248
            foreach (SampleModel item in result.Data)
            {
                Console.WriteLine($"ID: {item.Id}, team: {item.Team}");
                //OUTPUT:
                //ID: 11, team: Team 3
                //ID: 15, team: Team 3
                //ID: 19, team: Team 3
                //ID: 23, team: Team 3
                //ID: 27, team: Team 3
            }
        }

        static IQueryable<SampleModel> GetData()
        {
            return Enumerable.Range(1, 1000).Select(x => new SampleModel 
            {
                Id = x,
                Team = $"Team {x % 4}"
            }).AsQueryable();
        }
    }

    public class SampleModel
    {
        public int Id { get; set; }
        public string Team { get; set; }
    }
}

Differences with Kendo DataSource

If you have used other Telerik products before, such as the Telerik UI for ASP.NET Core or Telerik UI for ASP.NET MVC, you may be familiar with or you may already be using the DataSourceResult, ToDataSourceResult and DataSourceResult features. They are available as part of those respective packages (assemblies), and the Telerik.DataSource package is those features extracted into a smaller, more lightweight package that is platform agnostic. This means that it has a few differences from the Kendo methods:

  • The Telerik.DataSource packages uses the System.Text.Json serializer, and if you use custom serializers such as Newtonsoft.Json, you may need to tweak their settings so they ignore casinng, and so they can serialize the Telerik objects. You can read more about this and find example in the Use DataSourceRequest and DataSourceResult and WebAPI in a WebAssembly Blazor app with custom serialization sample project.

  • The Telerik.DataSource package does not have model binding features, because it is not coupled to the MVC framework.

    • Other MVC-specific features that may exist in the Kendo version may not be present in the Telerik.DataSource package.
In this article
Not finding the help you need? Improve this article