is (odwołanie w C#)is (C# Reference)

is Operator sprawdza, czy wynikiem wyrażenia jest zgodne z danym typem lub (począwszy od C# 7.0) sprawdza wyrażenie do wzorca.The is operator checks if the result of an expression is compatible with a given type, or (starting with C# 7.0) tests an expression against a pattern. Aby uzyskać informacje na temat typu testowania is Zobacz operator jest operatorem części operatory badania typu i konwersji artykułu.For information about the type-testing is operator see the is operator section of the Type-testing and conversion operators article.

Dopasowywanie wzorca z isPattern matching with is

Począwszy od C# 7.0, is i Przełącz instrukcje obsługują dopasowywania do wzorca.Starting with C# 7.0, the is and switch statements support pattern matching. is — Słowo kluczowe obsługuje następujące wzorce:The is keyword supports the following patterns:

  • Wpisz wzór, który sprawdza, czy wyrażenie można przekonwertować na określony typ i, jeśli może zostać rzutuje zmiennej tego typu.Type pattern, which tests whether an expression can be converted to a specified type and, if it can be, casts it to a variable of that type.

  • Wzór stałej, która sprawdza, czy wyrażenie ma określoną wartość stałą.Constant pattern, which tests whether an expression evaluates to a specified constant value.

  • wzorzec var, dopasowania zawsze zakończy się pomyślnie i Nowa zmienna lokalna jest powiązana wartość wyrażenia.var pattern, a match that always succeeds and binds the value of an expression to a new local variable.

Wpisz wzórType pattern

W przypadku używania wzorca typu do realizacji dopasowania do wzorca, is sprawdza, czy wyrażenie można przekonwertować na określony typ i, jeśli może zostać rzutuje zmiennej tego typu.When using the type pattern to perform pattern matching, is tests whether an expression can be converted to a specified type and, if it can be, casts it to a variable of that type. To proste rozszerzenie is instrukcję, która umożliwia ocenę zwięzły typ i konwersji.It's a straightforward extension of the is statement that enables concise type evaluation and conversion. Ogólna postać is typu wzorzec jest:The general form of the is type pattern is:

   expr is type varname

gdzie expr jest wyrażeniem, które daje w wyniku wystąpienia określonego typu typu nazwę typu, do którego jest wynikiem wyrażenie ma być przekonwertowany i nazwa_zmiennej obiekt, do którego jest wynikiem expr jest konwertowany, jeśli is test jest true.where expr is an expression that evaluates to an instance of some type, type is the name of the type to which the result of expr is to be converted, and varname is the object to which the result of expr is converted if the is test is true.

is Wyrażenie jest true Jeśli expr nie jest null, i jest spełniony jeden z następujących czynności:The is expression is true if expr isn't null, and any of the following is true:

  • wyrażenie to wystąpienie tego samego typu co typu.expr is an instance of the same type as type.

  • wyrażenie jest wystąpieniem typu, który pochodzi od klasy typu.expr is an instance of a type that derives from type. Innymi słowy, wynikiem expr może być rzutowany w górę do wystąpienia typu.In other words, the result of expr can be upcast to an instance of type.

  • wyrażenie ma typ kompilacji, która jest klasą bazową dla typu, i expr ma typ środowiska uruchomieniowego, który jest typu lub typu pochodnego względem typu.expr has a compile-time type that is a base class of type, and expr has a runtime type that is type or is derived from type. Typów w czasie kompilacji zmiennej jest typem zmiennej, zgodnie z definicją w jego deklaracji.The compile-time type of a variable is the variable's type as defined in its declaration. Typ środowiska uruchomieniowego zmiennej jest typem wystąpienia, która jest przypisana do zmiennej.The runtime type of a variable is the type of the instance that is assigned to that variable.

  • wyrażenie jest wystąpieniem typu, który implementuje typu interfejsu.expr is an instance of a type that implements the type interface.

Począwszy od C# 7.1, expr może mieć typ kompilacji, zdefiniowane przez parametr typu ogólnego i ograniczenia.Beginning with C# 7.1, expr may have a compile-time type defined by a generic type parameter and its constraints.

Jeśli expr jest true i is jest używana z if instrukcji nazwa_zmiennej jest przypisywane w ramach if tylko instrukcji.If expr is true and is is used with an if statement, varname is assigned within the if statement only. Zakres nazwa_zmiennej pochodzi z is wyrażenia na końcu otaczający blok if instrukcji.The scope of varname is from the is expression to the end of the block enclosing the if statement. Za pomocą nazwa_zmiennej w dowolnej innej lokalizacji generuje błąd w czasie kompilacji do użytku w zmiennej, która nie została przypisana.Using varname in any other location generates a compile-time error for use of a variable that has not been assigned.

W poniższym przykładzie użyto is wpisz wzór do implementacji typu IComparable.CompareTo(Object) metody.The following example uses the is type pattern to provide the implementation of a type's IComparable.CompareTo(Object) method.

using System;

public class Employee : IComparable
{
    public String Name { get; set; }
    public int Id { get; set; }

    public int CompareTo(Object o)
    {
        if (o is Employee e)
        {
            return Name.CompareTo(e.Name);
        }
        throw new ArgumentException("o is not an Employee object.");
    }
}

Bez dopasowywania do wzorca, ten kod może być zapisana w następujący sposób.Without pattern matching, this code might be written as follows. Używanie dopasowania wzorca typu generuje kod bardziej zwarty, czytelny dzięki wyeliminowaniu konieczności, aby sprawdzić, czy wynik konwersji jest null.The use of type pattern matching produces more compact, readable code by eliminating the need to test whether the result of a conversion is a null.

using System;

public class Employee : IComparable
{
    public String Name { get; set; }
    public int Id { get; set; }

    public int CompareTo(Object o)
    {
        var e = o as Employee;
        if (e == null)
        {
           throw new ArgumentException("o is not an Employee object.");
        }
        return Name.CompareTo(e.Name);
    }
}

is Wpisz wzór również generuje kod bardziej zwarty podczas określania typu o typie wartości.The is type pattern also produces more compact code when determining the type of a value type. W poniższym przykładzie użyto is wpisz wzór, aby ustalić, czy obiekt jest Person lub Dog wystąpienia przed wyświetleniem wartości odpowiednich właściwości.The following example uses the is type pattern to determine whether an object is a Person or a Dog instance before displaying the value of an appropriate property.

using System;

public class Example
{
   public static void Main()
   {
      Object o = new Person("Jane");
      ShowValue(o);
      
      o = new Dog("Alaskan Malamute");
      ShowValue(o);
   }

   public static void ShowValue(object o)
   {
      if (o is Person p) {
         Console.WriteLine(p.Name);
      }   
      else if (o is Dog d) {
         Console.WriteLine(d.Breed);
      }             
   }
}

public struct Person
{  
   public string Name { get; set; }
   
   public Person(string name) : this()
   {
      Name = name;
   }
}

public struct Dog
{
   public string Breed { get; set; }

   public Dog(string breedName) : this()
   {
      Breed = breedName;
   }
}
// The example displays the following output:
//	Jane
//	Alaskan Malamute

Równoważny kod bez dopasowywania do wzorca wymaga oddzielnych przypisania, które obejmuje jawnego rzutowania.The equivalent code without pattern matching requires a separate assignment that includes an explicit cast.

using System;

public class Example
{
   public static void Main()
   {
      Object o = new Person("Jane");
      ShowValue(o);
      
      o = new Dog("Alaskan Malamute");
      ShowValue(o);
   }

   public static void ShowValue(object o)
   {
      if (o is Person) {
         Person p = (Person) o;
         Console.WriteLine(p.Name);
      }   
      else if (o is Dog) {
         Dog d = (Dog) o;
         Console.WriteLine(d.Breed);
      }             
   }
}

public struct Person
{  
   public string Name { get; set; }
   
   public Person(string name) : this()
   {
      Name = name;
   }
}

public struct Dog
{
   public string Breed { get; set; }

   public Dog(string breedName) : this()
   {
      Breed = breedName;
   }
}
// The example displays the following output:
//       Jane
//       Alaskan Malamute

Wzór stałejConstant pattern

Podczas przeprowadzania dopasowywanie wzorca za wzór stałej is sprawdza, czy wyrażenie jest równe określonej stałej.When performing pattern matching with the constant pattern, is tests whether an expression equals a specified constant. W języku C# 6 i starszych wersji wzór stałej jest obsługiwana przez Przełącz instrukcji.In C# 6 and earlier versions, the constant pattern is supported by the switch statement. Począwszy od C# 7.0, nie jest obsługiwany przez is także instrukcji.Starting with C# 7.0, it's supported by the is statement as well. Jego składnia jest następująca:Its syntax is:

   expr is constant

gdzie expr jest wyrażenie do oceny, i stałej jest wartością do testowania.where expr is the expression to evaluate, and constant is the value to test for. Stała może być dowolną z następujących stałych wyrażeń:constant can be any of the following constant expressions:

  • Wartość literału.A literal value.

  • Nazwa deklarowanej const zmiennej.The name of a declared const variable.

  • Stała wyliczenia.An enumeration constant.

Stałe wyrażenie jest obliczane w następujący sposób:The constant expression is evaluated as follows:

  • Jeśli expr i stałej typów całkowitych operatora porównania języka C# Określa, czy wyrażenie zwraca true (oznacza to, czy expr == constant).If expr and constant are integral types, the C# equality operator determines whether the expression returns true (that is, whether expr == constant).

  • W przeciwnym razie wartość wyrażenia jest określana przez wywołanie statycznego metody Object.Equals (wyrażenie stałe) metody.Otherwise, the value of the expression is determined by a call to the static Object.Equals(expr, constant) method.

Poniższy przykład łączy wzorców typu i stała, aby sprawdzić, czy obiekt jest Dice wystąpienia, a jeśli tak jest, aby określić, czy wartość skumulowane dice to 6.The following example combines the type and constant patterns to test whether an object is a Dice instance and, if it is, to determine whether the value of a dice roll is 6.

using System;

public class Dice
{
    Random rnd = new Random();
    public Dice()
    {

    }
    public int Roll()
    {
        return rnd.Next(1, 7); 
    }
}

class Program
{
    static void Main(string[] args)
    {
        var d1 = new Dice();
        ShowValue(d1);
    }

    private static void ShowValue(object o)
    {
        const int HIGH_ROLL = 6;

        if (o is Dice d && d.Roll() is HIGH_ROLL)
            Console.WriteLine($"The value is {HIGH_ROLL}!");
        else
            Console.WriteLine($"The dice roll is not a {HIGH_ROLL}!");
     }
}
// The example displays output like the following:
//      The value is 6!

Sprawdzanie null mogą być wykonywane przy użyciu wzorca stałej.Checking for null can be performed using the constant pattern. null — Słowo kluczowe jest obsługiwana przez is instrukcji.The null keyword is supported by the is statement. Jego składnia jest następująca:Its syntax is:

   expr is null

W poniższym przykładzie przedstawiono porównanie null sprawdza, czy:The following example shows a comparison of null checks:

using System;

class Program
{
    static void Main(string[] args)
    {
        object o = null;

        if (o is null)
        {
            Console.WriteLine("o does not have a value");
        }
        else
        {
            Console.WriteLine($"o is {o}");
        }
        
        int? x = 10;

        if (x is null)
        {
            Console.WriteLine("x does not have a value");
        }
        else
        {
            Console.WriteLine($"x is {x.Value}");
        }
        
        // 'null' check comparison
        Console.WriteLine($"'is' constant pattern 'null' check result : { o is null }");
        Console.WriteLine($"object.ReferenceEquals 'null' check result : { object.ReferenceEquals(o, null) }");
        Console.WriteLine($"Equality operator (==) 'null' check result : { o == null }");
    }

    // The example displays the following output:
    // o does not have a value
    // x is 10
    // 'is' constant pattern 'null' check result : True
    // object.ReferenceEquals 'null' check result : True
    // Equality operator (==) 'null' check result : True
}

wzorzec varvar pattern

var Wzorzec jest wychwytywania dla dowolnego typu lub wartości.The var pattern is a catch-all for any type or value. Wartość expr jest zawsze przypisywana do zmiennej lokalnej taki sam typ co typ czasu kompilacji expr.The value of expr is always assigned to a local variable the same type as the compile time type of expr. Wynik is wyrażenie ma zawsze wartość true.The result of the is expression is always true. Jego składnia jest następująca:Its syntax is:

   expr is var varname

W poniższym przykładzie użyto wzorca var można przypisać wyrażenia do zmiennej o nazwie obj.The following example uses the var pattern to assign an expression to a variable named obj. Następnie wyświetla wartość i typ obj.It then displays the value and the type of obj.

using System;

class Program
{
    static void Main()
   {
      object[] items = { new Book("The Tempest"), new Person("John") };
      foreach (var item in items) {
        if (item is var obj)
          Console.WriteLine($"Type: {obj.GetType().Name}, Value: {obj}"); 
      }
   }
}

class Book
{
    public Book(string title) 
    {
       Title = title;    
    }

    public string Title { get; set; }

    public override string ToString()
    {
       return Title;
    }
}

class Person
{
   public Person(string name)
   {
      Name = name;
   }

   public string Name 
   { get; set; }

   public override string ToString()
   {
      return Name;
   }
}
// The example displays the following output:
//       Type: Book, Value: The Tempest
//       Type: Person, Value: John

specyfikacja języka C#C# language specification

Aby uzyskać więcej informacji, zobacz jest operatorem części C# specyfikacji języka następujący kod C# propozycji języka:For more information, see The is operator section of the C# language specification and the following C# language proposals:

Zobacz takżeSee also