dotnet 连接使用ef orm连接sqlite数据库的小demo

EF6SQLiteTutorial/Program.cs

using EF6SQLiteTutorial.Data;

using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// ---------------------------------使用sqlite数据库------------------------------------------
// ---------------------------------使用sqlite数据库
// builder.Services.AddDbContext<DataContext>(options =>
//     options.UseSqlite(builder.Configuration.GetConnectionString("DefaultConnection")));

// ---------------------------------指定sqlite 数据库的位置和名称
var dbPath = Path.Combine(builder.Environment.ContentRootPath, "mydatabase.db");
builder.Services.AddDbContext<DataContext>(options =>
    options.UseSqlite($"Data Source={dbPath}"));


var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

EF6SQLiteTutorial/Models/RpgCharacter.cs

namespace EF6SQLiteTutorial.Models
{
    // 这段代码定义了一个名为 `RpgCharacter` 的类，它表示一个RPG游戏角色。这个类包含四个属性：
    // - `Id`：角色的唯一标识符。
    // - `Name`：角色的名称。
    // - `RpgClass`：角色的职业。
    // - `HitPoints`：角色的生命值。
    // 这些属性使用C#的自动实现属性语法定义。例如，`public int Id { get; set; }` 表示一个名为 `Id` 的整数类型属性，它具有公共的 `get` 和 `set` 访问器。
    // 此外，这个类还为某些属性指定了默认值。例如，`public string Name { get; set; } = string.Empty;` 表示 `Name` 属性的默认值为空字符串。
    public class RpgCharacter
    {
        public int Id { get; set; }
        public string Name { get; set; } = string.Empty;
        public string RpgClass { get; set; } = string.Empty;
        public int HitPoints { get; set; } = 100;
    }
}

EF6SQLiteTutorial/Models/WeatherForecast.cs

namespace EF6SQLiteTutorial.Models
{
    public class WeatherForecast
    {
        public DateTime Date { get; set; }

        public int TemperatureC { get; set; }

        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

        public string? Summary { get; set; }
    }
}

EF6SQLiteTutorial/Controllers/RpgCharacterController.cs

using EF6SQLiteTutorial.Data;
using EF6SQLiteTutorial.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace EF6SQLiteTutorial.Controllers
{

    // `RpgCharacterController` 类是一个ASP.NET Core Web API控制器，它由ASP.NET Core框架自动实例化并调用。当客户端向服务器发送HTTP请求时，ASP.NET Core框架会根据路由配置将请求映射到相应的控制器操作。然后，框架会创建控制器的实例，并调用相应的操作方法来处理请求。
    // 在这个例子中，当客户端向 `https://localhost:7115/api/RpgCharacter` 发送HTTP POST请求时，ASP.NET Core框架会将请求映射到 `RpgCharacterController` 类的 `AddCharacter` 操作。然后，框架会创建 `RpgCharacterController` 类的实例，并调用 `AddCharacter` 方法来处理请求。
    // 您不需要手动创建 `RpgCharacterController` 类的实例或调用它的方法。这些工作都由ASP.NET Core框架自动完成。

    [Route("api/[controller]")]  // https://localhost:7115/api/RpgCharacter
    [ApiController]
    public class RpgCharacterController : ControllerBase
    {
        private readonly DataContext _context;

        /*
            `RpgCharacterController` 构造函数接受一个 `DataContext` 对象作为参数，并将其赋值给类的私有字段 `_context`。
            这个 `DataContext` 对象是Entity Framework Core的数据库上下文，它用于管理数据库连接和执行数据库操作。
            在控制器的其他操作中，可以通过访问 `_context` 字段来使用这个数据库上下文对象。
            例如，在 `AddCharacter` 操作中，代码使用 `_context.RpgCharacters.Add(character)` 来将新角色添加到数据库中。
        */
        public RpgCharacterController(DataContext context)
        {
            _context = context;
        }

        // `Task<ActionResult<List<RpgCharacter>>>` 是一个复合类型，它表示一个异步操作，该操作返回一个 `ActionResult` 类型的结果，其中包含一个 `List<RpgCharacter>` 类型的数据。
        // - `Task` 类型表示一个异步操作。它通常用于表示一个正在进行的工作，该工作在未来某个时间点完成并返回结果。在这个例子中，`Task` 类型用于表示一个异步的Web API操作。
        // - `ActionResult` 类型表示一个操作结果。它是ASP.NET Core中的一个基类，用于表示控制器操作的返回值。`ActionResult` 类型可以包含各种类型的数据，例如HTTP状态代码、JSON数据和HTML视图。
        // - `List<RpgCharacter>` 类型表示一个RPG角色对象的列表。在这个例子中，它用于表示数据库中所有RPG角色的列表。
        // 综上所述，`Task<ActionResult<List<RpgCharacter>>>` 类型表示一个异步操作，该操作返回一个包含RPG角色列表的操作结果。
        [HttpPost]
        public async Task<ActionResult<List<RpgCharacter>>> AddCharacter(RpgCharacter character)
        {
            _context.RpgCharacters.Add(character);
            await _context.SaveChangesAsync();

            // 这行代码 `return Ok(await _context.RpgCharacters.ToListAsync());` 用于返回数据库中所有RPG角色的列表。它执行了以下操作：
            // 1. 调用 `_context.RpgCharacters.ToListAsync()` 方法来异步获取数据库中所有RPG角色的列表。
            // 2. 使用 `await` 关键字等待异步操作完成，并获取结果。
            // 3. 调用 `Ok` 方法来创建一个HTTP 200 OK响应，其中包含RPG角色列表。
            // 这行代码是 `AddCharacter` 操作的最后一行，它返回了一个包含RPG角色列表的HTTP响应。客户端可以通过解析响应中的JSON数据来获取RPG角色列表。
            return Ok(await _context.RpgCharacters.ToListAsync());
        }

        [HttpGet]
        public async Task<ActionResult<List<RpgCharacter>>> GetAllCharacters()
        {
            return Ok(await _context.RpgCharacters.ToListAsync());
        }

        [HttpGet("{id}")]
        public async Task<ActionResult<RpgCharacter>> GetCharacter(int id)
        {
            var character = await _context.RpgCharacters.FindAsync(id);
            if (character == null)
            {
                return BadRequest("Character not found.");
            }

            return Ok(character);
        }
    }
}

EF6SQLiteTutorial/Controllers/WeatherForecastController.cs

using Microsoft.AspNetCore.Mvc;
using EF6SQLiteTutorial.Models;


namespace EF6SQLiteTutorial.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

        private readonly ILogger<WeatherForecastController> _logger;

        public WeatherForecastController(ILogger<WeatherForecastController> logger)
        {
            _logger = logger;
        }

        [HttpGet(Name = "GetWeatherForecast")]
        public IEnumerable<WeatherForecast> Get()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }
}

EF6SQLiteTutorial/Data/DataContext.cs

using Microsoft.EntityFrameworkCore;
using EF6SQLiteTutorial.Models;



namespace EF6SQLiteTutorial.Data
{
    public class DataContext : DbContext
    {
        public DataContext(DbContextOptions<DataContext> options) : base(options)
        {

        }

        public DbSet<RpgCharacter> RpgCharacters => Set<RpgCharacter>();
    }
}

EF6SQLiteTutorial/appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=sqlite.db"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

EF6SQLiteTutorial/EF6SQLiteTutorial.csproj

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.8" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.8">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.8" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
  </ItemGroup>

</Project>

EF6SQLiteTutorial/appsettings.Development.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}