una - propiedades get c#

¿Puedo verificar si una variable puede convertirse a un tipo específico?

Question

Estoy tratando de verificar si una variable que se pasa puede convertirse a un tipo específico. He intentado lo siguiente pero no puedo compilarlo, así que supongo que lo estoy haciendo de la manera incorrecta (soy nuevo en C #)

string myType = "System.Int32";
string myValue = "42";

bool canBeCast = false;

try
{
  // try to convert the value to it''s intended type to see if it''s valid.
  var result = (Type.GetType(typeString))dataValue;
  canBeCast = true;
}
catch
{
  canBeCast = false;
}

Básicamente estoy tratando de evitar una declaración de cambio masivo a lo largo de las líneas de

  switch(myType){
    case "System.Int32":
      try
      {
        var convertedValue = Convert.ToInt32(myValue);
      }
      catch (Exception)
      {
        canBeConverted = false;
      }
      break;
    case "another type":
      ...
  }

EDITAR:

Ok, básicamente tengo una tabla db de tipos de entrada conocidos que se ve así:

CREATE TABLE [dbo].[MetadataTypes] (
    [typeName]  VARCHAR (50)  NOT NULL,
    [dataType]  VARCHAR (50)  NOT NULL,
    [typeRegex] VARCHAR (255) NULL
);

que puede tener datos tales como

"StartTime","System.DateTime",null
"TicketId","System.String","$[Ff][0-9]{7}^"

Y la entrada a mi función sería un KeyValuePair a lo largo de las líneas de

myInput = new KeyValuePair<string,string>("StartTime","31/12/2010 12:00");

Necesito verificar que el valor de KeyValuePair sea del tipo de datos correcto que espera MetaDataType.

EDITAR PARA RESPONDER:

Leon se acercó mucho a la solución que finalmente se me ocurrió.

Como referencia, mi función ahora se ve así:

public Boolean ValidateMetadata(KeyValuePair<string, string> dataItem)
{

  // Look for known metadata with name match
  MetadataType type = _repository.GetMetadataTypes().SingleOrDefault(t => t.typeName == dataItem.Key);
  if (type == null) { return false; }

  // Get the data type and try to match to the passed in data item.
  Boolean isCorrectType = false;
  string typeString = type.dataType;
  string dataValue = dataItem.Value;

  try
  {
    var cValue = Convert.ChangeType(dataValue, Type.GetType(typeString));
    isCorrectType = true;
  }
  catch
  {
    isCorrectType = false;
  }

  //TODO: Validate against possible regex here....            

  return isCorrectType;

}

Answer 1

¿Has probado TryParse que tiene un valor de retorno booleano para indicar si la conversión tuvo éxito

Answer 2

Consulte este enlace: http://msdn.microsoft.com/en-us/library/scekt9xw(v=vs.71).aspx

El operador is se usa para verificar si el tipo de tiempo de ejecución de un objeto es compatible con un tipo dado. El operador is se usa en una expresión de la forma:

if (expression is type){
    // do magic trick
}

Algo que puedes usar?

Answer 3

Creo que esto es lo que estás buscando:

var myValue = "42";
int parsedValue;

if (Int32.TryParse(myValue, out parsedValue)) {
    // it worked, and parsedValue is equal to 42
}
else {
    // it did not work and parsedValue is unmodified
}

EDITAR : Para que quede claro, los operadores is y as se usan de las siguientes maneras ...

El operador is devolverá un valor boolean para indicar si el objeto que se está probando es o no el tipo especificado o implementa la interfaz especificada. Es como preguntarle al compilador "¿Mi variable es este tipo?":

var someString = "test";
var result = someString is IComparable; // result will be true

El operador as intenta realizar la conversión y devuelve una referencia null si no puede. Esto es como decirle al compilador "Me gustaría utilizar esta variable como este tipo":

var someString = "test";
var comparable = someString as IComparable; // comparable will be of type String

Si trataste de hacer esto:

var someString = "42";
// using Int32? because the type must be a reference type to be used with as operator
var someIntValue = someString as Int32?;

El compilador emitirá un error:

No se puede convertir el tipo a través de una conversación incorporada.

Answer 4

Prueba esto

return myType.IsInstanceOfType(myObject);

Answer 5

Puede hacer la función int.TryParse() :

int myInt;
bool parsed = int.TryParse(myVariable, out myInt);

if (parsed) {
    // Do something with myInt or other logic
}

Answer 6

Use el operador "como" para intentar un lanzamiento:

var myObject = something as String

if (myObject != null)
{
  # successfully cast
}
else
{
  #cast failed
}

Si la conversión falla, no se lanza ninguna excepción, pero el objeto de destino será nulo.

EDITAR:

si sabe qué tipo de resultado desea, puede usar un método auxiliar como este:

public static Object TryConvertTo<T>(string input)
{
    Object result = null;
    try
    {
        result = Convert.ChangeType(input, typeof(T));
    }
    catch
    {
    }

    return result;
}