在我看来,隐式本地化优于显式本地化的优势在于,如果您有一个以上的属性可以为给定控件进行本地化,那么这是一种更经济的语法.
在你只需要本地化一些文本的情况下,我使用asp:Localize控件,它只有一个属性(Text)呈现给UI.是否有理由使用其中一个？任何风格偏好？有速度差异吗？
含蓄
<asp:Localize ID="Localize1" runat="server" meta:resourcekey="Something" />
VS
明确的
<asp:Localize ID="Localize1" runat="server" Text="<%$ Resources:Something %>" />
为什么Scala无法优化以下内容:
一个.
implicit def whatever[A](a: A) = new { ... }
至:
湾
class some$generated$name(a: A) {
...
}
implicit def whatever[A](a: A) = new some$generated$name(a)
？
为什么在这种情况下必须使用结构类型？我希望Scala编译器能够执行这种优化,因为写入样式b太丑了(因为,1.逻辑的局部性丢失了,2.你必须不必要地为这些额外的显式类创建名称),而且a的性能要差得多比b.
我读过N3291"12.8.(11/15/28)复制和移动类对象class.copy]"纠正隐式声明的移动构造函数
T(T&&)同样,移动分配,使用各自T operator=(T&&)的元素.
例:
struct CopyOnly {
CopyOnly();
CopyOnly(const CopyOnly&);
}; // declaring a copy means no implicit move.
struct Question {
std::vector<int> data_;
CopyOnly copyOnly_;
};
班级 Question
=delete剐,因为非静态数据成员data_是只可复制,但不移动？更新.可以侧面的问题:对于Question q;将std::move(q)仍然有效？复制的后备是否会在那里发生？或者隐式声明的 move-ctor会强制编译器因错误而停止吗？在这里它编译.
更新2.如果我声明move-ctor,编译器为不可移动的数据成员生成什么Question(Question&&) =default？是否然后退回到复制那些？
这是我遇到的简化.这编译:
trait A { implicit val x = 1 }
trait B extends A { val y = implicitly[Int] }
虽然这不(找不到隐含值):
trait B extends A { val y = implicitly[Int] }
trait A { implicit val x = 1 }
我试图通过指定一个自我类型来明确我的意图:trait A { this: B => ... }但无济于事.
如何处理这种依赖关系而不必担心我的代码是如何布局的？
在对SIP-13的评论中,Martin Odersky暗示可以使用多个参数创建隐式方法.根据我的经验,隐式方法总是只有一个参数,我无法想象如何使用具有多个参数的隐式方法.有人可以提供一些用例和解释吗？
我想要一个对象来实现trait Iterable并将另一个隐式参数传递给已实现的方法:
object MyRepository extends Iterable[Something] {
def iterator(implict entityManager: EntityManager): Iterator[Something] = ...
}
显然这不起作用,因为该iterator方法没有隐含参数,因此不能通过上面显示的方法实现.
示例用例是map我想要应用于存储库值的方法:
def get = Action {
Transaction { implicit EntityManager =>
val result = MyRepository.map(s => s ...)
}
}
有没有办法实现Iterable特征并捕获隐式pramameter？
我试图弄清楚如何编写一个适用于任何函数的函数交换函数Traversable[_],给定一个集合和交换索引.我想出了以下内容:
def swap[A, CC <% Traversable[A]](xs: CC, i: Int, j: Int): Traversable[A] = {
xs.slice(0, i) ++
xs.slice(j, j+1) ++
xs.slice(i+1, j) ++
xs.slice(i, i+1) ++
xs.slice(j+1, xs.size)
}
swap(List(1,2,3,4,5), 0, 4) // => List(5,2,3,4,1)
我想知道如何将它变成Traversable的隐式扩展,让我可以调用它List(1,2,3,4,5).swap(0, 4).我能得到的最接近的是:
import language.implicitConversions
class RichTraversable[A, B <% Traversable[A]](xs: B) {
def swap(i: Int, j: Int): Traversable[A] = {
xs.slice(0, i) ++
xs.slice(j, j+1) ++
xs.slice(i+1, j) ++
xs.slice(i, i+1) ++
xs.slice(j+1, xs.size)
}
}
implicit def richTraversable[A, B <% Traversable[A]](ys: …令我惊讶的是,我发现编译器无法解析以下示例中的隐含:
trait API {
def f(implicit a: Int) = ???
}
class Impl extends API {
implicit val int = 2
}
(new Impl).f
以及在
class Impl extends API
object Impl {
implicit val int = 2
}
我对此深感沮丧.为什么会这样,是否有解决方法？我必须注意,将隐式导入到外部作用域不是一个选项,因为上述的唯一目的是隐藏用户的实现细节Impl.
以上是API的实现者提供特定类型类实例的模式的摘要,这些实例被API中实现的函数使用.最终用户使用这些实现.
Scala中的类型类模式涉及定义特征,例如:
trait Show[T] {
def show(obj: T): String
}
然后,您可以定义此类型类的实例化:
object Show {
implicit val string = new Show[String] {
def show(obj: String): String = obj
}
implicit object BooleanShow extends Show[Boolean] {
def show(obj: Boolean): String = obj.toString
}
}
为伴随对象中的基本类型定义这些实例化的优点是,无论何时涉及类型类(粗略地),它们都自动在范围内.
在功能上它似乎将实例化定义为隐式val或隐式对象不会发生太大变化.
有区别吗？有一种方式比另一种更好吗？
我认为Implicit链接在应用程序启动后立即加载DLL,因为它也称为"加载时动态链接".但是我在下面的链接中找到了一些奇怪的解释(https://msdn.microsoft.com/en-us/library/253b8k2c(VS.80).aspx).
隐式链接
与程序代码的其余部分一样,DLL代码在进程启动时映射到进程的地址空间,并且只在需要时才加载到内存中.因此,.def文件用于控制以前版本的Windows中的加载的PRELOAD和LOADONCALL代码属性不再具有意义.
显式链接
隐式链接到许多DLL的应用程序启动很慢,因为Windows会在应用程序加载时加载所有DLL.为了提高启动性能,应用程序可以隐式链接到加载后立即需要的那些DLL,并等待在需要时显式链接到其他DLL.
从这里隐式链接的另一种解释(https://msdn.microsoft.com/en-us/library/151kt790.aspx).
隐式链接
Visual C++链接器现在支持DLL的延迟加载.这使您无需使用Windows SDK函数LoadLibrary和GetProcAddress来实现DLL延迟加载.
在Visual C++ 6.0之前,在运行时加载DLL的唯一方法是使用LoadLibrary和GetProcAddress; 当加载使用它的可执行文件或DLL时,操作系统将加载DLL.
从Visual C++ 6.0开始,当与DLL静态链接时,链接器提供延迟加载DLL的选项,直到程序调用该DLL中的函数.
应用程序可以使用带有辅助函数的/ DELAYLOAD(延迟加载导入)链接器选项延迟加载DLL(Visual C++提供的默认实现).辅助函数将通过为您调用LoadLibrary和GetProcAddress在运行时加载DLL .
我真的很困惑,不知道如何理解这些.
1.隐式链接是在启动时还是仅在调用DLL中的函数时加载DLL？
这意味着两者最终都是类似的,因为LoadLibrary()是在引擎盖下调用的？