linq2db.AspNet 4.3.0

.NET Standard 2.0 .NET Framework 4.5
dotnet add package linq2db.AspNet --version 4.3.0
NuGet\Install-Package linq2db.AspNet -Version 4.3.0
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="linq2db.AspNet" Version="4.3.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add linq2db.AspNet --version 4.3.0
#r "nuget: linq2db.AspNet, 4.3.0"
#r directive can be used in F# Interactive, C# scripting and .NET Interactive. Copy this into the interactive tool or source code of the script to reference the package.
// Install linq2db.AspNet as a Cake Addin
#addin nuget:?package=linq2db.AspNet&version=4.3.0

// Install linq2db.AspNet as a Cake Tool
#tool nuget:?package=linq2db.AspNet&version=4.3.0

LINQ to DB ASP.NET Core

License Follow @linq2db

Main article.

Setup Walkthrough

Create a new project

First thing we're going to do is create a new ASP.NET Core application using the dotnet CLI

dotnet new webapp -o gettingStartedLinqToDBAspNet

Install LINQ To DB

We can now use the CLI to install LINQ To DB and database provider (SQLite in this walkthrough)

dotnet add package linq2db.AspNet
dotnet add package System.Data.SQLite.Core

Custom Data Connection

We're going to create a custom data connection to use to access LINQ To DB, create a class like this:

using LinqToDB.Configuration;
using LinqToDB.Data;

public class AppDataConnection: DataConnection
{
    public AppDataConnection(LinqToDBConnectionOptions<AppDataConnection> options)
        :base(options)
    {

    }
}

[!TIP]
Note here our AppDataConnection inherits from LinqToDB.Data.DataConnection which is the base class for the Linq To DB connection.

[!TIP]
a public constructor that accepts LinqToDBConnectionOptions<AppDataConnection> and passes the options on to the base constructor is required.

Add Connection String

For this example we're going to use SQLite in memory mode, for production you'll want to use something else, but it's pretty easy to change.

First you want to add the connection string to appsettings.Development.json, something like this:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  //add this
  "ConnectionStrings": {
    "Default": ":memory:" //<-- connection string, used in the next step
  }
}

Configure Dependency injection

inside Startup.cs you want register the data connection like this:

public class Startup
{
    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        //...
        //using LinqToDB.AspNet
        services.AddLinqToDBContext<AppDataConnection>((provider, options) => {
            options
            //will configure the AppDataConnection to use
            //sqite with the provided connection string
            //there are methods for each supported database
            .UseSQLite(Configuration.GetConnectionString("Default"))
            //default logging will log everything using the ILoggerFactory configured in the provider
            .UseDefaultLogging(provider);
        });
        //...
    }
}

[!TIP]
There's plenty of other configuration options available, if you are familiar with LINQ To DB already, you can convert your existing application over to use the new LinqToDBConnectionOptions class as every configuration method is supported

[!TIP]
Note, only DataConnection supports LinqToDBConnectionOptions. DataContext is not yet supported.

[!TIP]
Use AddLinqToDBContext<TContext, TContextImplementation> if you would like to resolve an interface or base class instead of the concrete class in your controllers

By default this will configure the service provider to create a new AppDataConnection for each HTTP Request, and will dispose of it once the request is finished. This can be configured with the last parameter to AddLinqToDBContext(... ServiceLifetime lifetime), more information about lifetimes here

Simple Entity Configuration

Let's create this simple entity in our project

using System;
using LinqToDB.Mapping;

public class Person
{
    [PrimaryKey]
    public Guid Id { get; set; } = Guid.NewGuid();
    public string Name { get; set; }
    public DateTime Birthday { get; set; }
}

Add table property to the data connection

Open up our AppDataConnection and add this property

public class AppDataConnection: DataConnection
{
    //...
    public ITable<Person> People => GetTable<Person>();
    //...
}

Now we can inject our data connection into a controller and query and insert/update/delete using the ITable<Person> interface.

[!TIP] side note, since we don't have anything to create the actual database, we need to add this code into the configure method in Startup.cs

public class Startup
{
   //...
   public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
   {
       //...
       using (var scope = app.ApplicationServices.CreateScope())
       {
           var dataConnection = scope.ServiceProvider.GetService<AppDataConnection>();
           dataConnection.CreateTable<Person>();
       }
       //...
   }
}
//...

Inject the connection into a controller

In order to actually access the database we're going to want to use it from a controller, here's a sample controller to get you started with a few examples.

public class PeopleController : Controller
{
    private readonly AppDataConnection _connection;

    public PeopleController(AppDataConnection connection)
    {
        _connection = connection;
    }

    [HttpGet]
    public Task<Person[]> ListPeople()
    {
        return _connection.People.ToArrayAsync();
    }

    [HttpGet("{id}")]
    public Task<Person?> GetPerson(Guid id)
    {
        return _connection.People.SingleOrDefaultAsync(person => person.Id == id);
    }

    [HttpDelete("{id}")]
    public Task<int> DeletePerson(Guid id)
    {
        return _connection.People.Where(person => person.Id == id).DeleteAsync();
    }

    [HttpPatch]
    public Task<int> UpdatePerson(Person person)
    {
        return _connection.UpdateAsync(person);
    }

    [HttpPatch("{id}/new-name")]
    public Task<int> UpdatePersonName(Guid id, string newName)
    {
        return _connection.People.Where(person => person.Id == id)
            .Set(person => person.Name, newName)
            .UpdateAsync();
    }

    [HttpPut]
    public Task<int> InsertPerson(Person person)
    {
        return _connection.InsertAsync(person);
    }
}

Quick start for people already familiar with LINQ To DB

LINQ To DB now has support for ASP.NET Dependency injection. Here's a simple example of how to add it to dependency injection

public class Startup
{
    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        //...
        //using LinqToDB.AspNet
        services.AddLinqToDBContext<AppDataConnection>((provider, options) => {
            options
            //will configure the AppDataConnection to use
            //SqlServer with the provided connection string
            //there are methods for each supported database
            .UseSqlServer(Configuration.GetConnectionString("Default"))

            //default logging will log everything using
            //an ILoggerFactory configured in the provider
            .UseDefaultLogging(provider);
        });
        //...
    }
}

We've done our best job to allow any existing use case to be migrated to using the new configuration options, please create an issue if something isn't supported. There are also some methods to setup tracing and mapping schema.

You'll need to update your data connection to accept the new options class too.

public class AppDataConnection: DataConnection
{
    public AppDataConnection(LinqToDBConnectionOptions<AppDataConnection> options)
        :base(options)
    {

    }
}

DataConnection will used the options passed into the base constructor to setup the connection.

[!NOTE]
DataConnection supports LinqToDBConnectionOptions. However DataContext is not yet supported.

Product Versions
.NET net5.0 net5.0-windows net6.0 net6.0-android net6.0-ios net6.0-maccatalyst net6.0-macos net6.0-tvos net6.0-windows
.NET Core netcoreapp2.0 netcoreapp2.1 netcoreapp2.2 netcoreapp3.0 netcoreapp3.1
.NET Standard netstandard2.0 netstandard2.1
.NET Framework net45 net451 net452 net46 net461 net462 net463 net47 net471 net472 net48
MonoAndroid monoandroid
MonoMac monomac
MonoTouch monotouch
Tizen tizen40 tizen60
Xamarin.iOS xamarinios
Xamarin.Mac xamarinmac
Xamarin.TVOS xamarintvos
Xamarin.WatchOS xamarinwatchos
Compatible target framework(s)
Additional computed target framework(s)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
4.3.0 12,854 10/1/2022
4.2.0 4,909 9/1/2022
4.1.1 11,864 7/7/2022
4.1.0 27,222 6/16/2022
4.0.1 3,257 5/27/2022
4.0.0 6,353 5/19/2022
4.0.0-rc.2 88 5/15/2022
4.0.0-rc.1 100 4/29/2022
4.0.0-preview.10 17,168 11/15/2021
4.0.0-preview.9 125 11/11/2021
4.0.0-preview.8 191 10/22/2021
4.0.0-preview.7 259 10/14/2021
4.0.0-preview.6 213 10/2/2021
4.0.0-preview.5 242 9/10/2021
4.0.0-preview.4 725 8/13/2021
4.0.0-preview.3 721 7/9/2021
4.0.0-preview.2 211 7/1/2021
4.0.0-preview.1 145 6/9/2021
3.7.0 12,739 4/7/2022
3.6.0 68,416 11/15/2021
3.5.2 918 11/11/2021
3.5.1 1,276 10/22/2021
3.5.0 896 10/14/2021
3.4.5 1,148 10/2/2021
3.4.4 7,935 9/10/2021
3.4.3 6,192 8/13/2021
3.4.2 19,569 7/9/2021
3.4.1 794 7/1/2021
3.4.0 18,408 6/3/2021
3.3.0 162,932 3/25/2021
3.2.3 17,619 1/4/2021
3.2.2 3,980 12/26/2020
3.2.1 4,041 12/17/2020
3.2.0 395 12/17/2020
3.1.6 29,843 10/31/2020
3.1.5 5,367 10/15/2020
3.1.4 1,405 10/8/2020
3.1.3 7,494 9/17/2020
3.1.2 3,193 9/3/2020
3.1.1 1,403 8/27/2020
3.1.0 689 8/20/2020
3.0.1 4,882 7/13/2020
3.0.0 1,575 7/10/2020
3.0.0-rc.2 228 7/5/2020
3.0.0-rc.1 310 6/17/2020
3.0.0-rc.0 300 5/30/2020