Övning: Lagra data lokalt med SQLite

  • 15 minuter

I den här övningen använder du SQLite för att lagra information lokalt med ett program. I exempelscenariot bestämde du dig för att cachelagrat data för appen för sociala medier för att förbättra svarstiden. Den här övningen skapar och använder en lokal SQLite-databas för att lagra information om personer. Du sparar den fysiska databasfilen i lokal lagring.

I den här modulen används .NET 9.0 SDK. Kontrollera att du har .NET 9.0 installerat genom att köra följande kommando i önskad kommandoterminal:

dotnet --list-sdks

Utdata som liknar följande exempel visas:

8.0.100 [C:\Program Files\dotnet\sdk]
9.0.100 [C:\Program Files\dotnet\sdk]

Kontrollera att en version som börjar med 9 visas. Om inget visas eller om kommandot inte hittas installerar du den senaste .NET 9.0 SDK:t.

Öppna startlösningen

  1. Klona eller ladda ned övningsrepo.

    Kommentar

    Det är bäst att klona träningsinnehållet till en kort mappsökväg, till exempel C:\dev, för att undvika att bygggenererade filer överskrider den maximala sökvägslängden.

  2. Använd Visual Studio för att öppna den People.sln lösningen, som du hittar i >People, eller startmappen i Visual Studio Code.

    Kommentar

    Försök inte köra programmet ännu, koden är ofullständig och genererar undantag tills du lägger till de element som saknas senare i den här övningen.

Definiera en SQLite-entitet

  1. Öppna filen Person.cs i mappen Modeller .

  2. Lägg till en int egenskap som heter Id till Person klassen.

  3. Lägg till en string egenskap med namnet Name. Klassen bör se ut så här:

    namespace People.Models;

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

  4. Spara filen Person.cs .

Lägg till SQLite-biblioteket

  1. Högerklicka på projektnoden Personer från Solution Explorer i Visual Studio.

  2. I snabbmenyn som visas väljer du Hantera NuGet-paket.

  3. Sök efter och välj sqlite-net-pcl och välj sedan Installera.

    En skärmbild som visar NuGet-pakethanteraren med biblioteket sqlite-net-pcl valt.

Om du använder Visual Studio Code öppnar du terminalen och dessa paket med följande kommandon:

dotnet add package sqlite-net-pcl

Lägga till SQLite-attribut

  1. I filen Person.cs lägger du till ett using direktiv för SQLite namnområdet i filen för Person klassen. Med det här direktivet kan du använda attributen SQLite.

    using SQLite;

namespace People.Models;

public class Person
{
    ...
}

  2. Kommentera Person klassen med [Table] attributet och ange tabellnamnet som people.

  3. Ange egenskapen Id som primärnyckel. Kommentera den med attributen [PrimaryKey] och [AutoIncrement] .

  4. Lägg till anteckningar i egenskapen Name . Ange dess MaxLength som 250. Ange att varje värde i kolumnen ska vara Unique.

    Den slutförda klassen bör se ut så här:

    using SQLite;

namespace People.Models;

[Table("people")]
public class Person
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }

    [MaxLength(250), Unique]
    public string Name { get; set; }
}

  5. Spara filen Person.cs .

Ansluta till databasen

  1. Öppna filen PersonRepository.cs .

  2. Undersök PersonRepository klassen. Den här klassen innehåller ofullständig skelettkod med TODO markörer där du lägger till funktionerna för att komma åt databasen.

  3. Lägg till ett using direktiv för SQLite namnrymderna och People.Models i filen för PersonRepository.cs klassen.

  4. Lägg till ett privat SQLiteConnection fält med namnet conn i klassen ovanför Init funktionen.

  5. I funktionen Init kontrollerar du om conn inte är lika med null. I så fall returnerar du omedelbart.

    if (conn != null)
    return;

    På så sätt körs initieringskoden för SQLite-databasen bara en gång.

  6. Initiera fältet conn för att ansluta till databasen med hjälp av variabeln _dbPath .

  7. conn.CreateTable Använd metoden för att skapa en tabell för att lagra Person data. Den slutförda Init funktionen bör se ut så här:

    using SQLite;
using People.Models;
...

private SQLiteConnection conn;
...
private void Init()
{
   if (conn != null)
      return;

   conn = new SQLiteConnection(_dbPath);
   conn.CreateTable<Person>();
}

Infoga en rad i databasen

  1. Leta PersonRepository reda på metoden i AddNewPerson klassen.

  2. Om du vill infoga ett nytt Person objekt ersätter du kommentaren i den TODO här metoden med kod. Koden anropar Init först för att verifiera att databasen initieras och använder SQLiteConnection sedan objektets Insert -metod. Ange variabeln result till det värde Insert som metoden returnerar, enligt följande kod:

    public void AddNewPerson(string name)
{
    int result = 0;
    try
    {
        // enter this line
        Init();

        // basic validation to ensure a name was entered
        if (string.IsNullOrEmpty(name))
            throw new Exception("Valid name required");

        // enter this line
        result = conn.Insert(new Person { Name = name });
        ...
    }
    ...
}

Hämta rader från databasen

  1. Leta reda på PersonRepository metoden i GetAllPeople klassen.

  2. Anropa Init för att kontrollera att databasen har initierats.

  3. Använd den allmänna Table\<T> metoden för att hämta alla rader i tabellen. Ange Person som typparameter.

  4. ToList() Använd tilläggsmetoden för att omvandla resultatet till en List\<Person> samling och returnera den här samlingen.

  5. Lägg till felhantering genom att omsluta koden i ett try-catch block. Om det uppstår ett fel anger du StatusMessage egenskapen till undantagets Message egenskap och returnerar en tom samling. Den slutförda metoden bör se ut så här:

    public List<Person> GetAllPeople()
{
   try
   {
      Init();
      return conn.Table<Person>().ToList();
   }
   catch (Exception ex)
   {
      StatusMessage = string.Format("Failed to retrieve data. {0}", ex.Message);
   }

   return new List<Person>();
}

  6. Spara filen PersonRepository.cs .

Integrera lagringsplatsen i användargränssnittet

  1. Öppna filen MauiProgram.cs .

  2. CreateMauiApp I funktionen, efter de instruktioner som lägger till MainPage sidan som en singleton-tjänst i appen, lägger du till kod för att utföra följande uppgifter:

    • Skapa en strängvariabel med namnet dbPath. Initiera strängen med uttrycket FileAccessHelper.GetLocalFilePath("people.db3"). Databasfilen som appen använder kallas people.db3 och appen sparar filen i lokal lagring på enheten.

    • Använd beroendeinmatning för att lägga till PersonRepository klassen som en singleton-tjänst i appen. Klassen PersonRepository exponerar en konstruktor som tar sökvägen till databasfilen som en strängparameter.

    Den färdiga koden för CreateMauiApp funktionen bör se ut så här:

    public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
        });

    // Add this code
    string dbPath = FileAccessHelper.GetLocalFilePath("people.db3");
    builder.Services.AddSingleton<PersonRepository>(s => ActivatorUtilities.CreateInstance<PersonRepository>(s, dbPath));

    return builder.Build();
}

  3. Spara filen MauiProgram.cs .

  4. Expandera App.xaml i Solution Explorer och öppna sedan filen App.xaml.cs .

  5. Lägg till egenskapen public, static med namnet PersonRepo. Den här egenskapen innehåller ett PersonRepository objekt till App klassen.

  6. PersonRepo Initiera egenskapen i konstruktorn genom att lägga till en PersonRepository parameter i konstruktorn och ange egenskapen PersonRepo till värdet i den här parametern. Den slutförda App klassen bör se ut så här:

    public partial class App : Application
{
    public static PersonRepository PersonRepo { get; private set; }

    public App(PersonRepository repo)
    {
        InitializeComponent();
        PersonRepo = repo;
    }
}

Kommentar

Beroendeinmatningsprocessen fyller automatiskt i parametern repo till konstruktorn.

Testa programmet

  1. Skapa lösningen med hjälp av CTRL+Skift+B.

  2. När bygget är klart börjar du felsöka med hjälp av F5. När användargränssnittet visas anger du ditt namn och väljer Lägg till person.

    En skärmbild av appen med ett meddelande om att en post har lagts till.

  3. Välj Hämta alla personer och kontrollera att namnet visas.

    En skärmbild av appen med en lista över alla poster i databasen.

  4. Experimentera genom att lägga till fler namn och hämta listan över lagrade personer.

  5. Gå tillbaka till Visual Studio eller Visual Studio Code och sluta felsöka med hjälp av Skift+F5.

  6. Starta om appen och välj Hämta alla personer. Kontrollera att de namn som du lagrade tidigare fortfarande lagras i databasen. Stäng appen när du är klar.