explícito e implícito c#

En general

• Implícito: se está haciendo algo por ti automáticamente.
• Explícito: has escrito algo en el código fuente para indicar lo que quieres que suceda.

Por ejemplo:

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

Implícito y explícito se usan bastante en contextos diferentes, pero el significado general siempre estará en esa línea.

Tenga en cuenta que ocasionalmente los dos pueden unirse. Por ejemplo:

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

(Una conversión explícita es aquella que tienepara ser declarado explícitamente; una versión implícita es aquella que puede ser utilizada implícitamente, es decir, sin que el código tenga que declararla.)

Considera que tienes dos clases:

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


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

Y dos objetos:

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

Ahora puedes escribir:

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

O:

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

Pero:

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

La conversión implícita está destinada a ser utilizada cuando la conversión no pierde precisión. La conversión explícita significa que puedes perder algo de precisión y debes declarar claramente que sabes lo que estás haciendo.

También hay un segundo contexto en el que se aplican términos implícitos/explícitos: la implementación de la interfaz. Alli no hay palabras clave en ese caso.

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

Por lo tanto, cuando se utiliza una implementación de interfaz explícita, los métodos de interfaz no son visibles cuando se utiliza concrete type. Esto se puede usar cuando interface es una interfaz auxiliar, no es parte de la responsabilidad principal de class's y no desea métodos adicionales para engañar a alguien que usa su código.

Creo que este enlace deja bastante claro lo que es una conversión implícita - es una en la que no es necesario convertir explícitamente el valor en una asignación. Por lo tanto, en lugar de hacer

myDigit = (Digit) myDouble 

...solo puedes hacer:

myDigit = myDouble;

Ser explícito en C# se trata principalmente de mostrar sus intenciones de manera clara e inequívoca.

Por ejemplo:

class MyClass
{
    string myField;

    void MyMethod(int someNumber)
    {

    }
}

En el código anterior, la visibilidad de la clase, el campo y el método están implícitos. Utilizan los valores predeterminados del compilador.

Ahora, nunca puedo recordar cuáles son los valores predeterminados del compilador, y tal vez sus colegas tampoco pueden, así que en lugar de confiar en que todos recuerden cuáles son los valores predeterminados, puede ser explícito.

public class MyClass
{
    private string myField;

    public void MyMethod(int someNumber)
    {
    }
}

Implícito puede tomarse como implícito, pero explícito significa que usted afirma que debe hacerse usted mismo. Como con los moldes. Aquí hay un molde implícito:

int implicit;
implicit = 7.5;

El valor '7.5' se lanzará implícitamente como un int. Esto significa que el compilador lo hace por usted.

Aquí está explícito:

int explicit;
explicit = (int)7.5;

Aquí le dices al compilador que quieres que se lance. Usted declara explícitamente la conversión. Espero que eso ayude. Fuente: http://cboard.cprogramming.com/cplusplus-programming/24371-implicit-explicit.html

Este es un gran recurso para aprender C#: http://www.functionx.com/csharp /

Echa un vistazo aquí específicamente: http://www.functionx.com/csharp/math/Lesson20.htm