explicite et implicite c#

en général

• implicite: quelque chose est fait pour vous automatiquement.
• explicite: vous avez écrit quelque chose dans le code source pour indiquer ce que vous voulez qu'il arrive.

par exemple:

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

implicite et explicite sont utilisés assez souvent dans des contextes différents, mais le sens général sera toujours dans ce sens.

noter que parfois les deux peuvent se rencontrer. Par exemple:

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

(une conversion explicite est une conversion qui a à indiquer explicitement; une version implicite est une version qui peut à utiliser implicitement, c'est-à-dire sans que le code ait à l'indiquer.)

Considérez que vous avez deux classes:

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


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

et deux objets:

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

vous pouvez maintenant écrire:

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

ou:

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

mais:

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

conversion implicite est destiné à être utilisé lorsque la conversion ne perd aucune précision. Conversion explicite signifie que vous pouvez perdre un peu de précision et doit indiquer clairement que vous savez ce que vous êtes faire.

il y a aussi un second contexte dans lequel des termes implicites/explicites sont appliqués - la mise en œuvre de l'interface. Il n'y a pas de mots clés dans cette affaire.

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

Ainsi, lorsque vous utilisez l'implémentation explicite de l'interface, les méthodes de l'interface ne sont pas visibles lorsque vous utilisez le type de béton. Cela peut être utilisé lorsque l'interface est une interface d'aide, ne fait pas partie de la responsabilité première de classe et vous ne voulez pas de méthodes supplémentaires pour induire quelqu'un en erreur en utilisant votre code.

je pense ce lien , il est assez clair qu'une conversion implicite est - il un endroit où vous n'avez pas besoin de convertir explicitement la valeur dans une tâche. Donc, au lieu de faire

myDigit = (Digit) myDouble 

...vous pouvez simplement faire:

myDigit = myDouble;

être explicite en C#, c'est surtout montrer ses intentions clairement et sans ambiguïté.

par exemple:

class MyClass
{
    string myField;

    void MyMethod(int someNumber)
    {

    }
}

dans le code ci-dessus, la visibilité de la classe, du champ et de la méthode est implicite. Ils utilisent le compilateur par défaut.

maintenant, je ne peux jamais me rappeler ce que sont les valeurs par défaut du compilateur, et peut-être que vos collègues ne peuvent pas non plus, donc plutôt que de compter sur tout le monde se rappeler ce que sont les valeurs par défaut, vous pouvez être explicite.

public class MyClass
{
    private string myField;

    public void MyMethod(int someNumber)
    {
    }
}

implicite peut être considéré comme implicite, mais explicite signifie que vous déclarez qu'il doit être fait vous-même. Comme avec des plâtres. Voici un casting implicite:

int implicit;
implicit = 7.5;

la valeur '7.5' sera implicitement coulée comme un int. Cela signifie que le compilateur le fait pour vous.

ici est explicite:

int explicit;
explicit = (int)7.5;

ici vous dites au compilateur que vous voulez le lancer. Vous déclarez explicitement la conversion. Espérons que cela aide. Source: http://cboard.cprogramming.com/cplusplus-programming/24371-implicit-explicit.html

C'est une grande ressource pour l'apprentissage du C#: http://www.functionx.com/csharp/

regardez ici spécifiquement: http://www.functionx.com/csharp/math/Lesson20.htm