reactiveui/Akavache là dự án Backend trên GitHub, viết chủ yếu bằng C#, với 2.5k sao. An asynchronous, persistent key-value store for .NET desktop and mobile applications, backed by SQLite. Suited to both durable data such as user settings and cached data that expires, with optional encryption and System.Text.Json serialization.
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Akavache: An Asynchronous Key-Value Store for Native Applications
Akavache is an asynchronous, persistent (i.e., writes to disk) key-value store created for writing desktop and mobile applications in C#, based on SQLite3. Akavache is great for both storing important data (i.e., user settings) as well as cached local data that expires.
What's New in V12
Akavache V12 rewrites the SQLite backend for direct SQLitePCLRaw 3.x access, replacing the sqlite-net-pcl ORM layer entirely. The result is lower per-operation allocations, dedicated worker-thread serialization of all native handle access, and commit coalescing for concurrent writes.
SQLitePCLRaw direct access: Prepared statements cached and reused, parameters bound positionally — no ORM overhead
SQLite3MultipleCiphers: Encrypted databases use SQLite3MC instead of sqlcipher
Observable-first settings: SettingsBase properties are IObservable<T> — no more .Wait() deadlocks
AOT-safe serialization: JsonTypeInfo<T> overloads for System.Text.Json, trim-safe out of the box
System.Text.Json package split: Pure JSON package no longer pulls in Newtonsoft.Json
Thread-safe disposal: All cache types use lock-free Interlocked patterns for idempotent dispose
See the Migration Guide: V11 to V12 for upgrade instructions.
Note:WithAkavache, WithAkavacheCacheDatabase and Initialize always requires an ISerializer defined as a generic type, such as WithAkavache<SystemJsonSerializer>. This ensures the cache instance is properly configured for serialization.
Static Initialization (Recommended for most apps)
using Akavache.Core;
using Akavache.SystemTextJson;
using Akavache.Sqlite3;
using Splat.Builder;
// Initialize with the builder pattern
AppBuilder.CreateSplatBuilder()
.WithAkavacheCacheDatabase<SystemJsonSerializer>(builder =>
builder.WithSqliteProvider() // REQUIRED: Explicitly initialize SQLite provider
.WithSqliteDefaults(),
"MyApp");
Important: Always call WithSqliteProvider() explicitly before WithSqliteDefaults(). While WithSqliteDefaults() will automatically call WithSqliteProvider() if not already initialized (for backward compatibility), this automatic behavior is deprecated and may be removed in future versions. Explicit provider initialization is the recommended pattern for forward compatibility with other DI containers.
Dependency Injection Registration (for DI containers)
using Akavache.Core;
using Akavache.SystemTextJson;
using Akavache.Sqlite3;
using Splat.Builder;
// Example: Register Akavache with Splat DI
AppBuilder.CreateSplatBuilder()
.WithAkavache<SystemJsonSerializer>(
"MyApp",
builder => builder.WithSqliteProvider() // REQUIRED: Explicit provider initialization
.WithSqliteDefaults(),
(splat, instance) => splat.RegisterLazySingleton(() => instance));
// For in-memory cache (testing or lightweight scenarios):
AppBuilder.CreateSplatBuilder()
.WithAkavache<SystemJsonSerializer>(
"Akavache",
builder => builder.WithInMemoryDefaults(), // No provider needed for in-memory
(splat, instance) => splat.RegisterLazySingleton(() => instance));
3. Use the Cache
Basic Operations
// Store an object
var user = new User { Name = "John", Email = "[email protected]" };
await CacheDatabase.UserAccount.InsertObject("current_user", user);
// Retrieve an object
var cachedUser = await CacheDatabase.UserAccount.GetObject<User>("current_user");
// Store with expiration
await CacheDatabase.LocalMachine.InsertObject("temp_data", someData, DateTimeOffset.Now.AddHours(1));
// Get or fetch pattern
var data = await CacheDatabase.LocalMachine.GetOrFetchObject("api_data",
async () => await httpClient.GetFromJsonAsync<ApiResponse>("https://api.example.com/data"));
Cache Types
Akavache provides four types of caches:
UserAccount: User settings and preferences that should persist and potentially sync
LocalMachine: Cached data that can be safely deleted by the system
Secure: Encrypted storage for sensitive data like credentials and API keys
InMemory: Temporary storage that doesn't persist between app sessions
// User preferences (persistent)
await CacheDatabase.UserAccount.InsertObject("user_settings", settings);
// API cache (temporary)
await CacheDatabase.LocalMachine.InsertObject("api_cache", apiData, DateTimeOffset.Now.AddHours(6));
// Sensitive data (encrypted)
await CacheDatabase.Secure.SaveLogin("john.doe", "secretPassword", "myapp.com");
// Session data (in-memory only)
await CacheDatabase.InMemory.InsertObject("current_session", sessionData);
NuGet Packages
Install the packages that match your needs. At minimum you need the core package plus a storage backend and a serializer.
Purpose
Package
NuGet
Core (in-memory cache)
Akavache
SQLite persistence
Akavache.Sqlite3
Encrypted SQLite persistence
Akavache.EncryptedSqlite3
System.Text.Json serializer (recommended)
Akavache.SystemTextJson
System.Text.Json BSON serializer
Akavache.SystemTextJson.Bson
Newtonsoft.Json serializer
Akavache.NewtonsoftJson
HTTP download and caching extensions
Akavache.HttpDownloader
Image/bitmap caching
Akavache.Drawing
Application settings helpers
Akavache.Settings
Installation
Akavache uses a modular package structure. Choose the packages that match your needs:
Recommendation: Use System.Text.Json for new projects for best performance. Use Newtonsoft.Json when migrating from older Akavache versions or when you need maximum compatibility.
Akavache.Settings: Configuration Made Easy
Akavache.Settings provides a specialized settings database for application configuration that survives app updates and reinstalls.
Quick Settings Example
using Akavache.Settings;
// 1. Create a settings class — properties are IObservable<T>
public class AppSettings : SettingsBase
{
public AppSettings() : base(nameof(AppSettings)) { }
public IObservable<bool> EnableNotifications => GetOrCreateObservable(true);
public IObservable<Unit> SetEnableNotifications(bool value) => SetObservable(value, nameof(EnableNotifications));
public IObservable<string> UserName => GetOrCreateObservable("DefaultUser");
public IObservable<Unit> SetUserName(string value) => SetObservable(value, nameof(UserName));
}
// 2. Initialize with your app
var appSettings = default(AppSettings);
AppBuilder.CreateSplatBuilder()
.WithAkavache<SystemJsonSerializer>(builder =>
builder.WithApplicationName("MyApp")
.WithSqliteProvider()
.WithSettingsStore<AppSettings>(settings => appSettings = settings));
// 3. Use the settings — subscribe for live updates or read once
await appSettings.SetUserName("John Doe");
await appSettings.SetEnableNotifications(false);
var name = await appSettings.UserName.FirstAsync();
Console.WriteLine($"User: {name}");
Settings are automatically persisted and will survive app updates, making them perfect for user preferences and application configuration.
Documentation
📚 Complete documentation is available in the /docs folder:
Installation Guide - Detailed installation and package selection
Configuration - Builder pattern, providers, and advanced setup
Serializers - System.Text.Json vs Newtonsoft.Json comparison
Cache Types - UserAccount, LocalMachine, Secure, and InMemory caches
Basic Operations - CRUD operations and error handling
Migration: V10 → V11 - Upgrading from V10.x to V11.x
Migration: V11 → V12 - Upgrading from V11.x to V12.x
JetBrains gives ReactiveUI's maintainers licences for its tools through its
open source support programme.
Anthropic supports them with Claude through
Claude for Open Source.
OpenAI supports them with Codex through
Codex for Open Source.
This project is tested with BrowserStack.
See our sponsors for more information.
JetBrains, Claude, Anthropic, OpenAI and Codex names and logos are trademarks of their respective owners.
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/reactiveui/Akavache là nguồn chính thức.
reactiveui/Akavache có bao nhiêu sao?
reactiveui/Akavache có 2.5k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/reactiveui/Akavache. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
reactiveui/Akavache có phải mã nguồn mở không?
Có — reactiveui/Akavache phát hành theo license MIT, nghĩa là mã nguồn mở để đọc, fork và (tùy license) tái sử dụng. Mã: github.com/reactiveui/Akavache.
reactiveui/Akavache còn đang phát triển không?
Commit gần nhất trên reactiveui/Akavache là 3 tháng trước (theo timestamp GitHub). Repo có 280 fork — một chỉ báo về mức độ quan tâm của cộng đồng.
reactiveui/Akavache là gì?
reactiveui/Akavache (reactiveui/Akavache) là dự án C# trên GitHub. Theo mô tả gốc: An asynchronous, persistent key-value store for .NET desktop and mobile applications, backed by SQLite. Suited to both durable data such as user settings and cached data that expires, with optional encryption and System.Text.Json serialization.
reactiveui/Akavache so với các dự án Backend khác thế nào?
reactiveui/Akavache được TopGit xếp vào nhóm Backend, với 2.5k sao GitHub và viết bằng C#. Xem trang chủ đề Backend trên TopGit để so sánh với các dự án tương tự theo số sao và mức độ hoạt động.
Đọc đầy đủ README ở tab phía trên.
Vẫn đang phân vân về Akavache?
Một cú bấm sẽ gửi câu hỏi kèm trang này cho AI — xem AI nói gì về Akavache.