jawne i niejawne c#

Ogólnie

• Implicit: coś jest robione dla ciebie automatycznie.
• Explicit: napisałeś coś w kodzie źródłowym, aby wskazać, co chcesz się wydarzyć.

Na przykład:

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

Implicit i explicit są używane dość często w różnych kontekstach, ale ogólne znaczenie zawsze będzie podobne do tych.

Zauważ, że od czasu do czasu te dwie rzeczy mogą się ze sobą łączyć. Na przykład:

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

(Konwersja jawna to taka, która ma być określone jawnie; wersja dorozumiana to taka, która Może być używana dorozumiana, tzn. bez konieczności podawania kodu.)

Weź pod uwagę, że masz dwie klasy:

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


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

I dwa obiekty:

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

Możesz teraz napisać:

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

Lub:

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

Ale:

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

Implicit conversion jest przeznaczony do użycia, gdy konwersja nie traci żadnej precyzji. Konwersja Jawna oznacza, że możesz stracić pewną precyzję i musisz jasno stwierdzić, że wiesz, co robisz.

Istnieje również drugi kontekst, w którym stosuje się terminy implicit/explicit - implementacja interfejsu. Tam w takim przypadku nie ma słów kluczowych.

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

Więc gdy używasz jawnej implementacji interfejsu, metody interfejsu nie są widoczne, gdy używasz concrete type. Może to być użyte, gdy interfejs jest interfejsem pomocniczym, a nie częścią podstawowej odpowiedzialności klas i nie chcesz, aby dodatkowe metody wprowadzały kogoś w błąd używając Twojego kodu.

Myślę, że ten link wyjaśnia, czym jest konwersja ukryta - jest to taka, w której nie trzeba wyraźnie rzucać wartości w przypisaniu. Więc zamiast robić

myDigit = (Digit) myDouble 

...można po prostu zrobić:

myDigit = myDouble;

Bycie wyraźnym w C# polega głównie na wyraźnym i jednoznacznym pokazaniu swoich intencji.

Na przykład:

class MyClass
{
    string myField;

    void MyMethod(int someNumber)
    {

    }
}

W powyższym kodzie widoczność klasy, pola i metody są implikowane. Używają domyślnych wartości kompilatora.

Teraz, nigdy nie pamiętam, jakie są domyślne ustawienia kompilatora, i może twoi koledzy też nie mogą, więc zamiast polegać na tym, że wszyscy pamiętają, jakie są domyślne, możesz być wyraźny.

public class MyClass
{
    private string myField;

    public void MyMethod(int someNumber)
    {
    }
}

Implicit można traktować jako implicit, ale explicit oznacza, że należy to zrobić samemu. Jak z odlewami. Oto ukryta Obsada:

int implicit;
implicit = 7.5;

Wartość ' 7.5 ' będzie domyślnie rzucana jako int. Oznacza to, że kompilator robi to za Ciebie.

Tutaj jest wyraźnie:

int explicit;
explicit = (int)7.5;

Tutaj powiedz kompilatorowi, że chcesz go obsadzić. Jawnie deklarujesz konwersję. Mam nadzieję, że to pomoże. Źródło: http://cboard.cprogramming.com/cplusplus-programming/24371-implicit-explicit.html

Jest to świetny zasób do nauki C#: http://www.functionx.com/csharp/

Spójrz tutaj konkretnie: http://www.functionx.com/csharp/math/Lesson20.htm