Casting direct vs opérateur 'as'?

Considérez le code suivant:

void Handler(object o, EventArgs e)
{
   // I swear o is a string
   string s = (string)o; // 1
   //-OR-
   string s = o as string; // 2
   // -OR-
   string s = o.ToString(); // 3
}

Quelle est la différence entre les trois types de casting (d'accord, le 3ème n'est pas un casting, mais vous obtenez l'intention). Lequel devrait être préféré?

string s = (string)o; // 1

Lève InvalidCastException si on'est pas un string. Sinon, assigne oà s, même s'il l' oest null.

string s = o as string; // 2

Attribue nullà ssi on'est pas un stringou si oest null. Pour cette raison, vous ne pouvez pas l'utiliser avec des types de valeur (l'opérateur ne pourra jamais retourner nulldans ce cas). Sinon, attribue oà s.

string s = o.ToString(); // 3

Provoque une exception NullReferenceException si oest null. Attribue tout ce qui o.ToString()retourne s, quel que soit le type o.

Utilisez 1 pour la plupart des conversions - c'est simple et direct. J'ai tendance à ne presque jamais utiliser 2 car si quelque chose n'est pas du bon type, je m'attends généralement à ce qu'une exception se produise. Je n'ai vu qu'un besoin pour ce type de fonctionnalité de retour nul avec des bibliothèques mal conçues qui utilisent des codes d'erreur (par exemple, retourner null = erreur, au lieu d'utiliser des exceptions).

3 n'est pas un transtypage et n'est qu'un appel de méthode. Utilisez-le lorsque vous avez besoin de la représentation sous forme de chaîne d'un objet non-chaîne.

1. string s = (string)o;À utiliser lorsque quelque chose devrait être définitivement l'autre chose.
2. string s = o as string;À utiliser lorsque quelque chose pourrait être l'autre chose.
3. string s = o.ToString(); À utiliser lorsque vous ne vous souciez pas de ce que c'est mais que vous souhaitez simplement utiliser la représentation de chaîne disponible.

Cela dépend vraiment si vous savez si oc'est une chaîne et ce que vous voulez en faire. Si votre commentaire signifie qu'il os'agit vraiment d'une chaîne, je préfère la (string)odistribution directe - il est peu probable qu'elle échoue.

Le plus grand avantage de l'utilisation de la distribution directe est qu'en cas d'échec, vous obtenez une InvalidCastException , qui vous indique à peu près ce qui n'a pas fonctionné.

Avec l' asopérateur, si on'est pas une chaîne, sest défini sur null, ce qui est pratique si vous n'êtes pas sûr et que vous souhaitez tester s:

string s = o as string;
if ( s == null )
{
    // well that's not good!
    gotoPlanB();
}

Cependant, si vous n'effectuez pas ce test, vous l'utiliserez splus tard et une exception NullReferenceException sera levée. Celles-ci ont tendance à être plus courantes et beaucoup plus difficiles à retrouver une fois qu'elles se produisent dans la nature, car presque chaque ligne déréférence une variable et peut en lancer une. D'un autre côté, si vous essayez de transtyper en un type de valeur (toute primitive ou structure telle que DateTime ), vous devez utiliser le transtypage direct - le asne fonctionnera pas.

Dans le cas particulier de la conversion en chaîne, chaque objet a un ToString, donc votre troisième méthode peut être correcte si elle on'est pas nulle et vous pensez que la ToStringméthode pourrait faire ce que vous voulez.

Si vous savez déjà dans quel type il peut être casté, utilisez un cast de style C:

var o = (string) iKnowThisIsAString; 

Notez que ce n'est qu'avec une conversion de style C que vous pouvez effectuer une coercition de type explicite.

Si vous ne savez pas si c'est le type souhaité et que vous allez l'utiliser si c'est le cas, utilisez comme mot-clé:

var s = o as string;
if (s != null) return s.Replace("_","-");

//or for early return:
if (s==null) return;

Notez que as n'appellera aucun opérateur de conversion de type. Il ne sera pas non nul si l'objet n'est pas nul et nativement du type spécifié.

Utilisez ToString () pour obtenir une représentation sous forme de chaîne lisible par l'homme de tout objet, même s'il ne peut pas être converti en chaîne.

Le mot clé as est bon dans asp.net lorsque vous utilisez la méthode FindControl.

Hyperlink link = this.FindControl("linkid") as Hyperlink;
if (link != null)
{
     ...
}

Cela signifie que vous pouvez opérer sur la variable typée plutôt que de la convertir ensuite objectcomme vous le feriez avec une conversion directe:

object linkObj = this.FindControl("linkid");
if (link != null)
{
     Hyperlink link = (Hyperlink)linkObj;
}

Ce n'est pas énorme, mais cela permet d'économiser des lignes de code et d'affectation de variables, en plus c'est plus lisible

'as' est basé sur 'is', qui est un mot clé qui vérifie au moment de l'exécution si l'objet est compatible polimorphiquement (essentiellement si un transtypage peut être effectué) et retourne null si la vérification échoue.

Ces deux sont équivalents:

Utilisation de 'as':

string s = o as string;

Utiliser «est»:

if(o is string) 
    s = o;
else
    s = null;

Au contraire, la conversion de style c est également effectuée lors de l'exécution, mais lève une exception si la conversion ne peut pas être effectuée.

Juste pour ajouter un fait important:

Le mot clé 'as' ne fonctionne qu'avec les types de référence. Tu ne peux pas faire:

// I swear i is an int
int number = i as int;

Dans ces cas, vous devez utiliser le casting.

2 est utile pour convertir en un type dérivé.

Supposons qu'un est un animal:

b = a as Badger;
c = a as Cow;

if (b != null)
   b.EatSnails();
else if (c != null)
   c.EatGrass();

obtiendra un fed avec un minimum de lancers.

Selon les expériences effectuées sur cette page: http://www.dotnetguru2.org/sebastienros/index.php/2006/02/24/cast_vs_as

(cette page affiche parfois des erreurs de "référent illégal", alors actualisez-le si c'est le cas)

La conclusion est que l'opérateur "as" est normalement plus rapide qu'un cast. Parfois beaucoup plus vite, parfois à peine plus vite.

Personnellement, je pense que "as" est aussi plus lisible.

Donc, comme il est à la fois plus rapide et "plus sûr" (ne lancera pas d'exception), et peut-être plus facile à lire, je recommande d'utiliser "as" tout le temps.

"(string) o" entraînera une InvalidCastException car il n'y a pas de transtypage direct.

"o as string" aura pour résultat que s sera une référence nulle, plutôt qu'une exception levée.

"o.ToString ()" n'est pas un transtypage en soi, c'est une méthode qui est implémentée par objet, et donc d'une manière ou d'une autre, par chaque classe de .net qui "fait quelque chose" avec l'instance de la classe sur laquelle il est appelé et renvoie une chaîne.

N'oubliez pas que pour la conversion en chaîne, il y a aussi Convert.ToString (someType instanceOfThatType) où someType fait partie d'un ensemble de types, essentiellement les types de base des frameworks.

Toutes les réponses données sont bonnes, si je peux ajouter quelque chose: pour utiliser directement les méthodes et les propriétés de la chaîne (par exemple ToLower), vous ne pouvez pas écrire:

(string)o.ToLower(); // won't compile

vous ne pouvez écrire que:

((string)o).ToLower();

mais vous pourriez écrire à la place:

(o as string).ToLower();

L' asoption est plus lisible (du moins à mon avis).

string s = o as string; // 2

Est préférable, car il évite la pénalité de performance de la double coulée.

Il semble que les deux soient conceptuellement différents.

Casting direct

Les types n'ont pas à être strictement liés. Il se décline dans tous les types de saveurs.

• Casting implicite / explicite personnalisé: un nouvel objet est généralement créé.
• Type de valeur implicite: copiez sans perdre d'informations.
• Type de valeur explicite: la copie et les informations peuvent être perdues.
• Relation IS-A: changez le type de référence, sinon lève une exception.
• Même type: «La diffusion est redondante».

C'est comme si l'objet allait être converti en quelque chose d'autre.

Opérateur AS

Les types ont une relation directe. Un péché:

• Types de référence: relation IS-A Les objets sont toujours les mêmes, seules les références changent.
• Types de valeurs: copie les types boxing et nullable.

On a l'impression que vous allez manipuler l'objet d'une manière différente.

Échantillons et IL

    class TypeA
    {
        public int value;
    }

    class TypeB
    {
        public int number;

        public static explicit operator TypeB(TypeA v)
        {
            return new TypeB() { number = v.value };
        }
    }

    class TypeC : TypeB { }
    interface IFoo { }
    class TypeD : TypeA, IFoo { }

    void Run()
    {
        TypeA customTypeA = new TypeD() { value = 10 };
        long longValue = long.MaxValue;
        int intValue = int.MaxValue;

        // Casting 
        TypeB typeB = (TypeB)customTypeA; // custom explicit casting -- IL:  call class ConsoleApp1.Program/TypeB ConsoleApp1.Program/TypeB::op_Explicit(class ConsoleApp1.Program/TypeA)
        IFoo foo = (IFoo)customTypeA; // is-a reference -- IL: castclass  ConsoleApp1.Program/IFoo

        int loseValue = (int)longValue; // explicit -- IL: conv.i4
        long dontLose = intValue; // implict -- IL: conv.i8

        // AS 
        int? wraps = intValue as int?; // nullable wrapper -- IL:  call instance void valuetype [System.Runtime]System.Nullable`1<int32>::.ctor(!0)
        object o1 = intValue as object; // box -- IL: box [System.Runtime]System.Int32
        TypeD d1 = customTypeA as TypeD; // reference conversion -- IL: isinst ConsoleApp1.Program/TypeD
        IFoo f1 = customTypeA as IFoo; // reference conversion -- IL: isinst ConsoleApp1.Program/IFoo

        //TypeC d = customTypeA as TypeC; // wouldn't compile
    }

Je voudrais attirer l'attention sur les spécificités suivantes de l' opérateur as :

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/as

Notez que l'opérateur as effectue uniquement les conversions de référence, les conversions annulables et les conversions de boxe. L'opérateur as ne peut pas effectuer d'autres conversions, telles que des conversions définies par l'utilisateur, qui devraient plutôt être effectuées à l'aide d'expressions cast.

Lorsque j'essaie d'obtenir la représentation sous forme de chaîne de tout (de tout type) qui pourrait potentiellement être nul, je préfère la ligne de code ci-dessous. Il est compact, il appelle ToString () et il gère correctement les valeurs nulles. Si o est nul, s contiendra String.Empty.

String s = String.Concat(o);

Puisque personne ne l'a mentionné, le plus proche de instanceOf to Java par mot-clé est le suivant:

obj.GetType().IsInstanceOfType(otherObj)

Utilisez la conversion directe string s = (string) o;si dans le contexte logique de votre application stringest le seul type valide. Avec cette approche, vous obtiendrez InvalidCastExceptionet implémenterez le principe de Fail-fast . Votre logique sera protégée contre la transmission du type non valide ou obtiendra NullReferenceException si l' asopérateur est utilisé .

Si la logique attend plusieurs types différents castés string s = o as string;et cochez-la nullou utilisez l' isopérateur.

De nouvelles fonctionnalités intéressantes sont apparues dans C # 7.0 pour simplifier la distribution et la vérification est une correspondance de modèle :

if(o is string s)
{
  // Use string variable s
}

or

switch (o)
{
  case int i:
     // Use int variable i
     break;
  case string s:
     // Use string variable s
     break;
 }

Les deux formes suivantes de conversion de type (conversion) sont prises en charge en C #:

|

(CV

• Convertir le type statique de v en c dans l'expression donnée

• Possible uniquement si le type dynamique de v est c ou un sous-type de c

• Sinon, une InvalidCastException est levée

|

v comme C

• Variante non mortelle de (c) v

• Ainsi, convertissez le type statique de v en c dans l'expression donnée

• Renvoie null si le type dynamique de v n'est pas c, ou un sous-type de c