Déterminer à l'exécution si une distribution est autorisée (C#)

Question

J'ai une classe C# wraper avec une série de méthodes acceptant différents types de données:

public class MyClass 
{ 
    public void ProcessString(string Value) { // implementation } 
    public void ProcessInt(int? Value) { // implementation }\ 
    public void ProcessOther(MyClass Value) { // implementation } 
} 

Je veux maintenant ajouter une méthode ProcessObject() générique pour éviter la nécessité de jeter explicitement un objet avant d'appeler une méthode de processus pertinent:

public void ProcessObject(object Value) 
{ 
    if (CanCastToString(Value) 
    { 
     ProcessString((string)Value); 
    } 
    else if (CanCastToInt(Value)) 
    { 
     ProcessInt((int?)Value); 
    } 
    // etc... 
} 

Le problème est que je ne sais pas ce que mes CanCastToInt méthodes devraient être - je besoin de ces méthodes pour pouvoir être robuste et faire face à des choses comme types nullable et autre ca défini par l'utilisateur sts

Comment est-ce que je peux faire ceci? Tout ce que je veux savoir est si un objet donné peut être jeté à un type donné, à savoir si oui ou non:

(SomeType)Value 

fonctionnera.

Answer 1

Il y a deux façons principales cela se fait habituellement:

if (Value is SomeType) 
{ 
    // Do something with a cast 
} 

ou

var v = Value as SomeType; 
if (v != null) 
{ 
    // Value was successfully cast as SomeType 
} 

Lorsque vous travaillez avec struct ou types intrinsèques, les rendre annulable:

var v = Value as int?; 
if (v != null) 
{ 
    ProcessInt(v.Value); 
} 

Answer 2

vous avez besoin de l'opérateur is. CanCastToString(x) ->x is string.

Answer 3

public void QuickTest() 
    { 
     object stringObj = "string"; 
     object nullableInt1 = (int?)null; 
     object nullableInt2 = (int?)1; 
     object decimalObj = 1.5m; 

     ProcessObject(stringObj); 
     ProcessObject(nullableInt1); 
     ProcessObject(nullableInt2); 
     ProcessObject(decimalObj); 
    } 

    public void ProcessObject(object value) 
    { 
     if (value == null) 
     { 
      Debug.WriteLine("null"); 
      return; 
     } 


     if (value is string) 
     { 
      Debug.WriteLine((string)value); 
      return; 
     } 

     string stringValue = value.ToString(); 

     int intTemp; 
     if (int.TryParse(stringValue, out intTemp)) 
     { 
      Debug.WriteLine(intTemp); 
      return; 
     } 

     decimal decimalTemp; 
     if (decimal.TryParse(stringValue, out decimalTemp)) 
     { 
      Debug.WriteLine(decimalTemp); 
      return; 
     } 
     // etc... 
    } 

Answer 4

Pourquoi ne pas exposer votre proc essing API directement, avec des surcharges pour différents paramètres?

public class MyClass 
{ 
    public void Process(string Value) { // implementation } 
    public void Process(int Value) { // implementation }\ 
    public void Process(MyClass Value) { // implementation } 
    public void Process(object Value) { // catch all method. Handle unknown entities, e.g. call ToString() } 
} 

EDIT Avec certains génériques magique vous pouvez avoir une seule méthode d'interface, un tas de méthodes d'assistance qui font le travail et une méthode fourre-tout où vous gérez les cas d'angle. De cette façon, vous évitez la boxe pour les types fondamentaux et vous avez une sécurité de type légèrement supérieure.

Pour votre méthode fourre-tout, vous pouvez essayer d'utiliser la méthode Type.IsAssignableFrom. Par exemple:

if (typeof(short).IsAssignableFrom(Value) 
    DoProcess((short)Value); 
if (typeof(byte).IsAssignableFrom(Value) 
    DoProcess((byte)Value); 

Je vous recommande de lire l'essai d'Eric Lippert sur les représentations. Heureusement, après cela, vous réaliserez qu'il pourrait être plus facile d'avoir une surcharge pour chaque type pris en charge. En outre, vous pourriez réaliser que le traitement des types de valeur Unboxing pourrait être une route vers l'enfer.

Answer 5

Si (contrairement OP?) Vous ne connaissez pas le type impliqué avant l'exécution, vous pouvez essayer d'employer une variante de celle-ci:

http://codegoeshere.blogspot.com/2007/05/dynamic-cast-in-c.html