77

我是 C# 新手，正在学习新单词。在编写 c# 时，我发现很难理解这两个词的含义。我在字典中查找了含义，这就是我得到的：

隐式

“隐含的东西以间接的方式表达。”

“如果某种品质或元素隐含在某事物中，它就包含在其中或被它表现出来；”

显式

“明确而公开地表达或显示的东西，没有任何隐藏任何东西的企图”

“如果你对某事直言不讳，你就会非常公开和清楚地谈论它。”

我想用 C# 来理解它。

谢谢你的帮助。

干杯

附加信息：

这是我现在正在阅读的书中的一部分句子，其中包含“隐式”一词

“这意味着里面的 Area 和 OccupantsAreaPerPerson( ) 隐式引用了在调用的对象中找到的那些变量的副本AreaPerPerson( )”

我完全不明白这句话在这里想说什么。

4

8 回答 8

141

C# 中的implicitandexplicit关键字用于声明转换运算符。假设您有以下课程：

public class Role
{
    public string Name { get; set; }
}

如果您想创建一个新的Role并为其分配一个Name，您通常会这样做：

Role role = new Role();
role.Name = "RoleName";

由于它只有一个属性，如果我们可以这样做可能会更方便：

Role role = "RoleName";

这意味着我们希望将字符串隐式转换为 a Role（因为代码中不涉及特定的强制转换）。为此，我们添加了一个隐式转换运算符：

public static implicit operator Role(string roleName)
{
    return new Role() { Name = roleName };
}

另一种选择是实现显式转换运算符：

public static explicit operator Role(string roleName)
{
    return new Role() { Name = roleName };
}

在这种情况下，我们不能将字符串隐式转换为 a Role，但我们需要在代码中对其进行强制转换：

Role r = (Role)"RoleName";
于 2009-07-24T09:47:56.430 回答
66

一般来说

  • 隐式：某事正在自动为您完成。
  • 明确的：你在源代码中写了一些东西来表明你想要发生的事情。

例如：

int x = 10;
long y = x; // Implicit conversion from int to long
int z = (int) y; // Explicit conversion from long to int

隐式和显式在不同的上下文中被大量使用，但一般含义将始终沿着这些思路。

请注意，有时两者可以结合在一起。例如：

int x = 10;
long y = (long) x; // Explicit use of implicit conversion!

（显式转换是必须显式说明的转换；隐式转换是可以隐式使用的转换，即无需代码说明。）

于 2009-07-24T09:43:50.323 回答
9

考虑你有两个类：

internal class Explicit
{
    public static explicit operator int (Explicit a)
    {
        return 5;
    }
}


internal class Implicit
{
    public static implicit operator int(Implicit a)
    {
        return 5;
    }
}

和两个对象：

var obj1 = new Explicit();
var obj2 = new Implicit();

你现在可以写：

int integer = obj2; // implicit conversion - you don't have to use (int)

或者：

int integer = (int)obj1; // explicit conversion

但：

int integer = obj1; // WON'T WORK - explicit cast required

当转换不丢失任何精度时，应使用隐式转换。显式转换意味着您可以降低一些精度，并且必须清楚地说明您知道自己在做什么。

还有另一个应用隐式/显式术语的上下文 - 接口实现。在这种情况下没有关键字。

internal interface ITest
{
    void Foo();
}

class Implicit : ITest
{
    public void Foo()
    {
        throw new NotImplementedException();
    }
}

class Explicit : ITest
{
    void ITest.Foo() // note there's no public keyword!
    {
        throw new NotImplementedException();
    }
}

Implicit imp = new Implicit();
imp.Foo();
Explicit exp = new Explicit();
// exp.Foo(); // won't work - Foo is not visible
ITest interf = exp;
interf.Foo(); // will work

所以当你使用显式接口实现时，当你使用具体类型时，接口的方法是不可见的。这可以在接口是帮助接口时使用，而不是类的主要职责的一部分，并且您不希望其他方法误导使用您的代码的人。

于 2009-07-24T09:45:52.690 回答
2

我认为这个链接很清楚什么是隐式转换 - 这是你不需要在赋值中显式转换值的地方。所以，而不是做

myDigit = (Digit) myDouble

...你可以这样做：

myDigit = myDouble;
于 2009-07-24T09:44:40.027 回答
1

在 C# 中明确表达主要是为了清楚明确地表达你的意图。

例如：

class MyClass
{
    string myField;

    void MyMethod(int someNumber)
    {

    }
}

在上面的代码中，类、字段和方法的可见性都是隐含的。他们使用编译器默认值。

现在，我永远不记得编译器的默认值是什么，也许你的同事也不记得，所以与其依赖每个人都记住默认值是什么，你可以是明确的。

public class MyClass
{
    private string myField;

    public void MyMethod(int someNumber)
    {
    }
}
于 2009-07-24T09:44:07.407 回答
0

隐式可以视为隐式，但显式意味着您声明必须自己完成。就像演员一样。这是一个隐式转换：

int implicit;
implicit = 7.5;

值 '7.5' 将隐式转换为 int。这意味着编译器会为你做这件事。

这里是明确的：

int explicit;
explicit = (int)7.5;

在这里你告诉编译器你想要它强制转换。您明确声明转换。希望有帮助。来源：http ://cboard.cprogramming.com/cplusplus-programming/24371-implicit-explicit.html

于 2016-08-17T00:52:54.087 回答
0

因为 C# 在编译时是静态类型的。

隐式转换：不需要特殊语法，因为转换总是成功并且不会丢失任何数据。示例包括从较小的整数类型到较大的整数类型的转换，以及从派生类到基类的转换。

显式转换（强制转换）：显式转换需要强制转换表达式。当转换中可能会丢失信息，或者由于其他原因转换可能不成功时，需要进行强制转换。典型示例包括将数值转换为精度较低或范围较小的类型，以及将基类实例转换为派生类。

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }

    public static explicit operator Person(Employe employe) => new Person { Id = employe.Id, Name = employe.Name };
}

public class Employe
{

    public int Id { get; set; }
    public string Name { get; set; }
    public string Family { get; set; }

    public static implicit operator Employe(Person person) => new Employe { Id = person.Id, Name = person.Name };
}

static void Main(string[] args)
{
    Person person = new Person() { Id = 1, Name = "Reza" };

    //implicit operator
    Employe employe = person;
    employe.Family = "Jenabi";

    //explicit operator
    Person person1 = (Person)employe;
}
于 2020-10-02T11:23:10.220 回答
0

Microsoft 代码生成器使用关键字“var”表示隐式，但我认为重要的是要注意

var builder = WebApplication.CreateBuilder(args);

和

WebApplicationBuilder? builder = WebApplication.CreateBuilder(args);

是一样的，但是

var builder = WebApplication.CreateBuilder(args);

和

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

不一样。

为了代码清晰起见，我总是更喜欢 Explicit，但正如您所见，Microsoft 的代码生成器没有。从代码执行的角度来看，没有性能差异。

于 2022-03-04T19:17:38.023 回答