Neat solution, but each instance of LifetimeManager should use a unique key rather than a constant: private string _key = string.Format(“PerCallContextLifeTimeManager_{0}”, Guid.NewGuid()); Otherwise if you have more than one object registered with PerCallContextLifeTimeManager, they’re sharing the same key to access CallContext, and you won’t get your expected object back. Also worth implementing RemoveValue to ensure … Read more
In the first example, your objects don’t overlap in time: one is created then destroyed, then another is created with the same id. When you compare them with is, you are holding onto both objects, so they get different ids.
What T: ‘a is saying is that any references in T must outlive ‘a. What this means is that you can’t do something like: let mut o: Option<&str> = Some(“foo”); let mut nt = NewType { x: &o }; // o has a reference to &’static str, ok. { let s = “bar”.to_string(); let o2: … Read more
No, this is not safe. More precisely this is UB, means anything is possible. When you pass 123.0 + 2.0 to the constructor of Foo, a temporary double will be constructed and bound to the parameter fx. The temporary will be destroyed after the full expression (i.e. Foo p(123.0 + 2.0);), then the reference member … Read more
Let’s compare the two definitions. First, the trait method: fn to_c<‘a>(&self, r: &’a Ref) -> Container<‘a>; And the implementation: fn to_c(&self, r: &’a Ref) -> Container<‘a>; See the difference? The latter doesn’t have <‘a>. <‘a> has been specified elsewhere; the fact that it has the same name does not matter: it is a different thing … Read more
You cannot do this because it would allow you to circumvent runtime checks for uniqueness violations. RefCell provides you a way to “defer” mutability exclusiveness checks to runtime, in exchange allowing mutation of the data it holds inside through shared references. This is done using RAII guards: you can obtain a guard object using a … Read more
This is a case for Higher Ranked Trait Bounds (HRTB). The point is that you do not want &L to implement IntoIterator<Item = &T> for one lifetime but for all potential lifetimes that L may happen to have. In this case, you need to use a Higher Ranked Trait Bound: for<‘a> will take care of … Read more
You want a session management strategy that allows your app to function effectively and take advantage of the things that NHibernate gives you – most notably caching and lazy loading. Creating sessions is an inexpensive process and requires little up-front RAM or CPU, so you shouldn’t worry about conserving or re-using sessions (indeed, re-using them … Read more
You can’t forcibly extend a value’s lifetime; you just have to return the full Vec. If I may ask, why do you want to return the slice itself? It is almost always unnecessary, since a Vec can be cheaply (both in the sense of easy syntax and low-overhead at runtime) coerced to a slice. Alternatively, … Read more
A really common pitfall in C++ programs, and even in Java programs, is modifying a collection while iterating over it, like this: for (it: collection) { if (predicate(*it)) { collection.remove(it); } } For C++ standard library collections, this causes undefined behaviour. Maybe the iteration will work until you get to the last entry, but the … Read more