Diferencia entre conversión, análisis y conversión

Question

He estado trabajando en algún código por un tiempo. Y tenía una pregunta: ¿Cuál es la diferencia entre el casting, el análisis sintáctico y la conversión? ¿Y cuándo podemos usarlos?

Answer 1

Casting es cuando toma una variable de un tipo y la cambia a un tipo diferente. Sólo se puede hacer que en algunos casos, así:

string str = "Hello"; 
object o = str; 
string str2 = (string)o; // <-- This is casting 

casting tiene valor no cambio de la variable de - el valor sigue siendo del mismo tipo (la cadena "Hola").

de conversión es cuando se toma un valor de un tipo y lo convierten en un tipo diferente:

double d = 5.5; 
int i = (int)d; // <---- d was converted to an integer 

Tenga en cuenta que en este caso, la conversión se realiza en forma de fundición.

El análisis está tomando una cadena y convirtiéndola en un tipo diferente al comprender su contenido. Por ejemplo, convertir la cadena "123" al número 123, o la cadena "Sábado, 22 de septiembre" a un DateTime.

Answer 2

fundición (casting para trabajar los tipos tienen que ser compatibles) La conversión entre tipos de datos que se puede hacer de forma explícita el uso de un molde

static void _Casting() 
{ 
    int i = 10; 
    float f = 0; 
    f = i; // An implicit conversion, no data will be lost. 
    f = 0.5F; 
    i = (int)f; // An explicit conversion. Information will be lost. 
} 

análisis sintáctico (Parsing es la conversión entre diferentes tipos :) convierte un tipo a otro tipo puede ser llamado como uisng análisis int.parse

int num = int.Parse("500"); 

atravesar por los elementos de datos como XML pueden también llamado como el análisis

Cuando se involucran las conversiones definidas por el usuario, esto generalmente implica la devolución de un objeto/valor diferente. las conversiones definidas por el usuario generalmente existen entre tipos de valores en lugar de tipos de referencia, por lo que esto rara vez es un problema.

convertir Uso de la clase Convertir en realidad sólo le ayuda a analizarlo

para más consulte http://msdn.microsoft.com/en-us/library/ms228360%28VS.80%29.aspx

Answer 3

Estos son tres términos, cada uno con usos específicos:

• de fundición - el cambio de una type a otro. Para hacer esto, los tipos deben ser compatibles: int ->object; IList<T> ->IEnumerable<T>
• de análisis - por lo general se refiere a la lectura de las cadenas y la extracción de partes útiles
• de conversión - similar a la fundición, pero típicamente una conversión implicaría cambiar un tipo a un tipo compatible no lo contrario. Un ejemplo de eso sería convertir objetos en cadenas.

Una conversión de un tipo a otro requiere alguna forma de compatibilidad, generalmente a través de la herencia o la implementación de una interfaz.De fundición puede ser implícito o explícito:

class Foo : IFoo { 
    // implementations 
} 

// implicit cast 
public IFoo GetFoo() { 
    return Foo; 
} 

// explicit cast 
public IFoo GetFoo() { 
    return Foo as IFoo; 
} 

Hay bastantes maneras de analizar. Leemos sobre el análisis de XML; algunos tipos tienen los métodos Parse y TryParse; y luego hay veces que necesitamos analizar cadenas u otros tipos para extraer las 'cosas que nos importan'.

int.Parse("3") // returns an integer value of 3 
int.TryParse("foo", out intVal) // return true if the string could be parsed; otherwise false 

La conversión puede implicar el cambio de un tipo a otro incompatible. Esto podría implicar algunos análisis también. Los ejemplos de conversión suelen ser, IMO, muy vinculados a contextos específicos.

Answer 4

casting: indica al compilador que un objeto es realmente algo sin cambiarlo (aunque algunos la pérdida de datos puede incurrir).

object obj_s= "12345"; 
string str_i = (string) obj; // "12345" as string, explicit 

int small = 12345; 
long big = 0; 
big = small; // 12345 as long, implicit 

Analizar: Contar el programa de interpretar (en tiempo de ejecución) una cadena.

string int_s = "12345"; 
int i = int.Parse(int_s); // 12345 as int 

conversión de: Decir que el programa utilice construido en métodos para tratar de cambiar el tipo de lo que puede ser no simplemente intercambiables.

double dub = 123.45; 
int i = System.Convert.ToInt32(dub); // 123 as int 

Answer 5

Esta pregunta es realmente muy complicado ...

Normalmente, un fundido simplemente indica al tiempo de ejecución para cambiar un tipo a otro. Estos deben ser tipos que sean compatibles. Por ejemplo, un int siempre se puede representar como long, por lo que puede enviarlo a long. Algunos yesos tienen efectos secundarios. Por ejemplo, un float disminuirá su precisión si se lanza a int. Por lo tanto, (int)1.5f dará como resultado el valor int 1. Los lanzamientos suelen ser la forma más rápida de cambiar el tipo, ya que es un único operador de IL. Por ejemplo, el código:

public void CastExample() 
    { 
     int i = 7; 
     long l = (long)i; 
    } 

Realiza el molde mediante la ejecución del código IL:

conv.i8 //convert to 8-byte integer (a.k.a. Int64, a.k.a. long). 

---

A de análisis sintáctico es alguna función que toma en una vez tipo y devuelve otro. Es una función de código real, no solo un operador IL. Esto normalmente demora más en ejecutarse, ya que ejecuta varias líneas de código.

Por ejemplo, este código:

public void ParseExample() 
    { 
     string s = "7"; 
     long l = long.Parse(s); 
    } 

ejecuta el código IL:

call  int64 [mscorlib]System.Int64::Parse(string) 

En otras palabras, se llama a un método real. Internamente, el tipo Int64 proporciona ese método:

public static long Parse(String s) { 
     return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo); 
    } 

Y Number.Parse:

[System.Security.SecuritySafeCritical] // auto-generated 
    internal unsafe static Int64 ParseInt64(String value, NumberStyles options, NumberFormatInfo numfmt) { 
     Byte * numberBufferBytes = stackalloc Byte[NumberBuffer.NumberBufferBytes]; 
     NumberBuffer number = new NumberBuffer(numberBufferBytes); 
     Int64 i = 0; 

     StringToNumber(value, options, ref number, numfmt, false); 

     if ((options & NumberStyles.AllowHexSpecifier) != 0) { 
      if (!HexNumberToInt64(ref number, ref i)) { 
       throw new OverflowException(Environment.GetResourceString("Overflow_Int64")); 
      } 
     } 
     else { 
      if (!NumberToInt64(ref number, ref i)) { 
       throw new OverflowException(Environment.GetResourceString("Overflow_Int64")); 
      } 
     } 
     return i; 
    } 

Y así sucesivamente ...para que pueda ver que en realidad está haciendo mucho código.

---

Ahora donde las cosas se ponen más complicadas es que a pesar de un reparto suele ser el más rápido, las clases sustituyan los operadores de conversión implícita y explícita. Por ejemplo, si escribo la clase:

public class CastableClass 
{ 
    public int IntValue { get; set; } 

    public static explicit operator int(CastableClass castable) 
    { 
     return castable.IntValue; 
    } 
} 

he anulado el operador de conversión explícita para int, así que ahora puedo hacer:

public void OverridedCastExample() 
    { 
     CastableClass cc = new CastableClass {IntValue = 7}; 
     int i = (int)cc; 
    } 

Qué ve como un molde normal, pero en realidad llama a mi método que definí en mi clase. El código IL es:

call  int32 UnitTestProject1.CastableClass::op_Explicit(class UnitTestProject1.CastableClass) 

---

Así que de todos modos, normalmente desea echar siempre que pueda. Luego analiza si no puedes.

Answer 6

Casting: o analizar

un elenco explícitamente invoca el operador de conversión de un tipo a otro. Variables de conversión no es simple. Un conjunto complicado de reglas resuelve moldes. En algunos casos, los datos se pierden y el lanzamiento no se puede revertir. En otros, se provoca una excepción en el motor de ejecución. int.Parse es el método más simple pero arroja excepciones sobre la entrada no válida.

TryParse

int.TryParse es uno de los métodos más útiles para el análisis de los números enteros en el lenguaje C#. Este método funciona de la misma manera que int.Parse. int.TryParse ha intentado y atrapa la estructura adentro. Por lo tanto, no lanza excepciones

Convert:

Convierte un tipo de datos base a otro tipo de datos base. Convert.ToInt32, junto con sus hermanos Convert.ToInt16 y Convert.ToInt64, es en realidad un método de envoltura estático para el método int.Parse.

El uso de TryParse en lugar de Convert o Cast es recomendado por muchos programadores.

fuente: www.dotnetperls.com

Answer 7

Diferentes personas lo utilizan para significar cosas diferentes. No es necesario que sea cierto fuera del mundo .net, pero esto es lo que he entendido en .net context reading Blogs de Eric Lippert:

Todas las transformaciones de tipos de una forma a otra se pueden llamar conversion. Una forma de categorización puede ser

1. implícita -

   a.representación cambiar (también llamado coacción)

   int i = 0; 
   double d = i; 
   
   object o = i; // (specifically called boxing conversion) 
   IConvertible o = i; // (specifically called boxing conversion) 
   

   Requiere operador de conversión implícita, la conversión siempre tiene éxito (operador de conversión implícita nunca debe tirar), cambia la identidad referencial del objeto que está siendo convertido.

   b. representación preservar (también llamado conversión referencia implícita)

   string s = ""; 
   object o = s; 
   
   IList<string> l = new List<string>(); 
   

   Sólo válido para los tipos de referencia, nunca cambia la identidad de referencia del objeto que se convierte, la conversión siempre tiene éxito, garantizado en tiempo de compilación, no hay controles de tiempo de ejecución.

2. explícita (también llamada casting) -

   a. representación cambiar

   int i = 0; 
   enum e = (enum)i; 
   
   object o = i; 
   i = (int)o; // (specifically called unboxing conversion) 
   

   Requiere operador de conversión explícita, cambia la identidad referencial del objeto que está siendo convertido, la conversión puede o no puede tener éxito, hace de verificación de tiempo de ejecución para la compatibilidad.

   b. representación preservar (también llamado conversión referencia explícita)

   object o = ""; 
   string s = (string)o; 
   

   Sólo es válido para los tipos de referencia, nunca cambia la identidad referencial del objeto que está siendo convertida, conversión puede o no puede tener éxito, hace tiempo de ejecución de verificación de la compatibilidad.

Mientras que las conversiones son nivel de idioma construcciones, Analizar es una cosa muy diferente en el sentido de que es nivel del marco, o en otras palabras, son métodos personalizados escritas para obtener una salida de una entrada, como int.Parse que toma en string y devuelve int.