using System.Collections; using System.Collections.Generic; using UnityEngine;

/* ▶ C# 언어 자료형의 특징 - C# 언어는 기본적으로 모든 데이터가 클래스 또는 객체로 인식이 된다. ㄴ C / C++ / C# 자료형의 차이점에 대해서 ㄴ 즉, int, float, double 등의 기본 자료형에도 C#에서는 내부적으로 클래스로 표현된다는 것을 의미한다.

★
- 또한, C# 언어의 자료형의 데이터 타입에 따라서 값 타입과 참조 타입으로 나뉜다.
- 그리고 데이터의 형식에 따라서 기본 데이터 형식과 복합 데이터 형식으로 구분된다.

복합 데이터 형식:
ㄴ 구조체와 클래스 + 배열

< C# 필수 지식 > 
▷ 값 형식 데이터 타입의 특징 (깊은 복사)
-값 형식의 데이터 타입은 스택 메모리에 할당된다.
ㄴ 즉, 시스템에 의해서 메모리가 관리된다. (정적)
- 박싱, 언박싱이 발생한다.

▷ 참조 형식 데이터 타입의 특징 (앝은 복사)
 - 참조 형식의 데이터 타입은 실제적인 값을 스택에 할당하는 값 형식과는 달리
실제 값은 힙 메모리에 할당되며 해당 메모리에 대한 참조 값을 스택에 할당하는 변수에 보관한다.
ㄴ 즉, 함조 형식의 데이터 타입은 가비지 컬렉션에 의해서 메모리가 관리된다.

이는 C# 언어는 기본적으로 다른 언어와의 호환성을 지닐 필요가 있기 때문에 
C# 언어의 자료형이 CTS 표준을 따르고 있기 때문

*최선을 다해 최적화 해야하는 부분은 힙이다


C++ STL         C# STL
Vector     ->     array List
Q          -> 
map        ->     Dictionary
List       ->     L
bitset     -> 
func       ->     E.V           

▶ C# 언어의 변수 특징
- C# 언어의 모든 클래스는 Object 클래스를 직 / 간접적으로 상속하는 것이 원칙이다
ㄴ 즉, Object 타입의 변수로 모든 데이터를 보관하는 것이 가능

- Object 타입을 다른 데이터 형식의 값으로 제어하는 것을 박싱/ 언박싱이라고 지칭한다.

- 박싱은 데이터를 보관하는 행위
- 언박싱은 데이터를 읽어들이는 행위

- 박싱 언박싱을 최대한 배제시키는 것이 중요

Object 타입의 변수는 기본적으로 참조 타입이기 때문에 해당 변수에 참조 타입의 값을 보관할 때는
퍼포먼스 저하를 일으키지 않지만, 값 형식의 데이터를 보관할때는 박싱/ 언박싱이 수행되기 때문에
퍼포먼스 저하가 발생한다.

▷ 값 형식의 종류
- byte / sbyte
- int, uint, long
- float(정밀도:7), double(정밀도: 15), decimal (정밀도: 29 / 연산 느림 / 메모리 : 16Byte)
- char
- enum
- struct
- Nullable (값 형식에서도 null 체크가 가능하게 해줌)

- C 계열 언어는 타입에 매우 엄격한 언어이다.
ㄴ 오류를 방지하기 위해 

▷ 참조 형식의 종류

- 기본적으로 참조 형식은 null 대입이 가능하다.
- null은 쓰레기값 오류를 방지하기 위함

- Object
- string
- Class
- Delegate

▷ 값 형식과 참조 타입의 차이점
- 기본적으로 C#의 Object 타입은 모든 데이터를 가르키는 것이 가능하지만
Object 타입은 참조 타입에 해당되기 때문에 해당 타입의 변수에 값 타입의 데이터를 할당할 경우
내부적으로 방식 / 언박싱이 발생한다.

- 값 타입의 자료형은 스택에 할당되기 때문에 시스템에 의해서 메모리가 관리되고
값을 할당할 때는 내부적으로 복사가 발생한다 (즉, 값 자체가 복사된다.)

- 반면 참조 타입의 자료형은 힙에 해당되기 때문에 가비지 컬렉션에 의해서 메모리가 ㄱ
관리되고 값을 할당할 때 참조 값의 복사가 이뤄진다. (메모리 주소 할당)

- 단, C# 언어의 문자열은 기본적으로 변경이 불가능하기 때문에 (권한이 없기때문)
기본 문자열을 편집한 새로운 문자열을 얻기 위해서는 새로운 메모리 공간에 문자열을
생성해야 한다.
(즉, 한번 할당되어 만들어진 문자열은 더 이상 편집이 불가능하다.)

* 
Nullable 타입이란? 
- 기본적으로 C# 언어는 참조 타입 데이터의 유효하지 않는 여부를 null 키워드를 통해서 구분할 수 있는
반면에 값 타입의 데이터는 null 키워드를 이용하는 것이 불가능하다. 
(이는 오류를 미리 방지 할 수 없음을 의미)

- 그렇기 때문에 Nullable 타입이라는 자료형이 주어지며 해당 자료형은 값 타입에 
null 키워드를 사용할 수 있게 하는 기능을 제공한다.

- Nullablie 값 타입의 데이터에만 사용하는 것이 가능하다.


C++ 11 (모던 C++) 14, 17 b 
C# 6.0 (10까지 나옴)



2D에서는 int가 압도적이지만
3D에서는 float이 우세다.
float은 소수점 7자리까지

7자리는 컴파일러가 뽑은 근사치
C++은 
double은 15자리
decimal은 c++에 없음 대략적으로 29자리 
중첩에 중첩

라운딩에러 (컴파일러가 잘라먹어요)

 */

public class Example_2 : MonoBehaviour { private void Awake() { #if EXAMPLE_TYPE_VALUE int nValue = 10; float fValue = 3.14f; double dValue = 3.14; decimal mValue = 3.14m;

    Debug.LogFormat("데이터 출력: {0}, {1}, {2}, {3}", 
        nValue, fValue, dValue, mValue);

#elif EXAMPLE_TYPE_REFERENCE objuct oValue = 10; string oString = "Hell Fire";

    /*
    $:
    ㄴ C# 6의 추가된 기능
    ㄴ 문자열 보간 (보간된 문자열로 식별하는 기능)
    ㄴ {0}, {1}, ...과 같이 서식 항목들의 순서를 정해주는 Format()방법과는 달리,
    문자열 보간은 string 안에 직접 변수 이름을 할당한다.
    */

    Debug.Log($"데이터 출력 : {oValue}, {oString}");

#else //C# Nullable 타입은 Null을 가질 수 없는 데이터 타입을 Null을 가질 수 있도록 새롭게 만든 타입이다. // 선언하는 방법 2가지 1. 데이터 타입? // 2. Nullable

    int? nValue = null;
    float? fValue = null;
    System.Nullable<int> nValueB = 10;

    // HasValue : 값이 있으면 t 없으면 (null) f
    if (nValue.HasValue)
    {
        Debug.Log("정수형 값이 유효하다.");
    }

    else
    {
        Debug.Log("정수형 값이 유효하지 않다");
    }

    if (fValue != null)
    {
        Debug.Log("실수형 값이 유효하다");
    }

    else
    {
        Debug.Log("정수형 값이 유효하지 않다");
    }

    if (nValueB.HasValue)
    {
        Debug.Log("정수형 값이 유효하다.");
    }

    else
    {
        Debug.Log("정수형 값이 유효하지 않다");
    }

#endif } }

using System.Collections; using System.Collections.Generic; using UnityEngine;

#region 배열 / 정적 클래스 / 확장 메서드

/* ▶ C# 언어의 배열 특징 List는 권장하지 않음 - 퍼포먼스 저하

• C#언어의 배열은 참조 형식의 데이터 타입에 속한다. ㄴ 즉, 가비지 컬렉션에 의해서 메모리가 관리된다.
• C# 언어의 배열은 가변 길이 배열을 지원한다. ㄴ 즉, 배열의 각 행의 길이를 서로 다르게 명시하는 것이 가능하다.

단, 가변 길이 배열은 2차원 배열만 지원한다

C++은 다차원을 지원한다. C++는 4차원이상의 배열부터는 프로그래머가 힘들다 C#은 2차원까지만 지원한다. 왜? 행렬을 지원하기 위해

▶ 정적 클래스

• 클래스의 멤버 변수, 함수가 모두 정적으로 이루어진 클래스를 의미한다. ㄴ 정적 클래스는 객체화 시키는 것이 불가능하다.

• 또한, 정적 클래스는 정적 변수, 함수 이외에 멤버 변수, 함수 등을 선언하는 것이 불가능하며, 상속 또한 불가능

C# 언어 정적 클래스 특징:

• C# 언어의 정적 클래스는 static 키워드를 명시함으로 정의하는 것이 가능 ㄴ static 키워드가 명시된 클래스는 클래스 변수, 함수 이외에는 다른 멤버를 정의하는 것이 불가능

▶ 확장 메서드란?

• 기존에 제공되는 클래스 또는 외부 라이브러리에 속해있는 클래스에 새로운 기능을 "상속"이 아닌 메서드를 이용해서 기능을 확장하는 것을 의미한다.

▶ 확장 메서드의 특징

• C# 언어의 확장 메서드는 정적 클래스만을 통해서 정의하는 것이 가능하다. 즉, 정적 클래스가 아니면 확장 메서드 자체를 구현하는 것이 불가능하다.

• C# 언어의 확장 메서드를 정의하는 정적 클래스는 반드시 최상단 영역에 위치 시켜야 한다. (using과 클래스 사이)

• 특정 클래스의 중첩 클래스로는 확장 메서드를 정의하는 것이 불가능 (클래스 안에 클래스 : 중첩) C#은 다중상속을 지원하지 않는다 (상속이 1개만 들어간다) C#은 상속 + 확장메서드 + 인터페이스를 해야함.

유니티에서는 이미 MonoBehaviour를 상속 받고 시작한다.

확장메서드가 제일 중요하다! 많이 써야함

*/

#endregion public class Example_02 : MonoBehaviour {

private void Awake()
{

#if EXAMPLE_TYPE_ARRAY //1. 평균적으로 사용하는 방법 int[] oValues = new int[5]; //2. int[] oOtherValues = new int[] { 1,2, 3, 4, 5 };

    /*
     var: auto와 비슷한 키워드
    C#의 형식 검사는 강한 or 약한이 있다.

    강한 형식 검사 : int, float string 등등
    ㄴ 데이터 손실 및 프로그래머 실수 방지
    라운딩에러, 반올림 오차 

    약한 형식 검사 : 자동으로 해당 변수의 형식 지정(추정)
    ㄴ 단, 지역 변수로 선언하고 선언과 동시에 초기화를 해줘야 한다. 



    auto : C++ STL
     var : 컴파일러에게 유추하라고 시킴
    단점 : 가독성이 현저하게 떨어질 수 있다.
    멤버변수여야 유추할 수 있으며 전역변수는 유추할 수 없다.

     */

    /*
     String :
    - 읽기가 많은 경우는 String 클래스를 사용하는게 더 적합하다.

    게임쪽 로딩 데이터
    상점 등에 많이 쓰인다. 

    - 삽입에 있어 StringBuilder 느리다.


    StringBuilder :
    - 객체의 참조 값을 힙에 관리한다. (추가, 삽입, 삭제) - 힙은 동적메모리이기 때문에 
    - 새로운 객체를 만들지 않고 문자열을 수정할 수 있다.


    ㄴ 기존 + 연산자를 통한 문자열 연결은 메모리의 할당과 복사가 지속적으로 수행된다
    ㄴ 이건 모든 언어 공통 -> 느려진다.
    ㄴ 반복문에서 많은 문자열을 연결하면 매우 느리다.
    ㄴ 성능이 떨어지는 이유는 연결한 문자열 복사를 위해 매번 새로운 객체를 생성하기 때문에
    ㄴ 반면 stringBuilder는 메모리를 블럭 단위로 할당한 후 현재 블럭 내 메모리가 모두 소진된 경우에 한하여 
    메모리를 재할당하게 되어 있다. 

            - 읽어 들일때만 String을 쓰고 나머지는 빌더를 쓰자
     0
     */


    var oStringBuilder = new System.Text.StringBuilder();

    for (int i = 0; i < oValues.Length; i++)
    {
        oStringBuilder.AppendFormat("{0}", oOtherValues[i]);
    }

    Debug.Log(oStringBuilder.ToString());

#elif EXAMPLE_TYPE_STATIC_CLASS #else #endif } #if EXAMPLE_TYPE_ARRAY #elif EXAMPLE_TYPE_STATIC_CLASS #else #endif }

#define EXAMPLE_TYPE_VALUE #define EXAMPLE_TYPE_REFERENCE #define EXAMPLE_TYPE_NULLABLE

using System.Collections; using System.Collections.Generic; using UnityEngine;

#region C# Basic /* ▶ C# 언어의 문법을 숙지해야 하는 이유

• 유니티 엔진에서 기본적으로 스크립트는 대부분 C# 스크립트를 이용하기 때문에 유니티 엔진의 활용성을 높이기 위해서는 C# 언어에 대한 지식이 필수로 필요하다. C / C++ 스타일로 C# 문법을 모르고 작성하는 것도 가능하지만 결국엔 한계에 부딪히기 된다.

중요 ▶ C# 프로그램 동작 방식

• C# 프로그램은 CLR(Common Language Runtime)이라는 자바의 가상 머신과 비슷한 프로그램 위에 구동이 된다. C / C++ 언어와 달리 결과물이 컴퓨터가 바로 실행 할 수 있는 실행 파일로 생성되지 않는다는 것을 의미한다.

▶ CLR(Common Language Runtime)// 기계어로 변환해주는 가상머신

• 마이크로 소프트에서 개발한 가상 머신의 구성요소(Windows 전용)
• 기능은 크게 2가지로 말할 수 있다.

1. 중간 언어를 JIT 컴파일러를 이용해서 기계어로 변환 가능
2. 가비지 컬렉션을 통한 동적 메모리 관리

닷넷 프레임워크 박싱 / 언박싱 가비지 컬렉션은 2세대까지 있다. 애딧 타임 런타임 메모리가 오버플로우 될 것같으면 0세대에서 1세대로 간다 0세대는 동면시킨다 1세대가 다 차면 2세대를 부른다 2세대가 불러지면 재앙이 시작된다. 프레임이 떨어진다.

지울 거 없나 하고 다시 읽을 프레임 드랍.

가상 머신(Virtual Machine) : ㄴ 컴퓨터에서 가상으로 사용하는 컴퓨터 ㄴ 컴퓨터에서 1대 이상의 컴퓨터를 구동하는 것으로 하드웨어 등 모든 컴퓨터 자원을 가상화 시킨 것

ㄴ C#은 CLR이라는 중간 과정을 거쳐서 다른 언어를 사용할 수 있게 지원을 한다. ㄴ CLR은 CIT 코드를 읽어들여 OS가 이해할 수 있는 Native Code로 변환하는 역할을 한다. ㄴ 이때 서로 다른 언어들이 만나는 지점이 IL이라는 중간 언어이며 이 언어로 쓰여진 코드를 다시 CLR이 자신이 실핸한 플랫폼으로 맞춰서 컴파일 하는 구조

※ 요약하면 CLR은 따로 컴파일을 해서 실행을 시키고 그걸 해당 플랫폼에 다시 맞춰서 컴파일을 하게 하는 기능을 뜻한다. ※ C / C++은 컴파일을 진행해서 프로그램을 바로 만들어 낸다.(컴파일러가 있어서 바로 실행을 해준다.)

트리플 A 게임?

CIL (Common Intermediate Language: 공통 중간 언어) ㄴ 닷넷 프레임워크에서 실행되는 언어 ㄴ 닷넷 프레임워크 언어로 개발된 프로그램 코드는 컴파일 시 바이너리 형태로 CIL이라는 파일로 작성된다.

※ .Net FrameWork: ㄴ Windows 프로그램 개발 및 실행 환경 ㄴ 네트워크 작업, 인터페이스 등의 많은 작업을 캡슐화하여 코딩의 효율을 올려준다. 특징으로는 CLS (닷넷 프레임워크의 언어가 반드시 지켜야하는 언어 스펙)을 따르는 언어라면 어떠한 언어라도 닷넷 프레임워크에서 실행이 가능하며 ClR이라는 가상 기계위에서 작동하기 때문에 플랫폼에 독립적이며 궁극적으로는 프로그래머가 코딩을 하는데 더 편한 환경을 제공한다.

그리고 CLR구동중에 IL 코드를 읽어 들여서 특정 운영체제에 맞는 네이티브 코드로 변환시켜주는 작업을 JIT(Just In Time 컴파일 방식) 이라고 한다.

★ 즉, C# 프로그램은 컴파일 방식 + 인터프리트 방식의 혼합 하이브리드 방식으로 구동된다.

★ 실행순서 : C# 컴파일 -> IL 생성 -> CLR -> 실행파일

▶ JIT 컴파일 방식의 장점

• 프로그램이 구동 중에 즉시 네이티브 코드를 생성하기 때문에 특정 운영체제에 맞는 최적화 코드를 만들어 내는 것이 가능하다.

▶ JIT 컴파일 방식의 단점

• 프로그램이 구동중에 네이티브 코드를 생성하기 때문에 해당 코드를 생성하기 위한 시간이 필요하다.

▶ CLR의 두드러지는 3가지 역할 ㄴ 메모리 관리(가비지 컬렉션) ㄴ 예외처리 ㄴ 프로그래밍 언어간의 호환성 ㄴ .Net FrameWork는 C# 언어만을 위한 프레임 워크가 아니기 때문에 C# 언어를 제외한 다른 언어에서도 닷넷 프레임워크를 이용하는 것이 가능하다. 이때 발생하는 언어간의 문법적 차이를 CLR을 통해서 통일화 시키는 것이 가능

▶ C# 언어가 다른 언어와 호환이 가능한 이유:

• C# 언어는 내부적으로 CTS(Common Type System) 규칙에 따라 데이터 타입을 구현하기 때문에

※ CTS (Common Type System): ㄴ 공용 타입 시스템 ㄴ 닷넷 호환 언어가 지켜야 할 타입의 표준 규격으로 닷넷 호환 언어를 만든다면 CTS 규격을 반드시 지켜야 한다. ㄴ CTS를 모두 만들 필요는 없지만 필요한 규격만 지원해도 되며 CTS 규격을 벗어나는 새로운 타입은 만들 수 없다.

▶ C# 프로그램의 메모리 관리 방식(가비지 컬렉션):

1. 스택 메모리 관리 (정적)
2. 힙 메모리 관리 (동적)

• C# 언어는 힙 메모리를 프로그래머가 직접적으로 관리하는 C / C++ 언어와 달리 C# 언어의 힙 메로리는 가비지 컬렉션에 의해서 관리가 된다. (즉, 메모리 릭을 염두하지 않고 프로그램 로직을 구성하는 것이 가능하다.)

▶ 스택 메모리의 특징

• 스택 메모리는 지역적인 특징을 지니고 있기 때문에 "시스템에 의해서 메모리가 관리"된다. (즉, 스택에 할당 된 메로리는 따로 관리하기 위한 로직이 불필요하다.)

▶ 힙 메모리의 특징

• C / C++ 언어와는 달리 C# 언어에서 힙 메모리는 프로그래머에 의해서 직접적으로 관리되지 않는다 (즉, 해당 영역 메로리 영역은 가비지 컬렉션에 의해서 관리가 된다.)

▶가비지 컬렉션에 의한 메모리 관리 방식의 장점

• 메모리 릭을 염두하지 않고 프로그램 로직을 구성하는 것이 가능하기 때문에 편하다.

▶가비지 컬렉션에 의한 메모리 관리 방식의 단점

• C# 언어는 힙 메로리를 할당하는 것은 가능하지만 직접적으로 관리되지 않기 때문에 불필요한 메모리 공간이 있다는 것을 알아도 즉시 제거하는 것이 불가능하다.

• 권한이 없이 때문에 가비지 컬렉션이 구동 될 때까지 해당 데이터는 메모리에 계속 상주한다.

• 그렇기 때문에 가비지 컬렉션에 의한 메모리 관리는 많은 부하를 일으키는 원인이 된다.

그래서 프로그램을 작성할 때는 가비지 컬렉션의 상태를 신경써야 한다.(프로그램 로직) 또한, 높은 퍼포먼스를 요구하는 프로그램에서는 최적화에 대한 많은 노력이 필요하다.

<유니티 프레임 워크>

엔진의 정의 라이버러리의 집합 + 툴 ex) 유니티 에디터 엔진 사용하는 기능을 캡슐화해서 라이브러리화 해둔 것들 */

#endregion

public class Example_01 : MonoBehaviour {

public void Awake()
{

#if EXAMPLE_TYPE_VALUE Debug.Log #else EXAMPLE_TYPE_REFERENCE //레퍼런스 타입을 보고 싶으면 선택적 컴파일 //기능을 선택적으로 불러올 수 있다. #endif EXAMPLE_TYPE_NULLABLE

}
//<게임개발>

//네이티브 언어
//플랫폼 개발
//엔진
//3개를 관통하는 언어 : C++

//<유니티>
// C#을 쓰지만
// C++로 이루어져있다 
// transform은 DX
// 프로그래머는 엔진을 만들 수 있어야한다.

//프레임워크

// C# Script를 쓰는 것이다
// C# 네이티브 랭귀지보다 하이랭귀지

}

using System;

1. Action 리턴타입이 void이고 매개변수가 없는 델리게이트 public Action

2. Func

1. 인터페이스(Interface)

인터페이스는 약속이다 구현해야하는 약속 인터페이스를 상속한 클래스는 인터페이스에서 구현하기로 한 약속을 구현해줘야한다.

2. 추상클래스(abstract class)

추상클래스를 상속받은 자식 클래스는 반드시 추상클래스의 구현되지 않은 기능을 구현해야한다.

3. 추상클래스와 인터페이스의 차이점

추상클래스와 인터페이스의 차이는 그 목적에 있다. 추상클래스는 자식에서 상속받아 구현되지 않은 기능을 구현하는데에 그 목적이 있고, 인터페이스는 기능을 구현시켜주겠다는 약속이다. 이 약속이 보장됨으로써 우리는 후에 인터페이스만으로 처리가 가능하게 할 수 있다.

캡슐화

foreach는 IEnumerable를 상속받은 intList를 가져다 쓰고 또 그 안에서 GetEnumerator를 상속받은 놈을 사용하지만 foreach(기능을 사용하는 놈)가 알아야 되는 건 안에 구현된 내용이 아니라 사용할 수 있는 형태만 알면 된다. 이렇게 내부구현을 숨기면서 사용자에게 인터페이스(사용할 수 있는 기능)만을 제공해주는 것을 캡슐화라고 한다.

코루틴(Co-routine)

유니티가 싱글스레드를 권장하기 때문 협력하는 루틴

yield

yield는 상태가 true가 될때까지 기다리게 한다.

1. 델리게이트(Delegate)

델리게이트(Delegate)는 함수를 대신 실행해주는 대리자 델리게이틑 함수를 대신 실행해주는 역할을 하기 때문에 리턴타입과 매개변수가 꼭 동일한 함수만 대신 실행해줄 수 있다.

2. 델리게이트의 선언

public delegate 리턴타입 델리게이트명(매개변수);

public delegate void TestDel();     //틀
public TestDel testDel;                //인스턴스 - 함수가 들어갈 수 있는 곳

public void Process()
{
    Debug.Log("전처리")
    if(A가 처리되어야할 조건)
        FuncA();
    else if(B가 처리되어야할 조건)
        FuncB();
    Debug.Log("후처리");
}

public void Process()
{

}

public void FuncA()
{
    Debug.Log("A기능을 수행함");
}

public void FuncB()
{
    Debug.Log("B기능을 수행함");
}

public void FuncC(int value)
{
    Debug.Log("C기능을 수행함");
}

체인(chain)

델리게이트는 마치 구독을 했다가 구독을 취소하는 것처럼 연산자를 이용하여 넣고 뺄 수 있다.

testDel += FuncA;
testDel += FuncB;

testDel -= FuncA;
testDel -= FuncB;

testDel += () => {Debug.Log("람다식을 통한 기능추가");};
testDel += () =>
            {
                Debug.Log("람다문을 통한");
                Debug.Log("기능추가");
            };

1. 일반화(Generic)

일반화(Generic)는 공통적으로 사용되는 부분을 추상화 한 것을 의미한다.

//1
void PrintInt(int value)
{
    Debug.Log(value);
}
//2
void PrintFloat(float value)
{
    Debug.Log(value);
}

두 함수는 데이터타입을 제외하고 모두 동일한 기능을 가진다.

 void PrintValue<T>(T value)
    {
        Debug.Log(value);
    }

이때 데이터타입을 뭉퉁그려 T로 일반화하여 사용한다.

2. 일반화(Generic)를 사용할 때 주의할 점

 void Sum<T>(T valueA, T valueB)
    {
        return valueA + valueB;
        //오류가 뜨는 이유 : +연산자를 사용할 수 있는 데이터 타입인지 확인 할 수 없음
        //물론 다이나믹을 사용하면 가능함.
    }  

해당 코드는 오류를 배출할 것이다. 오류가 뜨는 이유는 +연산자를 사용할 수 있는 데이터 타입인지 확인 할 수 없기 때문이다.

3. where T :

 void DestrorComponent<T>(T value) where T : Component
    {                               //where은 T에 대한 정보를 알려준다.
        Destroy(value);
        //where이 없다면 <T>가 컴포넌트 인지 알 수 없음.
    }

 public static void DestroyComponent<T>(this T value) where T : Component
    {
        // Component 상속받는 자식들을 포함한다. ex) Renderer, Rigidbody 등
        // ----- //
        Debug.Log("컴포넌트 제거");
    }

굳이 where을 사용하여 데이터타입을 특정해야하는 이유는 무엇일까? 확장메서드를 좀더 용이하게 사용하기 위해서다.