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

Sprawdza, czy obiekt jest zgodny z danego typu, lub (rozpoczynający się znakami języka C# 7.0) sprawdza się wyrażenie do wzorca.Checks if an object is compatible with a given type, or (starting with C# 7.0) tests an expression against a pattern.

Testowanie zgodności typuTesting for type compatibility

is — Słowo kluczowe ocenia zgodność z typem w czasie wykonywania.The is keyword evaluates type compatibility at runtime. Określa, czy wystąpienie obiektu lub wyniku wyrażenia można przekonwertować na określony typ.It determines whether an object instance or the result of an expression can be converted to a specified type. Ma składnięIt has the syntax

   expr is type

gdzie expr jest wyrażeniem, które daje w wyniku wystąpienia określonego typu i typu jest nazwą typu, do której wynik expr do przekonwertowania.where expr is an expression that evaluates to an instance of some type, and type is the name of the type to which the result of expr is to be converted. is Instrukcja jest true Jeśli expr jest inna niż null i wyniki z obliczając wartość wyrażenia można przekonwertować na obiekt typu; w przeciwnym razie zwraca false.The is statement is true if expr is non-null and the object that results from evaluating the expression can be converted to type; otherwise, it returns false.

Na przykład, poniższy kod określa, czy obj mogą być rzutowane na wystąpienie Person typu:For example, the following code determines if obj can be cast to an instance of the Person type:

if (obj is Person) {
   // Do something if obj is a Person.
}

is Instrukcja jest wartość true, jeśli:The is statement is true if:

  • 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.

Poniższy przykład pokazuje, że is wyrażenie daje w wyniku true dla każdej takiej konwersji.The following example shows that the is expression evaluates to true for each of these conversions.

using System;

public class Class1 : IFormatProvider
{
   public object GetFormat(Type t)
   {
      if (t.Equals(this.GetType()))      
         return this;
      return null;
   }
}

public class Class2 : Class1
{
   public int Value { get; set; }
}

public class Example
{
   public static void Main()
   {
      var cl1 = new Class1();
      Console.WriteLine(cl1 is IFormatProvider);
      Console.WriteLine(cl1 is Object);
      Console.WriteLine(cl1 is Class1);
      Console.WriteLine(cl1 is Class2); 
      Console.WriteLine();
 
      var cl2 = new Class2();
      Console.WriteLine(cl2 is IFormatProvider);
      Console.WriteLine(cl2 is Class2);
      Console.WriteLine(cl2 is Class1);
      Console.WriteLine();
      
      Class1 cl = cl2;
      Console.WriteLine(cl is Class1);
      Console.WriteLine(cl is Class2);
   }
}
// The example displays the following output:
//     True
//     True
//     True
//     False
//     
//     True
//     True
//     True
//     
//     True
//     True

is — Słowo kluczowe generuje ostrzeżenie kompilacji, jeśli wiadomo, że wyrażenie zawsze być true lub false.The is keyword generates a compile-time warning if the expression is known to always be either true or false. Analizuje ona tylko konwersje odwołań, konwersje boxing i konwersji unboxing; nie traktuje konwersje zdefiniowane przez użytkownika lub konwersje zdefiniowane przez typ niejawne i jawne operatorów.It only considers reference conversions, boxing conversions, and unboxing conversions; it does not consider user-defined conversions or conversions defined by a type's implicit and explicit operators. Poniższy przykład generuje ostrzeżenia, ponieważ wynik konwersji jest znany w czasie kompilacji.The following example generates warnings because the result of the conversion is known at compile time. is Wyrażenia w przypadku konwersji z typu int do long i double zwraca wartość FAŁSZ, ponieważ te konwersje są obsługiwane przez niejawne operatora.The is expression for conversions from int to long and double return false, since these conversions are handled by the implicit operator.

Console.WriteLine(3 is int);
Console.WriteLine();

int value = 6;
Console.WriteLine(value is long);
Console.WriteLine(value is double);
Console.WriteLine(value is object);
Console.WriteLine(value is ValueType);
Console.WriteLine(value is int);
// Compilation generates the following compiler warnings:
//   is2.cs(8,25): warning CS0183: The given expression is always of the provided ('int') type
//   is2.cs(12,25): warning CS0184: The given expression is never of the provided ('long') type
//   is2.cs(13,25): warning CS0184: The given expression is never of the provided ('double') type
//   is2.cs(14,25): warning CS0183: The given expression is always of the provided ('object') type
//   is2.cs(15,25): warning CS0183: The given expression is always of the provided ('ValueType') type
//   is2.cs(16,25): warning CS0183: The given expression is always of the provided ('int') type

expr nie może być anonimowa metoda lub wyrażenie lambda.expr cannot be an anonymous method or lambda expression. Może być dowolne wyrażenie zwracające wartość.It can be any other expression that returns a value. W poniższym przykładzie użyto is można obliczyć wartość zwracaną przez wywołanie metody.The following example uses is to evaluate the return value of a method call.

using System;

public class Example
{
   public static void Main()
   {
      double number1 = 12.63; 
      if (Math.Ceiling(number1) is double)
         Console.WriteLine("The expression returns a double.");
      else if (Math.Ceiling(number1) is decimal)    
         Console.WriteLine("The expression returns a decimal.");

      decimal number2 = 12.63m; 
      if (Math.Ceiling(number2) is double)
         Console.WriteLine("The expression returns a double.");
      else if (Math.Ceiling(number2) is decimal)    
         Console.WriteLine("The expression returns a decimal.");

   }
}
// The example displays the following output:
//     The expression returns a double.
//     The expression returns a decimal.

Począwszy od języka C# 7.0, można użyć dopasowywania do wzorca z wpisz wzór napisać bardziej zwięzły widok kodu, który używa is instrukcji.Starting with C# 7.0, you can use pattern matching with the type pattern to write more concise code that uses the is statement.

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łej Constant 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 var var 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 Specyfikacja języka C#.For more information, see the C# Language Specification. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.The language specification is the definitive source for C# syntax and usage.

Zobacz takżeSee also