给定以下代码片段，如何将成员变量传递_tenantContext到Lazy<CloudBlobContainer>构造函数中？
public class BlobStorage : IStorage
{
private readonly ITenantContext _tenantContext;
public BlobStorage(ITenantContext tenantContext)
{
_tenantContext = tenantContext;
}
private readonly Lazy<CloudBlobContainer> _blobcontainer = new Lazy<CloudBlobContainer>(() =>
{
var connectionString = ConfigurationManager.ConnectionStrings["FileStorage"].ConnectionString;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer = blobClient.GetContainerReference("attachments");
blobContainer.CreateIfNotExists();
return blobContainer;
});
我想使用Rust和once_cell来实现一些静态const结构实例，并且一个静态const向量包含这些静态结构实例。
这是示例代码：
use once_cell::sync::Lazy;
pub struct Kind {
name: String,
value: i32,
}
impl Kind {
pub fn new(name: &str, value: i32) -> Kind {
Kind {name: String::from(name), value}
}
}
const HYBRID: Lazy<Kind> = Lazy::new(|| Kind::new("a", 1));
const BOND: Lazy<Kind> = Lazy::new(|| Kind::new("b", 2));
// other instances
static KINDS: Lazy<Vec<Kind>> = Lazy::new(|| {
vec![
HYBRID,
BOND,
// other instances,
]
});
这是编译器错误：
use once_cell::sync::Lazy;
pub struct Kind {
name: String,
value: i32,
}
impl Kind {
pub …static存储在编译时决定.但是,请考虑我们在函数中进行大量延迟初始化的情况:
void foo ()
{
static int a[1000];
}
我不是在讨论这里的编码实践,而是讨论技术方面.由于执行了许多其他类似 foo()的功能,static因此将在数据段上引入这些许多变量.
在为数据段分配空间时,编译器是否也会在帐户中进行延迟初始化.如果'否'那么,它会在代码执行时在运行时导致分段错误吗？(当方法static内部有大量数据时更有可能发生template).
我的游戏有一个像这样的声音对象:
object Sounds {
SoundFactory.setAssetBasePath("mfx/")
val EXPLOSION_0 = ESound("explosion1.ogg")
val EXPLOSION_1 = ESound("explosion2.ogg")
val EXPLOSION_2 = ESound("explosion3.ogg")
val IMPACT_0 = ESound("impact1.ogg", 0.4f)
val IMPACT_1 = ESound("impact2.ogg", 0.4f)
val IMPACT_2 = ESound("impact3.ogg", 0.4f)
val BONUS = ESound("bonus.ogg", 0.7f)
// -- snip --
def load() {
println("Sounds loaded")
}
case class ESound(sound_file: String, volume: Float = 1) {
private val sound = SoundFactory.createSoundFromAsset(AndEngine.engine.getSoundManager, AndEngine.activity.get, sound_file)
sound.setVolume(volume)
sound.setLoopCount(0)
def play() { sound.play() }
}
}
为简洁起见,我删除了许多方法等.但基本的想法是Scala懒惰地load()将对象初始化,所以我第一次在这个对象上调用一些方法()它会被初始化.这将在例如纹理加载等之后完成.
但是使用上面的代码,我第一次按下游戏中的某个菜单按钮时,我得到一个长时间的停顿,因为它只会加载所有这些声音(由SoundFactory.createSound...构造函数中的引起).
现在,如果我将load …
我正在努力学习Hibernate,我来了hibernate lazy initialization.我对此有一些澄清lazy initialization.
首先,什么是所谓的Lazy初始化,它做什么？其次,我该什么时候去？接下来,我发现,在博客中说,使用它可以提高性能,我只需要知道如何.那么,有没有使用它的缺点？任何人都可以帮我理解这个lazy initialization吗？
我想知道是否有可能在我的视图控制器中使用惰性属性，并在deinit方法中仅在初始化时才调用我的惰性属性的方法。下面是一些代码：
fileprivate lazy var session: MySession = {
let session: MySession = MySession()
session.delegate = self
return session
}()
deinit {
session.delete()
}
这样，当方法session.delete()中deinit被调用且session尚未使用时（仍然如此nil），它会被初始化，然后delete被调用。我不想要这个。我只想在之前已初始化的delete情况下调用。session
有办法实现这一点吗？我必须放弃惰性初始化的想法吗？
我正在尝试构建一个包含在子类中初始化的属性的字符串.
我读到了懒惰的初始化,但不知怎的,这不像我预期的那样工作.
abstract class SubProcessFullNameBuilder(technicalDomain: TechnicalDomainEnumeration) {
protected val moduleName = "td.${technicalDomain.value().toLowerCase()}.shared"
private val packageName by lazy { packageName() }
private val processName by lazy { processName() }
val processFullName: String = "$moduleName/$packageName.$processName"
protected abstract fun packageName(): String
protected abstract fun processName(): String
}
class WorkerFullNameBuilder(
private val jmsDirection: JmsDirectionEnumeration,
technicalDomain: TechnicalDomainEnumeration,
private val cdmCode: String) : SubProcessFullNameBuilder(technicalDomain) {
override fun packageName() = "$moduleName.workers.${jmsDirection.value().toLowerCase()}.${cdmCode.toLowerCase()}"
override fun processName() = "Worker"
}
既然我已经覆盖了packageName()和processName()性质,我希望上调用packageName,它将使用从子类的实现财产.
但是,当我打电话给processFullName财产时,它会抛出一个 …
我正面临着有趣的 LazyInitializationException 解决方案。为了防止这种情况（在 OneToMany 或 ManyToMany 上），一种已知的解决方案是使用 JOIN FETCH Query。你可以看到她的几个例子之一：https ://thoughts-on-java.org/best-practices-for-many-to-many-associations-with-hibernate-and-jpa/
其他更简单的解决方案是使用 Spring 中的 @Transactional。例如像这样：
@DeleteMapping(value ="/product/{tagId}")
@ResponseBody
@Transactional
public String deleteProductWithoutRelation(@PathVariable String product, Model model) {
Optional<Product> pr = productService.selectProduct(product);
if (pr.isPresent()) {
tag.get().getCustomer().size(); //usualy throws LazyInitializationException,
//without JOIN-FETCH Statment or @Transactional
return deletedTagId;
}
当然，您可以在存储库服务中放置一些方法的@Transactional，以封装此解决方案。那么这两种解决方案的优点或缺点是什么？
我想在我的 Kotlin 代码中尝试一些新的委托属性。我在文档中发现，对于自定义委托属性，我需要创建一个具有强制性方法的类 -getValue以及可选的setValue，它们是文档中提到的接口的一部分：
您可以将委托创建为匿名对象，而无需使用接口
ReadOnlyProperty和ReadWritePropertyKotlin 标准库创建新类
我开始研究 Kotlin 的内置委托函数。我研究了lazy如下函数的实现：
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
这就是我的问题所在：为什么它实际上有效？ Lazy接口只有value属性和一些确定其值初始化的方法。SynchronizedLazyImpl没有比这更多的了。他们都没有getValue或setValue方法，那么为什么 Kotlin 不抱怨并成功编译？
假设我有一个包含 的结构Option<Resource>，其中Resource我需要使用某种类型，需要分配外部资源（在实际情况下是 GPU 内存），因此可能会失败。在方法内部，如果尚未完成分配，我想尝试分配，但如果失败则传播或处理错误。
如果没有失败案例Option::get_or_insert_with就完美了。事实上，我想到的最简洁的解决方案涉及一个unwrap()，这是不优雅的，因为它看起来像是潜在的恐慌：
struct Container {
resource: Option<Resource>,
...
}
impl Container {
...
fn activate(&mut self) -> Result<(), Error> {
if self.resource.is_none() {
self.resource = Some(Resource::new()?);
}
let resource: &mut Resource = self.resource.as_mut().unwrap();
// ... now do things with `resource` ...
Ok(())
}
...
}
Option有没有比这更简单的初始化方法？需要明确的是，我不仅仅寻求避免unwrap()，而且还寻求整体可读性。如果替代方案更加复杂和间接，我宁愿坚持这个。
完整的示例代码（在 Rust Playground 上）：
#[derive(Debug)]
struct Resource {}
#[derive(Debug)]
struct Error;
impl Resource {
fn new() …