标签: implicit-conversion

我们在域模型中使用了自定义LocalizedString类型.我们想用验证属性来装饰属性MaxLength.为此,我们添加了隐式运算符以启用此属性所需的强制转换.

奇怪的是,运算符似乎永远不会被调用,并且在属性IsValid方法中抛出了InvalidCastException .在我们自己的项目中执行此演员表.

在这个系统clr ngen'ed属性中有没有特殊的强制转换行为编译器magix？

// Custom type
public class LocalizedString
{
    public string Value
    {
        get { return string.Empty; }
    }

    public static implicit operator Array(LocalizedString localizedString)
    {
        if (localizedString.Value == null)
        {
            return new char[0];
        }

        return localizedString.Value.ToCharArray();
    }
}

// Type: System.ComponentModel.DataAnnotations.MaxLengthAttribute
// Assembly: System.ComponentModel.DataAnnotations, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35
// Assembly location: C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.ComponentModel.DataAnnotations.dll
public override bool IsValid(object value)
{
  this.EnsureLegalLengths();
  if (value == null)
  {
    return true;
  }
  else
  {
    string str = value …

Java中有一个问题是我兄弟:

通过隐式转换原始数据类型,您可能会丢失精度并获得不正确的结果.

A,B,False

答案的关键是答:是的

我认为既不会失去精确度也不会得到不正确的结果.我知道显式转换可能会失去精度并得到不正确的结果,但不是隐式转换.

例如:

int i = 9;

short s = 3;

i = s; // implicit conversion, neither loose 
      //precision nor incorrect results

s = i; // compile error, do we call this implicit conversion? 
       //if yes, then the answer to question 3 is True, 
       //but I don't think this is an implicit conversion, 
       //so I think answer is false.   

作为注释中的州:

隐式类型转换:程序员不会尝试转换类型,而是在某些情况下系统会自动转换类型.

有人可以建议吗？

非常感谢.

我将我的数据模型表示为案例类,键入可能为null的值作为Option.

case class Document(id: Long, title: String, subtitle: Option[String])

现在我尝试实例化case类:

Document(123, "The Title", "Subtitle") // Doesn't work

但是NOPE!这不起作用,我必须将可选值包装在Some中.

Document(123, "The Title", Some("Subtitle")) // Works

Scala对于类型一般非常聪明,但为什么硬编码文字或(任何字符串)与null/None不同,这是不言自明的？

通过添加这种隐式转换,我能够解决这个问题并使Scala"更加聪明"

implicit def autoSome[T](any:T) = Some(any)
Document(123, "The Title", "Subtitle") // Now it works!

问题:我是唯一一个应该提供隐式转换的语言T - > Some(T)开箱即用吗？或者是否有任何我不知道的问题是默认情况下如此广泛隐含？

我刚刚接触过akka,在学习akka-http时,我被Rest API DSL所吸引,这里是一段代码:

import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._
import akka.http.scaladsl.server.Directives._
import akka.stream.ActorMaterializer
import scala.io.StdIn

object WebServer {
   def main(args: Array[String]) {
      implicit val system = ActorSystem("my-system")
      implicit val materializer = ActorMaterializer()
      // needed for the future flatMap/onComplete in the end
      implicit val executionContext = system.dispatcher
      val route =
         path("hello") {
            get {
               complete("Say hello to akka-http")
            }
         }
      val bindingFuture = Http().bindAndHandle(route, "localhost", 8080)
      println(s"Server online at http://localhost:8080/\nPress RETURN to stop...")
      StdIn.readLine() // let it run until user presses …

我试图定义一个函数,它应该从返回一个范围1,以n类型T.这里,T作为用户输入给出,并且implicit def可以转换int为方法T.即,我想拥有但不起作用的是:

def createSeq[T](n: Int): Seq[T] = 
  1 to n map _.asInstanceOf[T]

例如,我可以打电话createSeq[Int](3),它就像一个魅力.但是,当我调用时createSeq[String](3),它仍然返回Vector(1,2,3),它包含整数而不是字符串.

请考虑以下的类定义A和B:

class A {
public:
   void func() const {}
};

class B {
public:
   // user-defined conversion operator to A
   operator A() const { return a_; }
private:
   A a_;
};

该类A定义了一个名为的公共成员函数func().该类B没有,但它确实为该类型定义了用户定义的转换运算符A.这样,一个实例B可以转换为一个实例A.以下代码按预期工作:

B b;
static_cast<A>(b).func(); // call func() on temporary instance of A

在上面的代码中,转换运算符通过static_cast 命名转换隐式调用.

请注意,转换运算符in B未指定为explicit允许隐式转换.但是,以下代码无法编译:

B b;
b.func(); // <-- error: 'class B' has …

我想编写一个方法,None如果集合为空,则返回该方法Some(collection).

我能得到的最好的是

implicit class CollectionExtensions[A, Repr](self: TraversableLike[A, Repr]){
  def toOption: Option[Repr] = if (self.nonEmpty) Some(self.asInstanceOf[Repr]) else None
}

但铸造.asInstanceOf[Repr]似乎是错误的.什么是正确的方法？

初步问题:

在Scala中,我想使用隐式Ordering[T]#Ops来比较两个LocalDate.

它只是用来>代替"运营商" isAfter.

它应该只是一个导入: import scala.math.Ordering.Implicits._

检查:

看起来它适用LocalTime而不是LocalDate因为LocalTime而不是LocalDate工具Comparable<LocalTime>.

题:

我想知道,

为什么要LocalDate实现Comparable<ChronoLocalDate>而不是 Comparable<LocalDate>？

在C＃中，没有从int?类型到int类型的隐式转换。

我定义了以下隐式运算符

namespace System
{
    public partial struct Int32
    {
        public static implicit operator Int32(int? v)
        {
            return (Int32)(v ?? 0);
        }
    }
}

这使我可以编译以下代码

int? nullableInt = 0;
Int32 regularInt = nullableInt;

但是如果我定义regularInt为int而不是Int32我得到以下错误

无法隐式转换类型'int？' 为“ int”。存在显式转换（您是否缺少演员表？）

我期望int并且Int32可以互换，但是显然在构建C＃语言时并未考虑到此功能。

不能定义此操作背后是否有技术原因，是否已做出决定以防止潜在的代码气味？

我知道定义这样的隐式运算符可能会导致某些非常意外的行为，因为从null值到0整数的转换并非在每种情况下都有意义。这个问题更多的是“为什么不能做”比“为什么做这是一个真正的 坏主意”

我试图理解C中的隐式数据类型转换。我以为我已经理解了这个主题，但是下面的代码示例仍然让我感到困惑。

具体来说，我以前从C标准的草稿中了解了常用的算术转换和整数提升。

    unsigned short int a = 0;
    printf("\n%lld", (signed int)a - 1);

我正在使用GCC进行编译。

unsigned short int是2个字节。 int是4个字节。

运行此代码时，将得到以下结果：4294967295

我期望结果为-1。

这是我期望发生的事情：

1. Typecast优先，的LHS -变为signed int。

2. -操作已执行。由于LHS和RHS都已经存在，因此这里没有整数提升或隐式转换signed int。运算结果为-1，数据类型为signed int。

3. 在printf语句内，值-1保留在到的转换中long long int，并且-1显示为结果。

有人可以解释我的逻辑缺陷在哪里吗？