标签: lazy-initialization

在C++中,对于多阶段构造/初始化对象,有什么好的现有类/设计模式？

我有一个带有一些数据成员的类,应该在程序流程的不同点初始化,因此必须延迟它们的初始化.例如,可以从文件中读取一个参数,从网络中读取另一个参数.

目前我使用boost :: optional来延迟构建数据成员,但是让我感到烦恼的是,optional在语义上与delay-construct不同.

我需要提醒boost :: bind和lambda部分函数应用程序的功能,并且使用这些库我可以设计多阶段构造 - 但我更喜欢使用现有的测试类.(或许还有另一种我不熟悉的多阶段建筑模式).

我一直在使用gcc const和pure属性来返回指向"常量"数据的函数,这些数据在第一次使用时被分配和初始化,即每次调用时函数将返回相同的值.作为一个例子(不是我的用例,但是一个众所周知的例子)想到一个函数,它在第一次调用时分配和计算trig查找表,并在第一次调用后返回指向现有表的指针.

问题:我被告知这种用法不正确,因为这些属性禁止副作用,并且如果不使用返回值,编译器甚至可以在某些情况下完全优化调用.我对const/ pureattributes的使用是安全的,还是有任何其他方法告诉编译器对该N>1函数的调用等效于对该函数的1次调用,但是该函数的1次调用是否等同于对函数的0调用？或者换句话说,该函数在第一次被调用时只有副作用？

我想使用Lazy<T>我的类中的行为来确保某个操作只发生一次.我之前做过这个,通过一个Lazy本质上调用一个Func做某事然后返回一个空值.我不关心返回值,我只是想确保事情只发生一次.

我在想它可以被称为Once.我会自己构建它并在Lazy内部使用它,如果它还不存在,但我想在做之前先问一下.谢谢!

从.NET 4开始,Lazy<T>可以用来懒惰地初始化对象.直观地,懒惰初始化也可以在公共属性的getter中执行,以向调用者提供相同的功能.我想知道是否Lazy<T>提供了后者的任何固有优势,因此应该优先考虑？

就个人而言,我觉得Lazy<>可以迅速降低代码的可读性,但也许我刚看到它被误用了.从好的方面来说,它确保了线程的安全性,但是有很多.NET同步结构 - 也许我错了 - 让它很容易在getter中实现相同的功能.

选择最佳方法时需要注意哪些注意事项？

我正在尝试在 youtube 中实现一个示例，导师做对了，但我遇到了错误。
我已经有一个私有构造函数，我的代码中不能有公共构造函数。

private static int _InstanceCount = 0;

private SingletonDemo1()
{
    _InstanceCount++;
    Console.WriteLine("Instance Count: " + _InstanceCount.ToString());
}

private static readonly Lazy<SingletonDemo1> _Instance = new Lazy<SingletonDemo1>();

public static SingletonDemo1 Instance
{
    get
    {                               
        return _Instance.Value;
    }
}

我意识到Lazy使用 Dagger 完成注入的推荐方法是添加Lazy到字段注入点。例如，

class Foo {
    @Inject lateinit var bar: Lazy<Bar>

    fun useBar() = bar.get().doSomething()
}

使用构造函数注入怎么样？我还没有看到有人这样做。

class Foo @Inject constructor(private val fizz: Fizz,
                              private val bar: Lazy<Bar>) {    
    fun useBar() = bar.get().doSomething()
}

总结一下，在进行 Dagger 延迟注入时，我可以Lazy<Bar>在构造函数中使用吗？或者我唯一的选择是转移Lazy<Bar>到字段注入，同时将其他非惰性依赖项保留在通过构造函数注入的同一类中？

感谢您的指点！

我正在使用CDI 1.0的Weld实现,我找不到如何在Spring中使用bean的方式(使用@Lazy或lazy-init在XML中).有没有办法告诉CDI Injector不要在启动时初始化bean？

我收到错误

无法在当前上下文中推断闭包类型

在使用Swift 1.2的代码中

private lazy var _messagesVC =  { return MessagesViewController(nibName:"MessagesViewController",bundle:nil)}()

整个视图控制器,我收到此错误

import UIKit
class FriendsViewController: UIViewController {

@IBOutlet weak var containerView: UIView!
@IBOutlet weak var segmentContainerView: UIView!
private lazy var _connectionVC  =  { return FriendsConnectionViewController(nibName:"FriendsConnectionViewController",bundle:nil)}()
private lazy var _messagesVC =  { return MessagesViewController(nibName:"MessagesViewController",bundle:nil)}()


override func viewDidLoad() {
    super.viewDidLoad()
    self.selectedControllerFrom(index: 0)
     // Do any additional setup after loading the view.
}

override func viewWillAppear(animated: Bool) {
    super.viewWillAppear(animated)

}

func selectedControllerFrom(index index:UInt)
{
    var vc:UIViewController?
    switch index{
    case 0: vc …

Android数据绑定支持最酷的功能之一是它还为View设置了ID字段.这样可以整理代码库,因为不需要字段或findViewById()调用.

但问题是绑定实例只能通过bind()调用来检索,该调用往往会调度绑定.当异步接收数据并且通常NullPointerException抛出数据时,这是不好的.

可以检索带有View字段的绑定实例减去实际的数据绑定过程吗？

堆栈跟踪:

java.lang.NullPointerException: Attempt to invoke virtual method 'boolean java.lang.Boolean.booleanValue()' on a null object reference
         at com.app.android.databinding.ActivityRestaurantDetailsBinding.executeBindings(ActivityRestaurantDetailsBinding.java:381)
         at android.databinding.ViewDataBinding.executePendingBindings(ViewDataBinding.java:350)
         at android.databinding.ViewDataBinding$6.run(ViewDataBinding.java:167)
         at android.databinding.ViewDataBinding$5.onViewAttachedToWindow(ViewDataBinding.java:137)
         at android.view.View.dispatchAttachedToWindow(View.java:14525)

我们现在有了一种创建惰性变量的新方法。它在swift-evolution/proposals/0258-property-wrappers.md 中有描述：

@propertyWrapper
enum Lazy<Value> {
    case uninitialized(() -> Value)
    case initialized(Value)

    init(wrappedValue: @autoclosure @escaping () -> Value) {
        self = .uninitialized(wrappedValue)
    }

    var wrappedValue: Value {
        mutating get {
            switch self {
            case .uninitialized(let initializer):
                let value = initializer()
                self = .initialized(value)
                return value
            case .initialized(let value):
                return value
            }
        }
        set {
            self = .initialized(newValue)
        }
    }
}

它是线程安全的实现吗？如果没有，如何重现非线程安全行为？