web-dev-qa-db-fra.com

Puis-je vérifier si une variable peut être convertie en un type spécifié?

J'essaie de vérifier si une variable transmise peut être convertie en un type spécifique. J'ai essayé ce qui suit mais je n'arrive pas à le compiler, donc je suppose que je m'y trompe (je suis nouveau 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;
}

J'essaie essentiellement d'éviter une déclaration de commutation massive le long des lignes de

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

MODIFIER:

Ok, fondamentalement, j'ai une table db de types d'entrée connus qui ressemble à:

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

qui peut contenir des données telles que

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

Et l'entrée de ma fonction serait un KeyValuePair le long des lignes de

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

Je dois vérifier que la valeur de KeyValuePair est du type de données correct attendu par le MetaDataType.

MODIFIER POUR RÉPONDRE:

Leon s'est vraiment approché de la solution que j'ai finalement trouvée.

Pour référence, ma fonction ressemble maintenant à ceci:

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;

}
c#castingtype-conversion
41
Nick

Utilisez l'opérateur "as" pour tenter une conversion:

var myObject = something as String;

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

Si le transtypage échoue, aucune exception n'est levée, mais l'objet de destination sera Null.

MODIFIER:

si vous savez quel type de résultat vous voulez, vous pouvez utiliser une méthode d'assistance comme celle-ci:

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

    return result;
}
54
Leon

Essaye ça

return myType.IsInstanceOfType(myObject);
10
kernowcode

Je pense que c'est ce que vous recherchez:

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
}

EDIT : Juste pour être clair, les opérateurs is et as sont utilisés de la manière suivante ...

L'opérateur is renverra une valeur boolean pour indiquer si l'objet testé est soit le type spécifié ou implémente l'interface spécifiée. C'est comme demander au compilateur "Ma variable est-elle de ce type?":

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

L'opérateur as tente d'effectuer la conversion et renvoie une référence null s'il ne le peut pas. C'est comme dire au compilateur "Je voudrais utiliser cette variable comme ce type":

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

Si vous avez essayé de le faire:

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

Le compilateur émettra une erreur:

Impossible de convertir le type via une converstion intégrée.

6
Yuck

Consultez ce lien: http://msdn.Microsoft.com/en-us/library/scekt9xw (v = vs.71) .aspx

L'opérateur is est utilisé pour vérifier si le type d'exécution d'un objet est compatible avec un type donné. L'opérateur is est utilisé dans une expression de la forme:

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

Quelque chose que vous pouvez utiliser?

5
321X

Avez-vous essayé TryParse qui a une valeur de retour booléenne pour indiquer si la conversion a réussi

1
kd7

Vous pouvez faire la fonction int.TryParse():

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

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