Явный и неявный С#

Я новичок в С# и изучаю новые слова. Мне трудно понять, что означает эти два слова, когда дело доходит до программирования С#. Я заглянул в словарь по смыслу, и вот что я получил:

Неявное

"Что-то неявное выражается косвенным образом".

"Если качество или элемент что-то скрыто, оно задействовано в нем или показано им;"

Явное

"То, что явствует, выражается или отображается четко и открыто, без каких-либо попыток скрыть что-либо"

"Если вы явно о чем-то говорите, вы говорите об этом очень открыто и ясно".

Я хотел бы понять это на С#.

Спасибо за вашу помощь.

Приветствия

Дополнительная информация:

Вот часть предложения в книге, которую я сейчас читаю, у которого есть это слово "неявное"

"Это означает, что Area и Occupants внутри AreaPerPerson( ) неявно относятся к копиям тех переменных, которые находятся в объекте, который вызывает AreaPerPerson( )"

Я совершенно не понимаю, что здесь пытается сказать это предложение.

Ответы

Ответ 1

implicit и explicit ключевые слова в С# используются при объявлении операторов преобразования. Скажем, что у вас есть следующий класс:

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

Если вы хотите создать новый Role и назначить ему Name, вы, как правило, выполните следующее:

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

Поскольку у него есть только одно свойство, возможно, было бы удобно, если бы мы могли сделать это следующим образом:

Role role = "RoleName";

Это означает, что мы хотим неявно преобразовать строку в 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 };
}

В этом случае мы не можем неявно преобразовать строку в Role, но нам нужно указать ее в нашем коде:

Role r = (Role)"RoleName";

Ответ 2

В общем

  • Неявно: что-то делается для вас автоматически.
  • Явно: вы написали что-то в исходном коде, чтобы указать, что вы хотите.

Например:

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!

(Явное преобразование - это то, которое должно быть указано явно, неявная версия - это та, которая может использоваться неявно, т.е. без кода, который должен ее указать).

Ответ 3

У вас есть два класса:

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 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

Поэтому, когда вы используете явную реализацию интерфейса, методы интерфейса не видны при использовании конкретного типа. Это можно использовать, когда интерфейс является вспомогательным интерфейсом, а не частью основной ответственности класса, и вы не хотите, чтобы дополнительные методы вводили в заблуждение кого-то, использующего ваш код.

Ответ 4

Я думаю, эта ссылка позволяет понять, что такое неявное преобразование - это то, где вам не нужно явно указывать значение в задании. Итак, вместо того, чтобы делать

myDigit = (Digit) myDouble

... вы можете просто:

myDigit = myDouble;

Ответ 5

Явное выражение в С# в основном демонстрирует ваши намерения четко и недвусмысленно.

Например:

class MyClass
{
    string myField;

    void MyMethod(int someNumber)
    {

    }
}

В приведенном выше коде подразумевается видимость класса, поля и метода. Они используют настройки по умолчанию для компилятора.

Теперь я никогда не могу вспомнить, что такое параметры по умолчанию для компилятора, и, может быть, ваши коллеги тоже не могут, поэтому вместо того, чтобы полагаться на всех, помнящих, что такое значения по умолчанию, вы можете быть явным.

public class MyClass
{
    private string myField;

    public void MyMethod(int someNumber)
    {
    }
}

Ответ 6

Неявный может восприниматься как подразумеваемый, но явный означает, что вы заявляете, что это должно быть сделано самостоятельно. Как с отливками. Вот неявный листинг:

int implicit;
implicit = 7.5;

Значение "7.5" будет неявно передаваться как int. Это означает, что компилятор сделает это за вас.

Здесь указано:

int explicit;
explicit = (int)7.5;

Здесь вы сообщаете компилятору, что вы хотите его отличить. Вы явно объявляете преобразование. Надеюсь, это поможет. Источник: http://cboard.cprogramming.com/cplusplus-programming/24371-implicit-explicit.html