is(C# 참조)is (C# Reference)

is 연산자는 식의 결과가 지정된 형식과 호환되는지 확인하거나, (C# 7.0부터) 패턴에 대해 식을 테스트합니다.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. 형식 테스트 is 연산자에 대한 자세한 내용은 형식 테스트 및 캐스트 연산자 문서의 is 연산자 섹션을 참조하세요.For information about the type-testing is operator see the is operator section of the Type-testing and cast operators article.

is를 사용한 패턴 일치Pattern matching with is

C# 7.0부터는 isswitch 문에서 패턴 일치를 지원합니다.Starting with C# 7.0, the is and switch statements support pattern matching. is 키워드는 다음과 같은 패턴을 지원합니다.The is keyword supports the following patterns:

  • 형식 패턴 - 식을 지정된 형식으로 변환할 수 있는지를 테스트하고, 변환할 수 있으면 해당 형식의 변수로 캐스트합니다.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.

  • 상수 패턴 - 식이 지정된 상수 값으로 평가되는지 여부를 테스트합니다.Constant pattern, which tests whether an expression evaluates to a specified constant value.

  • var 패턴 - 항상 성공하고 식의 값을 새 로컬 변수에 바인딩하는 일치입니다.var pattern, a match that always succeeds and binds the value of an expression to a new local variable.

형식 패턴Type pattern

형식 패턴을 사용하여 패턴 일치를 수행하는 경우 is는 식을 지정된 형식으로 변환할 수 있는지 여부를 테스트하고, 변환할 수 있으면 해당 형식의 변수로 캐스트합니다.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. 간결한 형식 평가 및 변환을 사용하는 is 문의 간단한 확장입니다.It's a straightforward extension of the is statement that enables concise type evaluation and conversion. is 형식 패턴의 일반적인 형식은 다음과 같습니다.The general form of the is type pattern is:

   expr is type varname

여기서 expr은 일부 형식의 인스턴스로 평가되는 식이고 typeexpr의 결과가 변환될 형식의 이름이며 varnameis 테스트가 true인 경우 expr의 결과가 변환되는 개체입니다.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.

exprnull이 아니고 다음 중 하나가 true일 경우 is 식은 true입니다.The is expression is true if expr isn't null, and any of the following is true:

  • exprtype과 동일한 형식의 인스턴스입니다.expr is an instance of the same type as type.

  • exprtype에서 파생된 형식의 인스턴스입니다.expr is an instance of a type that derives from type. 즉, expr의 결과를 type의 인스턴스로 업캐스트할 수 있습니다.In other words, the result of expr can be upcast to an instance of type.

  • expr의 컴파일 시간 형식은 type의 기본 클래스이고 expr의 런타임 형식은 type이거나 type에서 파생됩니다.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. 변수의 컴파일 시간 형식은 해당 선언에 정의된 변수의 형식입니다.The compile-time type of a variable is the variable's type as defined in its declaration. 변수의 런타임 형식은 해당 변수에 할당된 인스턴스의 형식입니다.The runtime type of a variable is the type of the instance that is assigned to that variable.

  • exprtype 인터페이스를 구현하는 형식의 인스턴스입니다.expr is an instance of a type that implements the type interface.

C# 7.1부터 expr은 제네릭 형식 매개 변수 및 해당 제약 조건을 통해 컴파일 시간 형식을 정의할 수 있습니다.Beginning with C# 7.1, expr may have a compile-time type defined by a generic type parameter and its constraints.

exprtrue이고 isif 문에서 사용되는 경우 varnameif 문 내에서만 할당됩니다.If expr is true and is is used with an if statement, varname is assigned within the if statement only. varname의 범위는 is 식에서부터 if 문을 닫는 블록의 끝까지입니다.The scope of varname is from the is expression to the end of the block enclosing the if statement. 다른 위치에서 varname을 사용하여 할당되지 않은 변수 사용에 대한 컴파일 시간 오류를 생성합니다.Using varname in any other location generates a compile-time error for use of a variable that has not been assigned.

다음 예제에서는 is 형식 패턴을 사용하여 형식의 IComparable.CompareTo(Object) 메서드 구현을 제공합니다.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.");
    }
}

패턴 일치를 사용하지 않을 경우 이 코드를 다음과 같이 작성할 수 있습니다.Without pattern matching, this code might be written as follows. 형식 패턴 일치를 사용하면 변환 결과가 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 형식 패턴은 값 형식의 형식을 확인할 때 보다 간결한 코드를 생성합니다.The is type pattern also produces more compact code when determining the type of a value type. 다음 예제에서는 is 형식 패턴을 사용하여 개체가 Person 인스턴스인지 Dog 인스턴스인지를 확인한 후 적절한 속성의 값을 표시합니다.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

패턴 일치를 사용하지 않는 동일한 코드에는 명시적 캐스트를 포함하는 별도의 할당이 필요합니다.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

상수 패턴Constant pattern

상수 패턴을 사용한 패턴 일치를 수행하는 경우 is는 식이 지정된 상수와 같은지 여부를 테스트합니다.When performing pattern matching with the constant pattern, is tests whether an expression equals a specified constant. C# 6 이전 버전에서는 상수 패턴이 switch 문에서 지원됩니다.In C# 6 and earlier versions, the constant pattern is supported by the switch statement. C# 7.0부터는 is 문에서도 지원됩니다.Starting with C# 7.0, it's supported by the is statement as well. 사용되는 구문은 다음과 같습니다.Its syntax is:

   expr is constant

여기서 expr은 평가할 식이고 constant는 테스트할 값입니다.where expr is the expression to evaluate, and constant is the value to test for. constant는 다음 상수 식 중 하나가 될 수 있습니다.constant can be any of the following constant expressions:

  • 리터럴 값.A literal value.

  • 선언된 const 변수의 이름.The name of a declared const variable.

  • 열거형 상수.An enumeration constant.

상수 식은 다음과 같이 계산됩니다.The constant expression is evaluated as follows:

  • exprconstant가 정수 형식인 경우 C# 같음 연산자는 식에서 true를 반환하는지 여부 즉, expr == constant인지 여부를 확인합니다.If expr and constant are integral types, the C# equality operator determines whether the expression returns true (that is, whether expr == constant).

  • 정수 형식이 아닌 경우 정적 Object.Equals(expr, constant) 메서드 호출을 통해 식의 값이 결정됩니다.Otherwise, the value of the expression is determined by a call to the static Object.Equals(expr, constant) method.

다음 예제에서는 형식 패턴과 상수 패턴을 결합하여 개체가 Dice 인스턴스인지 여부를 테스트하고, 그럴 경우 주사위 굴리기 값이 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!

상수 패턴을 사용하여 null을 검사할 수 있습니다.Checking for null can be performed using the constant pattern. null 키워드는 is 문에서 지원됩니다.The null keyword is supported by the is statement. 사용되는 구문은 다음과 같습니다.Its syntax is:

   expr is null

다음 예제는 null 검사의 비교를 보여 줍니다.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 패턴var pattern

var 패턴은 모든 형식 또는 값에 대해 catch-all입니다.The var pattern is a catch-all for any type or value. expr의 값은 항상 expr의 컴파일 시간 형식과 동일한 형식의 지역 변수에 할당됩니다.The value of expr is always assigned to a local variable the same type as the compile time type of expr. is 식의 결과는 항상 true입니다.The result of the is expression is always true. 사용되는 구문은 다음과 같습니다.Its syntax is:

   expr is var varname

다음 예제에서는 var 패턴을 사용하여 obj라는 변수에 식을 할당합니다.The following example uses the var pattern to assign an expression to a variable named obj. 그런 다음 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

C# 언어 사양C# language specification

자세한 내용은 C# 언어 사양s 연산자 섹션과 다음 C# 언어 제안을 참조하세요.For more information, see The is operator section of the C# language specification and the following C# language proposals:

참고 항목See also