явный и неявный c#

В целом

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

Например:

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!

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

Предположим, у вас есть два класса:

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

Поэтому, когда вы используете явную реализацию интерфейса, методы интерфейса не видны, когда вы используете конкретный тип.

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

myDigit = (Digit) myDouble 

... вы можете просто сделать:

myDigit = myDouble;

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

Например:

class MyClass
{
    string myField;

    void MyMethod(int someNumber)
    {

    }
}

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

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

public class MyClass
{
    private string myField;

    public void MyMethod(int someNumber)
    {
    }
}

Это отличный ресурс для изучения C #: http://www.functionx.com/csharp/

Взгляните конкретно сюда: http: // www.functionx.com/csharp/math/Lesson20.htm[12126 impression