c esplicito e implicito #

Question

Sono nuovo di C# e sto imparando nuove parole. Trovo difficile capire qual è il significato di queste due parole quando si tratta di programmare C#. Ho guardato nel dizionario per il significato ed ecco cosa ho ottenuto:

implicito

"Qualcosa che è implicita è espressa in modo indiretto".

"Se una qualità o un elemento è implicito in qualcosa, è coinvolto in esso o è mostrato da esso;"

esplicita

"Qualcosa che è esplicito è espressa o mostrato chiaramente e apertamente, senza alcun tentativo di nascondere nulla"

"Se sei esplicita di qualcosa, si parla di è molto apertamente e chiaramente. "

Mi piacerebbe capirlo in C#.

Grazie per il vostro aiuto.

Acclamazioni

---

informazioni aggiuntive:

Ecco una parte della frase nel libro quello che sto leggendo ora che ha questa parola "implicito"

"Questo significa quell'area e gli occupanti all'interno di AreaPerPerson()implicitamente si riferiscono alle copie di quelle variabili trovate nell'oggetto che richiama AreaPerPerson() "

Io proprio non capisco cosa questa frase qui cercando di dire.

Answer 1

Le parole chiave implicit e explicit in C# vengono utilizzate per la dichiarazione degli operatori di conversione. Diciamo che si ha la seguente classe:

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

Se si desidera creare un nuovo Role e assegnare un Name ad esso, in genere fare in questo modo:

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

Dal momento che ha solo una proprietà, sarebbe forse conveniente se invece potessimo fare in questo modo:

Role role = "RoleName"; 

Ciò significa che vogliamo impl iconicmente convertire una stringa in un Role (poiché non vi è alcun cast specifico coinvolto nel codice). Per raggiungere questo obiettivo, si aggiunge un operatore di conversione implicita:

public static implicit operator Role(string roleName) 
{ 
    return new Role() { Name = roleName }; 
} 

Un'altra opzione è quella di implementare un operatore di conversione esplicita:

public static explicit operator Role(string roleName) 
{ 
    return new Role() { Name = roleName }; 
} 

In questo caso, non possiamo implicitamente convertire una stringa in un Role, ma abbiamo bisogno di gettarlo nel nostro codice:

Role r = (Role)"RoleName"; 

Answer 2

In generale

• implicito: qualcosa è stato fatto per voi automaticamente.
• Esplicito: hai scritto qualcosa nel codice sorgente per indicare cosa vuoi che accada.

Ad esempio:

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

impliciti ed espliciti sono usati parecchio in contesti diversi, ma il senso generale saranno sempre lungo queste linee.

Nota che occasionalmente i due possono riunirsi.Per esempio:

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

(conversione esplicita è quella che deve essere formulato esplicitamente; una versione implicita è quella che può essere utilizzato implicitamente, cioè senza il codice dover indicare esso.)

Answer 3

Essendo esplicito in C# si tratta principalmente di mostrare le proprie intenzioni in modo chiaro e inequivocabile.

Ad esempio:

class MyClass 
{ 
    string myField; 

    void MyMethod(int someNumber) 
    { 

    } 
} 

Nel codice precedente la visibilità della classe, campo e il metodo sono tutti i implicita. Usano i valori predefiniti del compilatore.

Ora, non riesco mai a ricordare quali sono le impostazioni predefinite del compilatore, e forse nemmeno i tuoi colleghi possono farlo, quindi piuttosto che fare affidamento su chiunque ricordi quali sono le impostazioni predefinite, puoi essere esplicito.

public class MyClass 
{ 
    private string myField; 

    public void MyMethod(int someNumber) 
    { 
    } 
} 

Answer 4

Penso this link rende abbastanza chiaro quello che una conversione implicita è - è quella in cui non c'è bisogno di lanciare esplicitamente il valore di un incarico. Così, invece di fare

myDigit = (Digit) myDouble 

... si può solo fare:

myDigit = myDouble; 

Answer 5

Questa è una grande risorsa per l'apprendimento C#: http://www.functionx.com/csharp/

dare uno sguardo qui specificamente: http://www.functionx.com/csharp/math/Lesson20.htm

Answer 6

Considerate che avete due classi:

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


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

e due oggetti:

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

ora si può scrivere:

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

o:

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

ma:

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

conversione implicita è destinata ad essere Usato quando la conversione non perde precisione. La conversione esplicita significa che puoi perdere un po 'di precisione e devi dichiarare chiaramente che sai cosa stai facendo.

Esiste anche un secondo contesto in cui vengono applicati i termini implicito/esplicito - implementazione dell'interfaccia. Non ci sono parole chiave in questo 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 

Pertanto, quando si utilizza l'implementazione dell'interfaccia esplicita, i metodi dell'interfaccia non sono visibili quando si utilizza il tipo di calcestruzzo. Questo può essere usato quando l'interfaccia è un'interfaccia helper, non fa parte della responsabilità primaria della classe e non si desidera che metodi aggiuntivi ingannino qualcuno usando il proprio codice.

Answer 7

implicito possono essere presi come implicita, ma significa che si espliciti Stato deve essere fatto da soli. Come con i calchi. Ecco un cast implicito:

int implicit; 
implicit = 7.5; 

Il valore '7.5' sarà implicitamente gettato come un int. Questo significa che il compilatore lo fa per te.

Qui è esplicito:

int explicit; 
explicit = (int)7.5; 

Qui dicono al compilatore che si desidera lanciare. Dichiari esplicitamente la conversione. Spero possa aiutare. Fonte: http://cboard.cprogramming.com/cplusplus-programming/24371-implicit-explicit.html