제네릭 사용 예시 코드

제네릭 사용 예시 코드

▼제네릭 계산기

using System;

namespace GenericCalculator
{
    // 제네릭 델리게이트 선언
    delegate T Operation<T>(T a, T b);

    class Program
    {
        // 제네릭 연산 메서드
        static T Add<T>(T a, T b) => (dynamic)a + (dynamic)b;
        static T Subtract<T>(T a, T b) => (dynamic)a - (dynamic)b;
        static T Multiply<T>(T a, T b) => (dynamic)a * (dynamic)b;
        static T Divide<T>(T a, T b)
        {
            if ((dynamic)b == 0) throw new DivideByZeroException();
            return (dynamic)a / (dynamic)b;
        }

        static void Main()
        {
            // int 계산기
            Operation<int> intCalc = Add;
            intCalc += Subtract;
            intCalc += Multiply;
            intCalc += Divide;

            int intA = 10, intB = 5;
            Console.WriteLine("=== int 계산 ===");
            int intResult = intCalc(intA, intB);
            Console.WriteLine($"마지막 반환값: {intResult}");
            foreach (var op in intCalc.GetInvocationList())
                Console.WriteLine($"개별 결과: {((Operation<int>)op)(intA, intB)}");

            // double 계산기
            Operation<double> doubleCalc = Add;
            doubleCalc += Subtract;
            doubleCalc += Multiply;
            doubleCalc += Divide;

            double doubleA = 10.5, doubleB = 2.5;
            Console.WriteLine("\n=== double 계산 ===");
            double doubleResult = doubleCalc(doubleA, doubleB);
            Console.WriteLine($"마지막 반환값: {doubleResult}");
            foreach (var op in doubleCalc.GetInvocationList())
                Console.WriteLine($"개별 결과: {((Operation<double>)op)(doubleA, doubleB)}");

            // decimal 계산기
            Operation<decimal> decimalCalc = Add;
            decimalCalc += Subtract;
            decimalCalc += Multiply;
            decimalCalc += Divide;

            decimal decA = 10.5m, decB = 2.5m;
            Console.WriteLine("\n=== decimal 계산 ===");
            decimal decResult = decimalCalc(decA, decB);
            Console.WriteLine($"마지막 반환값: {decResult}");
            foreach (var op in decimalCalc.GetInvocationList())
                Console.WriteLine($"개별 결과: {((Operation<decimal>)op)(decA, decB)}");
        }
    }
}

 

 

 

▼코드 풀이

1. 제네릭 델리게이트

delegate T Operation<T>(T a, T b);

• T 형식 두 개를 받아 T 를 반환하는 연산 '시그니처'
• 타입별로 Operation<int> , Operation<doubld> , Operation<decimal> 같은 형식화된 델리게이트가 만들어진다

 

 

2. 제네릭 연산 메서드

static T Add<T>(T a, T b) => (dynamic)a + (dynamic)b;
static T Subtract<T>(T a, T b) => (dynamic)a - (dynamic)b;
static T Multiply<T>(T a, T b) => (dynamic)a * (dynamic)b;
static T Divide<T>(T a, T b)
{
    if ((dynamic)b == 0) throw new DivideByZeroException();
    return (dynamic)a / (dynamic)b;
}

▲핵심은 dynamic 캐스팅 이다

• 제네릭 T 에는 "숫자 타입만" 같은 제약을 걸 수 없다 ( C# 7.3 버전 기준 )
  └ 런타임 바인딩으로 연산을 수항하게 한다.
• 컴파일 타임에선 타입을 몰라도 런타임에 실제 타입 ( int , double , decimal ) 의 연산자가 선택된다.
• Divide<T> 는 0 나눗셈을 미리 체크한다.
  └ int 의 0 , doubld 의 0.0 , decimal 의 0m 모두 ( dynamic ) b == 0 비교로 안전하게 잡힌다

 

 

캐스팅 과 dynamic 

캐스팅 ( Casting 형변환 )

형변환이라고도 부르고, 어떤 타입의 값을 다른 타입으로 바꾸는 것을 말한다

 

▼1. 암시적 캐스팅 ( Implicit Casting ) : 안전할 때 자동 변환

int a = 10;
double b = a;

 

▼2. 명시적 캐스팅 ( Explicit Casting ) : 개발자가 직접 지정해야 하는 변환

double x = 9.7;
int y = (int)x;

 

 

dynamic ( 동적 )

dynamic 키워드는 컴파일 시점이 아니라 런타임 ( 실행 시점 ) 에 타입이 결정된다.

object 와 비슷하지만 , dynamic 은 컴파일러 타입 검사를 하지 않는다.

실행 시점에 실제 타입을 확인하고 동작한다.

dynamic value = 10;
Console.WriteLine(value + 5); // ( int로 동작 )
value = "Hello";
Console.WriteLine(value.Length); // ( string으로 동작 )

▼만약 잘못된 메서드를 호출하면 컴파일 에러는 안 나지만 런타임에서 에러가 발생한다

dynamic v = 123;
v.NonExistentMethod(); // 컴파일은 됨, 실행 시 에러

정리

캐스팅 = 타입 변환 ( 형변환 )

dynamic = 실행 시점에 타입을 결정하는 "동적 타입"

 

 

 

3. 멀티캐스트 델리게이트

Operation<int> intCalc = Add;
intCalc += Subtract;
intCalc += Multiply;
intCalc += Divide;

• 하나의 델리게이트 변수 intCalc 에 여러 메서드를 연결 ( += ) 한다.
• 이렇게 연결된 델리게이트를 "델리게이트 체인" 또는 "멀티캐스트 델리게이트" 라고 부른다.
• 호출 시 연결된 순서대로 전부 호출된다.
  └ 다만 반환값은 마지막 메서드의 반환값 한 번만 돌려준다.

 

 

 

4. 호출 + 개별 결과

int intResult = intCalc(intA, intB); // 마지막 메서드(= Divide)의 결과
foreach (var op in intCalc.GetInvocationList())
    Console.WriteLine(((Operation<int>)op)(intA, intB));

GetInvocationList() 로 연결된 각 메서드에 직접 다시 인자를 넣어 호출└ 각 연산의 개별 결과를 확인할수 있다.

 

 

 

실제 출력

▼int ( 10 , 5 )

=== int 계산 ===
마지막 반환값: 2
개별 결과: 15
개별 결과: 5
개별 결과: 50
개별 결과: 2

 

 

▼double ( 10.5 , 2.5 )

=== double 계산 ===
마지막 반환값: 4.2
개별 결과: 13
개별 결과: 8
개별 결과: 26.25
개별 결과: 4.2

 

 

▼decimal ( 10.5m , 2.5m )

=== decimal 계산 ===
마지막 반환값: 4.2
개별 결과: 13.0
개별 결과: 8.0
개별 결과: 26.25
개별 결과: 4.2