geçiş (C# Başvurusu)switch (C# reference)

switch tek bir seçtiği bir seçim deyimi geçiş bölümüne bir desen eşleştirme ile temel adaylar listesinden yürütülecek eşleşen ifade.switch is a selection statement that chooses a single switch section to execute from a list of candidates based on a pattern match with the match expression.

using System;

public class Example
{
   public static void Main()
   {
      int caseSwitch = 1;
      
      switch (caseSwitch)
      {
          case 1:
              Console.WriteLine("Case 1");
              break;
          case 2:
              Console.WriteLine("Case 2");
              break;
          default:
              Console.WriteLine("Default case");
              break;
      }
   }
}
// The example displays the following output:
//       Case 1

switch Deyimi bir alternatifi olarak kullanılan genellikle bir if-else tek bir ifade, üç veya daha fazla koşul karşı test edildiyse oluşturun.The switch statement is often used as an alternative to an if-else construct if a single expression is tested against three or more conditions. Örneğin, aşağıdaki switch ifadesi bir değişken türü olup olmadığını belirler Color üç değerden birine sahiptir:For example, the following switch statement determines whether a variable of type Color has one of three values:

using System;

public enum Color { Red, Green, Blue }

public class Example
{
   public static void Main()
   {
      Color c = (Color) (new Random()).Next(0, 3);
      switch (c)
      {
         case Color.Red:
            Console.WriteLine("The color is red");
            break;
         case Color.Green:
            Console.WriteLine("The color is green");
            break;
         case Color.Blue:
            Console.WriteLine("The color is blue");   
            break;
         default:
            Console.WriteLine("The color is unknown.");
            break;   
      }
   }
}

Kullanan aşağıdaki örneğe eşdeğerdir bir if - else oluşturun.It's equivalent to the following example that uses an if-else construct.

using System;

public enum Color { Red, Green, Blue }

public class Example
{
   public static void Main()
   {
      Color c = (Color) (new Random()).Next(0, 3);
      if (c == Color.Red)
         Console.WriteLine("The color is red");
      else if (c == Color.Green)
         Console.WriteLine("The color is green");
      else if (c == Color.Blue)
         Console.WriteLine("The color is blue");   
      else
         Console.WriteLine("The color is unknown.");
   }
}
// The example displays the following output:
//       The color is red

Eşleştirme ifadesiThe match expression

Eşleşme ifade desenlerinde eşleştirilecek değer sağlar case etiketler.The match expression provides the value to match against the patterns in case labels. Kendi sözdizimi aşağıdaki gibidir:Its syntax is:

   switch (expr)

İçinde C# 6 ve önceki sürümlerde eşleştirme ifadesi bir değer türlerinden birini döndüren bir ifade olması gerekir:In C# 6 and earlier, the match expression must be an expression that returns a value of the following types:

C# 7.0 ile başlayarak, eşleştirme ifadesi null olmayan herhangi bir ifade olabilir.Starting with C# 7.0, the match expression can be any non-null expression.

Anahtar bölümüThe switch section

A switch deyimi bir veya daha fazla anahtar bölüm içerebilir.A switch statement includes one or more switch sections. Her anahtar bölümü bir veya daha fazla içeren case etiketleri (bir case veya default etiketi) ve ardından bir veya daha fazla deyim tarafından.Each switch section contains one or more case labels (either a case or default label) followed by one or more statements. switch Deyimi herhangi bir anahtar bölümü yerleştirilen en fazla bir varsayılan etiket içerebilir.The switch statement may include at most one default label placed in any switch section. Aşağıdaki örnek, basit bir gösterir switch üç anahtar bölümü, her iki deyim içeren olan ifade.The following example shows a simple switch statement that has three switch sections, each containing two statements. İkinci bölüm anahtarını içeren case 2: ve case 3: etiketler.The second switch section contains the case 2: and case 3: labels.

A switch deyimi anahtar bölümlerinin sayısını içerir ve her bölüm aşağıdaki örnekte gösterildiği gibi bir veya daha fazla durum etiketi olabilir.A switch statement can include any number of switch sections, and each section can have one or more case labels, as shown in the following example. Ancak, hiçbir iki durum etiketi aynı ifadesi içeriyor olabilir.However, no two case labels may contain the same expression.

using System;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      int caseSwitch = rnd.Next(1,4);
      
      switch (caseSwitch)
      {
          case 1:
              Console.WriteLine("Case 1");
              break;
          case 2:
          case 3:
              Console.WriteLine($"Case {caseSwitch}");
              break;
          default:
              Console.WriteLine($"An unexpected value ({caseSwitch})");
              break;
      }
   }
}
// The example displays output like the following:
//       Case 1

Switch deyimi içinde yalnızca bir anahtar bölümü yürütür.Only one switch section in a switch statement executes. C#bir geçiş bölümünden diğerine devam etmek için yürütmeye izin vermez.C# doesn't allow execution to continue from one switch section to the next. Bu nedenle, aşağıdaki kod bir Derleyici Hatası CS0163 oluşturur: "Denetim olamaz atlayabilir bir case etiketinden (<case etiketi >) diğerine."Because of this, the following code generates a compiler error, CS0163: "Control cannot fall through from one case label (<case label>) to another."

switch (caseSwitch)
{
    // The following switch section causes an error.
    case 1:
        Console.WriteLine("Case 1...");
        // Add a break or other jump statement here.
    case 2:
        Console.WriteLine("... and/or Case 2");
        break;
}

Bu gereksinim, genellikle açıkça kullanarak switch bölümüne çıkarak karşılanır bir sonu, goto, veya dönüş deyimi.This requirement is usually met by explicitly exiting the switch section by using a break, goto, or return statement. Program denetimi için geçemez sağlar ancak, aşağıdaki kod Ayrıca, geçersiz çünkü default bölümüne geçin.However, the following code is also valid, because it ensures that program control can't fall through to the default switch section.

switch (caseSwitch)  
{  
    // The following switch section causes an error.  
    case 1:  
        Console.WriteLine("Case 1...");  
        break;  
    case 2:  
    case 3:
        Console.WriteLine("... and/or Case 2");  
        break;
    case 4:  
        while (true)  
           Console.WriteLine("Endless looping. . . ."); 
    default:
        Console.WriteLine("Default value...");
        break;                 
}  

Eşleştirme ifadesi ile eşleşen bir durum etiketi ile anahtar bölümdeki ifade listesinin yürütülmesi ilk deyimden başlar ve deyim listesi boyunca genellikle bir atlama deyimine ulaşılıncaya kadar devam eder bir break, goto case, goto label, return, veya throw, ulaşıldı.Execution of the statement list in the switch section with a case label that matches the match expression begins with the first statement and proceeds through the statement list, typically until a jump statement, such as a break, goto case, goto label, return, or throw, is reached. Bu noktada, denetimi dışında aktarılan switch deyimi veya başka bir case etiketi.At that point, control is transferred outside the switch statement or to another case label. A goto deyimi kullanılırsa, gerekir aktarım denetimi için sabit bir etiket.A goto statement, if it's used, must transfer control to a constant label. Sabit olmayan etiketine denetim aktarmaya çalışırken istenmeyen yan etkileri, bu tür istenmeyen bir kod konumuna denetimi aktarma veya sonsuz bir döngüye oluşturma olabileceği için bu kısıtlama gereklidir.This restriction is necessary, since attempting to transfer control to a non-constant label can have undesirable side-effects, such transferring control to an unintended location in code or creating an endless loop.

Durum etiketiCase labels

Her durum etiketi eşleşen ifade karşılaştırmak için bir desen belirtir ( caseSwitch önceki örneklerde değişken).Each case label specifies a pattern to compare to the match expression (the caseSwitch variable in the previous examples). Eşleşiyorlarsa denetimi içeren anahtar bölüme aktarılır ilk eşleşen case etiketi.If they match, control is transferred to the switch section that contains the first matching case label. Hiçbir durum etiketi desen eşleştirme ifadesi eşleşirse denetimi ile bölümüne aktarılır default varsa durum etiketi.If no case label pattern matches the match expression, control is transferred to the section with the default case label, if there's one. Yoksa hiçbir default çalışması, her anahtar bölümü yok deyimlerinde yürütülür ve denetimin dışına aktarılır switch deyimi.If there's no default case, no statements in any switch section are executed, and control is transferred outside the switch statement.

Hakkında bilgi için switch deyimi ve desen eşleştirme, ile desen eşleştirme switch deyimi bölümü.For information on the switch statement and pattern matching, see the Pattern matching with the switch statement section.

Çünkü C# 6 yalnızca sabit desen destekler ve sabit değerleri tekrarını izin vermez, case etiketleri birbirini dışlayan değerleri tanımlayın ve yalnızca bir desen eşleştirme ifadesi eşleşebilir.Because C# 6 supports only the constant pattern and doesn't allow the repetition of constant values, case labels define mutually exclusive values, and only one pattern can match the match expression. Sonuç olarak, bir sırayı case deyimlerinizin önemli olduğu.As a result, the order in which case statements appear is unimportant.

C# 7.0, ancak diğer desenleri desteklendiğinden, case etiketleri birbirini dışlayan değerleri tanımlamanız gerekir değil ve eşleştirme ifadesi birden çok desen eşleştiğinde.In C# 7.0, however, because other patterns are supported, case labels need not define mutually exclusive values, and multiple patterns can match the match expression. Yalnızca eşleşen desen içeren ilk geçiş bölümündeki deyimlerin yürütülme nedeni sırayı case deyimlerinizin'ın, artık önemlidir.Because only the statements in the first switch section that contains the matching pattern are executed, the order in which case statements appear is now important. C#, case deyimi veya deyimler eşdeğerdir veya önceki deyimlerin kümeleridir switch bölümüne algılarsa, "anahtar durumu önceki bir case tarafından zaten işlendi." bir derleyici hatası, CS8120, oluşturur.If C# detects a switch section whose case statement or statements are equivalent to or are subsets of previous statements, it generates a compiler error, CS8120, "The switch case has already been handled by a previous case."

Aşağıdaki örnekte bir switch olmayan-birbirini dışlayan desenleri çeşitli kullanan deyimi.The following example illustrates a switch statement that uses a variety of non-mutually exclusive patterns. Taşırsanız case 0: artık ilk bölümü olması bölüm anahtarı switch deyimi C# tarafındantanımlananörnekleolduğubirtamsayıdeğerisıfırolantümtamsayılarınbiraltkümesiolduğuiçinbirderleyicihatasınanedenolur.case int val deyimi.If you move the case 0: switch section so that it's no longer the first section in the switch statement, C# generates a compiler error because an integer whose value is zero is a subset of all integers, which is the pattern defined by the case int val statement.

using System;
using System.Collections.Generic;
using System.Linq;

public class Example
{
   public static void Main()
   {
      var values = new List<object>();
      for (int ctr = 0; ctr <= 7; ctr++) {
         if (ctr == 2) 
            values.Add(DiceLibrary.Roll2());
         else if (ctr == 4)
            values.Add(DiceLibrary.Pass());
         else   
            values.Add(DiceLibrary.Roll());
      }   

      Console.WriteLine($"The sum of { values.Count } die is { DiceLibrary.DiceSum(values) }");
   }
}

public static class DiceLibrary
{
   // Random number generator to simulate dice rolls.
   static Random rnd = new Random();

   // Roll a single die.
   public static int Roll()
   {
      return rnd.Next(1, 7);
   }

   // Roll two dice.
   public static List<object> Roll2()
   {
      var rolls = new List<object>();      
      rolls.Add(Roll());
      rolls.Add(Roll());
      return rolls;
   }

   // Calculate the sum of n dice rolls.
   public static int DiceSum(IEnumerable<object> values)
   {
      var sum = 0;
      foreach (var item in values)
      {
            switch (item)
            {
               // A single zero value.
               case 0:
                  break;
               // A single value.
               case int val:
                  sum += val;
                  break;
               // A non-empty collection.
               case IEnumerable<object> subList when subList.Any():
                  sum += DiceSum(subList);
                  break;
               // An empty collection.
               case IEnumerable<object> subList:
                  break;
               //  A null reference.
               case null:
                  break;
               // A value that is neither an integer nor a collection.
               default:
                  throw new InvalidOperationException("unknown item type");
            }
      }
      return sum;
   }

   public static object Pass()
   {
      if (rnd.Next(0, 2) == 0)
         return null;
      else
         return new List<object>();
   }
}

Bu sorunu gidermek ve iki yoldan biriyle derleyici uyarısı ortadan kaldırır:You can correct this issue and eliminate the compiler warning in one of two ways:

  • Anahtar bölümlerin sırası değiştirerek.By changing the order of the switch sections.

  • Kullanarak bir zaman yan tümcesi içinde case etiketi.By using a when clause in the case label.

default ÇalışmasıThe default case

default Çalışması belirtir eşleştirme ifadesi diğer eşleşmiyorsa yürütmek için anahtar bölümü case etiketi.The default case specifies the switch section to execute if the match expression doesn't match any other case label. Varsa bir default durumu mevcut değil ve diğer eşleştirme ifadesi eşleşmeyen case program akışı etiketi geçmez switch deyimi.If a default case is not present and the match expression doesn't match any other case label, program flow falls through the switch statement.

default Çalışması herhangi bir sırada görünebilir switch deyimi.The default case can appear in any order in the switch statement. Kaynak kodunda kendi sırasını ne olursa olsun, her zaman son olarak, tüm değerlendirilmeden case etiketleri değerlendirilir.Regardless of its order in the source code, it's always evaluated last, after all case labels have been evaluated.

İle desen eşleştirme switch deyimi Pattern matching with the switch statement

Her case eşleşme ifadesi eşleşirse, yürütülecek içeren anahtar bölümü neden olan bir desen tanımlar.Each case statement defines a pattern that, if it matches the match expression, causes its containing switch section to be executed. Sabit desen C# ' in tüm sürümleri destekler.All versions of C# support the constant pattern. Kalan desenleri, C# 7. 0'den itibaren desteklenir.The remaining patterns are supported beginning with C# 7.0.

Sabit desenConstant pattern

Sabit desen eşleştirme ifadesi belirtilen bir sabit eşit olup olmadığını sınar.The constant pattern tests whether the match expression equals a specified constant. Kendi sözdizimi aşağıdaki gibidir:Its syntax is:

   case constant:

Burada sabit sınamak için değer.where constant is the value to test for. Sabit aşağıdaki sabit ifadeler biri olabilir:constant can be any of the following constant expressions:

  • A bool değişmez değer, ya da true veya false.A bool literal, either true or false.
  • Herhangi bir integral sabit gibi bir int, uzun, veya bir bayt.Any integral constant, such as an int, a long, or a byte.
  • Bildirilen bir adı const değişkeni.The name of a declared const variable.
  • Bir numaralandırma sabiti.An enumeration constant.
  • A char değişmez.A char literal.
  • A dize değişmez.A string literal.

Sabit ifade gibi değerlendirilir:The constant expression is evaluated as follows:

  • Varsa expr ve sabit integral türleri, C# eşitlik işlecini ifade döndürüp döndürmediğini belirler true (olup, diğer bir deyişle, expr == constant).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ğerini statik bir çağrı tarafından belirlenir Object.Equals (ifade, sabit) yöntemi.Otherwise, the value of the expression is determined by a call to the static Object.Equals(expr, constant) method.

Aşağıdaki örnek, belirli bir tarihin hafta, çalışma haftası ya da ikinci iş haftanın son gününü iş haftanın ilk günü olup olmadığını belirlemek için sabit bir desen kullanır.The following example uses the constant pattern to determine whether a particular date is a weekend, the first day of the work week, the last day of the work week, or the middle of the work week. Bu hesaplar DateTime.DayOfWeek üyelerinin göre geçerli günün özelliği DayOfWeek sabit listesi.It evaluates the DateTime.DayOfWeek property of the current day against the members of the DayOfWeek enumeration.

using System;

class Program
{
    static void Main()
    {
        switch (DateTime.Now.DayOfWeek)
        {
           case DayOfWeek.Sunday:
           case DayOfWeek.Saturday:
              Console.WriteLine("The weekend");
              break;
           case DayOfWeek.Monday:
              Console.WriteLine("The first day of the work week.");
              break;
           case DayOfWeek.Friday:
              Console.WriteLine("The last day of the work week.");
              break;
           default:
              Console.WriteLine("The middle of the work week.");
              break;   
        }
    }
}
// The example displays output like the following:
//       The middle of the work week.

Aşağıdaki örnek, kullanıcı girişini otomatik kahve makine taklit eden bir konsol uygulamasında işlemek için sabit desen kullanır.The following example uses the constant pattern to handle user input in a console application that simulates an automatic coffee machine.

using System;

class Example
{
   static void Main()
   {
       Console.WriteLine("Coffee sizes: 1=small 2=medium 3=large");
       Console.Write("Please enter your selection: ");
       string str = Console.ReadLine();
       int cost = 0;

       // Because of the goto statements in cases 2 and 3, the base cost of 25
       // cents is added to the additional cost for the medium and large sizes.
       switch (str)
       {
          case "1":
          case "small":
              cost += 25;
              break;
          case "2":
          case "medium":
              cost += 25;
              goto case "1";
          case "3":
          case "large":
              cost += 50;
              goto case "1";
          default:
              Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");
              break;
      }
      if (cost != 0)
      {
          Console.WriteLine("Please insert {0} cents.", cost);
      }
      Console.WriteLine("Thank you for your business.");
   }
}
// The example displays output like the following:
//         Coffee sizes: 1=small 2=medium 3=large
//         Please enter your selection: 2
//         Please insert 50 cents.
//         Thank you for your business.


Tür deseniType pattern

Tür düzeni kısa türü değerlendirme ve dönüştürme sağlar.The type pattern enables concise type evaluation and conversion. İle kullanıldığında switch desen eşleştirme, gerçekleştirmek için deyimi, bir ifadenin belirtilen bir türe dönüştürülüp dönüştürülemeyeceğini test eder ve olabilir, bu türden bir değişkene çevirir.When used with the switch statement to perform pattern matching, it tests whether an expression can be converted to a specified type and, if it can be, casts it to a variable of that type. Kendi sözdizimi aşağıdaki gibidir:Its syntax is:

   case type varname

Burada türü türün adı sonucunu expr Boolean'a dönüştürülecek ve varname hangi nesne sonucu expreşleşmenin başarılı olursa dönüştürülür.where 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 match succeeds. Derleme zamanı türü expr ile başlayarak, bir genel tür parametresi olabilir C# 7.1.The compile-time type of expr may be a generic type parameter, starting with C# 7.1.

case İfade true herhangi biri doğru ise:The case expression is true if any of the following is true:

  • Expr örneği aynı türde olan türü.expr is an instance of the same type as type.

  • Expr türetilen türün bir örneği türü.expr is an instance of a type that derives from type. Diğer bir deyişle, sonucunu expr örneğine başvurmanıza olabilir türü.In other words, the result of expr can be upcast to an instance of type.

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

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

Case ifadesi true ise varname kesinlikle atanır ve yalnızca anahtarı bölüm içinde yerel kapsama sahiptir.If the case expression is true, varname is definitely assigned and has local scope within the switch section only.

Unutmayın null bir türü ile eşleşmiyor.Note that null doesn't match a type. Eşleştirilecek bir null, kullanarak aşağıdaki case etiketi:To match a null, you use the following case label:

case null:

Aşağıdaki örnek, çeşitli koleksiyon türleri hakkında bilgi sağlamak için tür deseni kullanır.The following example uses the type pattern to provide information about various kinds of collection types.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

class Example
{
    static void Main(string[] args)
    {
        int[] values = { 2, 4, 6, 8, 10 };
        ShowCollectionInformation(values);
        
        var names = new List<string>();
        names.AddRange( new string[] { "Adam", "Abigail", "Bertrand", "Bridgette" } );
        ShowCollectionInformation(names);

        List<int> numbers = null;
        ShowCollectionInformation(numbers);
    }
   
    private static void ShowCollectionInformation(object coll)
    {
        switch (coll)
        {
            case Array arr:
               Console.WriteLine($"An array with {arr.Length} elements.");
               break;
            case IEnumerable<int> ieInt:
               Console.WriteLine($"Average: {ieInt.Average(s => s)}");
               break;   
            case IList list:
               Console.WriteLine($"{list.Count} items");
               break;
            case IEnumerable ie:
               string result = "";
               foreach (var e in ie) 
                  result += "${e} ";
               Console.WriteLine(result);
               break;   
            case null:
               // Do nothing for a null.
               break;
            default:
               Console.WriteLine($"A instance of type {coll.GetType().Name}");
               break;   
        }
    }
}
// The example displays the following output:
//     An array with 5 elements.
//     4 items

Yerine object, genel bir yöntem tür parametresi, aşağıdaki kodda gösterildiği gibi toplama türünü kullanarak yapabilirsiniz:Instead of object, you could make a generic method, using the type of the collection as the type parameter, as shown in the following code:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

class Example
{
    static void Main(string[] args)
    {
        int[] values = { 2, 4, 6, 8, 10 };
        ShowCollectionInformation(values);
        
        var names = new List<string>();
        names.AddRange( new string[] { "Adam", "Abigail", "Bertrand", "Bridgette" } );
        ShowCollectionInformation(names);

        List<int> numbers = null;
        ShowCollectionInformation(numbers);
    }
   
    private static void ShowCollectionInformation<T>(T coll)
    {
        switch (coll)
        {
            case Array arr:
               Console.WriteLine($"An array with {arr.Length} elements.");
               break;
            case IEnumerable<int> ieInt:
               Console.WriteLine($"Average: {ieInt.Average(s => s)}");
               break;   
            case IList list:
               Console.WriteLine($"{list.Count} items");
               break;
            case IEnumerable ie:
               string result = "";
               foreach (var e in ie) 
                  result += "${e} ";
               Console.WriteLine(result);
               break;   
            case object o:
               Console.WriteLine($"A instance of type {o.GetType().Name}");
               break;   
            default:
                Console.WriteLine("Null passed to this method.");
                break;
        }
    }
}
// The example displays the following output:
//     An array with 5 elements.
//     4 items
//     Null passed to this method.

Genel sürüm, iki yolla ilk örnek farklıdır.The generic version is different than the first sample in two ways. İlk olarak, kullanamazsınız null çalışması.First, you can't use the null case. Herhangi bir sabit çalışması kullanamazsınız, çünkü rastgele her türlü derleyici dönüştürülemiyor T dışındaki birine yazın object.You can't use any constant case because the compiler can't convert any arbitrary type T to any type other than object. Çürütülen default artık testler için null olmayan bir durumda object.What had been the default case now tests for a non-null object. Anlamına default case yalnızca testleri null.That means the default case tests only for null.

Desen eşleştirme olmadan, bu kod şu şekilde yazılmış olabilir.Without pattern matching, this code might be written as follows. Kullanım türü desen eşleştirme bir dönüştürmenin sonucu olup olmadığını sınamak için gereksinimini ortadan kaldırarak daha kompakt ve okunabilir bir kod oluşturur bir null veya yinelenen atamalar gerçekleştirmek için.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 or to perform repeated casts.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

class Example
{
    static void Main(string[] args)
    {
        int[] values = { 2, 4, 6, 8, 10 };
        ShowCollectionInformation(values);
        
        var names = new List<string>();
        names.AddRange( new string[] { "Adam", "Abigail", "Bertrand", "Bridgette" } );
        ShowCollectionInformation(names);
        
        List<int> numbers = null;
        ShowCollectionInformation(numbers);
    }
   
    private static void ShowCollectionInformation(object coll)
    {
        if (coll is Array) {
           Array arr = (Array) coll;
           Console.WriteLine($"An array with {arr.Length} elements.");
        }
        else if (coll is IEnumerable<int>) {
            IEnumerable<int> ieInt = (IEnumerable<int>) coll;
            Console.WriteLine($"Average: {ieInt.Average(s => s)}");
        }
        else if (coll is IList) {
            IList list = (IList) coll;
            Console.WriteLine($"{list.Count} items");
        }
        else if (coll is IEnumerable) { 
            IEnumerable ie = (IEnumerable) coll;
            string result = "";
            foreach (var e in ie) 
               result += "${e} ";
            Console.WriteLine(result);
        }
        else if (coll == null) { 
            // Do nothing. 
        }
        else {
            Console.WriteLine($"An instance of type {coll.GetType().Name}");
        }   
    }
}
// The example displays the following output:
//     An array with 5 elements.
//     4 items

case Deyimi ve when yan tümcesi The case statement and the when clause

Ekleyebileceğiniz Case deyimleri birbirini dışlayan olması gerekmez çünkü C# 7.0 ile başlayarak, bir when ek bir koşulu belirtmek için yan tümcesi memnun, doğru olarak değerlendirilebilmesi case deyimi için.Starting with C# 7.0, because case statements need not be mutually exclusive, you can add a when clause to specify an additional condition that must be satisfied for the case statement to evaluate to true. when Yan tümcesi, bir Boole değeri döndüren herhangi bir ifade olabilir.The when clause can be any expression that returns a Boolean value.

Aşağıdaki örnek, bir taban tanımlar Shape sınıfı, bir Rectangle türetilen sınıf Shapeve Square türetilen sınıf Rectangle.The following example defines a base Shape class, a Rectangle class that derives from Shape, and a Square class that derives from Rectangle. Kullandığı when emin olmak için yan ShowShapeInfo değerlendirir bir Rectangle eşit uzunlukta ve genişlikleri olarak atanmış olan bir nesne bir Square bile bunu olarak örneği edilmemiş bir Square nesne.It uses the when clause to ensure that the ShowShapeInfo treats a Rectangle object that has been assigned equal lengths and widths as a Square even if it hasn't been instantiated as a Square object. Yöntem bilgileri görüntülemek çalışmaz herhangi bir nesne hakkında null veya bir şekil, alan sıfırdır.The method doesn't attempt to display information either about an object that is null or a shape whose area is zero.

using System;

public abstract class Shape
{
   public abstract double Area { get; }
   public abstract double Circumference { get; } 
}

public class Rectangle : Shape
{
   public Rectangle(double length, double width) 
   {
      Length = length;
      Width = width; 
   }

   public double Length { get; set; }
   public double Width { get; set; }
   
   public override double Area
   { 
      get { return Math.Round(Length * Width,2); } 
   } 
   
   public override double Circumference 
   {
      get { return (Length + Width) * 2; }
   }
}

public class Square : Rectangle
{
   public Square(double side) : base(side, side) 
   {
      Side = side; 
   }

   public double Side { get; set; }
}

public class Circle : Shape
{
   public Circle(double radius) 
   {
      Radius = radius;
   } 
   
   public double Radius { get; set; }

   public override double Circumference
   {
      get { return 2 * Math.PI * Radius; }
   }

   public override double Area
   {
      get { return Math.PI * Math.Pow(Radius, 2); } 
   }
}

public class Example
{
   public static void Main()
   {
      Shape sh = null;
      Shape[] shapes = { new Square(10), new Rectangle(5, 7),
                         sh, new Square(0), new Rectangle(8, 8),
                         new Circle(3) };
      foreach (var shape in shapes)
         ShowShapeInfo(shape);
   }

   private static void ShowShapeInfo(Shape sh)
   {
      switch (sh)
      {
         // Note that this code never evaluates to true.
         case Shape shape when shape == null:
            Console.WriteLine($"An uninitialized shape (shape == null)");
            break;
         case null:
            Console.WriteLine($"An uninitialized shape");
            break;
         case Shape shape when sh.Area == 0:
            Console.WriteLine($"The shape: {sh.GetType().Name} with no dimensions");
            break;
         case Square sq when sh.Area > 0:
            Console.WriteLine("Information about square:");
            Console.WriteLine($"   Length of a side: {sq.Side}");
            Console.WriteLine($"   Area: {sq.Area}");
            break;
         case Rectangle r when r.Length == r.Width && r.Area > 0:
            Console.WriteLine("Information about square rectangle:");
            Console.WriteLine($"   Length of a side: {r.Length}");
            Console.WriteLine($"   Area: {r.Area}");
            break;
         case Rectangle r when sh.Area > 0:
            Console.WriteLine("Information about rectangle:");
            Console.WriteLine($"   Dimensions: {r.Length} x {r.Width}");
            Console.WriteLine($"   Area: {r.Area}");
            break;
         case Shape shape when sh != null:
            Console.WriteLine($"A {sh.GetType().Name} shape");
            break;
         default:
            Console.WriteLine($"The {nameof(sh)} variable does not represent a Shape.");
            break;   
      }
   }
}
// The example displays the following output:
//       Information about square:
//          Length of a side: 10
//          Area: 100
//       Information about rectangle:
//          Dimensions: 5 x 7
//          Area: 35
//       An uninitialized shape
//       The shape: Square with no dimensions
//       Information about square rectangle:
//          Length of a side: 8
//          Area: 64
//       A Circle shape

Unutmayın when yan tümcesinde test dener örnek olup olmadığını bir Shape nesnedir null yürütülmez.Note that the when clause in the example that attempts to test whether a Shape object is null doesn't execute. Test etmek için doğru türde deseni bir null olduğu case null:.The correct type pattern to test for a null is case null:.

C# dili belirtimiC# language specification

Daha fazla bilgi için switch deyimi içinde C# dil belirtimi.For more information, see The switch statement in the C# Language Specification. Dil belirtimi, C# sözdizimi ve kullanımı için kesin bir kaynaktır.The language specification is the definitive source for C# syntax and usage.

Ayrıca bkz.See also