如何在dart中实现具有异步初始化和空安全性的singleton

Question

我需要一个用于共享首选项的Singleton，它具有异步初始化功能，但也可以使用零安全性。通常我使用下面的singleton实现，但使用null安全性的singleton的最佳方式是什么？

class SharedPrefs {
static SharedPrefs _instance;
static Future<Null> _mutex;
static Future<SharedPrefs> getInstance() async {
if (_mutex != null) {
await _mutex;
}
var completer = Completer<Null>();
_mutex = completer.future;
if (_instance == null) {
_instance = SharedPrefs();
await _instance.init();
}
completer.complete();
_mutex = null;
return _instance;
}
SharedPreferences prefs;
SharedPrefs();
Future<SharedPrefs> init() async {
SharedPreferences prefs = await SharedPreferences.getInstance();
return this;
}
dynamic get(String key) {
return prefs.getString(key);
}
Future<bool> put(String key, dynamic value) async {
return await prefs.setString(key,value);
}
}

Answer 1

开始：

class SharedPreferencesProvider {
static SharedPreferencesProvider? _instance;
final SharedPreferences _sharedPreferences;
static Future<SharedPreferencesProvider> getInstance() async {
if (_instance == null) {
final sharedPreferences = await SharedPreferences.getInstance();
_instance = SharedPreferencesProvider._(sharedPreferences);
}
return _instance!;
}
SharedPreferencesProvider._(SharedPreferences sharedPreferences)
: _sharedPreferences = sharedPreferences;

Answer 2

初始化第一个单例

class Singleton {
late Map<String,String> obj;
Db._();
static Db? _instance;
static Db get inst => _instance ??= Db._();
init () async {
// await ...
obj = {'a': 1};
}
}
void main () async {
// put init first
await Db.inst.init();
// your other code
// your other code
print(Db.inst.obj);
// your other code
// your other code

}

我在所有语言中都使用这种方法，它稳定且易于理解。

一个经过测试的例子

db.dart

import 'package:mongo_dart/mongo_dart.dart' as Mongo;
class Db {
late Mongo.DbCollection test;
Db._();
static Db? _instance;
static Db get inst => _instance ??= Db._();
init () async {
var db = Mongo.Db("mongodb://localhost:27017/");
await db.open();
test = db.collection('test');
}
}

test.dart

import 'package:mj_desk_server/db.dart';
void main () async {

await Db.inst.init();

myApp();
}
myApp () async {
// do anything
// do anything
// do anything
print(await Db.inst.test.find().toList());
print('ok');
}

Answer 3

当对SharedPreferencesProvider.getInstances()进行两次背靠背调用时，不确定接受的答案是否有效

无论getInstance()方法得到多少背靠背调用，以及创建需要多少时间，以下代码都应该有效

class SharedPreferencesProvider {
static SharedPreferences? _backingFieldPrefs;
static Future<SharedPreferences>? _prefsFuture;
static Future<SharedPreferences> getInstance() async {
if (_backingFieldPrefs != null) {
return _backingFieldPrefs!;
}
_prefsFuture ??= await SharedPreferences.getInstance();
_backingFieldPrefs ??= await _prefsFuture!;
return _backingFieldPrefs!;
}
}

Answer 4

我认为最简单的解决方案(同时也是安全的(将Future缓存在静态的final属性中。根本不需要任何可以为null的类属性。

import 'package:shared_preferences/shared_preferences.dart';
class SharedPreferencesProvider {
static final _instance = () async {
final sp = await SharedPreferences.getInstance();
return SharedPreferencesProvider._(sp);
}();
static Future<SharedPreferencesProvider> getInstance() => _instance;
const SharedPreferencesProvider._(SharedPreferences sharedPreferences)
: _sharedPreferences = sharedPreferences;

final SharedPreferences _sharedPreferences;
}