Skip to content
Go to file

Latest commit


Git stats


Failed to load latest commit information.


branch AppVeyor Travis CI Codacy CodeFactor License
master AppVeyor Build Status Travis Build Status codecov Codacy CodeFactor GitHub license
package nuget myget
Remote.Linq NuGet Badge MyGet Pre Release
Remote.Linq.EntityFramework NuGet Badge MyGet Pre Release
Remote.Linq.EntityFrameworkCore NuGet Badge MyGet Pre Release
Remote.Linq.Newtonsoft.Json NuGet Badge MyGet Pre Release
Remote.Linq.protobuf-net MyGet Pre Release


Remote Linq is a small and easy to use - yet very powerful - library to translate LINQ expression trees to strongly typed, serializable expression trees and vice versa. It provides functionality to send arbitrary LINQ queries to a remote service to be applied and executed against any enumerable or queryable data collection.

Building a LINQ interface for custom services is made a breeze by using Remote Linq.


  • Translate LINQ expressions into serializable expression trees (remote LINQ expression) and vice versa.
  • Build remote single-type query services (paging, sorting, filtering)
  • Build remote complex LINQ query services (arbitrary LINQ query including joins, groupings, aggregations, projections, etc.)


In contrast to re-linq, this project enables serialization and deserialization of expression trees and applying LINQ expressions to other LINQ providers e.g. linq-to-object, linq-to-entity, etc.

Remote.Linq makes it super easy to implement a service allowing LINQ queries defined on a client to be executed on a remote server.

Write operations (insert/update/delete) have to be implemented by other means if needed. InfoCarrier.Core might be interesting for such scenarios.


Client Implement a repository class to set-up server connection and expose the queryable data sets (IQueryable<>)

public class ClientDataRepository
    private readonly Func<Expression, IEnumerable<DynamicObject>> _dataProvider;

    public RemoteRepository(string uri)
        _dataProvider = expression =>
                // setup service connectivity
                IQueryService service = CreateServerConnection(uri);
                // send expression to service and get back results
                IEnumerable<DynamicObject> result = service.ExecuteQuery(expression);
                return result;

    public IQueryable<Blog> Blogs => RemoteQueryable.Factory.CreateQueryable<Blog>(_dataProvider);
    public IQueryable<Post> Posts => RemoteQueryable.Factory.CreateQueryable<Post>(_dataProvider);
    public IQueryable<User> Users => RemoteQueryable.Factory.CreateQueryable<User>(_dataProvider);

Use your repository to compose LINQ query and let the data be retrieved from the backend service

var repository = new ClientDataRepository();

var myBlogPosts = (
    from blog in repository.Blogs
    from post in blog.Posts
    join owner in repository.Users on blog.OwnerId equals owner.Id
    where owner.login == "hi-its-me"
    select new 
        Preview = post.Text.Substring(0, 50)

Server Implement the backend service to handle the client's query expression by applying it to a data source e.g. an ORM

public interface IQueryService
    IEnumerable<DynamicObject> ExecuteQuery(Expression queryExpression);

public class QueryService : IQueryService, IDisposable
    // any linq provider e.g. entity framework, nhibernate, ...
    private IDataProvider _datastore = new ObjectRelationalMapper();

    // you need to be able to retrieve an IQueryable by type
    private Func<Type, IQueryable> _queryableProvider = type => _datastore.GetQueryableByType(type);

    public IEnumerable<DynamicObject> ExecuteQuery(Expression queryExpression)
        // `Execute` is an extension method provided by Remote.Linq
        // it applies an expression to a data source and returns the result
        return queryExpression.Execute(queryableProvider: _queryableProvider);

    public void Dispose() => _datastore.Dispose();

Remote.Linq.EntityFramework / Remote.Linq.EntityFrameworkCore

Remote linq extensions for entity framework and entity framework core.

Use this package when using features specific to EF6 and EF Core:

  • Apply eager-loading (Include-expressions)

  • Make use of DB functions
    e.g. queryable.Where(x => Microsoft.EntityFrameworkCore.EF.Functions.Like(x.Name, "%fruit%"))


Client Query blogs including posts and owner

using var repository = new RemoteRepository();
var blogs = repository.Blogs

Server Execute query on database via EF Core

public IEnumerable<DynamicObject> ExecuteQuery(Expression queryExpression)
    using var dbContext = new DbContext();
    return queryExpression.ExecuteWithEntityFrameworkCore(dbContext);


Provides Json.NET serialization settings for Remote.Linq types.


public TExpression DeepCopy<TExpression>(TExpression expression)
    where TExpression : Remote.Linq.Expressions.Expression
    JsonSerializerSettings serializerSettings = new JsonSerializerSettings().ConfigureRemoteLinq(); 
    string json = JsonConvert.SerializeObject(expression, serializerSettings); 
    TExpression copy = JsonConvert.DeserializeObject<TExpression>(json, serializerSettings); 
    return copy;


Simply LINQ your remote resources...




No packages published
You can’t perform that action at this time.