is (C# Başvurusu)is (C# Reference)

İşleci, bir ifadenin sonucunun verilen türle uyumlu olup olmadığını denetler veya (7,0 ile C# başlayarak) bir ifadeyi bir düzene göre sınar. isThe 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. Tür testi is işleci hakkında daha fazla bilgi için, tür-test ve atama işleçleri makalesinin işleç bölümüne bakın.For information about the type-testing is operator see the is operator section of the Type-testing and cast operators article.

İle eşleşen desenlerisPattern matching with is

7,0 ile C# başlayarak, is ve Switch deyimleri, model eşleştirmeyi destekler.Starting with C# 7.0, the is and switch statements support pattern matching. is Anahtar sözcüğü aşağıdaki desenleri destekler:The is keyword supports the following patterns:

  • Bir ifadenin belirtilen türe dönüştürülüp dönüştürülebileceğini test eden tür stili, bu, bir ifadenin bu türden bir değişkene dönüştürülmesini sağlar.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.

  • Bir ifadenin belirtilen sabit değer olarak değerlendirilip değerlendirilmediğini test eden sabit bir model.Constant pattern, which tests whether an expression evaluates to a specified constant value.

  • var olan model, her zaman başarılı olan ve bir ifadenin değerini yeni bir yerel değişkene bağlayan bir eşleşme.var pattern, a match that always succeeds and binds the value of an expression to a new local variable.

Tür stiliType pattern

Model eşleştirmeyi gerçekleştirmek için tür modelini kullanırken, is bir ifadenin belirtilen bir türe dönüştürülüp dönüştürülebileceğini ve bu türden bir değişkene bir değişken verip etmediğini test eder.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. Bu, is kısa tür değerlendirmesi ve dönüştürmeyi sağlayan deyimin basit bir uzantısıdır.It's a straightforward extension of the is statement that enables concise type evaluation and conversion. is Tür deseninin genel formu:The general form of the is type pattern is:

   expr is type varname

Burada Expr , bir türün bir örneğini değerlendiren bir ifadedir, tür , Expr 'nin sonucunun dönüştürülecek türün adı, varname ise ifadenin sonucunun dönüştürüldüğü nesne, is test .truewhere 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.

İfade, Exprnulldeğilse ve aşağıdakilerden herhangi biri doğru ise geçerlidir: is trueThe is expression is true if expr isn't null, and any of the following is true:

  • Expr , türüile aynı türde bir örneğidir.expr is an instance of the same type as type.

  • Expr türündentüretilen bir türün örneğidir.expr is an instance of a type that derives from type. Diğer bir deyişle, ifadenin sonucu türündebir örneğe eklenebilir.In other words, the result of expr can be upcast to an instance of type.

  • ifadenin türünde bir temel sınıf olan bir derleme zamanı türü vardır ve Expr türü veya türünden türetilmiş bir çalışma zamanı türü vardır.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. Bir değişkenin derleme zamanı türü , bildiriminde tanımlanan değişkenin türüdür.The compile-time type of a variable is the variable's type as defined in its declaration. Bir değişkenin çalışma zamanı türü , bu değişkene atanan örneğin türüdür.The runtime type of a variable is the type of the instance that is assigned to that variable.

  • Expr , tür arabirimini uygulayan bir türün örneğidir.expr is an instance of a type that implements the type interface.

7,1 ile C# başlayarak, Expr genel bir tür parametresi ve kısıtlamaları tarafından tanımlanan bir derleme zamanı türüne sahip olabilir.Beginning with C# 7.1, expr may have a compile-time type defined by a generic type parameter and its constraints.

Expr ise true ve is bir if ifadesiyle birlikte kullanılırsa, varname yalnızca deyimin içinde atanır. ifIf expr is true and is is used with an if statement, varname is assigned within the if statement only. Varname kapsamı, is ifadeden if deyimi kapsayan bloğun sonuna kadar olur.The scope of varname is from the is expression to the end of the block enclosing the if statement. Başka bir konumda varname kullanılması atanmamış bir değişkenin kullanımı için derleme zamanı hatası oluşturur.Using varname in any other location generates a compile-time error for use of a variable that has not been assigned.

Aşağıdaki örnek, bir is IComparable.CompareTo(Object) türün yönteminin uygulanmasını sağlamak için tür modelini kullanır.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.");
    }
}

Model eşleştirmesi olmadan bu kod aşağıdaki gibi yazılabilir.Without pattern matching, this code might be written as follows. Tür deseninin kullanımı, dönüştürmenin sonucunun bir nullolup olmadığını test etme gereksinimini ortadan kaldırarak daha kompakt, okunabilir kod üretir.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 Tür deseninin de bir değer türünün türü belirlenirken daha kompakt kod üretir.The is type pattern also produces more compact code when determining the type of a value type. Aşağıdaki örnek, uygun bir is özelliğin değerini görüntülemeden önce bir nesnenin bir Person mi Dog yoksa bir örnek mi olduğunu anlamak için tür modelini kullanır.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

Desenler eşleşmesi olmayan eşdeğer kod, açık bir dönüştürme içeren ayrı bir atama gerektirir.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

Sabit modelConstant pattern

Sabit örüntüyle eşleşen desenler gerçekleştirirken, is bir ifadenin belirtilen bir sabit değere eşit olup olmadığını sınar.When performing pattern matching with the constant pattern, is tests whether an expression equals a specified constant. C# 6 ve önceki sürümlerde, sabit model Switch ifadesiyle desteklenir.In C# 6 and earlier versions, the constant pattern is supported by the switch statement. 7,0 ' C# den başlayarak, bu, is bildiri tarafından da desteklenir.Starting with C# 7.0, it's supported by the is statement as well. Sözdizimi şöyledir:Its syntax is:

   expr is constant

Burada Expr , değerlendirilecek ifadedir ve sabitin test edilecek değerdir.where expr is the expression to evaluate, and constant is the value to test for. sabit , aşağıdaki sabit ifadelerden herhangi biri olabilir:constant can be any of the following constant expressions:

  • Değişmez değer.A literal value.

  • Belirtilen const değişkenin adı.The name of a declared const variable.

  • Bir numaralandırma sabiti.An enumeration constant.

Sabit ifade aşağıdaki gibi değerlendirilir:The constant expression is evaluated as follows:

  • Eğer Expr ve Constant integral türse, C# eşitlik işleci ifadenin döndürülüp döndürülmeyeceğini true (yani, expr == constantne olduğunu) belirler.If expr and constant are integral types, the C# equality operator determines whether the expression returns true (that is, whether expr == constant).

  • Aksi takdirde, ifadenin değeri static Object. Equals (Expr, Constant) yöntemi çağrısıyla belirlenir.Otherwise, the value of the expression is determined by a call to the static Object.Equals(expr, constant) method.

Aşağıdaki örnek, bir nesnenin bir Dice örnek olup olmadığını test etmek için tür ve sabit desenleri ve bir zar rulosu değerinin 6 olup olmadığını anlamak için birleştirir.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!

İçin null denetim, sabit model kullanılarak gerçekleştirilebilir.Checking for null can be performed using the constant pattern. Anahtar sözcüğü, is ifadesiyle desteklenir. nullThe null keyword is supported by the is statement. Sözdizimi şöyledir:Its syntax is:

   expr is null

Aşağıdaki örnek, null denetimlerin karşılaştırmasını gösterir: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
}

var desenininvar pattern

Bu var , herhangi bir tür veya değer için bir catch-all ' dır.The var pattern is a catch-all for any type or value. Expr 'nin değeri her zaman bir yerel değişkene, aynı türde Expr'nin derleme zamanı türüyle atanır.The value of expr is always assigned to a local variable the same type as the compile time type of expr. is İfadenin sonucu her zaman trueolur.The result of the is expression is always true. Sözdizimi şöyledir:Its syntax is:

   expr is var varname

Aşağıdaki örnek, adlı objbir değişkene bir ifade atamak için var modelini kullanır.The following example uses the var pattern to assign an expression to a variable named obj. Daha sonra değerini ve türünü objgörüntüler.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

C# dili belirtimiC# language specification

Daha fazla bilgi için, C# dil belirtiminin ve aşağıdaki C# dil tekliflerinin işleç bölümüne bakın:For more information, see The is operator section of the C# language specification and the following C# language proposals:

Ayrıca bkz.See also