linq2db.AspNet 5.4.1

The ID prefix of this package has been reserved for one of the owners of this package by NuGet.org. Prefix Reserved
dotnet add package linq2db.AspNet --version 5.4.1
NuGet\Install-Package linq2db.AspNet -Version 5.4.1
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="5.4.1" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add linq2db.AspNet --version 5.4.1
#r "nuget: linq2db.AspNet, 5.4.1"
#r directive can be used in F# Interactive and Polyglot Notebooks. 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=5.4.1

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

LINQ to DB ASP.NET Core

License

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(DataOptions<AppDataConnection> options)
        :base(options.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 DataOptions<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 DataOptions class as every configuration method is 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(DataOptions<AppDataConnection> options)
        :base(options.Options)
    {

    }
}

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

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

NuGet packages (2)

Showing the top 2 NuGet packages that depend on linq2db.AspNet:

Package Downloads
RCommon.Linq2Db

A cohesive set of infrastructure libraries for dotnet that utilizes abstractions for event handling persistence unit of work mediator distributed messaging event bus CQRS email and more

XulBenet.CRUD.DAL.Linq2Db

Package Description

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
5.4.1 15,369 4/7/2024
5.4.0 20,160 2/20/2024
5.3.2 83,258 10/18/2023
5.3.1 443 10/16/2023
5.3.0 2,592 10/12/2023
5.2.2 48,240 6/8/2023
5.2.1 22,881 5/18/2023
5.2.0 17,835 5/4/2023
5.1.1 4,101 3/25/2023
5.1.0 25,329 3/16/2023
5.0.0 5,186 2/23/2023
5.0.0-rc.2 122 2/16/2023
5.0.0-rc.1 106 2/9/2023
5.0.0-preview.2 122 2/2/2023
5.0.0-preview.1 186 1/12/2023
4.4.1 11,311 2/2/2023
4.4.0 31,718 12/15/2022
4.3.0 134,531 10/1/2022
4.2.0 15,464 9/1/2022
4.1.1 32,702 7/7/2022
4.1.0 43,799 6/16/2022
4.0.1 5,477 5/27/2022
4.0.0 9,306 5/19/2022
4.0.0-rc.2 139 5/15/2022
4.0.0-rc.1 146 4/29/2022
4.0.0-preview.10 61,916 11/15/2021
4.0.0-preview.9 168 11/11/2021
4.0.0-preview.8 236 10/22/2021
4.0.0-preview.7 309 10/14/2021
4.0.0-preview.6 260 10/2/2021
4.0.0-preview.5 304 9/10/2021
4.0.0-preview.4 2,168 8/13/2021
4.0.0-preview.3 769 7/9/2021
4.0.0-preview.2 263 7/1/2021
4.0.0-preview.1 186 6/9/2021
3.7.0 31,249 4/7/2022
3.6.0 133,320 11/15/2021
3.5.2 1,044 11/11/2021
3.5.1 1,974 10/22/2021
3.5.0 1,088 10/14/2021
3.4.5 1,306 10/2/2021
3.4.4 11,344 9/10/2021
3.4.3 7,460 8/13/2021
3.4.2 25,265 7/9/2021
3.4.1 956 7/1/2021
3.4.0 20,666 6/3/2021
3.3.0 395,442 3/25/2021
3.2.3 24,881 1/4/2021
3.2.2 4,100 12/26/2020
3.2.1 5,379 12/17/2020
3.2.0 501 12/17/2020
3.1.6 39,161 10/31/2020
3.1.5 5,849 10/15/2020
3.1.4 2,269 10/8/2020
3.1.3 8,919 9/17/2020
3.1.2 3,705 9/3/2020
3.1.1 1,511 8/27/2020
3.1.0 1,875 8/20/2020
3.0.1 5,011 7/13/2020
3.0.0 3,698 7/10/2020
3.0.0-rc.2 270 7/5/2020
3.0.0-rc.1 355 6/17/2020
3.0.0-rc.0 345 5/30/2020