c# - texto - ¿Cuál es la diferencia entre los moldes de tipo explícito e implícito?
ejemplos de implícito y explícito (9)
¿Cuál es la diferencia entre el Presidente de los Estados Unidos y el Presidente de Canadá?
Como no hay presidente de Canadá, es difícil responder la pregunta. Lo correcto es retroceder y pedir aclaraciones sobre la pregunta. Por "el Presidente de Canadá", ¿se refiere el interrogador a la Reina (jefe de estado ceremonial), al Gobernador General (que puede vetar proyectos de ley) o al Primer Ministro (que efectivamente actúa como ejecutivo) u otra cosa? Difícil de decir sin aclaración.
E incluso aclarando, es una pregunta vaga. ¿De qué diferencias quieres saber?
Como no existe un "reparto implícito" en C #, es difícil responder a tu pregunta. En C #, el casting es un operador. Así que lo presionaré nuevamente.
¿Quería preguntar "¿cuál es la diferencia entre una conversión explícita y una conversión implícita?" ¿O quisiste preguntar sobre la semántica del operador de reparto? ¿O la diferencia entre el operador de elenco y otros operadores de conversión de tipo? ¿O situaciones en las que el compilador puede insertar "implícitamente" operadores de conversión en su código? (Por ejemplo, el bucle foreach y el operador + = pueden insertar implícitamente un lanzamiento invisible).
¿Puedes aclarar la pregunta? ¿Qué dos cosas está pidiendo para comparar y qué tipo de diferencias le interesan?
Puede considerar leer el capítulo "Conversiones" de la especificación C #. Las probabilidades son buenas de que cualquier pregunta que tenga sobre las conversiones se responda allí.
¿Podrías explicar la diferencia entre los moldes de tipos explicit e implicit ?
Creo que esta post explica mejor.
Esto es un poco complicado porque la sintaxis del "elenco" en C # realmente hace una variedad de cosas diferentes (elenco, conversión primitiva, conversión a medida, etc.)
En un molde implícito, hay una conversión obvia que preserva la referencia entre los dos:
List<int> l = new List<int>();
IList<int> il = l;
El compilador puede probar que esto es seguro solo por análisis estático ( List<int> siempre es un IList<int> )
Con un reparto explícito, o le está diciendo al compilador que sabe más de lo que dice : "créame, pero compruebe de todos modos":
List<int> l = new List<int>();
IList<int> il = l;
List<int> l2 = (List<int>)il;
Aunque este molde es posible , el compilador no aceptará que todos los IList<int> son en realidad List<int> , por lo que debemos indicarle que lo deje.
En una conversión primitiva implícita (proporcionada por la especificación del idioma), generalmente se supone que hay una conversión segura, no arriesgada, sin pérdida (advertencia: vea el comentario de Jon):
int i = 1;
float f = i;
Con una conversión primitiva explícita, es probable que la conversión pueda perder datos o que no sea obvia:
float f = 1;
int i = (int)f;
Con los operadores a medida, todas las apuestas están apagadas, y tendrías que mirar la documentación. Podría ser un elenco de referencia, o podría ser cualquier cosa . Puede seguir reglas similares a las conversiones primitivas (ejemplo: decimal ), o podría hacer cualquier cosa al azar:
XNamespace ns = "http://abc/def"; // implicit
XAttribute attrib = GetAttrib();
int i = (int)attrib; // explicit (extracts text from attrib value and
// parses to an int)
Ambos ejecutan código personalizado que es específico del contexto.
Explicito de MSDN -
Si una operación de conversión puede causar excepciones o perder información, debe marcarla explícitamente. Esto evita que el compilador invoca silenciosamente la operación de conversión con consecuencias posiblemente imprevistas.
Implícito de MSDN -
si la conversión está garantizada para no causar una pérdida de datos
Lanzamiento explícito:
int x = 0;
float y = 3.8f;
x += (int) y; //Explicit cast.
Esto le dice al compilador que el lanzamiento fue intencional y que usted sabe que la parte fraccionaria se perderá. El compilador no se quejará.
Lanzamiento implícito:
int x = 0;
float y = 3.8f;
x += y; //Implicit cast
El compilador se quejará porque la parte fraccionaria se perderá al convertir float a int.
Una simple búsqueda dará mucha información en la red.
diferencia entre tipo implícito y explícito
Conversiones explícitas
Si no se puede realizar una conversión sin riesgo de perder información, se trata de una conversión explícita.
Por ejemplo -
class ExplicitConversions
{
static void Main()
{
int x;
double y = 6358.057;
// Cast double to int.
x = (int)y;
System.Console.WriteLine(x);
}
}
Conversiones implícitas
Si se puede realizar una conversión sin riesgo de perder información, se trata de una conversión implícita. No se requiere una sintaxis especial porque la conversión es segura y no se pierden datos.
Por ejemplo -
class ImplicitConversions
{
static void Main()
{
int x = 6714;
double y;
// Cast int to double.
y = x;
System.Console.WriteLine(y);
}
}
int i = 2;
float a = i; // Implicit
float b = (float)i; // Explicit