자습서: 패턴 매칭을 사용하여 알고리즘 작성

패턴 일치를 사용하면 해당 형식을 수정하지 않고도 다른 라이브러리에 정의된 형식에 대한 기능을 추가할 수 있습니다. 패턴의 또 다른 용도는 확장되는 형식의 기초 기능이 아닌 애플리케이션에 필요한 기능을 만드는 것입니다.

이 튜토리얼에서는 다음을 배우게 됩니다:

패턴 일치를 사용해야 하는 상황을 인식합니다.
패턴 일치 식을 사용하여 형식 및 속성 값에 따라 동작을 구현합니다.
패턴 일치를 다른 기술과 결합하여 완전한 알고리즘을 만듭니다.

Prerequisites

설치 지침

Windows에서 이 WinGet 구성 파일을 사용하여 모든 필수 구성 요소를 설치하십시오. 이미 설치된 항목이 있는 경우 WinGet은 해당 단계를 건너뜁니다.

파일을 다운로드하고 두 번 클릭하여 실행합니다.
사용권 계약을 읽고, y입력하고, 동의하라는 메시지가 표시되면 Enter 키를 선택합니다.
작업 표시줄에 깜박이는 UAC(사용자 계정 컨트롤) 프롬프트가 표시되면 설치를 계속하도록 허용합니다.

다른 플랫폼에서는 이러한 각 구성 요소를 별도로 설치해야 합니다.

.NET SDK 다운로드 페이지 권장 설치 관리자를 다운로드하고 두 번 클릭하여 실행합니다. 다운로드 페이지에서 플랫폼을 검색하고 플랫폼에 대한 최신 설치 관리자를 권장합니다.
Visual Studio Code 홈페이지에서 최신 설치 관리자를 다운로드하고 두 번 클릭하여 실행합니다. 그 페이지는 또한 플랫폼을 탐지하며, 링크는 시스템에 맞게 정확할 것입니다.
C# DevKit 확장 페이지에서 "설치" 단추를 클릭합니다. 그러면 Visual Studio 코드가 열리고 확장을 설치하거나 사용하도록 설정할지 묻습니다. "설치"를 선택합니다.

패턴 일치 시나리오

최신 개발에는 종종 여러 소스의 데이터를 통합하고 해당 데이터의 정보와 인사이트를 단일 결합 애플리케이션에서 제공하는 작업이 포함됩니다. 귀하와 팀은 들어오는 데이터를 나타내는 형식을 제어하지 않을 수 있습니다.

클래식 개체 지향 디자인 접근 방식은 여러 데이터 원본의 각 데이터 형식을 나타내는 형식을 애플리케이션에 생성하도록 요구합니다. 그런 다음, 애플리케이션은 이러한 새 형식을 사용하고, 상속 계층 구조를 빌드하고, 가상 메서드를 만들고, 추상화를 구현합니다. 이러한 기술은 효과가 있으며 때로는 최고의 도구가 되기도 합니다. 경우에 따라 더 적은 코드를 작성할 수 있습니다. 경우에 따라 데이터를 이를 사용하는 작업으로부터 분리하면 코드를 더 쉽게 읽을 수 있습니다.

이 자습서에서는 단일 시나리오를 위해 여러 외부 원본에서 들어오는 데이터를 수집하는 애플리케이션을 만들고 탐색합니다. 패턴 일치가 원래 시스템의 일부가 아닌 방식으로 해당 데이터를 효율적으로 사용하고 처리하게 해 주는지 알 수 있습니다.

통행료와 피크 시간 가격을 사용하여 트래픽을 관리하는 주요 대도시 지역을 고려해 보세요. 형식에 따라 차량의 통행료를 계산하는 애플리케이션을 작성합니다. 나중에 차량 탑승자 수에 따른 가격이 개선 사항에 통합됩니다. 추가로 시간 및 요일에 따른 가격이 개선 사항에 추가됩니다.

이 간단한 설명에서 개체 계층 구조를 빠르게 스케치하여 이 시스템을 모델링할 수 있습니다. 그러나 귀하의 데이터는 다른 차량 등록 관리 시스템과 같은 여러 원본에서 제공됩니다. 이러한 시스템은 해당 데이터를 모델링하기 위한 다양한 클래스를 제공하며, 이러한 시스템은 단일 개체 모델을 공유하지 않습니다. 이 자습서에서는 다음 코드와 같이 이러한 간소화된 클래스를 사용하여 이러한 외부 시스템의 차량 데이터를 모델링합니다.

namespace ConsumerVehicleRegistration
{
    public class Car
    {
        public int Passengers { get; set; }
    }
}

namespace CommercialRegistration
{
    public class DeliveryTruck
    {
        public int GrossWeightClass { get; set; }
    }
}

namespace LiveryRegistration
{
    public class Taxi
    {
        public int Fares { get; set; }
    }

    public class Bus
    {
        public int Capacity { get; set; }
        public int Riders { get; set; }
    }
}

시작 코드는 dotnet/samples GitHub 리포지토리에서 다운로드할 수 있습니다. 차량 클래스는 서로 다른 시스템에서 온 것이며 다른 네임스페이스에 있음을 알 수 있습니다. System.Object 외의 공통 기본 클래스는 사용할 수 없습니다.

패턴 매칭 설계

이 자습서에서 사용되는 시나리오는 패턴 일치로 효과적으로 해결할 수 있는 문제의 종류를 강조 표시합니다.

사용해야 하는 개체는 목표와 일치하는 개체 계층 구조에 없습니다. 관련 없는 시스템의 일부인 클래스로 작업할 수 있습니다.
추가할 기능은 이 클래스에 대한 핵심 추상화에 포함되지 않습니다. 차량에 따른 통행료는 차량 형식에 따라 변경되지만 통행료는 차량의 핵심 기능이 아닙니다.

데이터의 모양과 해당 데이터에 대한 작업을 분리해서 설명하면 C#의 패턴 일치 기능을 더 쉽게 사용할 수 있습니다.

기본 통행료 계산 구현

가장 기본적인 통행료 계산에는 차량 형식만 사용됩니다.

Car는 2.00 USD입니다.
Taxi는 3.50 USD입니다.
Bus는 5.00 USD입니다.
DeliveryTruck는 $10.00입니다.

새 TollCalculator 클래스를 만들고 차량 형식에 대한 패턴 일치를 구현하여 통행료 액수를 얻습니다. 다음 코드에서는 TollCalculator의 초기 구현을 보여줍니다.

using System;
using CommercialRegistration;
using ConsumerVehicleRegistration;
using LiveryRegistration;

namespace Calculators;

public class TollCalculator
{
    public decimal CalculateToll(object vehicle) =>
        vehicle switch
    {
        Car c           => 2.00m,
        Taxi t          => 3.50m,
        Bus b           => 5.00m,
        DeliveryTruck t => 10.00m,
        { }             => throw new ArgumentException(message: "Not a known vehicle type", paramName: nameof(vehicle)),
        null            => throw new ArgumentNullException(nameof(vehicle))
    };
}

앞의 코드는 switch을 테스트하는 (switch 문과 같지 않음)을 사용합니다. switch 식은 이전 코드의 vehicle 변수로 시작하고 그 뒤에 switch 키워드가 옵니다. 다음은 중괄호로 묶인 모든 스위치 암(arm)입니다. switch 식은 switch 문을 둘러싸는 구문을 다르게 구체화합니다. case 키워드가 생략되며 각 분기별 결과는 표현식입니다. 마지막 두 개의 팔은 새 언어 기능을 보여 줍니다. { } 사례는 이전의 arm과 일치하지 않는 비-null 개체와 일치합니다. 이 모듈은 이 메서드에 전달된 잘못된 형식을 포착합니다. { } 사례는 각 차량 형식에 대한 사례를 따라야 합니다. 순서가 반대로 된 경우 { } 사례가 우선적으로 적용됩니다. 마지막으로 null상수 패턴은 null이 언제 이 메서드에 전달되는지를 검색합니다. 다른 패턴은 올바른 형식의 null이 아닌 개체와만 일치하므로 null 패턴이 마지막일 수 있습니다.

Program.cs에서 다음 코드를 사용하여 이 코드를 테스트할 수 있습니다:

using System;
using CommercialRegistration;
using ConsumerVehicleRegistration;
using LiveryRegistration;

using toll_calculator;

var tollCalc = new TollCalculator();

var car = new Car();
var taxi = new Taxi();
var bus = new Bus();
var truck = new DeliveryTruck();

Console.WriteLine($"The toll for a car is {tollCalc.CalculateToll(car)}");
Console.WriteLine($"The toll for a taxi is {tollCalc.CalculateToll(taxi)}");
Console.WriteLine($"The toll for a bus is {tollCalc.CalculateToll(bus)}");
Console.WriteLine($"The toll for a truck is {tollCalc.CalculateToll(truck)}");

try
{
    tollCalc.CalculateToll("this will fail");
}
catch (ArgumentException e)
{
    Console.WriteLine("Caught an argument exception when using the wrong type");
}
try
{
    tollCalc.CalculateToll(null!);
}
catch (ArgumentNullException e)
{
    Console.WriteLine("Caught an argument exception when using null");
}

이 코드는 시작 프로젝트에 포함되지만 주석 처리되어 있습니다. 주석을 제거하고 작성한 내용을 테스트할 수 있습니다.

먼저 패턴을 사용하여 코드 및 데이터가 구분되는 알고리즘을 만드는 방법을 확인하겠습니다. switch 식은 형식을 테스트하고 결과에 따라 다른 값을 생성합니다. 이는 시작에 불과합니다.

점유 가격 추가

통행료 징수 기관은 차량이 최대 탑승자 수로 이동하도록 권장하려고 합니다. 그들은 차량에 더 적은 승객이 있을 때 더 많은 요금을 부과하기로 결정하고, 더 낮은 가격을 제공하여 승객이 가득 찬 차량을 장려하기로 결정합니다.

승객이 없는 승용차와 택시에는 0.50 USD의 추가 통행료가 부과됩니다.
승객이 2명인 승용차와 택시는 $0.50의 할인을 받습니다.
승객이 3명 이상인 승용차와 택시는 1.00 USD의 할인을 받습니다.
최대 탑승자 수의 50% 미만이 탑승한 버스는 2.00 USD의 추가 요금이 부과됩니다.
탑승자 수가 90%를 초과하는 버스는 1.00 USD의 할인을 받습니다.

동일한 스위치 식에서 속성 패턴을 사용하여 이러한 규칙을 구현할 수 있습니다. 속성 패턴은 속성 값을 상수 값과 비교합니다. 속성 패턴은 형식이 결정되면 개체의 속성을 검사합니다. Car {Passengers: 0} 는 그 자체로 재귀 패턴입니다. Car에 대한 외부 속성 패턴에는 Passengers 값을 테스트하는 내부 상수 패턴이 포함됩니다. Car 사례 1개는 다른 사례 4개로 확장됩니다.

vehicle switch
{
    Car {Passengers: 0} => 2.00m + 0.50m,
    Car {Passengers: 1} => 2.0m,
    Car {Passengers: 2} => 2.0m - 0.50m,
    Car                 => 2.00m - 1.0m,

    // ...
};

처음 3개 사례는 형식을 Car로 테스트한 다음, Passengers 속성 값을 확인합니다. 둘 다 일치하면 식이 평가되고 값이 반환됩니다.

비슷한 방식으로 택시의 케이스를 확장할 수도 있습니다.

vehicle switch
{
    // ...

    Taxi {Fares: 0}  => 3.50m + 1.00m,
    Taxi {Fares: 1}  => 3.50m,
    Taxi {Fares: 2}  => 3.50m - 0.50m,
    Taxi             => 3.50m - 1.00m,

    // ...
};

다음으로, 다음 예제와 같이 버스 사례를 확장하여 점유 규칙을 구현합니다.

vehicle switch
{
    // ...

    Bus b when ((double)b.Riders / (double)b.Capacity) < 0.50 => 5.00m + 2.00m,
    Bus b when ((double)b.Riders / (double)b.Capacity) > 0.90 => 5.00m - 1.00m,
    Bus => 5.00m,

    // ...
};

통행료 징수 기관은 배달 트럭의 승객 수에 관심이 없습니다. 대신 다음과 같이 트럭의 중량 등급을 기준으로 요금을 조정합니다.

5000lbs를 초과하는 트럭에는 5.00 USD가 추가로 부과됩니다.
3000lbs 미만의 경량 트럭에는 $2.00 할인이 제공됩니다.

다음 코드를 사용하여 해당 규칙을 구현할 수 있습니다.

vehicle switch
{
    // ...

    DeliveryTruck t when (t.GrossWeightClass > 5000) => 10.00m + 5.00m,
    DeliveryTruck t when (t.GrossWeightClass < 3000) => 10.00m - 2.00m,
    DeliveryTruck => 10.00m,
};

앞의 코드는 스위치 암(arm)의 when 절을 표시합니다. 속성에서 같음 이외의 조건을 테스트하려면 when 절을 사용합니다. 완료되면 다음 코드와 비슷한 메서드가 있습니다.

vehicle switch
{
    Car {Passengers: 0}        => 2.00m + 0.50m,
    Car {Passengers: 1}        => 2.0m,
    Car {Passengers: 2}        => 2.0m - 0.50m,
    Car                        => 2.00m - 1.0m,

    Taxi {Fares: 0}  => 3.50m + 1.00m,
    Taxi {Fares: 1}  => 3.50m,
    Taxi {Fares: 2}  => 3.50m - 0.50m,
    Taxi             => 3.50m - 1.00m,

    Bus b when ((double)b.Riders / (double)b.Capacity) < 0.50 => 5.00m + 2.00m,
    Bus b when ((double)b.Riders / (double)b.Capacity) > 0.90 => 5.00m - 1.00m,
    Bus => 5.00m,

    DeliveryTruck t when (t.GrossWeightClass > 5000) => 10.00m + 5.00m,
    DeliveryTruck t when (t.GrossWeightClass < 3000) => 10.00m - 2.00m,
    DeliveryTruck => 10.00m,

    { }     => throw new ArgumentException(message: "Not a known vehicle type", paramName: nameof(vehicle)),
    null    => throw new ArgumentNullException(nameof(vehicle))
};

앞에서 설명한 것처럼 이러한 스위치 암은 재귀 패턴으로, 속성 패턴 내에 상수 패턴을 중첩합니다.

중첩된 스위치를 사용하여 이 코드의 반복 횟수를 줄일 수 있습니다. Car와 Taxi는 모두 앞의 예제에서 각각 다른 기능의 4개의 팔을 가지고 있습니다. 두 경우 모두 상수 패턴으로 피드되는 선언 패턴을 만들 수 있습니다. 이 기술이 다음 코드에 나옵니다.

public decimal CalculateToll(object vehicle) =>
    vehicle switch
    {
        Car c => c.Passengers switch
        {
            0 => 2.00m + 0.5m,
            1 => 2.0m,
            2 => 2.0m - 0.5m,
            _ => 2.00m - 1.0m
        },

        Taxi t => t.Fares switch
        {
            0 => 3.50m + 1.00m,
            1 => 3.50m,
            2 => 3.50m - 0.50m,
            _ => 3.50m - 1.00m
        },

        Bus b when ((double)b.Riders / (double)b.Capacity) < 0.50 => 5.00m + 2.00m,
        Bus b when ((double)b.Riders / (double)b.Capacity) > 0.90 => 5.00m - 1.00m,
        Bus b => 5.00m,

        DeliveryTruck t when (t.GrossWeightClass > 5000) => 10.00m + 5.00m,
        DeliveryTruck t when (t.GrossWeightClass < 3000) => 10.00m - 2.00m,
        DeliveryTruck t => 10.00m,

        { }  => throw new ArgumentException(message: "Not a known vehicle type", paramName: nameof(vehicle)),
        null => throw new ArgumentNullException(nameof(vehicle))
    };

앞의 샘플에서 스위치 식을 다른 스위치 암 안에 중첩하면 속성 값을 테스트하는 자식 암이 포함된 Taxi 및 Car 암을 반복하지 않게 됩니다. Bus 및 DeliveryTruck 암은 불연속 값이 아니라 속성의 범위를 테스트하므로 이러한 기술은 사용되지 않습니다.

최대 가격 추가

최종 기능의 경우 통행료 당국은 시간에 민감한 피크 요금제를 추가하려고 합니다. 아침 및 저녁 교통 체증 시간 중에 통행료는 2배로 부과됩니다. 해당 규칙은 아침에는 도시로 들어오고 저녁 교통 체증 시간에는 나가는 한 방향의 교통량에만 영향을 줍니다. 평일 중 다른 시간에 통행료는 50% 증가합니다. 늦은 밤과 이른 아침에는 통행료가 25% 감소합니다. 주말에는 시간과 관계없이 정상 요금입니다. 일련의 if 문과 else 문을 사용하여 다음 코드를 사용하여 이 규칙을 표현할 수 있습니다.

public decimal PeakTimePremiumIfElse(DateTime timeOfToll, bool inbound)
{
    if ((timeOfToll.DayOfWeek == DayOfWeek.Saturday) ||
        (timeOfToll.DayOfWeek == DayOfWeek.Sunday))
    {
        return 1.0m;
    }
    else
    {
        int hour = timeOfToll.Hour;
        if (hour < 6)
        {
            return 0.75m;
        }
        else if (hour < 10)
        {
            if (inbound)
            {
                return 2.0m;
            }
            else
            {
                return 1.0m;
            }
        }
        else if (hour < 16)
        {
            return 1.5m;
        }
        else if (hour < 20)
        {
            if (inbound)
            {
                return 1.0m;
            }
            else
            {
                return 2.0m;
            }
        }
        else // Overnight
        {
            return 0.75m;
        }
    }
}

위의 코드는 올바르게 작동하지만 가독성이 떨어집니다. 모든 입력 사례와 중첩된 if 문을 연결하여 코드에 대해 추론해야 합니다. 이 기능을 위해 패턴 일치를 대신 사용하되, 다른 기술과 통합합니다. 방향, 요일 및 시간의 모든 조합을 고려하는 단일 패턴 일치 식을 작성할 수 있습니다. 복잡한 식이 생성됩니다. 읽기 힘들고 이해하기 어려울 것입니다. 정확성을 보장하기 어렵습니다. 대신, 해당 메서드를 결합하여 모든 상태를 간결하게 설명하는 값 튜플을 빌드합니다. 그런 다음, 패턴 매칭을 사용하여 통행료의 승수를 계산합니다. 튜플에는 다음 세 가지 불연속 조건이 포함됩니다.

요일은 주중 또는 주말입니다.
통행료가 징수되는 시간대.
방향은 도시로 들어가거나 도시를 벗어나는 것입니다.

다음 표는 입력 값과 최대 가격 승수의 조합을 보여 줍니다.

Day	시간	Direction	Premium
평일	아침 교통 체증	inbound	x 2.00
평일	아침 교통 체증	outbound	x 1.00
평일	낮	inbound	x 1.50
평일	낮	outbound	x 1.50
평일	저녁 시간대 붐빔	inbound	x 1.00
평일	저녁 시간대 붐빔	outbound	x 2.00
평일	밤새	inbound	x 0.75
평일	밤새	outbound	x 0.75
주말	아침 교통 체증	inbound	x 1.00
주말	아침 교통 체증	outbound	x 1.00
주말	낮	inbound	x 1.00
주말	낮	outbound	x 1.00
주말	저녁 시간대 붐빔	inbound	x 1.00
주말	저녁 시간대 붐빔	outbound	x 1.00
주말	밤새	inbound	x 1.00
주말	밤새	outbound	x 1.00

세 가지 변수의 조합은 16가지입니다. 일부 조건을 결합하여 최종 스위치 식을 간소화합니다.

통행료를 징수하는 시스템은 통행료가 징수된 시간에 DateTime 구조체를 사용합니다. 앞의 표에서 변수를 만드는 멤버 메서드를 작성합니다. 다음 함수는 패턴 일치 switch 식을 사용하여 DateTime이 주말 또는 주중을 나타내는지 여부를 표시합니다.

private static bool IsWeekDay(DateTime timeOfToll) =>
    timeOfToll.DayOfWeek switch
    {
        DayOfWeek.Monday    => true,
        DayOfWeek.Tuesday   => true,
        DayOfWeek.Wednesday => true,
        DayOfWeek.Thursday  => true,
        DayOfWeek.Friday    => true,
        DayOfWeek.Saturday  => false,
        DayOfWeek.Sunday    => false
    };

해당 메서드는 올바른 것이지만 반복적입니다. 다음 코드와 같이 단순화할 수 있습니다.

private static bool IsWeekDay(DateTime timeOfToll) =>
    timeOfToll.DayOfWeek switch
    {
        DayOfWeek.Saturday => false,
        DayOfWeek.Sunday => false,
        _ => true
    };

다음으로, 시간을 블록으로 분류하는 비슷한 함수를 추가합니다.

private enum TimeBand
{
    MorningRush,
    Daytime,
    EveningRush,
    Overnight
}

private static TimeBand GetTimeBand(DateTime timeOfToll) =>
    timeOfToll.Hour switch
    {
        < 6 or > 19 => TimeBand.Overnight,
        < 10 => TimeBand.MorningRush,
        < 16 => TimeBand.Daytime,
        _ => TimeBand.EveningRush,
    };

프라이빗 enum을 추가하여 각 시간 범위를 불연속 값으로 변환합니다. 그런 다음, 이 메서드는 GetTimeBand관계형 패턴 과 논리 패턴을 사용합니다. 관계형 패턴을 사용하면 <, >, <= 또는 >=로 숫자 값을 테스트할 수 있습니다. 논리 패턴은 다른 패턴을 결합합니다. or 패턴은 식이 하나 이상의 패턴과 일치하는지 테스트하고, and 패턴은 식이 서로 다른 두 패턴과 일치하는지 테스트하며, not 패턴은 식이 패턴과 일치하지 않는지 테스트합니다.

이러한 메서드를 만든 후에는 가격 책정 프리미엄을 계산하기 위해 각 튜플 요소와 일치하는 위치 패턴인 switch을 사용하는 또 다른 식을 사용할 수 있습니다. 모든 16개 암(arm)을 사용하여 switch 식을 작성할 수 있습니다.

public decimal PeakTimePremiumFull(DateTime timeOfToll, bool inbound) =>
    (IsWeekDay(timeOfToll), GetTimeBand(timeOfToll), inbound) switch
    {
        (true, TimeBand.MorningRush, true) => 2.00m,
        (true, TimeBand.MorningRush, false) => 1.00m,
        (true, TimeBand.Daytime, true) => 1.50m,
        (true, TimeBand.Daytime, false) => 1.50m,
        (true, TimeBand.EveningRush, true) => 1.00m,
        (true, TimeBand.EveningRush, false) => 2.00m,
        (true, TimeBand.Overnight, true) => 0.75m,
        (true, TimeBand.Overnight, false) => 0.75m,
        (false, TimeBand.MorningRush, true) => 1.00m,
        (false, TimeBand.MorningRush, false) => 1.00m,
        (false, TimeBand.Daytime, true) => 1.00m,
        (false, TimeBand.Daytime, false) => 1.00m,
        (false, TimeBand.EveningRush, true) => 1.00m,
        (false, TimeBand.EveningRush, false) => 1.00m,
        (false, TimeBand.Overnight, true) => 1.00m,
        (false, TimeBand.Overnight, false) => 1.00m,
    };

앞의 코드는 작동하지만 간소화할 수 있습니다. 주말에 대한 8개 조합에는 모두 동일한 통행료가 포함됩니다. 8개 모두를 다음 줄로 바꿀 수 있습니다.

(false, _, _) => 1.0m,

인바운드 및 아웃바운드 교통량은 평일 주간 및 야간 시간 동안 동일한 승수를 가집니다. 이러한 4개의 스위치 암을 다음 두 줄로 바꿀 수 있습니다.

(true, TimeBand.Overnight, _) => 0.75m,
(true, TimeBand.Daytime, _)   => 1.5m,

해당하는 두 줄이 변경된 후 코드는 다음과 같이 표시됩니다.

public decimal PeakTimePremium(DateTime timeOfToll, bool inbound) =>
    (IsWeekDay(timeOfToll), GetTimeBand(timeOfToll), inbound) switch
    {
        (true, TimeBand.MorningRush, true)  => 2.00m,
        (true, TimeBand.MorningRush, false) => 1.00m,
        (true, TimeBand.Daytime,     _)     => 1.50m,
        (true, TimeBand.EveningRush, true)  => 1.00m,
        (true, TimeBand.EveningRush, false) => 2.00m,
        (true, TimeBand.Overnight,   _)     => 0.75m,
        (false, _,                   _)     => 1.00m,
    };

마지막으로, 일반 요금이 적용되는 혼잡 시간대 두 개를 제거합니다. 해당 암을 제거한 후 마지막 스위치 암에서 _를 폐기(false)로 바꿉니다. 다음과 같은 완료된 메서드가 제공됩니다.

public decimal PeakTimePremium(DateTime timeOfToll, bool inbound) =>
    (IsWeekDay(timeOfToll), GetTimeBand(timeOfToll), inbound) switch
    {
        (true, TimeBand.Overnight, _) => 0.75m,
        (true, TimeBand.Daytime, _) => 1.5m,
        (true, TimeBand.MorningRush, true) => 2.0m,
        (true, TimeBand.EveningRush, false) => 2.0m,
        _ => 1.0m,
    };

이 예제는 패턴 일치의 장점 중 하나를 강조 표시합니다. 패턴 분기는 순서대로 평가됩니다. 이전 분기가 이후 사례 중 하나를 처리하도록 분기를 재배열하는 경우 컴파일러는 접근할 수 없는 코드에 대해 경고합니다. 이 언어 규칙을 사용하면 코드가 변경되지 않는다는 확신과 함께 앞의 단순화 작업을 더 쉽게 수행할 수 있습니다.

패턴 일치는 일부 유형의 코드를 더 쉽게 읽을 수 있도록 해주며 클래스에 코드를 추가할 수 없을 때 개체 지향 기술에 대한 대안을 제공합니다. 클라우드로 인해 데이터와 기능이 분리되어 있습니다. 데이터의 모양과 데이터에 대한 작업을 반드시 함께 설명할 필요는 없습니다. 이 자습서에서는 원래 함수와 완전히 다른 방식으로 기존 데이터를 사용했습니다. 해당 형식을 확장할 수 없더라도 패턴 일치를 통해 해당 형식을 재정의하는 기능을 작성할 수 있었습니다.

다음 단계

완료된 코드는 dotnet/samples GitHub 리포지토리에서 다운로드할 수 있습니다. 혼자 패턴을 살펴보고 이 기술을 일반적인 코딩 활동에 추가하세요. 이 기술을 학습하면 다른 방법으로 문제에 접근하고 새 기능을 만들 수 있습니다.

또한, 다음을 참조하세요.

피드백

이 페이지가 도움이 되었나요?

2026-10-08 에 마지막으로 업데이트됨