C #: mot-clé 'is' et vérification de Non

StackOverflow https://stackoverflow.com/questions/811614

  •  03-07-2019
  •  | 
  •  

Question

C'est une question idiote, mais vous pouvez utiliser ce code pour vérifier si quelque chose est d'un type particulier ... 

if (child is IContainer) { //....

Existe-t-il un moyen plus élégant de rechercher le & "NOT &"; exemple? 

if (!(child is IContainer)) { //A little ugly... silly, yes I know...

//these don't work :)
if (child !is IContainer) {
if (child isnt IContainer) { 
if (child aint IContainer) { 
if (child isnotafreaking IContainer) {

Oui, oui ... question idiote ....

Comme il existe une question sur l'apparence du code, il ne s'agit que d'un simple retour au début d'une méthode. 

public void Update(DocumentPart part) {
    part.Update();
    if (!(DocumentPart is IContainer)) { return; }
    foreach(DocumentPart child in ((IContainer)part).Children) {
       //...etc...
Était-ce utile?

La solution 

if(!(child is IContainer))

est le seul opérateur à partir (aucun IsNot opérateur).

Vous pouvez construire une méthode d'extension qui le fait: 

public static bool IsA<T>(this object obj) {
    return obj is T;
}

puis utilisez-le pour: 

if (!child.IsA<IContainer>())

Et vous pouvez suivre votre thème: 

public static bool IsNotAFreaking<T>(this object obj) {
    return !(obj is T);
}

if (child.IsNotAFreaking<IContainer>()) { // ...

Mise à jour (en tenant compte de l'extrait de code de l'OP):

Puisque vous définissez la valeur par la suite, vous pouvez simplement utiliser as à la place: 

public void Update(DocumentPart part) {
    part.Update();
    IContainer containerPart = part as IContainer;
    if(containerPart == null) return;
    foreach(DocumentPart child in containerPart.Children) { // omit the cast.
       //...etc...

Autres conseils

Vous pouvez le faire de cette façon: 

object a = new StreamWriter("c:\\temp\\test.txt");

if (a is TextReader == false)
{
   Console.WriteLine("failed");
}

Pourquoi ne pas simplement utiliser le reste? 

if (child is IContainer)
{
  //
}
else
{
  // Do what you want here
}

C'est soigné, c'est familier et simple?

Votre façon de procéder est correcte, mais vous pouvez créer un ensemble de méthodes d'extension pour faire de & un moyen plus élégant de rechercher l'instance 'NOT'. & « ; 

public static bool Is<T>(this object myObject)
{
    return (myObject is T);
}

public static bool IsNot<T>(this object myObject)
{
    return !(myObject is T);
}

Ensuite, vous pouvez écrire: 

if (child.IsNot<IContainer>())
{
    // child is not an IContainer
}

Moche? Je ne suis pas d'accord. Le seul autre moyen (personnellement, je pense que c'est & "; Plus laid &";): 

var obj = child as IContainer;
if(obj == null)
{
   //child "aint" IContainer
}

L'opérateur is évalue un résultat booléen afin que vous puissiez faire tout ce que vous seriez autrement en mesure de faire sur un booléen. Pour l'annuler, utilisez l'opérateur !. Pourquoi voudriez-vous avoir un autre opérateur rien que pour ça?

La méthode d'extension IsNot<T> est un bon moyen d'étendre la syntaxe. Gardez à l'esprit 

var container = child as IContainer;
if(container != null)
{
  // do something w/ contianer
}

fonctionne mieux que de faire quelque chose comme 

if(child is IContainer)
{
  var container = child as IContainer;
  // do something w/ container
}

Dans votre cas, peu importe le retour de la méthode. En d'autres termes, veillez à ne pas effectuer à la fois la vérification du type, puis la conversion du type immédiatement après.

Bien que l’opérateur IS soit normalement la meilleure solution, il existe une alternative que vous pouvez utiliser dans certaines circonstances. Vous pouvez utiliser l'opérateur as et tester la valeur null. 

MyClass mc = foo as MyClass;
if ( mc == null ) { }
else {}

Bien que cela n’évite pas le problème des parenthèses, il est à noter que la syntaxe la plus récente existe (à partir de C # 7) pour rendre le reste de votre code un peu plus clair: 

if (!(DocumentPart is IContainer container)) { return; }
foreach(DocumentPart child in container.Children) {
    ...

Ceci évite la conversion double, le contrôle nul et la disponibilité d'une variable dans les portées où elle pourrait être nulle.

Cela n’a pas encore été mentionné. Cela fonctionne et je pense que ça a l'air mieux que d'utiliser !(child is IContainer) 

if (part is IContainer is false)
{
    return;
}

if (child is IContainer ? false : true)
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top