Posteriormente a investigar con especialistas en el tema, programadores de deferentes ramas y maestros dimos con la respuesta al dilema y la dejamos plasmada en esta publicación.
El implicit y explicit Las palabras clave en C# se utilizan al declarar operadores de conversión. Digamos que tienes la siguiente clase:
public class Role
public string Name get; set;
Si desea crear una nueva Role y asigna un Name para ello, normalmente lo harás así:
Role role = new Role();
role.Name = "RoleName";
Dado que solo tiene una propiedad, tal vez sería conveniente si pudiéramos hacerlo así:
Role role = "RoleName";
Esto significa que queremos implícitamente convertir un string a un Role (ya que no hay un elenco específico involucrado en el código). Para lograr esto, agregamos un operador de conversión implícito:
public static implicit operator Role(string roleName)
return new Role() Name = roleName ;
Otra opción es implementar un operador de conversión explícito:
public static explicit operator Role(string roleName)
return new Role() Name = roleName ;
En este caso, no podemos convertir implícitamente un string a un Role, pero necesitamos convertirlo en nuestro código:
Role r = (Role)"RoleName";
En general
- Implícito: algo se está haciendo 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 diferentes contextos, 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 posee ser declarado explícitamente; una versión implícita es aquella que poder usarse implícitamente, es decir, sin que el código tenga que indicarlo).
Considere que tiene 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 usarse cuando la conversión no pierde precisión. La conversión explícita significa que puede perder algo de precisión y debe indicar claramente que sabe lo que está haciendo.
También hay un segundo contexto en el que se aplican términos implícitos/explícitos: implementación de interfaz. 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
Entonces, cuando usa una implementación de interfaz explícita, los métodos de la interfaz no son visibles cuando usa un tipo concreto. Esto se puede usar cuando la interfaz es una interfaz de ayuda, no es parte de la responsabilidad principal de la clase y no desea métodos adicionales para engañar a alguien que usa su código.
Puntuaciones y reseñas
Recuerda que tienes la capacidad de añadir una estimación objetiva si diste con la solución.