Add MCP server design doc

Design for a read-only MCP server that exposes the accounting data to Claude (or another MCP client) via stdio: project layout, DI wiring, year/mandator scope handling, tool catalog with input/output schemas, packaging + Claude Desktop config, and three privacy modes (Full / Aggregate / Local) covering what actually leaves the machine when a hosted-model client relays tool results to its model provider. Not implemented; PR sequencing sketched at the end of the doc. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
PR P: full async I/O top to bottom (item 19)
2026-07-03 18:46:23 +02:00 · 2026-07-03 18:30:44 +02:00 · 2026-07-03 17:56:29 +02:00
63 changed files with 1081 additions and 756 deletions
--- a/IMPROVEMENT_PLAN.md
+++ b/IMPROVEMENT_PLAN.md
@ -101,7 +101,7 @@ Analysis and phased plan produced 2026-07-02. See conversation history for full
 - **PR D** — Phase 2 item 9: per-request unit of work / cache. Split off from PR C because it is invasive enough to warrant its own review.
 - **PR E** — Phase 3 item 22: ChartService cleanup. Promoted ahead of async because it fixes an active correctness bug — `GetAccountExpensesPerMonth(accountId, year)` was mutating `ISettingsService` on the singleton to hop years, with the year parameter always hardcoded to `DateTime.Now.Year`, so the Spendings-over-time chart discarded the user's header year selection.
 - **PR F** — Phase 3 item 21: precomputed dictionaries in `ViewService` to eliminate O(N·M) `Single(...)` scans and per-account transaction filtering.
- **Item 19 (async I/O)** — deferred. After PR D, each XML file is loaded at most once per SignalR circuit, and this app is single-user local Blazor Server. Converting every repository/service method to async would touch ~40 files for negligible user-visible benefit and real regression risk. Revisit if the app is ever hosted for multiple concurrent users.
+- **Item 19 (async I/O)** — landed as PR P after being explicitly requested. See PR P entry below.
 - **PR G** — Phase 4 items 23 + 24: `Schaad.Accounting.Tests` xUnit + NSubstitute + Shouldly project. Adopts the `xxxTestShould.DoThisWhenThat` naming convention with Shouldly assertions (no xUnit `Assert.*`). Covers `ViewService`, `TransactionRepository`, `Formatting`, `RepositoryCache`, `AccountRepository`, `ChartService`, and `FileService.GetTransactionListCsv` — 38 tests locking in the earlier PRs' behavior. Note: originally shipped as three separate commits (initial project, expanded coverage, Shouldly + naming conversion) and later squashed into one commit at the user's request.
 - **PR H** — Phase 2 item 18 (first slice): add `ILogger<FileService>` to `FileService.ImportAccountStatementFile` so bank-statement imports emit `Information` for the file being processed and each account's import count, `Warning` when an account is skipped because it belongs to a different mandator, and `Error` when the vendor parser reports a failure. Rest of the logging (BaseRepository save failures, MatchOpenBankTransactions summary) tracked as a follow-up because it requires threading loggers through all seven repositories.
 - **PR I** — Phase 2 item 12: move the service interfaces (`IViewService`, `IFileService`, `IChartService`) from `Schaad.Accounting.Common` into `Schaad.Accounting.Services/Interfaces/`. Namespaces are unchanged (`Schaad.Accounting.Interfaces`), so no consumer needs a `using` update. Drops the `Schaad.Finance.Api` `<Reference>` from `Common.csproj` — Common is now vendor-free and matches its documented role as the "shared models, DTOs, interfaces" layer.
@ -110,3 +110,5 @@ Analysis and phased plan produced 2026-07-02. See conversation history for full
 - **PR L** — Phase 2 item 10: drop the hand-rolled `Copy(target)` methods from `Account`, `BookingRule`, `BookingText`, `SubClass`, and `SplitPredefinition`; keep only a `Transaction.Clone()` for defensive-copy needs in `GetTransaction` / `ViewService.WithDisplaySign`. Every `SaveXxx` now uses `FindIndex` → in-place replace (or `Add` for new entries), moving the two "hidden" defaults (`Account.Currency = "CHF"` when unset, `Transaction.BookingDate = ValueDate` when unset) into the corresponding `SaveXxx` method where they belong. Fixes a pre-existing bug: `Transaction.Copy` never copied `RelatedParty`, so update-saves silently dropped it. Added `PreserveRelatedPartyWhenRoundTrippingTransaction` and `DefaultBookingDateToValueDateWhenBookingDateIsUnset` as regression tests. 42 tests total.
 - **PR M** — Phase 2 item 18 (final slice): add `ILogger<ViewService>` and log a match-count summary from `MatchOpenBankTransactions` (`"Matched {Matched} of {Total} open bank transactions"`). Completes item 18 — statement imports (PR H), repository save failures (PR J), and match runs now all emit structured logs. Also removes a dead `ISettingsService` injection from `Home.razor.cs` (declared with `[Inject]` but never used anywhere in the file).
 - **PR N** — Small polish pass covering three long-noted rough edges from the original analysis: `ClassIds` becomes a `static class` (was instantiable); `Home.razor.cs` loses the redundant `loaded` guard in `OnInitializedAsync` (Blazor already runs that lifecycle hook once per component instance); the hardcoded `mandator = "Claudio Schaad"` in `SettingsService` moves to a `DefaultMandator` field on `SettingsDataset`, plumbed through `appsettings.Development.json`.
+- **PR O** — Phase 5 item 26 (partial): convert `BalanceDataset` and `BalanceSheetDataset` to positional records. Both were constructor-initialised value carriers with read-only usage. The rest of item 26 was descoped: the XML-serialised domain models (`Account`, `Transaction`, ...) need mutable public setters for `XmlSerializer`, and value-equality on mutable data is a footgun (hash changes on mutation); source-generated XML serialisers do not exist without switching file formats. `DataSerie` was already a record; `MessageDataset` has a real mutation method (`Add`) and stays a class; `AccountDataset` / `TransactionDataset` / `BookingRuleDataset` inherit from the mutable domain models and can't cleanly become records without a bigger refactor.
+- **PR P** — Phase 3 item 19: full async I/O top to bottom. `BaseRepository.LoadAsync/SaveAsync/LoadListAsync` return `Task<T>`; the per-file `lock (obj)` becomes `SemaphoreSlim` so it can be `await`-ed. `Save` serialises to a `MemoryStream` synchronously (XmlSerializer has no async form) then writes bytes with `File.WriteAllBytesAsync`; `File.Move` (atomic rename) has no async counterpart in .NET 9 and stays sync. Every repository interface + implementation, every service interface + implementation (except the vendor-owned `IFxService`), every Razor page/dialog `OnInitializedAsync`, and every test-file assertion becomes `async` / `await`. 51 files touched in one atomic diff — the codebase does not compile in intermediate states. `AccountRepository.EnsureAccountsFile` keeps two `.GetAwaiter().GetResult()` bridges because it runs from the constructor (constructors can't be async). The observed async payoff is one `File.ReadAllBytesAsync` and one `File.WriteAllBytesAsync` per Load/Save; after PR D each XML file is deserialised at most once per SignalR circuit, so on this single-user local Blazor Server app this is architectural-hygiene work, not a measurable perf win.
--- a/MCP_DESIGN.md
+++ b/MCP_DESIGN.md
@ -0,0 +1,354 @@
+# MCP server design
+
+Design produced 2026-07-03 in conversation with Claude. Read alongside `IMPROVEMENT_PLAN.md`.
+
+## Goals
+
+- Let Claude answer questions like *"how much did I spend on groceries in Q1?"*, *"what's my current balance in CHF?"*, *"which recurring debits changed vs. last year?"*.
+- **Read-only.** No `Save*`, `Delete*`, `Backup`, or `Import*` tools ever exposed.
+- Reuse the async `ViewService` / repository stack already in the codebase. No parallel data layer.
+- Local stdio transport. No HTTP, no auth surface. The MCP server process runs on your machine, but any field a tool returns is forwarded by the MCP client to whichever model it's paired with. See [Privacy modes](#privacy-modes) below for what that actually means in practice.
+
+## Architecture
+
+### Transport
+
+- **Stdio JSON-RPC** via the official `ModelContextProtocol` .NET SDK (Microsoft org's MCP package). Console app, `Microsoft.Extensions.Hosting`-based, `[McpServerToolType]` + `[McpServerTool]` attributes.
+- No custom framing/serialization — the SDK handles it.
+
+### Project layout
+
+```
+Schaad.Accounting.Mcp/
+├── Schaad.Accounting.Mcp.csproj        - net9.0 console
+├── Program.cs                          - host + DI + McpServer.CreateStdioServer
+├── Context/
+│   └── AccountingScope.cs              - year/mandator switching (see below)
+├── Dtos/
+│   ├── AccountDto.cs                   - flat records for LLM consumption
+│   ├── TransactionDto.cs
+│   └── ...
+└── Tools/
+    ├── ContextTools.cs                 - list_mandators, list_years
+    ├── AccountTools.cs                 - list_accounts, get_account
+    ├── BalanceTools.cs                 - get_balance_summary, get_income_statement
+    ├── TransactionTools.cs             - get_transactions, search_transactions
+    └── AnalysisTools.cs                - get_expenses_by_category, compare_years
+```
+
+### DI wiring
+
+The composition root `AddAccounting()` currently lives in `Schaad.Accounting.UI/Extensions.cs`. Two options:
+
+1. **Extract** to a new tiny `Schaad.Accounting.Composition` project that references Db + Services. UI and Mcp both reference it.
+2. **Duplicate** the ~15-line registration block in `Mcp/Program.cs`.
+
+Recommend **(1)** — with two composition roots, every subsequent DI change would otherwise need to touch both.
+
+`Mcp/Program.cs` is then:
+
+```csharp
+var builder = Host.CreateApplicationBuilder(args);
+builder.Services.Configure<SettingsDataset>(builder.Configuration.GetSection("Settings"));
+builder.Services.AddSingleton(sp => sp.GetRequiredService<IOptions<SettingsDataset>>().Value);
+builder.Services.AddAccounting();
+
+builder.Services
+    .AddMcpServer()
+    .WithStdioServerTransport()
+    .WithToolsFromAssembly();
+
+await builder.Build().RunAsync();
+```
+
+## Handling year/mandator
+
+`SettingsService` is `Singleton` and holds `year` + `mandator`. The UI mutates them via `MyHeader` + `forceLoad`. There is no equivalent in stdio MCP.
+
+**Approach: every tool takes optional `year` and `mandator`; wrap execution in a scope that stashes & restores.**
+
+```csharp
+public sealed class AccountingScope : IDisposable
+{
+    private readonly ISettingsService settings;
+    private readonly int oldYear;
+    private readonly string oldMandator;
+
+    public AccountingScope(ISettingsService settings, int? year, string? mandator)
+    {
+        this.settings = settings;
+        oldYear = settings.GetYear();
+        oldMandator = settings.GetMandator();
+        if (year.HasValue) settings.SetYear(year.Value);
+        if (mandator is not null) settings.SetMandator(mandator);
+    }
+
+    public void Dispose()
+    {
+        settings.SetYear(oldYear);
+        settings.SetMandator(oldMandator);
+    }
+}
+```
+
+Every tool wraps its body:
+
+```csharp
+[McpServerTool, Description("...")]
+public async Task<...> ListAccountsAsync(int? year = null, string? mandator = null, ...)
+{
+    using var _ = new AccountingScope(settingsService, year, mandator);
+    // RepositoryCache is Scoped; resolve a fresh IServiceScope so scoped services
+    // don't hold references to entries from an earlier (year, mandator).
+}
+```
+
+**Concurrency**: stdio MCP calls are serial (one JSON-RPC message at a time), so the Singleton mutation window is safe. If we ever move to HTTP transport with concurrent calls, this design breaks — flag that in code.
+
+**Cache freshness**: `RepositoryCache` is `Scoped` and keyed by absolute file path (which includes `dbPath` → year+mandator). When the scope changes year/mandator, the cache keys naturally change too, so stale data is not returned. But we should still resolve a fresh `IServiceScope` per tool call:
+
+```csharp
+public class ToolExecutor
+{
+    private readonly IServiceScopeFactory scopeFactory;
+    private readonly ISettingsService settings;
+
+    public async Task<T> Run<T>(int? year, string? mandator, Func<IServiceProvider, Task<T>> body)
+    {
+        using var _ = new AccountingScope(settings, year, mandator);
+        using var scope = scopeFactory.CreateScope();
+        return await body(scope.ServiceProvider);
+    }
+}
+```
+
+Each tool class takes `ToolExecutor` and wraps its body.
+
+## Tool catalog
+
+Naming: `snake_case`. All optional args default sensibly. All amounts are `decimal`, CHF-normalized where a currency isn't specified. All dates are ISO 8601 (`yyyy-MM-dd`).
+
+### `list_mandators`
+
+> List the mandators (client accounting sets) that have data.
+
+- **Input:** `{ year?: int }`
+- **Output:** `{ mandators: string[] }`
+
+### `list_years`
+
+> List the years for which the given mandator has data.
+
+- **Input:** `{ mandator?: string }`
+- **Output:** `{ years: int[] }`
+
+### `list_accounts`
+
+> List all accounts with their current-year balance in both account currency and CHF. Use before `get_transactions` to look up account IDs.
+
+- **Input:** `{ year?, mandator?, class?: "activa"|"passiva"|"income"|"expenses" }`
+- **Output:**
+  ```json
+  {
+    "accounts": [
+      { "id": "...", "number": 1010, "name": "Checking", "currency": "CHF",
+        "class": "activa", "subclassName": "Umlaufvermögen",
+        "balance": 12345.67, "balanceChf": 12345.67 }
+    ]
+  }
+  ```
+
+### `get_balance_summary`
+
+> Total activa vs. total passiva, plus equity (activa − passiva). CHF.
+
+- **Input:** `{ year?, mandator? }`
+- **Output:** `{ totalActivaChf, totalPassivaChf, equityChf }`
+
+### `get_income_statement`
+
+> Income statement (Erfolgsrechnung) for the year: profit, loss, net, and the account list per side.
+
+- **Input:** `{ year?, mandator? }`
+- **Output:** `{ profitChf, lossChf, netChf, incomeAccounts: [...], expenseAccounts: [...] }`
+
+### `get_transactions`
+
+> Fetch transactions with filters. Prefer narrow filters — this is the main workhorse. Truncated at `limit` (default 200, max 1000).
+
+- **Input:**
+  ```json
+  {
+    "year": 2026,
+    "mandator": null,
+    "accountId": null,
+    "fromDate": "2026-01-01",
+    "toDate": "2026-03-31",
+    "textSearch": "coop",
+    "minAmount": 100,
+    "maxAmount": null,
+    "limit": 200
+  }
+  ```
+- **Output:**
+  ```json
+  {
+    "transactions": [
+      { "id": "...", "date": "2026-02-14", "bookingDate": "2026-02-14",
+        "text": "Coop City", "value": 87.30, "currency": "CHF",
+        "originAccountId": "chk", "originAccountName": "Checking",
+        "targetAccountId": "groc", "targetAccountName": "Groceries",
+        "relatedParty": "Coop Genossenschaft" }
+    ],
+    "total": 47,
+    "truncated": false
+  }
+  ```
+
+Backed by `ITransactionRepository.GetTransactionListAsync()` + in-memory filter — datasets are small enough that we don't need repo-level query pushdown.
+
+### `get_expenses_by_category`
+
+> Expenses grouped by subclass or account. Sorted descending by CHF total.
+
+- **Input:** `{ year?, mandator?, groupBy?: "subclass" | "account" }`
+- **Output:** `{ categories: [{ name, totalChf, transactionCount }] }`
+
+### `compare_years`
+
+> Side-by-side comparison for equivalent categories across years. Useful for *"how did my spending change YoY"*.
+
+- **Input:** `{ years: int[], mandator?, side: "income" | "expenses" | "both" }`
+- **Output:**
+  ```json
+  {
+    "comparison": [
+      { "year": 2025, "totalIncomeChf": ..., "totalExpensesChf": ...,
+        "byCategory": { "Groceries": 4800.50, "Rent": 24000, ... } },
+      { "year": 2026, ... }
+    ]
+  }
+  ```
+
+## Output shape conventions
+
+- **Flat records**: no nested navigation properties. Account name inlined next to id so the LLM doesn't need a follow-up call.
+- **CHF-normalized**: any total is always in CHF. Per-transaction values keep the account currency plus the CHF equivalent when accounts differ.
+- **No booleans for "successful"** — either the tool returns data or it errors. MCP has native error surfacing.
+- **Cap collection sizes**: `get_transactions` truncates at `limit`; the LLM decides whether to narrow the filter.
+
+## Read-only enforcement
+
+- Repository / service **interfaces** still expose write methods (they're used from the UI). What's exposed is controlled by simply not authoring a `[McpServerTool]` for those verbs.
+- To make this explicit, the `Tools/` folder contains **only read operations**, and typed errors (or similar) are the only way the LLM sees "no such account".
+- **Do NOT expose `SetYear` / `SetMandator` as tools.** Year/mandator switching happens implicitly per-call via `AccountingScope`. Otherwise the LLM could clobber the UI's session state.
+
+## Packaging & Claude Desktop
+
+Build once:
+
+```bash
+dotnet publish Schaad.Accounting.Mcp/ -c Release -o D:/AccountingMcp
+```
+
+Claude Desktop `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "schaad-accounting": {
+      "command": "D:/AccountingMcp/Schaad.Accounting.Mcp.exe",
+      "env": {
+        "Settings__DataPath": "D:/Developer/AccountingData/",
+        "Settings__DefaultMandator": "Claudio Schaad"
+      }
+    }
+  }
+}
+```
+
+`FixerIoApiKey` doesn't need to be set — MCP tools only ever need CHF conversions of stored CHF values, and `DummyFxService` is the current implementation.
+
+## Security
+
+- **Local stdio only.** No listening port. Anything running as your user can already read the XML files; MCP doesn't widen the local-attack blast radius.
+- **`DataPath` only from environment / config.** Never accept `set_data_path` or similar. The LLM must not be able to point the server at arbitrary directories.
+- **No write tools** — repeated deliberately because it's the single biggest risk mitigation.
+- No secrets in tool outputs. The `FixerIoApiKey` is not returned by any tool.
+- Data exposure to the model provider is a separate axis from local security. See [Privacy modes](#privacy-modes) below.
+
+## Privacy modes
+
+**The data-flow reality.** When Claude Desktop calls an MCP tool, the invocation and result are relayed through the Anthropic API so the model can reason over them. "Local stdio" only means the *server process* runs on your PC — the JSON payload it emits still crosses the network on its way to the model. Other MCP clients (Cursor, Zed, any hosted-model client) work the same way.
+
+To make the trade-off explicit, the server supports three privacy modes via a `Mcp:Privacy` config key.
+
+### `Full` (default)
+
+Every tool from the catalog is registered. Tool results include per-transaction detail: text, related party, amount, dates, source/target account names. Most useful for open-ended questions, most exposing — a single `get_transactions` call can send hundreds of rows of counterparty/amount data to the model provider.
+
+**Use when:** you're comfortable with the model provider's data-use policy on your account, and you want maximum answer quality.
+
+### `Aggregate`
+
+Only aggregate tools are registered:
+
+- `list_accounts` — trimmed: name, currency, class, `balanceChf`. **No account IDs, no bank account numbers, no start balance.**
+- `get_balance_summary`
+- `get_income_statement` — trimmed: totals per class, no per-account rows.
+- `get_expenses_by_category` — grouped by subclass name.
+- `compare_years` — same as `Full`.
+
+Withheld: `get_transactions` (entirely), per-account balance rows, related-party names, individual dates and texts.
+
+**Use when:** you want spending/income insight without exposing individual counterparties or transaction narratives. Trades power for privacy — Claude can answer *"how did my grocery spending change YoY?"* but not *"what was that odd 850 CHF withdrawal in March?"*.
+
+### `Local`
+
+Same tool catalog as `Full`, but intended to be paired with a **local** MCP client — e.g. an Ollama- or LM-Studio-backed client that runs the model on your own machine. The MCP server itself doesn't and can't enforce this; the choice happens in which client you point at the server binary. Nothing crosses the network. Answer quality is lower than Claude, sometimes considerably.
+
+**Use when:** you don't want any financial data leaving your PC at all.
+
+### Configuring the mode
+
+```json
+{
+  "mcpServers": {
+    "schaad-accounting": {
+      "command": "D:/AccountingMcp/Schaad.Accounting.Mcp.exe",
+      "env": {
+        "Settings__DataPath": "D:/Developer/AccountingData/",
+        "Settings__DefaultMandator": "Claudio Schaad",
+        "Mcp__Privacy": "Aggregate"
+      }
+    }
+  }
+}
+```
+
+`Program.cs` reads `Mcp:Privacy` at startup and decides which `[McpServerToolType]` classes to register with the SDK. Modes are enforced by *registration*, not by runtime filtering — a tool that's not registered simply doesn't exist from the model's point of view, so the model can't accidentally call it.
+
+For belt-and-braces defence-in-depth, the sensitive-output DTOs (`TransactionDto`, per-account rows) can also live in a separate namespace whose types are only ever *constructed* by tools that are registered under `Full`; that way an accidentally shipped aggregate build won't compile against them.
+
+## Out of scope for v1
+
+- **Resources**: expose the chart of accounts as an MCP `Resource` so the LLM reads structure once instead of via `list_accounts` on every conversation.
+- **Prompts**: prebuilt Claude prompts (*"Monatlicher Kassenbericht"*, *"Erklär mir das Q3-Wachstum"*).
+- **Bank-transaction matching preview**: expose the `MatchOpenBankTransactions` output as a read-only tool so Claude can review the auto-matcher's guesses.
+- **Budgets / alerts**: not modelled in the app yet, so no data to expose.
+
+## Rough implementation size
+
+- New project + csproj + Program.cs: ~40 LOC
+- `AccountingScope` + `ToolExecutor`: ~40 LOC
+- 8 tools with DTOs: ~350 LOC (mostly declarative attribute schemas + `Select` projections)
+- Extract `AddAccounting()` to `Composition` project: ~30 LOC (mostly moving)
+- **Total: ~450 LOC**, plus config/docs.
+
+## Suggested PR sequencing
+
+- **PR Q** — Extract `AddAccounting()` from `Schaad.Accounting.UI/Extensions.cs` to a new `Schaad.Accounting.Composition` project referenced by UI and Mcp. Mechanical, low risk.
+- **PR R** — Add the `Schaad.Accounting.Mcp` project with `Program.cs`, `AccountingScope`, `ToolExecutor`, and the first two tools (`list_mandators`, `list_accounts`). Enough to wire Claude Desktop and iterate on the actual conversation feel before adding analytics tools.
+- **PR S** — Balance + income statement tools (`get_balance_summary`, `get_income_statement`).
+- **PR T** — `get_transactions` (the workhorse) with filter validation and truncation.
+- **PR U** — Analytics (`get_expenses_by_category`, `compare_years`).
--- a/Schaad.Accounting.Common/Datasets/Reports/BalanceDataset.cs
+++ b/Schaad.Accounting.Common/Datasets/Reports/BalanceDataset.cs
@ -1,23 +1,10 @@
-using System.Collections.Generic;
+using System.Collections.Generic;

 namespace Schaad.Accounting.Datasets.Reports
 {
-    public class BalanceDataset
-    {
-        public List<AccountDataset> ActivaAccountList { get; set; }
-
-        public List<AccountDataset> PassivaAccountList { get; set; }
-
-        public decimal TotalActivaCHF { get; set; }
-
-        public decimal TotalPassivaCHF { get; set; }
-
-        public BalanceDataset(List<AccountDataset> activaAccountList, List<AccountDataset> passivaAccountList, decimal totalActivaCHF, decimal totalPassivaCHF)
-        {
-            ActivaAccountList = activaAccountList;
-            PassivaAccountList = passivaAccountList;
-            TotalActivaCHF = totalActivaCHF;
-            TotalPassivaCHF = totalPassivaCHF;
-        }
-    }
-}
+    public record BalanceDataset(
+        List<AccountDataset> ActivaAccountList,
+        List<AccountDataset> PassivaAccountList,
+        decimal TotalActivaCHF,
+        decimal TotalPassivaCHF);
+}
--- a/Schaad.Accounting.Common/Datasets/Reports/BalanceSheetDataset.cs
+++ b/Schaad.Accounting.Common/Datasets/Reports/BalanceSheetDataset.cs
@ -1,29 +1,12 @@
-using System.Collections.Generic;
+using System.Collections.Generic;

 namespace Schaad.Accounting.Datasets.Reports
 {
-    public class BalanceSheetDataset
-    {
-        public List<AccountDataset> ActivaAccountList { get; }
-
-        public List<AccountDataset> IncomeAccountList { get; }
-
-        public List<AccountDataset> ExpensesAccountList { get; }
-
-        public decimal ProfitCHF { get; }
-
-        public decimal LossCHF { get; }
-
-        public int Year { get; }
-
-        public BalanceSheetDataset(List<AccountDataset> activaAccountList, List<AccountDataset> incomeAccountList, List<AccountDataset> expensesAccountList, decimal profitCHF, decimal lossCHF, int year)
-        {
-            ActivaAccountList = activaAccountList;
-            IncomeAccountList = incomeAccountList;
-            ExpensesAccountList = expensesAccountList;
-            ProfitCHF = profitCHF;
-            LossCHF = lossCHF;
-            Year = year;
-        }
-    }
-}
+    public record BalanceSheetDataset(
+        List<AccountDataset> ActivaAccountList,
+        List<AccountDataset> IncomeAccountList,
+        List<AccountDataset> ExpensesAccountList,
+        decimal ProfitCHF,
+        decimal LossCHF,
+        int Year);
+}
--- a/Schaad.Accounting.Common/Interfaces/IAccountRepository.cs
+++ b/Schaad.Accounting.Common/Interfaces/IAccountRepository.cs
@ -1,20 +1,21 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Models;

 namespace Schaad.Accounting.Interfaces
 {
    public interface IAccountRepository
    {
-        List<Account> GetAccountList();
+        Task<List<Account>> GetAccountListAsync();

-        void SaveAccount(Account account);
+        Task SaveAccountAsync(Account account);

-        Account GetAccount(string id);
-        
-        void DeleteAccount(string id);
+        Task<Account> GetAccountAsync(string id);

-        Account GetAccountForBankAccountNumber(string bankAccountNumber);
+        Task DeleteAccountAsync(string id);

-        void SaveBankAccountBalance(string bankAccountNumber, decimal accountBalance);
+        Task<Account> GetAccountForBankAccountNumberAsync(string bankAccountNumber);
+
+        Task SaveBankAccountBalanceAsync(string bankAccountNumber, decimal accountBalance);
    }
-}
+}
--- a/Schaad.Accounting.Common/Interfaces/IBankTransactionRepository.cs
+++ b/Schaad.Accounting.Common/Interfaces/IBankTransactionRepository.cs
@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Models;

@ -6,10 +7,10 @@ namespace Schaad.Accounting.Interfaces
 {
    public interface IBankTransactionRepository
    {
-        List<BankTransaction> GetBankTransactionList();
+        Task<List<BankTransaction>> GetBankTransactionListAsync();

-        int SaveBankTransactionList(string bankAccountNumber, List<BankTransactionDataset> bankTransactions);
+        Task<int> SaveBankTransactionListAsync(string bankAccountNumber, List<BankTransactionDataset> bankTransactions);

-        BankTransaction GetBankTransaction(string id);
+        Task<BankTransaction> GetBankTransactionAsync(string id);
    }
-}
+}
--- a/Schaad.Accounting.Common/Interfaces/IBookingRuleRepository.cs
+++ b/Schaad.Accounting.Common/Interfaces/IBookingRuleRepository.cs
@ -1,15 +1,17 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Models;

 namespace Schaad.Accounting.Interfaces
 {
    public interface IBookingRuleRepository
    {
-        List<BookingRule> GetBookingRuleList();
+        Task<List<BookingRule>> GetBookingRuleListAsync();

-        void SaveBookingRule(BookingRule bookingRule);
+        Task SaveBookingRuleAsync(BookingRule bookingRule);

-        BookingRule GetBookingRule(string id);
-        void DeleteBookingRule(string id);
+        Task<BookingRule> GetBookingRuleAsync(string id);
+
+        Task DeleteBookingRuleAsync(string id);
    }
-}
+}
--- a/Schaad.Accounting.Common/Interfaces/IBookingTextRepository.cs
+++ b/Schaad.Accounting.Common/Interfaces/IBookingTextRepository.cs
@ -1,16 +1,17 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Models;

 namespace Schaad.Accounting.Interfaces
 {
    public interface IBookingTextRepository
    {
-        List<BookingText> GetBookingTextList();
+        Task<List<BookingText>> GetBookingTextListAsync();

-        void SaveBookingText(BookingText bookingText);
+        Task SaveBookingTextAsync(BookingText bookingText);

-        BookingText GetBookingText(string id);
-        
-        void DeleteBookingText(string id);
+        Task<BookingText> GetBookingTextAsync(string id);
+
+        Task DeleteBookingTextAsync(string id);
    }
-}
+}
--- a/Schaad.Accounting.Common/Interfaces/ISplitPredefinitionRepository.cs
+++ b/Schaad.Accounting.Common/Interfaces/ISplitPredefinitionRepository.cs
@ -1,12 +1,13 @@
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Models;

 namespace Schaad.Accounting.Interfaces
 {
    public interface ISplitPredefinitionRepository
    {
-        List<SplitPredefinition> GetSplitPredefinitionList();
+        Task<List<SplitPredefinition>> GetSplitPredefinitionListAsync();

-        void SaveSplitPredefinition(SplitPredefinition splitPredefinition);
+        Task SaveSplitPredefinitionAsync(SplitPredefinition splitPredefinition);
    }
 }
--- a/Schaad.Accounting.Common/Interfaces/ISubclassRepository.cs
+++ b/Schaad.Accounting.Common/Interfaces/ISubclassRepository.cs
@ -1,20 +1,21 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Models;

 namespace Schaad.Accounting.Interfaces
 {
    public interface ISubclassRepository
    {
-        List<SubClass> GetSubClassList();
+        Task<List<SubClass>> GetSubClassListAsync();

-        void SaveSubClass(SubClass subClass);
+        Task SaveSubClassAsync(SubClass subClass);

-        SubClass GetSubClass(string id);
-        
-        void DeleteSubClass(string id);
+        Task<SubClass> GetSubClassAsync(string id);
+
+        Task DeleteSubClassAsync(string id);

        Dictionary<int, string> GetClasses();

        string GetClass(int classId);
    }
-}
+}
--- a/Schaad.Accounting.Common/Interfaces/ITransactionRepository.cs
+++ b/Schaad.Accounting.Common/Interfaces/ITransactionRepository.cs
@ -1,15 +1,17 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Models;

 namespace Schaad.Accounting.Interfaces
 {
    public interface ITransactionRepository
    {
-        List<Transaction> GetTransactionList();
+        Task<List<Transaction>> GetTransactionListAsync();

-        void SaveTransaction(Transaction transaction);
+        Task SaveTransactionAsync(Transaction transaction);

-        Transaction GetTransaction(string id);
-        void DeleteTransaction(string id);
+        Task<Transaction> GetTransactionAsync(string id);
+
+        Task DeleteTransactionAsync(string id);
    }
-}
+}
--- a/Schaad.Accounting.Db/Repositories/AccountRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/AccountRepository.cs
@ -1,7 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -18,22 +19,16 @@ namespace Schaad.Accounting.Repositories
            EnsureAccountsFile();
        }

-        /// <summary>
-        /// Load accounts
-        /// </summary>
-        public List<Account> GetAccountList() => LoadList<Account>(ACCOUNTS);
+        public Task<List<Account>> GetAccountListAsync() => LoadListAsync<Account>(ACCOUNTS);

-        /// <summary>
-        /// Save an account (insert/update)
-        /// </summary>
-        public void SaveAccount(Account account)
+        public async Task SaveAccountAsync(Account account)
        {
            if (string.IsNullOrEmpty(account.Currency))
            {
                account.Currency = "CHF";
            }

-            var accounts = GetAccountList();
+            var accounts = await GetAccountListAsync();
            var idx = accounts.FindIndex(a => a.Id == account.Id);
            if (idx >= 0)
            {
@ -44,42 +39,33 @@ namespace Schaad.Accounting.Repositories
                account.Id = Guid.NewGuid().ToString();
                accounts.Add(account);
            }
-            Save(accounts, ACCOUNTS);
+            await SaveAsync(accounts, ACCOUNTS);
        }

-        /// <summary>
-        /// Get account
-        /// </summary>
-        public Account GetAccount(string id)
+        public async Task<Account> GetAccountAsync(string id)
        {
-            var accounts = GetAccountList();
+            var accounts = await GetAccountListAsync();
            return accounts.FirstOrDefault(t => t.Id == id);
        }
-        
-        /// <summary>
-        /// Delete account
-        /// </summary>
-        public void DeleteAccount(string id)
+
+        public async Task DeleteAccountAsync(string id)
        {
-            var accounts = GetAccountList();
+            var accounts = await GetAccountListAsync();
            accounts.RemoveAll(t => t.Id == id);
-            Save(accounts, ACCOUNTS);
+            await SaveAsync(accounts, ACCOUNTS);
        }

-        /// <summary>
-        /// Get account
-        /// </summary>
-        public Account GetAccountForBankAccountNumber(string bankAccountNumber)
+        public async Task<Account> GetAccountForBankAccountNumberAsync(string bankAccountNumber)
        {
-            var accounts = GetAccountList();
+            var accounts = await GetAccountListAsync();
            return accounts.SingleOrDefault(t => t.BankAccountNumber == bankAccountNumber);
        }

-        public void SaveBankAccountBalance(string bankAccountNumber, decimal accountBalance)
+        public async Task SaveBankAccountBalanceAsync(string bankAccountNumber, decimal accountBalance)
        {
-            var account = GetAccountForBankAccountNumber(bankAccountNumber);
+            var account = await GetAccountForBankAccountNumberAsync(bankAccountNumber);
            account.LastBankBalance = accountBalance;
-            SaveAccount(account);
+            await SaveAccountAsync(account);
        }

        private void EnsureAccountsFile()
@ -98,7 +84,9 @@ namespace Schaad.Accounting.Repositories

            // Year rollover: seed start balances from the previous year's closing values.
            // Bank accounts start at the last known bank balance; cash accounts start at zero.
-            var accounts = GetAccountList();
+            // Uses the sync GetAwaiter().GetResult() bridge because this runs from the
+            // constructor; the file was just copied so the underlying I/O is local.
+            var accounts = GetAccountListAsync().GetAwaiter().GetResult();
            var modified = false;
            foreach (var account in accounts.Where(a => a.Class == ClassIds.Activa))
            {
@ -115,8 +103,8 @@ namespace Schaad.Accounting.Repositories
            }
            if (modified)
            {
-                Save(accounts, ACCOUNTS);
+                SaveAsync(accounts, ACCOUNTS).GetAwaiter().GetResult();
            }
        }
    }
-}
+}
--- a/Schaad.Accounting.Db/Repositories/BankTransactionRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/BankTransactionRepository.cs
@ -1,5 +1,6 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Interfaces;
@ -16,18 +17,15 @@ namespace Schaad.Accounting.Repositories
        {
        }

-        /// <summary>
-        /// Load bank transactions
-        /// </summary>
-        public List<BankTransaction> GetBankTransactionList() => LoadList<BankTransaction>(BANK_TRANSACTIONS);
+        public Task<List<BankTransaction>> GetBankTransactionListAsync() => LoadListAsync<BankTransaction>(BANK_TRANSACTIONS);

        /// <summary>
        /// Save new bank transactions, ignore existing ones (no update)
        /// </summary>
-        public int SaveBankTransactionList(string bankAccountNumber, List<BankTransactionDataset> bankTransactions)
+        public async Task<int> SaveBankTransactionListAsync(string bankAccountNumber, List<BankTransactionDataset> bankTransactions)
        {
            var count = 0;
-            var transactions = GetBankTransactionList();
+            var transactions = await GetBankTransactionListAsync();
            foreach (var bankTrx in bankTransactions)
            {
                var transaction = transactions.FirstOrDefault(t => t.Id == bankTrx.Id);
@ -48,17 +46,14 @@ namespace Schaad.Accounting.Repositories
                    count++;
                }
            }
-            Save(transactions, BANK_TRANSACTIONS);
+            await SaveAsync(transactions, BANK_TRANSACTIONS);
            return count;
        }

-        /// <summary>
-        /// Get bank transaction
-        /// </summary>
-        public BankTransaction GetBankTransaction(string id)
+        public async Task<BankTransaction> GetBankTransactionAsync(string id)
        {
-            var transactions = GetBankTransactionList();
+            var transactions = await GetBankTransactionListAsync();
            return transactions.FirstOrDefault(t => t.Id == id);
        }
    }
-}
+}
--- a/Schaad.Accounting.Db/Repositories/BaseRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/BaseRepository.cs
@ -1,8 +1,10 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Xml;
 using System.Xml.Serialization;
 using Microsoft.Extensions.Logging;
@ -12,9 +14,9 @@ namespace Schaad.Accounting.Repositories
 {
    public abstract class BaseRepository
    {
-        // One lock per absolute file path so concurrent Save+Save and Save+Load are serialized
-        // and can't observe a half-written file.
-        private static readonly ConcurrentDictionary<string, object> FileLocks =
+        // One semaphore per absolute file path so concurrent SaveAsync+SaveAsync and
+        // SaveAsync+LoadAsync are serialized and can't observe a half-written file.
+        private static readonly ConcurrentDictionary<string, SemaphoreSlim> FileLocks =
            new(StringComparer.OrdinalIgnoreCase);

        protected readonly ISettingsService settingsService;
@ -28,10 +30,17 @@ namespace Schaad.Accounting.Repositories
            this.logger = logger;
        }

+        /// <summary>
+        /// Copies fileName from last year's directory to the current year's directory when the
+        /// current year doesn't have it yet. Kept synchronous because it runs from repository
+        /// constructors; File.Copy has no async equivalent in .NET 9 either way.
+        /// </summary>
        protected void EnsureFileExists(string fileName)
        {
            string filePath = Path.Combine(settingsService.GetDbPath(), fileName);
-            lock (GetLock(filePath))
+            var semaphore = GetLock(filePath);
+            semaphore.Wait();
+            try
            {
                if (File.Exists(filePath) == false)
                {
@ -42,16 +51,20 @@ namespace Schaad.Accounting.Repositories
                    }
                }
            }
+            finally
+            {
+                semaphore.Release();
+            }
        }

        /// <summary>
        /// Load a list, cached per scope. First call reads the XML file; subsequent calls in
-        /// the same scope return the cached list. <see cref="Save"/> invalidates the entry.
+        /// the same scope return the cached list. <see cref="SaveAsync"/> invalidates the entry.
        /// </summary>
-        protected List<T> LoadList<T>(string fileName)
+        protected Task<List<T>> LoadListAsync<T>(string fileName)
        {
            var filePath = Path.Combine(settingsService.GetDbPath(), fileName);
-            return cache.GetOrLoad(filePath, () => Load<List<T>>(fileName) ?? new List<T>());
+            return cache.GetOrLoadAsync(filePath, async () => await LoadAsync<List<T>>(fileName) ?? new List<T>());
        }

        /// <summary>
@ -59,12 +72,14 @@ namespace Schaad.Accounting.Repositories
        /// renames it, so a crash mid-write leaves the previous file intact. Invalidates
        /// the corresponding cache entry.
        /// </summary>
-        protected void Save<T>(T obj, string fileName)
+        protected async Task SaveAsync<T>(T obj, string fileName)
        {
            var filePath = Path.Combine(settingsService.GetDbPath(), fileName);
            var tmpPath = filePath + ".tmp";

-            lock (GetLock(filePath))
+            var semaphore = GetLock(filePath);
+            await semaphore.WaitAsync();
+            try
            {
                var settings = new XmlWriterSettings
                {
@ -74,12 +89,16 @@ namespace Schaad.Accounting.Repositories

                try
                {
-                    using (var writer = XmlWriter.Create(tmpPath, settings))
+                    // XmlSerializer is synchronous — serialize to memory, then write async.
+                    using var memory = new MemoryStream();
+                    using (var writer = XmlWriter.Create(memory, settings))
                    {
                        var serializer = new XmlSerializer(typeof(T));
                        serializer.Serialize(writer, obj);
                    }
+                    await File.WriteAllBytesAsync(tmpPath, memory.ToArray());

+                    // File.Move has no async form in .NET 9.
                    File.Move(tmpPath, filePath, overwrite: true);
                }
                catch (Exception ex)
@ -92,34 +111,43 @@ namespace Schaad.Accounting.Repositories
                    throw;
                }
            }
+            finally
+            {
+                semaphore.Release();
+            }

            cache.Invalidate(filePath);
        }

        /// <summary>
        /// Load an object from an xml file (uncached; used for one-off reads such as file
-        /// existence bootstrapping). Prefer <see cref="LoadList{T}"/> for repository reads.
+        /// existence bootstrapping). Prefer <see cref="LoadListAsync{T}"/> for repository reads.
        /// </summary>
-        protected T Load<T>(string fileName)
+        protected async Task<T> LoadAsync<T>(string fileName)
        {
            var filePath = Path.Combine(settingsService.GetDbPath(), fileName);

-            lock (GetLock(filePath))
+            var semaphore = GetLock(filePath);
+            await semaphore.WaitAsync();
+            try
            {
                if (File.Exists(filePath) == false)
                {
                    return default(T);
                }

-                using (XmlReader reader = XmlReader.Create(filePath))
-                {
-                    var serializer = new XmlSerializer(typeof(T));
-                    return (T)serializer.Deserialize(reader);
-                }
+                var bytes = await File.ReadAllBytesAsync(filePath);
+                using var memory = new MemoryStream(bytes);
+                var serializer = new XmlSerializer(typeof(T));
+                return (T)serializer.Deserialize(memory);
+            }
+            finally
+            {
+                semaphore.Release();
            }
        }

-        private static object GetLock(string filePath)
-            => FileLocks.GetOrAdd(filePath, _ => new object());
+        private static SemaphoreSlim GetLock(string filePath)
+            => FileLocks.GetOrAdd(filePath, _ => new SemaphoreSlim(1, 1));
    }
-}
+}
--- a/Schaad.Accounting.Db/Repositories/BookingRuleRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/BookingRuleRepository.cs
@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -17,17 +18,11 @@ namespace Schaad.Accounting.Repositories
            EnsureFileExists(BOOKING_RULES);
        }

-        /// <summary>
-        /// Load booking rules
-        /// </summary>
-        public List<BookingRule> GetBookingRuleList() => LoadList<BookingRule>(BOOKING_RULES);
+        public Task<List<BookingRule>> GetBookingRuleListAsync() => LoadListAsync<BookingRule>(BOOKING_RULES);

-        /// <summary>
-        /// Save a booking rule (insert/update)
-        /// </summary>
-        public void SaveBookingRule(BookingRule bookingRule)
+        public async Task SaveBookingRuleAsync(BookingRule bookingRule)
        {
-            var bookingRules = GetBookingRuleList();
+            var bookingRules = await GetBookingRuleListAsync();
            var idx = bookingRules.FindIndex(r => r.Id == bookingRule.Id);
            if (idx >= 0)
            {
@ -38,26 +33,20 @@ namespace Schaad.Accounting.Repositories
                bookingRule.Id = Guid.NewGuid().ToString();
                bookingRules.Add(bookingRule);
            }
-            Save(bookingRules, BOOKING_RULES);
+            await SaveAsync(bookingRules, BOOKING_RULES);
        }

-        /// <summary>
-        /// Get booking rule
-        /// </summary>
-        public BookingRule GetBookingRule(string id)
+        public async Task<BookingRule> GetBookingRuleAsync(string id)
        {
-            var bookingRules = GetBookingRuleList();
+            var bookingRules = await GetBookingRuleListAsync();
            return bookingRules.FirstOrDefault(t => t.Id == id);
        }
-        
-        /// <summary>
-        /// Delete booking rule
-        /// </summary>
-        public void DeleteBookingRule(string id)
+
+        public async Task DeleteBookingRuleAsync(string id)
        {
-            var bookingRules = GetBookingRuleList();
+            var bookingRules = await GetBookingRuleListAsync();
            bookingRules.RemoveAll(t => t.Id == id);
-            Save(bookingRules, BOOKING_RULES);
+            await SaveAsync(bookingRules, BOOKING_RULES);
        }
    }
-}
+}
--- a/Schaad.Accounting.Db/Repositories/BookingTextRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/BookingTextRepository.cs
@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -17,17 +18,11 @@ namespace Schaad.Accounting.Repositories
            EnsureFileExists(BOOKING_TEXTS);
        }

-        /// <summary>
-        /// Load booking texts
-        /// </summary>
-        public List<BookingText> GetBookingTextList() => LoadList<BookingText>(BOOKING_TEXTS);
+        public Task<List<BookingText>> GetBookingTextListAsync() => LoadListAsync<BookingText>(BOOKING_TEXTS);

-        /// <summary>
-        /// Save a booking text (insert/update)
-        /// </summary>
-        public void SaveBookingText(BookingText bookingText)
+        public async Task SaveBookingTextAsync(BookingText bookingText)
        {
-            var bookingTexts = GetBookingTextList();
+            var bookingTexts = await GetBookingTextListAsync();
            var idx = bookingTexts.FindIndex(t => t.Id == bookingText.Id);
            if (idx >= 0)
            {
@ -38,26 +33,20 @@ namespace Schaad.Accounting.Repositories
                bookingText.Id = Guid.NewGuid().ToString();
                bookingTexts.Add(bookingText);
            }
-            Save(bookingTexts, BOOKING_TEXTS);
+            await SaveAsync(bookingTexts, BOOKING_TEXTS);
        }

-        /// <summary>
-        /// Get booking text
-        /// </summary>
-        public BookingText GetBookingText(string id)
+        public async Task<BookingText> GetBookingTextAsync(string id)
        {
-            var bookingTexts = GetBookingTextList();
+            var bookingTexts = await GetBookingTextListAsync();
            return bookingTexts.FirstOrDefault(t => t.Id == id);
        }
-        
-        /// <summary>
-        /// Delete booking text
-        /// </summary>
-        public void DeleteBookingText(string id)
+
+        public async Task DeleteBookingTextAsync(string id)
        {
-            var bookingTexts = GetBookingTextList();
+            var bookingTexts = await GetBookingTextListAsync();
            bookingTexts.RemoveAll(t => t.Id == id);
-            Save(bookingTexts, BOOKING_TEXTS);
+            await SaveAsync(bookingTexts, BOOKING_TEXTS);
        }
    }
-}
+}
--- a/Schaad.Accounting.Db/Repositories/SplitPredefinitionRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/SplitPredefinitionRepository.cs
@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -17,17 +18,11 @@ namespace Schaad.Accounting.Repositories
            EnsureFileExists(SPLIT_PREDEFINITION);
        }

-        /// <summary>
-        /// Load split predefinitions
-        /// </summary>
-        public List<SplitPredefinition> GetSplitPredefinitionList() => LoadList<SplitPredefinition>(SPLIT_PREDEFINITION);
+        public Task<List<SplitPredefinition>> GetSplitPredefinitionListAsync() => LoadListAsync<SplitPredefinition>(SPLIT_PREDEFINITION);

-        /// <summary>
-        /// Save a split predefinition (insert/update)
-        /// </summary>
-        public void SaveSplitPredefinition(SplitPredefinition splitPredefinition)
+        public async Task SaveSplitPredefinitionAsync(SplitPredefinition splitPredefinition)
        {
-            var definitions = GetSplitPredefinitionList();
+            var definitions = await GetSplitPredefinitionListAsync();
            var idx = definitions.FindIndex(d => d.Id == splitPredefinition.Id);
            if (idx >= 0)
            {
@ -38,7 +33,7 @@ namespace Schaad.Accounting.Repositories
                splitPredefinition.Id = Guid.NewGuid().ToString();
                definitions.Add(splitPredefinition);
            }
-            Save(definitions, SPLIT_PREDEFINITION);
+            await SaveAsync(definitions, SPLIT_PREDEFINITION);
        }
    }
 }
--- a/Schaad.Accounting.Db/Repositories/SubclassRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/SubclassRepository.cs
@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -23,17 +24,11 @@ namespace Schaad.Accounting.Repositories
            classes.Add(ClassIds.Expenses, "Ausgaben");
        }

-        /// <summary>
-        /// Load subclasses
-        /// </summary>
-        public List<SubClass> GetSubClassList() => LoadList<SubClass>(SUBCLASSES);
+        public Task<List<SubClass>> GetSubClassListAsync() => LoadListAsync<SubClass>(SUBCLASSES);

-        /// <summary>
-        /// Save a subclass (insert/update)
-        /// </summary>
-        public void SaveSubClass(SubClass subClass)
+        public async Task SaveSubClassAsync(SubClass subClass)
        {
-            var subclasses = GetSubClassList();
+            var subclasses = await GetSubClassListAsync();
            var idx = subclasses.FindIndex(s => s.Id == subClass.Id);
            if (idx >= 0)
            {
@ -44,23 +39,20 @@ namespace Schaad.Accounting.Repositories
                subClass.Id = Guid.NewGuid().ToString();
                subclasses.Add(subClass);
            }
-            Save(subclasses, SUBCLASSES);
+            await SaveAsync(subclasses, SUBCLASSES);
        }

-        /// <summary>
-        /// Get subclass
-        /// </summary>
-        public SubClass GetSubClass(string id)
+        public async Task<SubClass> GetSubClassAsync(string id)
        {
-            var subclasses = GetSubClassList();
+            var subclasses = await GetSubClassListAsync();
            return subclasses.FirstOrDefault(t => t.Id == id);
        }
-        
-        public void DeleteSubClass(string id)
+
+        public async Task DeleteSubClassAsync(string id)
        {
-            var subclasses = GetSubClassList();
+            var subclasses = await GetSubClassListAsync();
            subclasses.RemoveAll(t => t.Id == id);
-            Save(subclasses, SUBCLASSES);
+            await SaveAsync(subclasses, SUBCLASSES);
        }

        public Dictionary<int, string> GetClasses()
@ -73,4 +65,4 @@ namespace Schaad.Accounting.Repositories
            return classes[classId];
        }
    }
-}
+}
--- a/Schaad.Accounting.Db/Repositories/TransactionRepository.cs
+++ b/Schaad.Accounting.Db/Repositories/TransactionRepository.cs
@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -18,20 +19,14 @@ namespace Schaad.Accounting.Repositories
            this.accountRepository = accountRepository;
        }

-        /// <summary>
-        /// Get transaction list
-        /// </summary>
-        public List<Transaction> GetTransactionList() => LoadList<Transaction>(TRANSACTIONS);
+        public Task<List<Transaction>> GetTransactionListAsync() => LoadListAsync<Transaction>(TRANSACTIONS);

-        /// <summary>
-        /// Save a transaction (insert/update)
-        /// </summary>
-        public void SaveTransaction(Transaction transaction)
+        public async Task SaveTransactionAsync(Transaction transaction)
        {
            transaction.Value = Math.Abs(transaction.Value);

-            var originIsFx = accountRepository.GetAccount(transaction.OriginAccountId).IsFxAccount;
-            var targetIsFx = accountRepository.GetAccount(transaction.TargetAccountId).IsFxAccount;
+            var originIsFx = (await accountRepository.GetAccountAsync(transaction.OriginAccountId)).IsFxAccount;
+            var targetIsFx = (await accountRepository.GetAccountAsync(transaction.TargetAccountId)).IsFxAccount;
            var isFxAccount = originIsFx || targetIsFx;

            // user enters amount in the foreign account's currency -> convert to CHF for storage
@ -50,7 +45,7 @@ namespace Schaad.Accounting.Repositories
                transaction.BookingDate = transaction.ValueDate;
            }

-            var transactionList = GetTransactionList();
+            var transactionList = await GetTransactionListAsync();
            var idx = transactionList.FindIndex(t => t.Id == transaction.Id);
            if (idx >= 0)
            {
@ -61,15 +56,12 @@ namespace Schaad.Accounting.Repositories
                transaction.Id = Guid.NewGuid().ToString();
                transactionList.Add(transaction);
            }
-            Save(transactionList, TRANSACTIONS);
+            await SaveAsync(transactionList, TRANSACTIONS);
        }

-        /// <summary>
-        /// Get transaction
-        /// </summary>
-        public Transaction GetTransaction(string id)
+        public async Task<Transaction> GetTransactionAsync(string id)
        {
-            var transactions = GetTransactionList();
+            var transactions = await GetTransactionListAsync();
            var stored = transactions.FirstOrDefault(t => t.Id == id);
            if (stored == null)
            {
@ -79,8 +71,8 @@ namespace Schaad.Accounting.Repositories
            var result = stored.Clone();

            // value is stored in CHF -> convert back to foreign currency for display/editing
-            var isFxAccount = accountRepository.GetAccount(result.OriginAccountId).IsFxAccount
-                || accountRepository.GetAccount(result.TargetAccountId).IsFxAccount;
+            var isFxAccount = (await accountRepository.GetAccountAsync(result.OriginAccountId)).IsFxAccount
+                || (await accountRepository.GetAccountAsync(result.TargetAccountId)).IsFxAccount;
            if (isFxAccount && result.FxRate != 0)
            {
                result.Value = result.Value / result.FxRate.Value;
@ -88,15 +80,12 @@ namespace Schaad.Accounting.Repositories

            return result;
        }
-        
-        /// <summary>
-        /// Delete transaction
-        /// </summary>
-        public void DeleteTransaction(string id)
+
+        public async Task DeleteTransactionAsync(string id)
        {
-            var transactions = GetTransactionList();
+            var transactions = await GetTransactionListAsync();
            transactions.RemoveAll(t => t.Id == id);
-            Save(transactions, TRANSACTIONS);
+            await SaveAsync(transactions, TRANSACTIONS);
        }
    }
-}
+}
--- a/Schaad.Accounting.Db/RepositoryCache.cs
+++ b/Schaad.Accounting.Db/RepositoryCache.cs
@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;

 namespace Schaad.Accounting.Repositories
 {
@ -7,7 +8,7 @@ namespace Schaad.Accounting.Repositories
    /// Per-scope cache of deserialized XML lists, keyed by absolute file path.
    ///
    /// Registered as Scoped so it lives for the SignalR circuit; each XML file is
-    /// then loaded at most once per circuit. Writes go through <see cref="BaseRepository.Save"/>,
+    /// then loaded at most once per circuit. Writes go through <see cref="BaseRepository.SaveAsync"/>,
    /// which invalidates the corresponding entry so the next read reloads from disk.
    ///
    /// Not thread-safe — callers within a single Blazor Server circuit run serialized on the
@ -18,14 +19,14 @@ namespace Schaad.Accounting.Repositories
        private readonly Dictionary<string, object> entries =
            new(StringComparer.OrdinalIgnoreCase);

-        public List<T> GetOrLoad<T>(string cacheKey, Func<List<T>> loader)
+        public async Task<List<T>> GetOrLoadAsync<T>(string cacheKey, Func<Task<List<T>>> loader)
        {
            if (entries.TryGetValue(cacheKey, out var cached))
            {
                return (List<T>)cached;
            }

-            var list = loader();
+            var list = await loader();
            entries[cacheKey] = list;
            return list;
        }
--- a/Schaad.Accounting.Services/ChartService.cs
+++ b/Schaad.Accounting.Services/ChartService.cs
@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Datasets.Charts;
 using Schaad.Accounting.Interfaces;
@ -18,9 +19,9 @@ namespace Schaad.Accounting.Services
            this.viewService = viewService;
        }

-        public IReadOnlyList<DataSerie> GetExpensesPerMonth()
+        public async Task<IReadOnlyList<DataSerie>> GetExpensesPerMonthAsync()
        {
-            var expenseTransactions = viewService.GetTransactionViewList()
+            var expenseTransactions = (await viewService.GetTransactionViewListAsync())
                .Where(t => t.TargetAccount.Class == ClassIds.Expenses)
                .ToList();

@ -31,7 +32,7 @@ namespace Schaad.Accounting.Services

            return distinctSubClasses > 1
                ? GetSubClassExpensesPerMonth(expenseTransactions)
-                : GetAccountExpensesPerMonth();
+                : await GetAccountExpensesPerMonthAsync();
        }

        private List<DataSerie> GetSubClassExpensesPerMonth(List<TransactionDataset> expenseTransactions)
@ -59,11 +60,11 @@ namespace Schaad.Accounting.Services
            return list;
        }

-        private List<DataSerie> GetAccountExpensesPerMonth()
+        private async Task<List<DataSerie>> GetAccountExpensesPerMonthAsync()
        {
            var year = settingsService.GetYear();
-            var allTransactions = viewService.GetTransactionViewList();
-            var expenseAccounts = viewService.GetAccountViewList().Where(a => a.Class == ClassIds.Expenses);
+            var allTransactions = await viewService.GetTransactionViewListAsync();
+            var expenseAccounts = (await viewService.GetAccountViewListAsync()).Where(a => a.Class == ClassIds.Expenses);

            var list = new List<DataSerie>();
            foreach (var account in expenseAccounts)
--- a/Schaad.Accounting.Services/FileService.cs
+++ b/Schaad.Accounting.Services/FileService.cs
@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.IO.Compression;
 using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Interfaces;
@ -47,15 +48,14 @@ namespace Schaad.Accounting.Services
        }

        // Upload account statement file (mt940, camt053)
-        // http://www.mikesdotnetting.com/article/288/asp-net-5-uploading-files-with-asp-net-mvc-6
-        public IReadOnlyList<MessageDataset> ImportAccountStatementFile(string filePath)
+        public async Task<IReadOnlyList<MessageDataset>> ImportAccountStatementFileAsync(string filePath)
        {
            logger.LogInformation("Importing account statement file {FilePath}", filePath);

            var messages = new List<MessageDataset>();
            var accountStatementResults = accountStatementService.ReadFile(filePath, Encoding.UTF8);

-            var accountList = accountRepository.GetAccountList().Select(a => a.BankAccountNumber).ToList();
+            var accountList = (await accountRepository.GetAccountListAsync()).Select(a => a.BankAccountNumber).ToList();
            foreach (var accountStatementResult in accountStatementResults)
            {
                var account = accountStatementResult.AccountStatement;
@ -91,8 +91,8 @@ namespace Schaad.Accounting.Services
                                Creditor = t.Creditor
                            })
                        .ToList();
-                    var count = bankTransactionRepository.SaveBankTransactionList(account.AccountNumber, transactionsThisYear);
-                    accountRepository.SaveBankAccountBalance(account.AccountNumber, (decimal)account.EndBalance.Value);
+                    var count = await bankTransactionRepository.SaveBankTransactionListAsync(account.AccountNumber, transactionsThisYear);
+                    await accountRepository.SaveBankAccountBalanceAsync(account.AccountNumber, (decimal)account.EndBalance.Value);

                    logger.LogInformation("Imported {Imported} of {Total} transactions for account {AccountNumber}",
                        count, account.Transactions.Count, account.AccountNumber);
@ -124,11 +124,11 @@ namespace Schaad.Accounting.Services
            return creditCardTransactions;
        }

-        public byte[] GetTransactionListCsv(string accountId)
+        public async Task<byte[]> GetTransactionListCsvAsync(string accountId)
        {
            var sb = new StringBuilder();
-            var account = accountRepository.GetAccount(accountId);
-            var transactions = transactionsRepository.GetTransactionList()
+            var account = await accountRepository.GetAccountAsync(accountId);
+            var transactions = (await transactionsRepository.GetTransactionListAsync())
                .Where(t => t.OriginAccountId == accountId || t.TargetAccountId == accountId)
                .OrderBy(t => t.BookingDate)
                .ThenBy(t => t.ValueDate)
@ -159,4 +159,4 @@ namespace Schaad.Accounting.Services
            return fileBytes;
        }
    }
-}
+}
--- a/Schaad.Accounting.Services/Interfaces/IChartService.cs
+++ b/Schaad.Accounting.Services/Interfaces/IChartService.cs
@ -1,10 +1,11 @@
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Datasets.Charts;

 namespace Schaad.Accounting.Interfaces
 {
    public interface IChartService
    {
-        IReadOnlyList<DataSerie> GetExpensesPerMonth();
+        Task<IReadOnlyList<DataSerie>> GetExpensesPerMonthAsync();
    }
-}
+}
--- a/Schaad.Accounting.Services/Interfaces/IFileService.cs
+++ b/Schaad.Accounting.Services/Interfaces/IFileService.cs
@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Datasets;
 using Schaad.Finance.Api;
 using Schaad.Finance.Api.Datasets;
@ -8,8 +9,8 @@ namespace Schaad.Accounting.Interfaces
    public interface IFileService
    {
        string Backup();
-        IReadOnlyList<MessageDataset> ImportAccountStatementFile(string filePath);
+        Task<IReadOnlyList<MessageDataset>> ImportAccountStatementFileAsync(string filePath);
        IReadOnlyList<CreditCardTransaction> ImportCreditCardStatementFile(CreditCardProvider creditCardProvider, string filePath);
-        byte[] GetTransactionListCsv(string accountId);
+        Task<byte[]> GetTransactionListCsvAsync(string accountId);
    }
-}
+}
--- a/Schaad.Accounting.Services/Interfaces/IViewService.cs
+++ b/Schaad.Accounting.Services/Interfaces/IViewService.cs
@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Datasets.Reports;
 using Schaad.Accounting.Models;
@ -8,24 +9,24 @@ namespace Schaad.Accounting.Interfaces
 {
    public interface IViewService
    {
-        AccountDataset GetAccountView(string id);
+        Task<AccountDataset> GetAccountViewAsync(string id);

-        List<AccountDataset> GetAccountViewList();
+        Task<List<AccountDataset>> GetAccountViewListAsync();

-        BalanceDataset GetBalanceView();
+        Task<BalanceDataset> GetBalanceViewAsync();

-        BalanceSheetDataset GetBalanceSheetView(int year);
+        Task<BalanceSheetDataset> GetBalanceSheetViewAsync(int year);

-        List<TransactionDataset> GetTransactionViewList();
+        Task<List<TransactionDataset>> GetTransactionViewListAsync();

-        List<TransactionDataset> GetTransactionViewList(string accountId);
+        Task<List<TransactionDataset>> GetTransactionViewListAsync(string accountId);

-        List<BookingRuleDataset> GetBookingRuleViewList();
+        Task<List<BookingRuleDataset>> GetBookingRuleViewListAsync();

-        List<BankTransaction> GetOpenBankTransactionList();
+        Task<List<BankTransaction>> GetOpenBankTransactionListAsync();

-        List<Transaction> MatchOpenBankTransactions();
+        Task<List<Transaction>> MatchOpenBankTransactionsAsync();

-        List<Transaction> MatchCreditCardTransactions(string bankTransactionId, IReadOnlyList<CreditCardTransaction> creditCardTransactions);
+        Task<List<Transaction>> MatchCreditCardTransactionsAsync(string bankTransactionId, IReadOnlyList<CreditCardTransaction> creditCardTransactions);
    }
-}
+}
--- a/Schaad.Accounting.Services/ViewService.cs
+++ b/Schaad.Accounting.Services/ViewService.cs
@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Datasets.Reports;
@ -38,23 +39,17 @@ namespace Schaad.Accounting.Services
            this.logger = logger;
        }

-        /// <summary>
-        /// Load accounts
-        /// </summary>
-        public AccountDataset GetAccountView(string id)
+        public async Task<AccountDataset> GetAccountViewAsync(string id)
        {
-            var accounts = GetAccountViewList();
+            var accounts = await GetAccountViewListAsync();
            return accounts.Single(t => t.Id == id);
        }

-        /// <summary>
-        /// Load accounts and calculates their balances
-        /// </summary>
-        public List<AccountDataset> GetAccountViewList()
+        public async Task<List<AccountDataset>> GetAccountViewListAsync()
        {
-            var accounts = accountRepository.GetAccountList();
-            var transactionList = GetTransactionViewList();
-            var subClassNameByNumber = subclassRepository.GetSubClassList().ToDictionary(s => s.Number, s => s.Name);
+            var accounts = await accountRepository.GetAccountListAsync();
+            var transactionList = await GetTransactionViewListAsync();
+            var subClassNameByNumber = (await subclassRepository.GetSubClassListAsync()).ToDictionary(s => s.Number, s => s.Name);

            // Group transactions by account so per-account balance is O(k) instead of O(M).
            var creditsByAccount = transactionList.GroupBy(t => t.TargetAccountId).ToDictionary(g => g.Key, g => g.ToList());
@ -93,46 +88,40 @@ namespace Schaad.Accounting.Services
            return balance;
        }

-        public BalanceDataset GetBalanceView()
+        public async Task<BalanceDataset> GetBalanceViewAsync()
        {
-            var accountList = GetAccountViewList();
-            var balanceView = new BalanceDataset(
-                    activaAccountList: accountList.Where(m => m.Class == ClassIds.Activa).ToList(),
-                    passivaAccountList: accountList.Where(m => m.Class == ClassIds.Passiva).ToList(),
-                    totalActivaCHF: Math.Abs(accountList.Where(m => m.Class == ClassIds.Activa).Sum(m => m.BalanceCHF)),
-                    totalPassivaCHF: Math.Abs(accountList.Where(m => m.Class == ClassIds.Passiva).Sum(m => m.BalanceCHF))
-                );
-
-            return balanceView;
+            var accountList = await GetAccountViewListAsync();
+            return new BalanceDataset(
+                ActivaAccountList: accountList.Where(m => m.Class == ClassIds.Activa).ToList(),
+                PassivaAccountList: accountList.Where(m => m.Class == ClassIds.Passiva).ToList(),
+                TotalActivaCHF: Math.Abs(accountList.Where(m => m.Class == ClassIds.Activa).Sum(m => m.BalanceCHF)),
+                TotalPassivaCHF: Math.Abs(accountList.Where(m => m.Class == ClassIds.Passiva).Sum(m => m.BalanceCHF)));
        }

-        public BalanceSheetDataset GetBalanceSheetView(int year)
+        public async Task<BalanceSheetDataset> GetBalanceSheetViewAsync(int year)
        {
-            var accountList = GetAccountViewList();
+            var accountList = await GetAccountViewListAsync();

            var profit = Math.Abs(accountList.Where(m => m.Class == ClassIds.Income).Sum(m => m.BalanceCHF));
            profit += Math.Abs(accountList.Where(m => m.Class == ClassIds.Activa).Sum(m => fxConverter.ConvertToChf(m.StartBalance, m.Currency)));
            var loss = Math.Abs(accountList.Where(m => m.Class == ClassIds.Expenses).Sum(m => m.BalanceCHF));

-            var balanceView = new BalanceSheetDataset(
-                    activaAccountList: accountList.Where(m => m.Class == ClassIds.Activa).ToList(),
-                    incomeAccountList: accountList.Where(m => m.Class == ClassIds.Income).ToList(),
-                    expensesAccountList: accountList.Where(m => m.Class == ClassIds.Expenses).ToList(),
-                    profitCHF: profit,
-                    lossCHF: loss,
-                    year: year
-                );
-
-            return balanceView;
+            return new BalanceSheetDataset(
+                ActivaAccountList: accountList.Where(m => m.Class == ClassIds.Activa).ToList(),
+                IncomeAccountList: accountList.Where(m => m.Class == ClassIds.Income).ToList(),
+                ExpensesAccountList: accountList.Where(m => m.Class == ClassIds.Expenses).ToList(),
+                ProfitCHF: profit,
+                LossCHF: loss,
+                Year: year);
        }

        /// <summary>
        /// Get transaction list with the origin and target account for each transaction
        /// </summary>
-        public List<TransactionDataset> GetTransactionViewList()
+        public async Task<List<TransactionDataset>> GetTransactionViewListAsync()
        {
-            var accountsById = accountRepository.GetAccountList().ToDictionary(a => a.Id);
-            var transactionList = transactionRepository.GetTransactionList();
+            var accountsById = (await accountRepository.GetAccountListAsync()).ToDictionary(a => a.Id);
+            var transactionList = await transactionRepository.GetTransactionListAsync();

            return transactionList.Select(t =>
                    new TransactionDataset(
@ -143,12 +132,13 @@ namespace Schaad.Accounting.Services
        }

        /// <summary>
-        /// Get transaction list with the origin and target account for each transaction
+        /// Get transaction list filtered to a single account, with values sign-flipped
+        /// when the requested account is the origin of an activa booking.
        /// </summary>
-        public List<TransactionDataset> GetTransactionViewList(string accountId)
+        public async Task<List<TransactionDataset>> GetTransactionViewListAsync(string accountId)
        {
-            var accountsById = accountRepository.GetAccountList().ToDictionary(a => a.Id);
-            var transactionList = transactionRepository.GetTransactionList()
+            var accountsById = (await accountRepository.GetAccountListAsync()).ToDictionary(a => a.Id);
+            var transactionList = (await transactionRepository.GetTransactionListAsync())
                .Where(t => t.OriginAccountId == accountId || t.TargetAccountId == accountId);

            return transactionList.Select(t =>
@ -174,10 +164,10 @@ namespace Schaad.Accounting.Services
        /// <summary>
        /// Get booking rules with their account
        /// </summary>
-        public List<BookingRuleDataset> GetBookingRuleViewList()
+        public async Task<List<BookingRuleDataset>> GetBookingRuleViewListAsync()
        {
-            var accountsById = accountRepository.GetAccountList().ToDictionary(a => a.Id);
-            var bookingRules = bookingRuleRepository.GetBookingRuleList();
+            var accountsById = (await accountRepository.GetAccountListAsync()).ToDictionary(a => a.Id);
+            var bookingRules = await bookingRuleRepository.GetBookingRuleListAsync();

            return bookingRules.Select(t =>
                    new BookingRuleDataset(t, accountsById[t.AccountId].Name))
@ -187,28 +177,26 @@ namespace Schaad.Accounting.Services
        /// <summary>
        /// Load open bank transactions
        /// </summary>
-        public List<BankTransaction> GetOpenBankTransactionList()
+        public async Task<List<BankTransaction>> GetOpenBankTransactionListAsync()
        {
-            var transactions = transactionRepository
-                .GetTransactionList()
+            var transactions = (await transactionRepository.GetTransactionListAsync())
                .Where(t => string.IsNullOrEmpty(t.BankTransactionId) == false)
                .Select(t => t.BankTransactionId);

-            var bankTransactions = bankTransactionRepository
-                .GetBankTransactionList()
+            var bankTransactions = (await bankTransactionRepository.GetBankTransactionListAsync())
                .Where(b => b.Ignore == false && transactions.Contains(b.Id) == false)
                .ToList();

            return bankTransactions;
        }

-        public List<Transaction> MatchOpenBankTransactions()
+        public async Task<List<Transaction>> MatchOpenBankTransactionsAsync()
        {
            var newTransactionList = new List<Transaction>();
-            var transactions = transactionRepository.GetTransactionList();
-            var accounts = accountRepository.GetAccountList();
-            var bookingRules = bookingRuleRepository.GetBookingRuleList();
-            var bankTransactions = GetOpenBankTransactionList().OrderBy(t => t.ValueDate).ToList();
+            var transactions = await transactionRepository.GetTransactionListAsync();
+            var accounts = await accountRepository.GetAccountListAsync();
+            var bookingRules = await bookingRuleRepository.GetBookingRuleListAsync();
+            var bankTransactions = (await GetOpenBankTransactionListAsync()).OrderBy(t => t.ValueDate).ToList();
            foreach (var bankTransaction in bankTransactions)
            {
                var trx = new Transaction(bankTransaction, accounts);
@ -220,14 +208,15 @@ namespace Schaad.Accounting.Services

            var matched = newTransactionList.Count(t => string.IsNullOrEmpty(t.Text) == false);
            logger.LogInformation("Matched {Matched} of {Total} open bank transactions", matched, bankTransactions.Count);
+
            return newTransactionList;
        }

-        public List<Transaction> MatchCreditCardTransactions(string bankTransactionId, IReadOnlyList<CreditCardTransaction> creditCardTransactions)
+        public async Task<List<Transaction>> MatchCreditCardTransactionsAsync(string bankTransactionId, IReadOnlyList<CreditCardTransaction> creditCardTransactions)
        {
-            var accounts = accountRepository.GetAccountList();
-            var bankTrx = bankTransactionRepository.GetBankTransaction(bankTransactionId);
-            var bookingRules = bookingRuleRepository.GetBookingRuleList();
+            var accounts = await accountRepository.GetAccountListAsync();
+            var bankTrx = await bankTransactionRepository.GetBankTransactionAsync(bankTransactionId);
+            var bookingRules = await bookingRuleRepository.GetBookingRuleListAsync();

            var trxList = new List<Transaction>();
            foreach (var creditCardTransaction in creditCardTransactions)
@ -355,4 +344,4 @@ namespace Schaad.Accounting.Services
            }
        }
    }
-}
+}
--- a/Schaad.Accounting.Tests/AccountRepositoryTestShould.cs
+++ b/Schaad.Accounting.Tests/AccountRepositoryTestShould.cs
@ -34,79 +34,79 @@ public class AccountRepositoryTestShould : IDisposable
    }

    [Fact]
-    public void AssignNewIdWhenSavingAccountWithoutId()
+    public async Task AssignNewIdWhenSavingAccountWithoutId()
    {
        var account = new Account { Number = 1000, Name = "Cash", Currency = "CHF" };

-        sut.SaveAccount(account);
+        await sut.SaveAccountAsync(account);

-        var stored = sut.GetAccountList().Single();
+        var stored = (await sut.GetAccountListAsync()).Single();
        stored.Id.ShouldNotBeNullOrEmpty();
        stored.Name.ShouldBe("Cash");
    }

    [Fact]
-    public void UpdateInPlaceWhenSavingAccountWithExistingId()
+    public async Task UpdateInPlaceWhenSavingAccountWithExistingId()
    {
-        sut.SaveAccount(new Account { Number = 1000, Name = "Cash", Currency = "CHF" });
-        var id = sut.GetAccountList().Single().Id;
+        await sut.SaveAccountAsync(new Account { Number = 1000, Name = "Cash", Currency = "CHF" });
+        var id = (await sut.GetAccountListAsync()).Single().Id;

-        sut.SaveAccount(new Account { Id = id, Number = 1000, Name = "Cash renamed", Currency = "CHF" });
+        await sut.SaveAccountAsync(new Account { Id = id, Number = 1000, Name = "Cash renamed", Currency = "CHF" });

-        var accounts = sut.GetAccountList();
+        var accounts = await sut.GetAccountListAsync();
        accounts.Count.ShouldBe(1);
        accounts[0].Name.ShouldBe("Cash renamed");
    }

    [Fact]
-    public void DefaultCurrencyToChfWhenSavingAccountWithoutCurrency()
+    public async Task DefaultCurrencyToChfWhenSavingAccountWithoutCurrency()
    {
-        sut.SaveAccount(new Account { Number = 1000, Name = "Cash", Currency = null! });
+        await sut.SaveAccountAsync(new Account { Number = 1000, Name = "Cash", Currency = null! });

-        sut.GetAccountList().Single().Currency.ShouldBe("CHF");
+        (await sut.GetAccountListAsync()).Single().Currency.ShouldBe("CHF");
    }

    [Fact]
-    public void RemoveAccountWhenDeletingById()
+    public async Task RemoveAccountWhenDeletingById()
    {
-        sut.SaveAccount(new Account { Number = 1000, Name = "Cash", Currency = "CHF" });
-        var id = sut.GetAccountList().Single().Id;
+        await sut.SaveAccountAsync(new Account { Number = 1000, Name = "Cash", Currency = "CHF" });
+        var id = (await sut.GetAccountListAsync()).Single().Id;

-        sut.DeleteAccount(id);
+        await sut.DeleteAccountAsync(id);

-        sut.GetAccountList().ShouldBeEmpty();
+        (await sut.GetAccountListAsync()).ShouldBeEmpty();
    }

    [Fact]
-    public void ReturnAccountWhenLookingUpByBankAccountNumber()
+    public async Task ReturnAccountWhenLookingUpByBankAccountNumber()
    {
-        sut.SaveAccount(new Account { Number = 1010, Name = "Checking", Currency = "CHF", BankAccountNumber = "CH01" });
-        sut.SaveAccount(new Account { Number = 1020, Name = "Savings", Currency = "CHF", BankAccountNumber = "CH02" });
+        await sut.SaveAccountAsync(new Account { Number = 1010, Name = "Checking", Currency = "CHF", BankAccountNumber = "CH01" });
+        await sut.SaveAccountAsync(new Account { Number = 1020, Name = "Savings", Currency = "CHF", BankAccountNumber = "CH02" });

-        sut.GetAccountForBankAccountNumber("CH01").Name.ShouldBe("Checking");
-        sut.GetAccountForBankAccountNumber("CH02").Name.ShouldBe("Savings");
-        sut.GetAccountForBankAccountNumber("CH99").ShouldBeNull();
+        (await sut.GetAccountForBankAccountNumberAsync("CH01")).Name.ShouldBe("Checking");
+        (await sut.GetAccountForBankAccountNumberAsync("CH02")).Name.ShouldBe("Savings");
+        (await sut.GetAccountForBankAccountNumberAsync("CH99")).ShouldBeNull();
    }

    [Fact]
-    public void UpdateLastBankBalanceWhenSavingBankBalance()
+    public async Task UpdateLastBankBalanceWhenSavingBankBalance()
    {
-        sut.SaveAccount(new Account { Number = 1010, Name = "Checking", Currency = "CHF", BankAccountNumber = "CH01" });
+        await sut.SaveAccountAsync(new Account { Number = 1010, Name = "Checking", Currency = "CHF", BankAccountNumber = "CH01" });

-        sut.SaveBankAccountBalance("CH01", 1234.56m);
+        await sut.SaveBankAccountBalanceAsync("CH01", 1234.56m);

-        sut.GetAccountForBankAccountNumber("CH01").LastBankBalance.ShouldBe(1234.56m);
+        (await sut.GetAccountForBankAccountNumberAsync("CH01")).LastBankBalance.ShouldBe(1234.56m);
    }

    [Fact]
-    public void SurviveConstructorReRunWhenAccountsFileAlreadyExists()
+    public async Task SurviveConstructorReRunWhenAccountsFileAlreadyExists()
    {
-        sut.SaveAccount(new Account { Number = 1000, Name = "Cash", Currency = "CHF" });
+        await sut.SaveAccountAsync(new Account { Number = 1000, Name = "Cash", Currency = "CHF" });

        // Re-construct with the same directory: existing file, no year rollover, no data loss.
        var fresh = new AccountRepository(settingsService, new RepositoryCache(), NullLogger<AccountRepository>.Instance);

-        var accounts = fresh.GetAccountList();
+        var accounts = await fresh.GetAccountListAsync();
        accounts.Count.ShouldBe(1);
        accounts[0].Name.ShouldBe("Cash");
    }
--- a/Schaad.Accounting.Tests/ChartServiceTestShould.cs
+++ b/Schaad.Accounting.Tests/ChartServiceTestShould.cs
@ -20,18 +20,18 @@ public class ChartServiceTestShould
    private ChartService BuildService() => new(settingsService, viewService);

    [Fact]
-    public void HonourSelectedYearWhenBuildingMonthlySeries()
+    public async Task HonourSelectedYearWhenBuildingMonthlySeries()
    {
        settingsService.GetYear().Returns(2023);
        var groceries = MakeAccount("groc", 4200);
        var checking = MakeAccount("chk", 1010);
-        viewService.GetAccountViewList().Returns(new List<AccountDataset> { AsDataset(groceries), AsDataset(checking) });
-        viewService.GetTransactionViewList().Returns(new List<TransactionDataset>
+        viewService.GetAccountViewListAsync().Returns(new List<AccountDataset> { AsDataset(groceries), AsDataset(checking) });
+        viewService.GetTransactionViewListAsync().Returns(new List<TransactionDataset>
        {
            MakeTransaction(checking, groceries, value: 50m, valueDate: new DateTime(2023, 4, 5))
        });

-        var series = BuildService().GetExpensesPerMonth();
+        var series = await BuildService().GetExpensesPerMonthAsync();

        series.Count.ShouldBe(1);
        series[0].X.ShouldAllBe(x => ((DateOnly)x).Year == 2023);
@ -40,22 +40,22 @@ public class ChartServiceTestShould
    }

    [Fact]
-    public void GroupExpensesByAccountWhenAllExpensesShareOneSubClass()
+    public async Task GroupExpensesByAccountWhenAllExpensesShareOneSubClass()
    {
-        var mannenbach = MakeAccount("m1", 4000);       // SubClass 40
-        var mannenbach2 = MakeAccount("m2", 4001);      // SubClass 40 (same)
+        var mannenbach = MakeAccount("m1", 4000);
+        var mannenbach2 = MakeAccount("m2", 4001);
        var checking = MakeAccount("chk", 1010);
-        viewService.GetAccountViewList().Returns(new List<AccountDataset>
+        viewService.GetAccountViewListAsync().Returns(new List<AccountDataset>
        {
            AsDataset(mannenbach), AsDataset(mannenbach2), AsDataset(checking)
        });
-        viewService.GetTransactionViewList().Returns(new List<TransactionDataset>
+        viewService.GetTransactionViewListAsync().Returns(new List<TransactionDataset>
        {
            MakeTransaction(checking, mannenbach, value: 10m, valueDate: new DateTime(2026, 1, 1)),
            MakeTransaction(checking, mannenbach2, value: 20m, valueDate: new DateTime(2026, 1, 1))
        });

-        var series = BuildService().GetExpensesPerMonth();
+        var series = await BuildService().GetExpensesPerMonthAsync();

        series.Count.ShouldBe(2);
        series.ShouldContain(s => s.Id == "m1");
@ -63,44 +63,44 @@ public class ChartServiceTestShould
    }

    [Fact]
-    public void GroupExpensesBySubClassWhenMultipleSubClassesAreUsed()
+    public async Task GroupExpensesBySubClassWhenMultipleSubClassesAreUsed()
    {
-        var groceries = MakeAccount("groc", 4200);      // SubClass 42
-        var utilities = MakeAccount("util", 4300);      // SubClass 43
+        var groceries = MakeAccount("groc", 4200);
+        var utilities = MakeAccount("util", 4300);
        var checking = MakeAccount("chk", 1010);
-        viewService.GetAccountViewList().Returns(new List<AccountDataset>
+        viewService.GetAccountViewListAsync().Returns(new List<AccountDataset>
        {
            AsDataset(groceries), AsDataset(utilities), AsDataset(checking)
        });
-        viewService.GetTransactionViewList().Returns(new List<TransactionDataset>
+        viewService.GetTransactionViewListAsync().Returns(new List<TransactionDataset>
        {
            MakeTransaction(checking, groceries, value: 50m, valueDate: new DateTime(2026, 1, 1)),
            MakeTransaction(checking, utilities, value: 30m, valueDate: new DateTime(2026, 2, 1))
        });

-        var series = BuildService().GetExpensesPerMonth();
+        var series = await BuildService().GetExpensesPerMonthAsync();

        series.Count.ShouldBe(2);
-        series.ShouldContain(s => s.Id == "42"); // sub-class number as id
+        series.ShouldContain(s => s.Id == "42");
        series.ShouldContain(s => s.Id == "43");
    }

    [Fact]
-    public void SkipAccountsWithoutTransactionsWhenBuildingSeries()
+    public async Task SkipAccountsWithoutTransactionsWhenBuildingSeries()
    {
-        var groceries = MakeAccount("groc", 4000);      // has activity
-        var utilities = MakeAccount("util", 4001);      // same subclass, no activity
+        var groceries = MakeAccount("groc", 4000);
+        var utilities = MakeAccount("util", 4001);
        var checking = MakeAccount("chk", 1010);
-        viewService.GetAccountViewList().Returns(new List<AccountDataset>
+        viewService.GetAccountViewListAsync().Returns(new List<AccountDataset>
        {
            AsDataset(groceries), AsDataset(utilities), AsDataset(checking)
        });
-        viewService.GetTransactionViewList().Returns(new List<TransactionDataset>
+        viewService.GetTransactionViewListAsync().Returns(new List<TransactionDataset>
        {
            MakeTransaction(checking, groceries, value: 50m, valueDate: new DateTime(2026, 1, 1))
        });

-        var series = BuildService().GetExpensesPerMonth();
+        var series = await BuildService().GetExpensesPerMonthAsync();

        series.Count.ShouldBe(1);
        series[0].Id.ShouldBe("groc");
--- a/Schaad.Accounting.Tests/FileServiceTestShould.cs
+++ b/Schaad.Accounting.Tests/FileServiceTestShould.cs
@ -20,8 +20,6 @@ public class FileServiceTestShould

    public FileServiceTestShould()
    {
-        // Registering the ISO-8859-1 code page provider so the CSV encoding call works
-        // in the test host (which does not include legacy encodings by default).
        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
    }

@ -30,13 +28,11 @@ public class FileServiceTestShould
        accountStatementService, creditCardStatementService, NullLogger<FileService>.Instance);

    [Fact]
-    public void EmitHeaderRowAndRunningBalanceWhenExportingTransactionsCsv()
+    public async Task EmitHeaderRowAndRunningBalanceWhenExportingTransactionsCsv()
    {
        var checking = new Account { Id = "chk", Number = 1010, Name = "Checking", Currency = "CHF", StartBalance = 1000m };
-        var groceries = new Account { Id = "groc", Number = 4200, Name = "Groceries", Currency = "CHF" };
-        var salary = new Account { Id = "sal", Number = 3000, Name = "Salary", Currency = "CHF" };
-        accountRepo.GetAccount("chk").Returns(checking);
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>
+        accountRepo.GetAccountAsync("chk").Returns(checking);
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>
        {
            new()
            {
@ -50,26 +46,23 @@ public class FileServiceTestShould
            }
        });

-        var bytes = BuildService().GetTransactionListCsv("chk");
+        var bytes = await BuildService().GetTransactionListCsvAsync("chk");
        var csv = Encoding.GetEncoding("ISO-8859-1").GetString(bytes);
        var lines = csv.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

        lines[0].ShouldBe("Buchungsdatum;Valuta;Buchungstext;Belastung;Gutschrift;Saldo CHF");
        lines[1].ShouldBe(";;Startsaldo;;;1000");
-        // Debit line (outgoing) — value in Belastung column, balance drops
        lines[2].ShouldBe("05.01.2026;05.01.2026;Coop;50.00;;950.00");
-        // Credit line (incoming) — value in Gutschrift column, balance rises
        lines[3].ShouldBe("25.01.2026;25.01.2026;Salary;;5'000.00;5'950.00");
    }

    [Fact]
-    public void OrderTransactionsByBookingDateThenValueDateThenValueWhenExporting()
+    public async Task OrderTransactionsByBookingDateThenValueDateThenValueWhenExporting()
    {
        var checking = new Account { Id = "chk", Number = 1010, Name = "Checking", Currency = "CHF", StartBalance = 0m };
-        accountRepo.GetAccount("chk").Returns(checking);
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>
+        accountRepo.GetAccountAsync("chk").Returns(checking);
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>
        {
-            // Deliberately unordered
            new() { OriginAccountId = "chk", TargetAccountId = "x", Value = 10m, Text = "later",
                    BookingDate = new DateTime(2026, 2, 1), ValueDate = new DateTime(2026, 2, 1) },
            new() { OriginAccountId = "chk", TargetAccountId = "x", Value = 5m, Text = "earlier small",
@ -78,30 +71,28 @@ public class FileServiceTestShould
                    BookingDate = new DateTime(2026, 1, 15), ValueDate = new DateTime(2026, 1, 15) }
        });

-        var csv = Encoding.GetEncoding("ISO-8859-1").GetString(BuildService().GetTransactionListCsv("chk"));
+        var csv = Encoding.GetEncoding("ISO-8859-1").GetString(await BuildService().GetTransactionListCsvAsync("chk"));
        var lines = csv.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);

-        // Skip header + start balance rows
        lines[2].ShouldContain("earlier small");
        lines[3].ShouldContain("earlier large");
        lines[4].ShouldContain("later");
    }

    [Fact]
-    public void NotMutateTransactionValueWhenExportingCsv()
+    public async Task NotMutateTransactionValueWhenExportingCsv()
    {
        var checking = new Account { Id = "chk", Number = 1010, Name = "Checking", Currency = "CHF" };
-        accountRepo.GetAccount("chk").Returns(checking);
+        accountRepo.GetAccountAsync("chk").Returns(checking);
        var outgoing = new Transaction
        {
            OriginAccountId = "chk", TargetAccountId = "x", Value = 42m, Text = "test",
            BookingDate = new DateTime(2026, 1, 1), ValueDate = new DateTime(2026, 1, 1)
        };
-        transactionRepo.GetTransactionList().Returns(new List<Transaction> { outgoing });
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction> { outgoing });

-        BuildService().GetTransactionListCsv("chk");
+        await BuildService().GetTransactionListCsvAsync("chk");

-        // Regression: earlier code did `trx.Value *= -1` mid-loop.
        outgoing.Value.ShouldBe(42m);
    }
 }
--- a/Schaad.Accounting.Tests/RepositoryCacheTestShould.cs
+++ b/Schaad.Accounting.Tests/RepositoryCacheTestShould.cs
@ -6,13 +6,13 @@ namespace Schaad.Accounting.Tests;
 public class RepositoryCacheTestShould
 {
    [Fact]
-    public void CallLoaderOnceWhenKeyIsRequestedRepeatedly()
+    public async Task CallLoaderOnceWhenKeyIsRequestedRepeatedly()
    {
        var cache = new RepositoryCache();
        var loaderCalls = 0;

-        var first = cache.GetOrLoad("key", () => { loaderCalls++; return new List<int> { 1, 2 }; });
-        var second = cache.GetOrLoad("key", () => { loaderCalls++; return new List<int> { 99 }; });
+        var first = await cache.GetOrLoadAsync("key", () => { loaderCalls++; return Task.FromResult(new List<int> { 1, 2 }); });
+        var second = await cache.GetOrLoadAsync("key", () => { loaderCalls++; return Task.FromResult(new List<int> { 99 }); });

        loaderCalls.ShouldBe(1);
        second.ShouldBeSameAs(first);
@ -20,12 +20,12 @@ public class RepositoryCacheTestShould
    }

    [Fact]
-    public void KeepEntriesSeparateWhenKeysDiffer()
+    public async Task KeepEntriesSeparateWhenKeysDiffer()
    {
        var cache = new RepositoryCache();

-        var a = cache.GetOrLoad("a", () => new List<int> { 1 });
-        var b = cache.GetOrLoad("b", () => new List<int> { 2 });
+        var a = await cache.GetOrLoadAsync("a", () => Task.FromResult(new List<int> { 1 }));
+        var b = await cache.GetOrLoadAsync("b", () => Task.FromResult(new List<int> { 2 }));

        b.ShouldNotBeSameAs(a);
        a.ShouldBe(new[] { 1 });
@ -33,25 +33,25 @@ public class RepositoryCacheTestShould
    }

    [Fact]
-    public void ReloadFromLoaderWhenKeyIsInvalidated()
+    public async Task ReloadFromLoaderWhenKeyIsInvalidated()
    {
        var cache = new RepositoryCache();
        var loaderCalls = 0;

-        cache.GetOrLoad("k", () => { loaderCalls++; return new List<int> { 1 }; });
+        await cache.GetOrLoadAsync("k", () => { loaderCalls++; return Task.FromResult(new List<int> { 1 }); });
        cache.Invalidate("k");
-        cache.GetOrLoad("k", () => { loaderCalls++; return new List<int> { 2 }; });
+        await cache.GetOrLoadAsync("k", () => { loaderCalls++; return Task.FromResult(new List<int> { 2 }); });

        loaderCalls.ShouldBe(2);
    }

    [Fact]
-    public void MatchKeysCaseInsensitivelyWhenLookingUp()
+    public async Task MatchKeysCaseInsensitivelyWhenLookingUp()
    {
        var cache = new RepositoryCache();

-        cache.GetOrLoad("Path/To/File.xml", () => new List<int> { 1 });
-        var upper = cache.GetOrLoad("PATH/TO/FILE.XML", () => new List<int> { 99 });
+        await cache.GetOrLoadAsync("Path/To/File.xml", () => Task.FromResult(new List<int> { 1 }));
+        var upper = await cache.GetOrLoadAsync("PATH/TO/FILE.XML", () => Task.FromResult(new List<int> { 99 }));

        upper.ShouldBe(new[] { 1 });
    }
--- a/Schaad.Accounting.Tests/TransactionRepositoryTestShould.cs
+++ b/Schaad.Accounting.Tests/TransactionRepositoryTestShould.cs
@ -38,12 +38,12 @@ public class TransactionRepositoryTestShould : IDisposable
    }

    [Fact]
-    public void PreserveValueWhenRoundTrippingNonFxTransaction()
+    public async Task PreserveValueWhenRoundTrippingNonFxTransaction()
    {
-        accountRepo.GetAccount("chk").Returns(new Account { Id = "chk", Currency = "CHF" });
-        accountRepo.GetAccount("groc").Returns(new Account { Id = "groc", Currency = "CHF" });
+        accountRepo.GetAccountAsync("chk").Returns(new Account { Id = "chk", Currency = "CHF" });
+        accountRepo.GetAccountAsync("groc").Returns(new Account { Id = "groc", Currency = "CHF" });

-        sut.SaveTransaction(new Transaction
+        await sut.SaveTransactionAsync(new Transaction
        {
            OriginAccountId = "chk",
            TargetAccountId = "groc",
@ -53,22 +53,21 @@ public class TransactionRepositoryTestShould : IDisposable
            BookingDate = new DateTime(2026, 5, 10)
        });

-        var stored = sut.GetTransactionList().Single();
-        var loaded = sut.GetTransaction(stored.Id);
+        var stored = (await sut.GetTransactionListAsync()).Single();
+        var loaded = await sut.GetTransactionAsync(stored.Id);

        loaded.ShouldNotBeNull();
        loaded.Value.ShouldBe(42m);
-        loaded.FxRate.ShouldBeNull(); // Non-FX transactions have FxRate cleared
+        loaded.FxRate.ShouldBeNull();
    }

    [Fact]
-    public void StoreInChfAndReturnInAccountCurrencyWhenTransactionIsFx()
+    public async Task StoreInChfAndReturnInAccountCurrencyWhenTransactionIsFx()
    {
-        // User enters 100 USD at rate 0.9 CHF/USD -> stored as 90 CHF; read back as 100 USD.
-        accountRepo.GetAccount("chk").Returns(new Account { Id = "chk", Currency = "CHF" });
-        accountRepo.GetAccount("usd").Returns(new Account { Id = "usd", Currency = "USD" });
+        accountRepo.GetAccountAsync("chk").Returns(new Account { Id = "chk", Currency = "CHF" });
+        accountRepo.GetAccountAsync("usd").Returns(new Account { Id = "usd", Currency = "USD" });

-        sut.SaveTransaction(new Transaction
+        await sut.SaveTransactionAsync(new Transaction
        {
            OriginAccountId = "chk",
            TargetAccountId = "usd",
@ -79,28 +78,28 @@ public class TransactionRepositoryTestShould : IDisposable
            BookingDate = new DateTime(2026, 5, 10)
        });

-        var stored = sut.GetTransactionList().Single();
-        stored.Value.ShouldBe(90m); // stored in CHF
+        var stored = (await sut.GetTransactionListAsync()).Single();
+        stored.Value.ShouldBe(90m);

-        var loaded = sut.GetTransaction(stored.Id);
+        var loaded = await sut.GetTransactionAsync(stored.Id);
        loaded.ShouldNotBeNull();
-        loaded.Value.ShouldBe(100m); // display currency
+        loaded.Value.ShouldBe(100m);
        loaded.FxRate.ShouldBe(0.9m);
    }

    [Fact]
-    public void ReturnNullWhenGettingUnknownTransactionId()
+    public async Task ReturnNullWhenGettingUnknownTransactionId()
    {
-        sut.GetTransaction("no-such-id").ShouldBeNull();
+        (await sut.GetTransactionAsync("no-such-id")).ShouldBeNull();
    }

    [Fact]
-    public void NotMutateStoredValueWhenGettingFxTransactionTwice()
+    public async Task NotMutateStoredValueWhenGettingFxTransactionTwice()
    {
-        accountRepo.GetAccount("chk").Returns(new Account { Id = "chk", Currency = "CHF" });
-        accountRepo.GetAccount("usd").Returns(new Account { Id = "usd", Currency = "USD" });
+        accountRepo.GetAccountAsync("chk").Returns(new Account { Id = "chk", Currency = "CHF" });
+        accountRepo.GetAccountAsync("usd").Returns(new Account { Id = "usd", Currency = "USD" });

-        sut.SaveTransaction(new Transaction
+        await sut.SaveTransactionAsync(new Transaction
        {
            OriginAccountId = "chk",
            TargetAccountId = "usd",
@ -111,12 +110,11 @@ public class TransactionRepositoryTestShould : IDisposable
            BookingDate = new DateTime(2026, 5, 10)
        });

-        var stored = sut.GetTransactionList().Single();
+        var stored = (await sut.GetTransactionListAsync()).Single();
        var id = stored.Id;

-        // Get twice; if Get mutated the stored entity, the second call would divide by FxRate again.
-        var first = sut.GetTransaction(id);
-        var second = sut.GetTransaction(id);
+        var first = await sut.GetTransactionAsync(id);
+        var second = await sut.GetTransactionAsync(id);

        first.ShouldNotBeNull();
        first.Value.ShouldBe(100m);
@ -125,24 +123,24 @@ public class TransactionRepositoryTestShould : IDisposable
    }

    [Fact]
-    public void RemoveTransactionWhenDeletingById()
+    public async Task RemoveTransactionWhenDeletingById()
    {
-        accountRepo.GetAccount(Arg.Any<string>()).Returns(new Account { Currency = "CHF" });
+        accountRepo.GetAccountAsync(Arg.Any<string>()).Returns(new Account { Currency = "CHF" });

-        sut.SaveTransaction(new Transaction { OriginAccountId = "a", TargetAccountId = "b", Value = 1m, Text = "x", ValueDate = DateTime.Today });
-        var id = sut.GetTransactionList().Single().Id;
+        await sut.SaveTransactionAsync(new Transaction { OriginAccountId = "a", TargetAccountId = "b", Value = 1m, Text = "x", ValueDate = DateTime.Today });
+        var id = (await sut.GetTransactionListAsync()).Single().Id;

-        sut.DeleteTransaction(id);
+        await sut.DeleteTransactionAsync(id);

-        sut.GetTransactionList().ShouldBeEmpty();
+        (await sut.GetTransactionListAsync()).ShouldBeEmpty();
    }

    [Fact]
-    public void PreserveRelatedPartyWhenRoundTrippingTransaction()
+    public async Task PreserveRelatedPartyWhenRoundTrippingTransaction()
    {
-        accountRepo.GetAccount(Arg.Any<string>()).Returns(new Account { Currency = "CHF" });
+        accountRepo.GetAccountAsync(Arg.Any<string>()).Returns(new Account { Currency = "CHF" });

-        sut.SaveTransaction(new Transaction
+        await sut.SaveTransactionAsync(new Transaction
        {
            OriginAccountId = "a",
            TargetAccountId = "b",
@ -153,26 +151,23 @@ public class TransactionRepositoryTestShould : IDisposable
            BookingDate = new DateTime(2026, 4, 1)
        });

-        // Regression: earlier Transaction.Copy dropped RelatedParty on every save,
-        // so the round-trip lost it.
-        sut.GetTransactionList().Single().RelatedParty.ShouldBe("ACME Property AG");
+        (await sut.GetTransactionListAsync()).Single().RelatedParty.ShouldBe("ACME Property AG");
    }

    [Fact]
-    public void DefaultBookingDateToValueDateWhenBookingDateIsUnset()
+    public async Task DefaultBookingDateToValueDateWhenBookingDateIsUnset()
    {
-        accountRepo.GetAccount(Arg.Any<string>()).Returns(new Account { Currency = "CHF" });
+        accountRepo.GetAccountAsync(Arg.Any<string>()).Returns(new Account { Currency = "CHF" });

-        sut.SaveTransaction(new Transaction
+        await sut.SaveTransactionAsync(new Transaction
        {
            OriginAccountId = "a",
            TargetAccountId = "b",
            Value = 10m,
            Text = "x",
            ValueDate = new DateTime(2026, 4, 15)
-            // BookingDate left at default (DateTime.MinValue)
        });

-        sut.GetTransactionList().Single().BookingDate.ShouldBe(new DateTime(2026, 4, 15));
+        (await sut.GetTransactionListAsync()).Single().BookingDate.ShouldBe(new DateTime(2026, 4, 15));
    }
 }
--- a/Schaad.Accounting.Tests/ViewServiceTestShould.cs
+++ b/Schaad.Accounting.Tests/ViewServiceTestShould.cs
@ -18,12 +18,10 @@ public class ViewServiceTestShould

    public ViewServiceTestShould()
    {
-        // Cover every subclass number a test might reference (Account.SubClass = Number / 100).
-        subclassRepo.GetSubClassList().Returns(
+        subclassRepo.GetSubClassListAsync().Returns(
            Enumerable.Range(10, 50).Select(n => new SubClass { Number = n, Name = "sub-" + n }).ToList());
        subclassRepo.GetClass(Arg.Any<int>()).Returns("");

-        // Passthrough FX by default (CHF-only). Individual tests can override.
        fxConverter.ConvertToChf(Arg.Any<decimal>(), Arg.Any<string>())
            .Returns(ci => ci.ArgAt<decimal>(0));
    }
@ -34,16 +32,16 @@ public class ViewServiceTestShould
    // --- Balance math ---------------------------------------------------------

    [Fact]
-    public void SumActivaAndPassivaTotalsSeparatelyWhenGettingBalanceView()
+    public async Task SumActivaAndPassivaTotalsSeparatelyWhenGettingBalanceView()
    {
        var cash = Account("cash", 1000, "CHF", startBalance: 100m);
        var receivables = Account("recv", 1100, "CHF", startBalance: 50m);
        var payables = Account("pay", 2000, "CHF", startBalance: -200m);

-        accountRepo.GetAccountList().Returns(new List<Account> { cash, receivables, payables });
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>());
+        accountRepo.GetAccountListAsync().Returns(new List<Account> { cash, receivables, payables });
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>());

-        var view = BuildService().GetBalanceView();
+        var view = await BuildService().GetBalanceViewAsync();

        view.ActivaAccountList.Count.ShouldBe(2);
        view.PassivaAccountList.Count.ShouldBe(1);
@ -52,109 +50,105 @@ public class ViewServiceTestShould
    }

    [Fact]
-    public void ApplyTransactionsToStartBalanceWhenComputingAccountBalance()
+    public async Task ApplyTransactionsToStartBalanceWhenComputingAccountBalance()
    {
        var cash = Account("cash", 1000, "CHF", startBalance: 1000m);
        var groceries = Account("groc", 4000, "CHF");
-        accountRepo.GetAccountList().Returns(new List<Account> { cash, groceries });
+        accountRepo.GetAccountListAsync().Returns(new List<Account> { cash, groceries });

-        // Debit cash 50, credit groceries 50 (spending)
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>
        {
            new() { Id = "t1", OriginAccountId = "cash", TargetAccountId = "groc", Value = 50m, ValueDate = new DateTime(2026, 1, 1) },
            new() { Id = "t2", OriginAccountId = "cash", TargetAccountId = "groc", Value = 30m, ValueDate = new DateTime(2026, 1, 2) },
        });

-        var accounts = BuildService().GetAccountViewList();
+        var accounts = await BuildService().GetAccountViewListAsync();

-        accounts.Single(a => a.Id == "cash").Balance.ShouldBe(920m); // 1000 - 80
+        accounts.Single(a => a.Id == "cash").Balance.ShouldBe(920m);
        accounts.Single(a => a.Id == "groc").Balance.ShouldBe(80m);
    }

    [Fact]
-    public void ConvertBalanceToChfWhenAccountUsesForeignCurrency()
+    public async Task ConvertBalanceToChfWhenAccountUsesForeignCurrency()
    {
        var usd = Account("usd", 1050, "USD", startBalance: 100m);
-        accountRepo.GetAccountList().Returns(new List<Account> { usd });
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>());
+        accountRepo.GetAccountListAsync().Returns(new List<Account> { usd });
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>());

-        // 1 USD = 0.90 CHF
        fxConverter.ConvertToChf(Arg.Any<decimal>(), "USD")
            .Returns(ci => ci.ArgAt<decimal>(0) * 0.9m);

-        var account = BuildService().GetAccountViewList().Single();
+        var account = (await BuildService().GetAccountViewListAsync()).Single();

-        account.Balance.ShouldBe(100m);         // account currency
-        account.BalanceCHF.ShouldBe(90m);       // FX-converted
+        account.Balance.ShouldBe(100m);
+        account.BalanceCHF.ShouldBe(90m);
        account.StartBalanceCHF.ShouldBe(90m);
    }

    // --- Bank-transaction auto-matching --------------------------------------

    [Fact]
-    public void MatchBankTransactionByBookingRuleWhenLookupTextIsContained()
+    public async Task MatchBankTransactionByBookingRuleWhenLookupTextIsContained()
    {
        var checking = Account("chk", 1010, "CHF", bankAccountNumber: "CH01");
        var utilities = Account("util", 4200, "CHF");
-        accountRepo.GetAccountList().Returns(new List<Account> { checking, utilities });
-        bookingRuleRepo.GetBookingRuleList().Returns(new List<BookingRule>
+        accountRepo.GetAccountListAsync().Returns(new List<Account> { checking, utilities });
+        bookingRuleRepo.GetBookingRuleListAsync().Returns(new List<BookingRule>
        {
            new() { Id = "r1", LookupText = "electric", AccountId = "util", BookingText = "Strom" }
        });
-        bankTransactionRepo.GetBankTransactionList().Returns(new List<BankTransaction>
+        bankTransactionRepo.GetBankTransactionListAsync().Returns(new List<BankTransaction>
        {
            new() { Id = "b1", Text = "Monthly Electric Bill", Value = -85m, BankAccountNumber = "CH01",
                    ValueDate = new DateTime(2026, 3, 5), BookingDate = new DateTime(2026, 3, 5) }
        });
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>());
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>());

-        var matched = BuildService().MatchOpenBankTransactions().Single();
+        var matched = (await BuildService().MatchOpenBankTransactionsAsync()).Single();

        matched.Text.ShouldBe("Strom");
-        // negative value => bank account is origin; rule fills the target
        matched.OriginAccountId.ShouldBe("chk");
        matched.TargetAccountId.ShouldBe("util");
    }

    [Fact]
-    public void PreferBookingRuleWithMatchingValueWhenMultipleRulesMatchText()
+    public async Task PreferBookingRuleWithMatchingValueWhenMultipleRulesMatchText()
    {
        var checking = Account("chk", 1010, "CHF", bankAccountNumber: "CH01");
        var rent = Account("rent", 4100, "CHF");
        var groceries = Account("groc", 4200, "CHF");
-        accountRepo.GetAccountList().Returns(new List<Account> { checking, rent, groceries });
-        bookingRuleRepo.GetBookingRuleList().Returns(new List<BookingRule>
+        accountRepo.GetAccountListAsync().Returns(new List<Account> { checking, rent, groceries });
+        bookingRuleRepo.GetBookingRuleListAsync().Returns(new List<BookingRule>
        {
            new() { Id = "r1", LookupText = "coop", LookupValue = 0m, AccountId = "groc", BookingText = "Groceries" },
            new() { Id = "r2", LookupText = "coop", LookupValue = 1200m, AccountId = "rent", BookingText = "Rent via Coop" }
        });
-        bankTransactionRepo.GetBankTransactionList().Returns(new List<BankTransaction>
+        bankTransactionRepo.GetBankTransactionListAsync().Returns(new List<BankTransaction>
        {
            new() { Id = "b1", Text = "COOP payment", Value = -1200m, BankAccountNumber = "CH01",
                    ValueDate = new DateTime(2026, 3, 1), BookingDate = new DateTime(2026, 3, 1) }
        });
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>());
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>());

-        var matched = BuildService().MatchOpenBankTransactions().Single();
+        var matched = (await BuildService().MatchOpenBankTransactionsAsync()).Single();

        matched.Text.ShouldBe("Rent via Coop");
        matched.TargetAccountId.ShouldBe("rent");
    }

    [Fact]
-    public void FallBackToSameAccountsLastMonthWhenNoBookingRuleMatches()
+    public async Task FallBackToSameAccountsLastMonthWhenNoBookingRuleMatches()
    {
        var checking = Account("chk", 1010, "CHF", bankAccountNumber: "CH01");
        var salary = Account("sal", 3000, "CHF");
-        accountRepo.GetAccountList().Returns(new List<Account> { checking, salary });
-        bookingRuleRepo.GetBookingRuleList().Returns(new List<BookingRule>());
-        bankTransactionRepo.GetBankTransactionList().Returns(new List<BankTransaction>
+        accountRepo.GetAccountListAsync().Returns(new List<Account> { checking, salary });
+        bookingRuleRepo.GetBookingRuleListAsync().Returns(new List<BookingRule>());
+        bankTransactionRepo.GetBankTransactionListAsync().Returns(new List<BankTransaction>
        {
            new() { Id = "b2", Text = "Salary Feb", Value = 5000m, BankAccountNumber = "CH01",
                    ValueDate = new DateTime(2026, 2, 25), BookingDate = new DateTime(2026, 2, 25) }
        });
-        // A prior-month booking with same accounts + value should be picked up
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>
        {
            new()
            {
@ -168,33 +162,31 @@ public class ViewServiceTestShould
            }
        });

-        var matched = BuildService().MatchOpenBankTransactions().Single();
+        var matched = (await BuildService().MatchOpenBankTransactionsAsync()).Single();

        matched.Text.ShouldBe("Monatslohn");
    }

    [Fact]
-    public void ExcludeIgnoredAndAlreadyBookedWhenGettingOpenBankTransactions()
+    public async Task ExcludeIgnoredAndAlreadyBookedWhenGettingOpenBankTransactions()
    {
-        bankTransactionRepo.GetBankTransactionList().Returns(new List<BankTransaction>
+        bankTransactionRepo.GetBankTransactionListAsync().Returns(new List<BankTransaction>
        {
            new() { Id = "open", Text = "still open", Ignore = false },
            new() { Id = "ignored", Text = "ignore me", Ignore = true },
            new() { Id = "booked", Text = "already booked", Ignore = false }
        });
-        transactionRepo.GetTransactionList().Returns(new List<Transaction>
+        transactionRepo.GetTransactionListAsync().Returns(new List<Transaction>
        {
            new() { Id = "t1", BankTransactionId = "booked", OriginAccountId = "a", TargetAccountId = "b", Value = 10 }
        });

-        var open = BuildService().GetOpenBankTransactionList();
+        var open = await BuildService().GetOpenBankTransactionListAsync();

        open.Count.ShouldBe(1);
        open[0].Id.ShouldBe("open");
    }

-    // --- Helpers -------------------------------------------------------------
-
    private static Account Account(string id, int number, string currency, decimal startBalance = 0m, string? bankAccountNumber = null)
        => new()
        {
--- a/Schaad.Accounting.UI/Components/Pages/Accounts.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Accounts.razor.cs
@ -1,4 +1,4 @@
-using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components;
 using Microsoft.FluentUI.AspNetCore.Components;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -8,20 +8,20 @@ namespace Schaad.Accounting.UI.Components.Pages;

 public partial class Accounts : ComponentBase
 {
-     [Inject]
+    [Inject]
    private IAccountRepository accountRepository { get; set; } = null!;
-    
+
    [Inject]
    private IDialogService dialogService { get; set; } = null!;
-    
+
    private IQueryable<Account>? accountQueryable;
-    
-    protected override Task OnInitializedAsync()  
-    {  
-        accountQueryable = accountRepository.GetAccountList().AsQueryable();  
-        return base.OnInitializedAsync();  
+
+    protected override async Task OnInitializedAsync()
+    {
+        accountQueryable = (await accountRepository.GetAccountListAsync()).AsQueryable();
+        await base.OnInitializedAsync();
    }
-    
+
    private async Task AddAsync()
    {
        var data = new Account();
@ -36,13 +36,13 @@ public partial class Accounts : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            accountQueryable = accountRepository.GetAccountList().AsQueryable();  
+            accountQueryable = (await accountRepository.GetAccountListAsync()).AsQueryable();
        }
    }
-    
+
    private async Task EditAsync(string id)
    {
-        var data = accountRepository.GetAccount(id);
+        var data = await accountRepository.GetAccountAsync(id);
        var dialog = await dialogService.ShowDialogAsync<AccountDialog>(data, new DialogParameters()
        {
            Height = "500px",
@ -54,19 +54,19 @@ public partial class Accounts : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            accountQueryable = accountRepository.GetAccountList().AsQueryable();  
+            accountQueryable = (await accountRepository.GetAccountListAsync()).AsQueryable();
        }
    }
-    
+
    private async Task DeleteAsync(string id)
    {
-        var account = accountRepository.GetAccount(id);
+        var account = await accountRepository.GetAccountAsync(id);
        var dialog = await dialogService.ShowConfirmationAsync($"Konto '{account.Name}' wirklich löschen?", "Ja", "Nein", "Konto löschen");
        var result = await dialog.Result;
        if (!result.Cancelled)
        {
-            accountRepository.DeleteAccount(id);
-            accountQueryable = accountRepository.GetAccountList().AsQueryable();  
+            await accountRepository.DeleteAccountAsync(id);
+            accountQueryable = (await accountRepository.GetAccountListAsync()).AsQueryable();
        }
    }
-}
+}
--- a/Schaad.Accounting.UI/Components/Pages/BankTransactions.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/BankTransactions.razor.cs
@ -1,4 +1,4 @@
-using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;

@ -9,10 +9,10 @@ public partial class BankTransactions : ComponentBase
    [Inject]
    private IBankTransactionRepository bankTransactionRepository { get; set; } = null!;
    private IQueryable<BankTransaction>? TransactionList;
-    
-    protected override Task OnInitializedAsync()  
-    {  
-        TransactionList = bankTransactionRepository.GetBankTransactionList().AsQueryable();  
-        return base.OnInitializedAsync();  
+
+    protected override async Task OnInitializedAsync()
+    {
+        TransactionList = (await bankTransactionRepository.GetBankTransactionListAsync()).AsQueryable();
+        await base.OnInitializedAsync();
    }
-}
+}
--- a/Schaad.Accounting.UI/Components/Pages/BookingRules.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/BookingRules.razor.cs
@ -1,4 +1,4 @@
-using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components;
 using Microsoft.FluentUI.AspNetCore.Components;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Interfaces;
@ -11,21 +11,21 @@ public partial class BookingRules : ComponentBase
 {
    [Inject]
    private IViewService viewService { get; set; } = null!;
-    
+
    [Inject]
    private IBookingRuleRepository bookingRuleRepository { get; set; } = null!;
-    
+
    [Inject]
    private IDialogService dialogService { get; set; } = null!;
-    
+
    private IQueryable<BookingRuleDataset>? bookingRulesQueryable;
-    
-    protected override Task OnInitializedAsync()  
-    {  
-        bookingRulesQueryable = viewService.GetBookingRuleViewList().AsQueryable();  
-        return base.OnInitializedAsync();  
+
+    protected override async Task OnInitializedAsync()
+    {
+        bookingRulesQueryable = (await viewService.GetBookingRuleViewListAsync()).AsQueryable();
+        await base.OnInitializedAsync();
    }
-    
+
    private async Task AddAsync()
    {
        var data = new BookingRule();
@ -40,13 +40,13 @@ public partial class BookingRules : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            bookingRulesQueryable = viewService.GetBookingRuleViewList().AsQueryable();
+            bookingRulesQueryable = (await viewService.GetBookingRuleViewListAsync()).AsQueryable();
        }
    }
-    
+
    private async Task EditAsync(string id)
    {
-        var data = bookingRuleRepository.GetBookingRule(id);
+        var data = await bookingRuleRepository.GetBookingRuleAsync(id);
        var dialog = await dialogService.ShowDialogAsync<BookingRuleDialog>(data, new DialogParameters()
        {
            Height = "500px",
@ -58,19 +58,19 @@ public partial class BookingRules : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            bookingRulesQueryable = viewService.GetBookingRuleViewList().AsQueryable();
+            bookingRulesQueryable = (await viewService.GetBookingRuleViewListAsync()).AsQueryable();
        }
    }
-    
+
    private async Task DeleteAsync(string id)
    {
-        var bookingRule = bookingRuleRepository.GetBookingRule(id);
+        var bookingRule = await bookingRuleRepository.GetBookingRuleAsync(id);
        var dialog = await dialogService.ShowConfirmationAsync($"Regel '{bookingRule.LookupText}' wirklich löschen?", "Ja", "Nein", "Buchungsregel löschen");
        var result = await dialog.Result;
        if (!result.Cancelled)
        {
-            bookingRuleRepository.DeleteBookingRule(id);
-            bookingRulesQueryable = viewService.GetBookingRuleViewList().AsQueryable();
+            await bookingRuleRepository.DeleteBookingRuleAsync(id);
+            bookingRulesQueryable = (await viewService.GetBookingRuleViewListAsync()).AsQueryable();
        }
    }
-}
+}
--- a/Schaad.Accounting.UI/Components/Pages/BookingTexts.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/BookingTexts.razor.cs
@ -1,4 +1,4 @@
-using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components;
 using Microsoft.FluentUI.AspNetCore.Components;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -10,18 +10,18 @@ public partial class BookingTexts : ComponentBase
 {
    [Inject]
    private IBookingTextRepository bookingTextRepository { get; set; } = null!;
-    
+
    [Inject]
    private IDialogService dialogService { get; set; } = null!;
-    
+
    private IQueryable<BookingText>? bookingTextQueryable;
-    
-    protected override Task OnInitializedAsync()  
-    {  
-        bookingTextQueryable = bookingTextRepository.GetBookingTextList().AsQueryable();  
-        return base.OnInitializedAsync();  
+
+    protected override async Task OnInitializedAsync()
+    {
+        bookingTextQueryable = (await bookingTextRepository.GetBookingTextListAsync()).AsQueryable();
+        await base.OnInitializedAsync();
    }
-    
+
    private async Task AddAsync()
    {
        var data = new BookingText();
@ -36,13 +36,13 @@ public partial class BookingTexts : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            bookingTextQueryable = bookingTextRepository.GetBookingTextList().AsQueryable();
+            bookingTextQueryable = (await bookingTextRepository.GetBookingTextListAsync()).AsQueryable();
        }
    }
-    
+
    private async Task EditAsync(string id)
    {
-        var data = bookingTextRepository.GetBookingText(id);
+        var data = await bookingTextRepository.GetBookingTextAsync(id);
        var dialog = await dialogService.ShowDialogAsync<BookingTextDialog>(data, new DialogParameters()
        {
            Height = "500px",
@ -54,19 +54,19 @@ public partial class BookingTexts : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            bookingTextQueryable = bookingTextRepository.GetBookingTextList().AsQueryable();
+            bookingTextQueryable = (await bookingTextRepository.GetBookingTextListAsync()).AsQueryable();
        }
    }

    private async Task DeleteAsync(string id)
    {
-        var bookingText = bookingTextRepository.GetBookingText(id);
+        var bookingText = await bookingTextRepository.GetBookingTextAsync(id);
        var dialog = await dialogService.ShowConfirmationAsync($"Buchungstext '{bookingText.Text}' wirklich löschen?", "Ja", "Nein", "Buchungstext löschen");
        var result = await dialog.Result;
        if (!result.Cancelled)
        {
-            bookingTextRepository.DeleteBookingText(id);
-            bookingTextQueryable = bookingTextRepository.GetBookingTextList().AsQueryable();
+            await bookingTextRepository.DeleteBookingTextAsync(id);
+            bookingTextQueryable = (await bookingTextRepository.GetBookingTextListAsync()).AsQueryable();
        }
    }
-}
+}
--- a/Schaad.Accounting.UI/Components/Pages/Charts/Assets.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Charts/Assets.razor
@ -3,4 +3,7 @@

 <PageTitle>Ausgaben</PageTitle>

-<PlotlyChart style="height: 700px; min-height: 500px" @bind-Config="config" @bind-Layout="layout" @bind-Data="data" @ref="chart" />
+@if (config is not null && layout is not null && data is not null)
+{
+    <PlotlyChart style="height: 700px; min-height: 500px" @bind-Config="config" @bind-Layout="layout" @bind-Data="data" @ref="chart" />
+}
--- a/Schaad.Accounting.UI/Components/Pages/Charts/Assets.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Charts/Assets.razor.cs
@ -8,14 +8,14 @@ namespace Schaad.Accounting.UI.Components.Pages.Charts;
 public partial class Assets : ComponentBase
 {
    private PlotlyChart chart = null!;
-    private Config config = null!;
-    private Plotly.Blazor.Layout layout = null!;
-    private IList<ITrace> data = null!;
+    private Config? config;
+    private Plotly.Blazor.Layout? layout;
+    private IList<ITrace>? data;
    
    [Inject]
    private IViewService viewService { get; set; } = null!;
    
-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
        config = new Config
        {
@ -25,8 +25,8 @@ public partial class Assets : ComponentBase
        layout = new Plotly.Blazor.Layout
        {
        };
-        
-        var accounts = viewService.GetAccountViewList().Where(a => a.Class == ClassIds.Activa);
+
+        var accounts = (await viewService.GetAccountViewListAsync()).Where(a => a.Class == ClassIds.Activa);
        var values = new List<object>();
        var labels = new List<object>();
        var ids = new List<object>();
@ -50,6 +50,6 @@ public partial class Assets : ComponentBase
            }
        };

-        return base.OnInitializedAsync();  
+        await base.OnInitializedAsync();
    }
 }
--- a/Schaad.Accounting.UI/Components/Pages/Charts/Spendings.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Charts/Spendings.razor
@ -3,4 +3,7 @@

 <PageTitle>Ausgaben</PageTitle>

-<PlotlyChart style="height: 700px; min-height: 500px" @bind-Config="config" @bind-Layout="layout" @bind-Data="data" @ref="chart" />
+@if (config is not null && layout is not null && data is not null)
+{
+    <PlotlyChart style="height: 700px; min-height: 500px" @bind-Config="config" @bind-Layout="layout" @bind-Data="data" @ref="chart" />
+}
--- a/Schaad.Accounting.UI/Components/Pages/Charts/Spendings.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Charts/Spendings.razor.cs
@ -8,14 +8,14 @@ namespace Schaad.Accounting.UI.Components.Pages.Charts;
 public partial class Spendings : ComponentBase
 {
    private PlotlyChart chart = null!;
-    private Config config = null!;
-    private Plotly.Blazor.Layout layout = null!;
-    private IList<ITrace> data = null!;
+    private Config? config;
+    private Plotly.Blazor.Layout? layout;
+    private IList<ITrace>? data;
    
    [Inject]
    private IViewService viewService { get; set; } = null!;
    
-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
        config = new Config
        {
@ -25,8 +25,8 @@ public partial class Spendings : ComponentBase
        layout = new Plotly.Blazor.Layout
        {
        };
-        
-        var accounts = viewService.GetAccountViewList().Where(a => a.Class == ClassIds.Expenses);
+
+        var accounts = (await viewService.GetAccountViewListAsync()).Where(a => a.Class == ClassIds.Expenses);
        var values = new List<object>();
        var labels = new List<object>();
        foreach (var grp in accounts.GroupBy(a => a.SubClass).Select(a => new {Key = a.Key, List = a.ToList()}))
@ -47,6 +47,6 @@ public partial class Spendings : ComponentBase
            }
        };

-        return base.OnInitializedAsync();  
+        await base.OnInitializedAsync();
    }
 }
--- a/Schaad.Accounting.UI/Components/Pages/Charts/SpendingsOverTime.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Charts/SpendingsOverTime.razor
@ -3,4 +3,7 @@

 <PageTitle>Ausgaben im Verlauf</PageTitle>

-<PlotlyChart style="height: 700px; min-height: 500px" @bind-Config="config" @bind-Layout="layout" @bind-Data="data" @ref="chart" />
+@if (config is not null && layout is not null)
+{
+    <PlotlyChart style="height: 700px; min-height: 500px" @bind-Config="config" @bind-Layout="layout" @bind-Data="data" @ref="chart" />
+}
--- a/Schaad.Accounting.UI/Components/Pages/Charts/SpendingsOverTime.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Charts/SpendingsOverTime.razor.cs
@ -9,14 +9,14 @@ namespace Schaad.Accounting.UI.Components.Pages.Charts;
 public partial class SpendingsOverTime : ComponentBase
 {
    private PlotlyChart chart = null!;
-    private Config config = null!;
-    private Plotly.Blazor.Layout layout = null!;
+    private Config? config;
+    private Plotly.Blazor.Layout? layout;
    private IList<ITrace> data = new List<ITrace>();
    
    [Inject]
    private IChartService chartService { get; set; } = null!;
    
-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
        config = new Config
        {
@ -44,7 +44,7 @@ public partial class SpendingsOverTime : ComponentBase
        };
        

-        var dataSeries = chartService.GetExpensesPerMonth();
+        var dataSeries = await chartService.GetExpensesPerMonthAsync();
        foreach (var dataSerie in dataSeries)
        {
            data.Add(new Bar
@ -55,6 +55,6 @@ public partial class SpendingsOverTime : ComponentBase
            });
        };

-        return base.OnInitializedAsync();  
+        await base.OnInitializedAsync();
    }
 }
--- a/Schaad.Accounting.UI/Components/Pages/Classes.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Classes.razor.cs
@ -1,4 +1,4 @@
-using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components;
 using Microsoft.FluentUI.AspNetCore.Components;
 using Schaad.Accounting.Interfaces;
 using Schaad.Accounting.Models;
@ -10,18 +10,18 @@ public partial class Classes : ComponentBase
 {
    [Inject]
    private ISubclassRepository subclassRepository { get; set; } = null!;
-    
+
    [Inject]
    private IDialogService dialogService { get; set; } = null!;
-    
+
    private IQueryable<SubClass>? subclassQueryable;
-    
-    protected override Task OnInitializedAsync()  
-    {  
-        subclassQueryable = subclassRepository.GetSubClassList().AsQueryable();  
-        return base.OnInitializedAsync();  
+
+    protected override async Task OnInitializedAsync()
+    {
+        subclassQueryable = (await subclassRepository.GetSubClassListAsync()).AsQueryable();
+        await base.OnInitializedAsync();
    }
-    
+
    private async Task AddAsync()
    {
        var data = new SubClass();
@ -36,13 +36,13 @@ public partial class Classes : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            subclassQueryable = subclassRepository.GetSubClassList().AsQueryable();  
+            subclassQueryable = (await subclassRepository.GetSubClassListAsync()).AsQueryable();
        }
    }
-    
+
    private async Task EditAsync(string id)
    {
-        var data = subclassRepository.GetSubClass(id);
+        var data = await subclassRepository.GetSubClassAsync(id);
        var dialog = await dialogService.ShowDialogAsync<ClassDialog>(data, new DialogParameters()
        {
            Height = "500px",
@ -54,19 +54,19 @@ public partial class Classes : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            subclassQueryable = subclassRepository.GetSubClassList().AsQueryable(); 
+            subclassQueryable = (await subclassRepository.GetSubClassListAsync()).AsQueryable();
        }
    }
-    
+
    private async Task DeleteAsync(string id)
    {
-        var subclass = subclassRepository.GetSubClass(id);
+        var subclass = await subclassRepository.GetSubClassAsync(id);
        var dialog = await dialogService.ShowConfirmationAsync($"Klasse '{subclass.Name}' wirklich löschen?", "Ja", "Nein", "Klasse löschen");
        var result = await dialog.Result;
        if (!result.Cancelled)
        {
-            subclassRepository.DeleteSubClass(id);
-            subclassQueryable = subclassRepository.GetSubClassList().AsQueryable(); 
+            await subclassRepository.DeleteSubClassAsync(id);
+            subclassQueryable = (await subclassRepository.GetSubClassListAsync()).AsQueryable();
        }
    }
-}
+}
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/AccountDialog.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/AccountDialog.razor.cs
@ -28,7 +28,7 @@ public partial class AccountDialog : ComponentBase
    {
        if (editContext.Validate())
        {
-            accountRepository.SaveAccount(Content);
+            await accountRepository.SaveAccountAsync(Content);
            await Dialog.CloseAsync(Content);
        }
    }
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/BookingRuleDialog.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/BookingRuleDialog.razor
@ -12,6 +12,12 @@
 </FluentDialogHeader>

 <FluentDialogBody>
+    @if (editContext is null)
+    {
+        <p>Lädt…</p>
+        return;
+    }
+
    <EditForm EditContext="@editContext">
        <DataAnnotationsValidator />
        <FluentTextField @bind-Value="@Content.LookupText" Label="Suchtext" Style="width: 300px;"/>
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/BookingRuleDialog.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/BookingRuleDialog.razor.cs
@ -8,7 +8,7 @@ namespace Schaad.Accounting.UI.Components.Pages.Dialogs;

 public partial class BookingRuleDialog : ComponentBase
 {
-    private EditContext editContext = null!;
+    private EditContext? editContext;

    [CascadingParameter]
    public FluentDialog Dialog { get; set; } = null!;
@ -24,17 +24,17 @@ public partial class BookingRuleDialog : ComponentBase

    private IReadOnlyList<Account> accounts = [];

-    protected override void OnInitialized()
+    protected override async Task OnInitializedAsync()
    {
        editContext = new EditContext(Content);
-        accounts = viewService.GetAccountViewList();
+        accounts = await viewService.GetAccountViewListAsync();
    }

    private async Task SaveAsync()
    {
        if (editContext.Validate())
        {
-            bookingRuleRepository.SaveBookingRule(Content);
+            await bookingRuleRepository.SaveBookingRuleAsync(Content);
            await Dialog.CloseAsync(Content);
        }
    }
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/BookingTextDialog.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/BookingTextDialog.razor.cs
@ -28,7 +28,7 @@ public partial class BookingTextDialog : ComponentBase
    {
        if (editContext.Validate())
        {
-            bookingTextRepository.SaveBookingText(Content);
+            await bookingTextRepository.SaveBookingTextAsync(Content);
            await Dialog.CloseAsync(Content);
        }
    }
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/ClassDialog.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/ClassDialog.razor.cs
@ -28,7 +28,7 @@ public partial class ClassDialog : ComponentBase
    {
        if (editContext.Validate())
        {
-            bookingRuleRepository.SaveSubClass(Content);
+            await bookingRuleRepository.SaveSubClassAsync(Content);
            await Dialog.CloseAsync(Content);
        }
    }
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionDialog.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionDialog.razor
@ -11,6 +11,12 @@
 </FluentDialogHeader>

 <FluentDialogBody>
+    @if (editContext is null)
+    {
+        <p>Lädt…</p>
+        return;
+    }
+
    <EditForm EditContext="@editContext">
        <DataAnnotationsValidator />
        <FluentDatePicker @bind-Value="@SelectedValue" Label="Valuta" Style="width: 300px;"/>
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionDialog.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionDialog.razor.cs
@ -8,7 +8,7 @@ namespace Schaad.Accounting.UI.Components.Pages.Dialogs;

 public partial class TransactionDialog : ComponentBase
 {
-    private EditContext editContext = null!;
+    private EditContext? editContext;

    [CascadingParameter]
    public FluentDialog Dialog { get; set; } = null!;
@ -25,11 +25,11 @@ public partial class TransactionDialog : ComponentBase
    private IReadOnlyList<Account> accounts = [];
    private DateTime? SelectedValue;

-    protected override void OnInitialized()
+    protected override async Task OnInitializedAsync()
    {
        SelectedValue = Content.ValueDate;
        editContext = new EditContext(Content);
-        accounts = viewService.GetAccountViewList();
+        accounts = await viewService.GetAccountViewListAsync();
    }

    private async Task SaveAsync()
@ -38,7 +38,7 @@ public partial class TransactionDialog : ComponentBase
        {
            Content.ValueDate = SelectedValue!.Value;
            Content.BookingDate = SelectedValue!.Value;
-            transactionRepository.SaveTransaction(Content);
+            await transactionRepository.SaveTransactionAsync(Content);
            await Dialog.CloseAsync(Content);
        }
    }
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionSplitDialog.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionSplitDialog.razor
@ -11,6 +11,12 @@
 </FluentDialogHeader>

 <FluentDialogBody>
+    @if (editContext is null)
+    {
+        <p>Lädt…</p>
+        return;
+    }
+
    Total: @Math.Abs(Content.Value) / Rest: @openAmount
    <FluentButton Appearance="Appearance.Neutral" IconEnd="@(new Icons.Regular.Size24.Add())"
                  OnClick="@AddTransactionAsync">
--- a/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionSplitDialog.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Dialogs/TransactionSplitDialog.razor.cs
@ -9,7 +9,7 @@ namespace Schaad.Accounting.UI.Components.Pages.Dialogs;

 public partial class TransactionSplitDialog : ComponentBase
 {
-    private EditContext editContext = null!;
+    private EditContext? editContext;

    [CascadingParameter]
    public FluentDialog Dialog { get; set; } = null!;
@ -33,17 +33,17 @@ public partial class TransactionSplitDialog : ComponentBase
    private IViewService viewService { get; set; } = null!;
    
    private List<Transaction> transactionList = new();
-    private IReadOnlyList<AccountDataset> accounts = null!;
+    private IReadOnlyList<AccountDataset> accounts = [];
    private IReadOnlyList<string> bookingTexts = [];
    private decimal openAmount = 0;
    

-    protected override void OnInitialized()
+    protected override async Task OnInitializedAsync()
    {
-        accounts = viewService.GetAccountViewList();
-        bookingTexts = bookingTextRepository.GetBookingTextList().Select(b => b.Text).ToArray();
-        var accountList = accountRepository.GetAccountList();
-        var bankTrx = bankTransactionRepository.GetBankTransaction(Content.BankTransactionId);
+        accounts = await viewService.GetAccountViewListAsync();
+        bookingTexts = (await bookingTextRepository.GetBookingTextListAsync()).Select(b => b.Text).ToArray();
+        var accountList = await accountRepository.GetAccountListAsync();
+        var bankTrx = await bankTransactionRepository.GetBankTransactionAsync(Content.BankTransactionId);
        var trx = new Transaction(bankTrx, accountList);
        trx.Value = Math.Abs(bankTrx.Value);
        transactionList.Add(trx);
@ -74,7 +74,7 @@ public partial class TransactionSplitDialog : ComponentBase
        {
            foreach (var transtaction in transactionList)
            {
-                transactionRepository.SaveTransaction(transtaction);
+                await transactionRepository.SaveTransactionAsync(transtaction);
            }
            await Dialog.CloseAsync(Content);
        }
--- a/Schaad.Accounting.UI/Components/Pages/Home.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Home.razor.cs
@ -44,12 +44,12 @@ public partial class Home : ComponentBase
    bool IsCanceled;
    Dictionary<int, string> Files = new();

-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
-        matchingBankTransactions = viewService.MatchOpenBankTransactions();
-        accounts = viewService.GetAccountViewList();
-        bookingTexts = bookingTextRepository.GetBookingTextList().Select(b => b.Text).ToArray();
-        return base.OnInitializedAsync();
+        matchingBankTransactions = await viewService.MatchOpenBankTransactionsAsync();
+        accounts = await viewService.GetAccountViewListAsync();
+        bookingTexts = (await bookingTextRepository.GetBookingTextListAsync()).Select(b => b.Text).ToArray();
+        await base.OnInitializedAsync();
    }
    
    async Task OnProgressChangeAsync(FluentInputFileEventArgs file)
@ -95,13 +95,13 @@ public partial class Home : ComponentBase
            
            File.Delete(file.Value);
        }
-        
-        matchingBankTransactions = viewService.MatchOpenBankTransactions();
+
+        matchingBankTransactions = await viewService.MatchOpenBankTransactionsAsync();
    }

    private async Task ImportXmlAndShowResultAsync(string fileName)
    {
-        var messages = fileService.ImportAccountStatementFile(fileName);
+        var messages = await fileService.ImportAccountStatementFileAsync(fileName);
        foreach (var message in messages)
        {
            await ShowImportResultAsync(message);
@ -156,9 +156,8 @@ public partial class Home : ComponentBase
            ShowToast("Transaktion kann wegen fehlenden Daten nicht gespeichert werden!", ToastIntent.Error);
            return;
        }
-        transactionRepository.SaveTransaction(transaction);
+        await transactionRepository.SaveTransactionAsync(transaction);
        transaction.ReadOnly = true;
-        await Task.CompletedTask;
    }
    
    private async Task SplitBankTransactionAsync(Transaction transaction)
--- a/Schaad.Accounting.UI/Components/Pages/Reports/BalanceReport.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/BalanceReport.razor
@ -1,5 +1,11 @@
@page "/BalanceReport"

+@if (balance is null)
+{
+    <p>Lädt…</p>
+    return;
+}
+
 <h3>@header</h3>
 <a href="javascript:window.print()" class="hidePrint">Print</a>

--- a/Schaad.Accounting.UI/Components/Pages/Reports/BalanceReport.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/BalanceReport.razor.cs
@ -12,17 +12,17 @@ public partial class BalanceReport : ComponentBase
    [Inject]
    private ISettingsService settingsService { get; set; } = null!;
    
-    private BalanceDataset balance = null!;
+    private BalanceDataset? balance;
    private decimal win;
-    private string header = null!;
-    private string footer = null!;
+    private string header = "";
+    private string footer = "";
    
-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
-        balance = viewService.GetBalanceView();
+        balance = await viewService.GetBalanceViewAsync();
        win = balance.TotalActivaCHF - balance.TotalPassivaCHF;
        (header, footer) = Report.GetViewDataTitleAndFooter("Bilanz", settingsService);
-        
-        return base.OnInitializedAsync();  
+
+        await base.OnInitializedAsync();
    }
 }
--- a/Schaad.Accounting.UI/Components/Pages/Reports/BalanceSheetReport.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/BalanceSheetReport.razor
@ -1,5 +1,11 @@
@page "/BalanceSheetReport"

+@if (balanceSheet is null)
+{
+    <p>Lädt…</p>
+    return;
+}
+
 <h3>@header</h3>
 <a href="javascript:window.print()" class="hidePrint">Print</a>
 <br />
--- a/Schaad.Accounting.UI/Components/Pages/Reports/BalanceSheetReport.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/BalanceSheetReport.razor.cs
@ -12,17 +12,17 @@ public partial class BalanceSheetReport : ComponentBase
    [Inject]
    private ISettingsService settingsService { get; set; } = null!;
    
-    private BalanceSheetDataset balanceSheet = null!;
+    private BalanceSheetDataset? balanceSheet;
    private decimal win;
-    private string header = null!;
-    private string footer = null!;
+    private string header = "";
+    private string footer = "";
    
-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
-        balanceSheet = viewService.GetBalanceSheetView(settingsService.GetYear());
+        balanceSheet = await viewService.GetBalanceSheetViewAsync(settingsService.GetYear());
        win = balanceSheet.ProfitCHF - balanceSheet.LossCHF;
        (header, footer) = Report.GetViewDataTitleAndFooter("Jahresabschluss", settingsService);
-        
-        return base.OnInitializedAsync();  
+
+        await base.OnInitializedAsync();
    }
 }
--- a/Schaad.Accounting.UI/Components/Pages/Reports/DetailReport.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/DetailReport.razor
@ -1,5 +1,11 @@
@page "/DetailReport"

+@if (accounts is null || transactions is null)
+{
+    <p>Lädt…</p>
+    return;
+}
+
 <h3>@header</h3>
 <a href="javascript:window.print()" class="hidePrint">Print</a>

--- a/Schaad.Accounting.UI/Components/Pages/Reports/DetailReport.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/DetailReport.razor.cs
@ -12,23 +12,23 @@ public partial class DetailReport : ComponentBase
    [Inject]
    private ISettingsService settingsService { get; set; } = null!;
    
-    private IReadOnlyList<AccountDataset> accounts = null!;
-    private IReadOnlyList<TransactionDataset> transactions = null!;
+    private IReadOnlyList<AccountDataset>? accounts;
+    private IReadOnlyList<TransactionDataset>? transactions;
    private decimal profit;
    private decimal loss;
-    private string header = null!;
-    private string footer = null!;
+    private string header = "";
+    private string footer = "";
    
-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
-        accounts = viewService.GetAccountViewList();
-        transactions = viewService.GetTransactionViewList();
-        
-        profit = Math.Abs(accounts.Where(m => m.Class == 3).Sum(m => m.Balance));
-        loss = Math.Abs(accounts.Where(m => m.Class == 4).Sum(m => m.Balance));
-        
+        accounts = await viewService.GetAccountViewListAsync();
+        transactions = await viewService.GetTransactionViewListAsync();
+
+        profit = Math.Abs(accounts.Where(m => m.Class == ClassIds.Income).Sum(m => m.Balance));
+        loss = Math.Abs(accounts.Where(m => m.Class == ClassIds.Expenses).Sum(m => m.Balance));
+
        (header, footer) = Report.GetViewDataTitleAndFooter("Detailaufstellung", settingsService);
-        
-        return base.OnInitializedAsync();  
+
+        await base.OnInitializedAsync();
    }
 }
--- a/Schaad.Accounting.UI/Components/Pages/Reports/ProfitLossReport.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/ProfitLossReport.razor
@ -1,5 +1,11 @@
@page "/ProfitLossReport"

+@if (accounts is null)
+{
+    <p>Lädt…</p>
+    return;
+}
+
 <h3>@header</h3>
 <a href="javascript:window.print()" class="hidePrint">Print</a>

--- a/Schaad.Accounting.UI/Components/Pages/Reports/ProfitLossReport.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Reports/ProfitLossReport.razor.cs
@ -13,22 +13,22 @@ public partial class ProfitLossReport : ComponentBase
    [Inject]
    private ISettingsService settingsService { get; set; } = null!;
    
-    private IReadOnlyList<AccountDataset> accounts = null!;
+    private IReadOnlyList<AccountDataset>? accounts;
    private decimal profit;
    private decimal loss;
    private decimal win;
-    private string header = null!;
-    private string footer = null!;
+    private string header = "";
+    private string footer = "";
    
-    protected override Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync()
    {
-        accounts = viewService.GetAccountViewList();
+        accounts = await viewService.GetAccountViewListAsync();
        profit = Math.Abs(accounts.Where(m => m.Class == ClassIds.Income).Sum(m => m.Balance));
        loss = Math.Abs(accounts.Where(m => m.Class == ClassIds.Expenses).Sum(m => m.Balance));
-        win = profit-loss;
+        win = profit - loss;

        (header, footer) = Report.GetViewDataTitleAndFooter("Erfolgsrechnung", settingsService);
-        
-        return base.OnInitializedAsync();  
+
+        await base.OnInitializedAsync();
    }
 }
--- a/Schaad.Accounting.UI/Components/Pages/Transactions.razor
+++ b/Schaad.Accounting.UI/Components/Pages/Transactions.razor
@ -10,7 +10,7 @@
            <FluentNavGroup Title="@(gr.Key)" Expanded="true">
                @foreach (var account in gr)
                {
-                    <FluentNavLink OnClick="() => ShowTransactions(account.Id)" Icon="@(new Icons.Regular.Size24.CalendarAgenda())">
+                    <FluentNavLink OnClick="() => ShowTransactionsAsync(account.Id)" Icon="@(new Icons.Regular.Size24.CalendarAgenda())">
                        <FluentStack Orientation="Orientation.Horizontal">
                            <div>
                                @account.Number / @account.Name
@ -29,36 +29,39 @@
    </FluentNavMenu>
    
    <FluentBodyContent>
-        <FluentGrid Justify="JustifyContent.FlexStart">
-            <FluentGridItem xs="4" Class="align-content-center title">
-                @selectedAccount.Name
-            </FluentGridItem>
-            <FluentGridItem xs="4" Class="align-content-center">
-                Total @Math.Abs(selectedAccount.Balance).ToString("N2") @selectedAccount.Currency in @transactionList?.Count() Transaktionen
-            </FluentGridItem>
-            <FluentGridItem xs="4" Class="align-content-center" Justify="JustifyContent.FlexEnd">
-                <FluentButton IconStart="@(new Icons.Regular.Size16.Add())" Appearance="Appearance.Neutral" OnClick="AddAsync">Neue Transaktion hinzufügen</FluentButton>
-            </FluentGridItem>
-        </FluentGrid>
-        
-        <FluentPaginator State="@pagination" SummaryTemplate="@template"/>
-        <FluentDataGrid Items="@transactionList" Pagination="@pagination" RowSize="DataGridRowSize.Medium">
-            <PropertyColumn Property="@(p => p.BookingDate)" Format="dd.MM.yyyy" Sortable="true" IsDefaultSortColumn="true" InitialSortDirection="SortDirection.Descending"/>
-            <PropertyColumn Property="@(p => p.ValueDate)" Format="dd.MM.yyyy" Sortable="true"/>
-            <PropertyColumn Property="@(p => p.Text)"/>
-            <TemplateColumn Title="Gegenkonto">
-                @GetAccountName(context)
-            </TemplateColumn>
-            <TemplateColumn Title="Betrag" Align="Align.End">
-                @context.GetValue(selectedAccount.IsFxAccount).ToString("N2") @selectedAccount.Currency
-            </TemplateColumn>
-            <TemplateColumn Align="Align.Center" Width="50px">
-                <FluentButton IconEnd="@(new Icons.Regular.Size16.Delete())" Appearance="Appearance.Neutral" OnClick="@(() => DeleteAsync(context.Id))"/>
-            </TemplateColumn>
-            <TemplateColumn Align="Align.Center" Width="50px">
-                <FluentButton IconEnd="@(new Icons.Regular.Size16.Edit())" Appearance="Appearance.Neutral" OnClick="@(() => EditAsync(context.Id))"/>
-            </TemplateColumn>
-        </FluentDataGrid>
+        @if (selectedAccount is not null)
+        {
+            <FluentGrid Justify="JustifyContent.FlexStart">
+                <FluentGridItem xs="4" Class="align-content-center title">
+                    @selectedAccount.Name
+                </FluentGridItem>
+                <FluentGridItem xs="4" Class="align-content-center">
+                    Total @Math.Abs(selectedAccount.Balance).ToString("N2") @selectedAccount.Currency in @transactionList?.Count() Transaktionen
+                </FluentGridItem>
+                <FluentGridItem xs="4" Class="align-content-center" Justify="JustifyContent.FlexEnd">
+                    <FluentButton IconStart="@(new Icons.Regular.Size16.Add())" Appearance="Appearance.Neutral" OnClick="AddAsync">Neue Transaktion hinzufügen</FluentButton>
+                </FluentGridItem>
+            </FluentGrid>
+
+            <FluentPaginator State="@pagination" SummaryTemplate="@template"/>
+            <FluentDataGrid Items="@transactionList" Pagination="@pagination" RowSize="DataGridRowSize.Medium">
+                <PropertyColumn Property="@(p => p.BookingDate)" Format="dd.MM.yyyy" Sortable="true" IsDefaultSortColumn="true" InitialSortDirection="SortDirection.Descending"/>
+                <PropertyColumn Property="@(p => p.ValueDate)" Format="dd.MM.yyyy" Sortable="true"/>
+                <PropertyColumn Property="@(p => p.Text)"/>
+                <TemplateColumn Title="Gegenkonto">
+                    @GetAccountName(context)
+                </TemplateColumn>
+                <TemplateColumn Title="Betrag" Align="Align.End">
+                    @context.GetValue(selectedAccount.IsFxAccount).ToString("N2") @selectedAccount.Currency
+                </TemplateColumn>
+                <TemplateColumn Align="Align.Center" Width="50px">
+                    <FluentButton IconEnd="@(new Icons.Regular.Size16.Delete())" Appearance="Appearance.Neutral" OnClick="@(() => DeleteAsync(context.Id))"/>
+                </TemplateColumn>
+                <TemplateColumn Align="Align.Center" Width="50px">
+                    <FluentButton IconEnd="@(new Icons.Regular.Size16.Edit())" Appearance="Appearance.Neutral" OnClick="@(() => EditAsync(context.Id))"/>
+                </TemplateColumn>
+            </FluentDataGrid>
+        }
    </FluentBodyContent>
 </FluentStack>

--- a/Schaad.Accounting.UI/Components/Pages/Transactions.razor.cs
+++ b/Schaad.Accounting.UI/Components/Pages/Transactions.razor.cs
@ -1,4 +1,4 @@
-using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components;
 using Microsoft.FluentUI.AspNetCore.Components;
 using Schaad.Accounting.Datasets;
 using Schaad.Accounting.Interfaces;
@ -11,33 +11,33 @@ public partial class Transactions : ComponentBase
 {
    [Inject]
    private IViewService viewService { get; set; } = null!;
-    
+
    [Inject]
    private ITransactionRepository transactionRepository { get; set; } = null!;
-    
+
    [Inject]
    private IDialogService dialogService { get; set; } = null!;

-    private IReadOnlyList<AccountDataset> accounts = null!;
-    
+    private IReadOnlyList<AccountDataset> accounts = [];
+
    private IQueryable<TransactionDataset>? transactionList;
-    private string selectedAccountId = null!;
-    private AccountDataset selectedAccount = null!;
-    
-    protected override Task OnInitializedAsync()  
-    {  
-        accounts = viewService.GetAccountViewList();
-        ShowTransactions(accounts.First().Id);
-        return base.OnInitializedAsync();
+    private string? selectedAccountId;
+    private AccountDataset? selectedAccount;
+
+    protected override async Task OnInitializedAsync()
+    {
+        accounts = await viewService.GetAccountViewListAsync();
+        await ShowTransactionsAsync(accounts.First().Id);
+        await base.OnInitializedAsync();
    }

-    private void ShowTransactions(string accountId)
+    private async Task ShowTransactionsAsync(string accountId)
    {
        selectedAccountId = accountId;
        selectedAccount = accounts.Single(a => a.Id == accountId);
-        transactionList = viewService.GetTransactionViewList(accountId).AsQueryable();
+        transactionList = (await viewService.GetTransactionViewListAsync(accountId)).AsQueryable();
    }
-    
+
    private string GetAccountName(TransactionDataset transaction)
    {
        if (selectedAccountId == transaction.OriginAccountId)
@ -47,7 +47,7 @@ public partial class Transactions : ComponentBase

        return transaction.OriginAccount.Name;
    }
-    
+
    private async Task AddAsync()
    {
        var data = new Transaction
@ -68,13 +68,13 @@ public partial class Transactions : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            transactionList = viewService.GetTransactionViewList(selectedAccountId).AsQueryable();
+            transactionList = (await viewService.GetTransactionViewListAsync(selectedAccountId)).AsQueryable();
        }
    }
-    
+
    private async Task EditAsync(string id)
    {
-        var data = transactionRepository.GetTransaction(id);
+        var data = await transactionRepository.GetTransactionAsync(id);
        var dialog = await dialogService.ShowDialogAsync<TransactionDialog>(data, new DialogParameters()
        {
            Height = "500px",
@ -86,19 +86,19 @@ public partial class Transactions : ComponentBase
        var result = await dialog.Result;
        if (!result.Cancelled && result.Data != null)
        {
-            transactionList = viewService.GetTransactionViewList(selectedAccountId).AsQueryable();
+            transactionList = (await viewService.GetTransactionViewListAsync(selectedAccountId)).AsQueryable();
        }
    }
-    
+
    private async Task DeleteAsync(string id)
    {
-        var transaction = transactionRepository.GetTransaction(id);
+        var transaction = await transactionRepository.GetTransactionAsync(id);
        var dialog = await dialogService.ShowConfirmationAsync($"Transaction '{transaction.Text}' mit Betrag {transaction.Value} wirklich löschen?", "Ja", "Nein", "Transaktion löschen");
        var result = await dialog.Result;
        if (!result.Cancelled)
        {
-            transactionRepository.DeleteTransaction(id);
-            transactionList = viewService.GetTransactionViewList(selectedAccountId).AsQueryable();
+            await transactionRepository.DeleteTransactionAsync(id);
+            transactionList = (await viewService.GetTransactionViewListAsync(selectedAccountId)).AsQueryable();
        }
    }
-}
+}