개발자 소블리애

</head> 바로 위에 아래 코드를 추가 할 것 

<link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.9/styles/vs2015.min.css">

<script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.9/highlight.min.js"></script>

<script>hljs.initHighlightingOnLoad();</script>

미리보기로 볼 수있는 사이트

https://highlightjs.org/static/demo/

스타일 파일 리스트 실제로 이 파일을 추가해야 적용 됨

ex) vs2015.min.css

https://github.com/highlightjs/highlight.js/tree/master/src/styles

유니티는 단일 쓰레드로 동작한다. 하지만 코루틴을 사용하면 쓰레드를 사용하지 않고 멀티 태스킹을 구현 할 수 있다. C#에서 이터레이터는 프로그래머가 IEnumerator 를 구현할 수있도록 돕는 기능이다. 열거형의 MoveNext() 를호출 할 때마다. 해당하는 다음 값을 반환한다. 일반적으로 함수가 호출되서 끝나는 서브루틴의 개념과 달리 yield return 을 사용함으로써 그 위치를 기억하고 다음 호출 때 그곳부터 다음을 실핼 할 수있도록 하는 것이다. 그래서 여러개의 코루틴을 동작시키고 각기다른 시점에 yield가 반환되도록 한다면 마치 어러개의 쓰래드가 동시에 동작하는것과 같은 효과가 나타난다

아래의 예제는 코루틴을 실행할 때 함수를 직접 실행하는 방법과 함수의 이름 즉 스트링을 이용해 호출 하는 방법 두가지를 테스트 한다.

AAA(), BBB() 코루틴 함수는 1초마다 실행되며 2초 후에 코루틴은 멈추게 된다.

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

public class Test : MonoBehaviour
{
    Coroutine coroutine1;

    void Start()
    {
        // 코루틴 실행 방법 (함수)
        // 파라미터를 여러 개 쓸 수 있다.
        coroutine1 = StartCoroutine(AAA());

        // 코루틴 실행 방법 (스트링)
        // 성능상 함수로 호출하는 것보다 느리다.
        // 파라미터를 1개만 쓸 수 있다.
        StartCoroutine("BBB");

        StartCoroutine(STOP());
    }

    IEnumerator AAA()
    {
        for(int i = 0; i < 10; i++)
        {
            print("i 의 값 = " + i);

            // 1초 마다 호출 하게 된다.
            yield return new WaitForSeconds(1f);
        }
    }

    IEnumerator BBB()
    {
        for(int j = 0; j < 10; j++)
        {
            print("j 의 값 = " + j);

            // 1초 마다 호출 하게 된다.
            yield return new WaitForSeconds(1f);
        }
    }

    IEnumerator STOP()
    {
        yield return new WaitForSeconds(2f);
        StopCoroutine(coroutine1);

        yield return new WaitForSeconds(2f);
        StopCoroutine("BBB");
    }
}

프로그램을 짜다 보면 오류로 인해 프로그램이 크래쉬(죽게)된다. 오류가 나더라도 정상 동작하게 끔 바꾸어 주는 것이 예외 처리이다. try catch는 예외 처리하는 방법 중에 하나이고 catch 부분에 모든 오류를 다 출력 시킬 수도 있고 특정 오류만 들어오게 코드를 짤 수도 있다. 아래의 예제는 0으로 나눴을 때 발생하는 오류가 catch 문에 들어오게 되고 b의 값을 1로 수정하여 최종적으로 오류를 잡게 되는 코드이다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System; // Exception을 사용하기 위해 선언

public class Test : MonoBehaviour
{
    int a = 5;
    int b = 0;
    int c;

    void Start()
    {
        // 컴퓨터는 0으로 나누면 오류가 발생한다.
        // 이 상태에서는 크래쉬가 나서 프로그램이 종료하게 된다.
        // c = a / b;

        // 오류가 발생 하더라도 프로그램이 죽지 않게 예외 처리를 하면 아래와 같다.
        try
        {
            c = a / b;
        }

        // Exception으로 하면 모든 오류를 잡아낸다.
        // DivideByZeroException으로 하면 0으로 나눈 오류만 잡아내게 된다.
        // catch는 여러게를 쓸수도 있다.
        catch(DivideByZeroException ie) 
        {
            
            print(ie);
            b = 1;
            c = a / b;
        }

        // 오류가 발생하든 말든 최종적으로 출력된다.
        finally
        {
            print(c);
        }
    }
}

또한 프로그램 로직에는 오류가 없지만 일부러 코드를 통해 오류를 발생 시킬 수도 있다. 게임이라고 생각해보자 유저의 이상 행동이 감지가 되면 오류를 발생 시키고 프로그램을 끝내도록 유도하면 될거 같다.또한 프로그램 로직에는 오류가 없지만 일부러 코드를 통해 오류를 발생시킬 수도 있다. 게임이라고 생각해보자 유저의 이상 행동이 감지가 되면 오류를 발생시키고 프로그램을 끝내도록 유도하면 될 거 같다.

throw new Exception("일부러 오류를 발생한다.");

델리게이트를 조금더 간편하게 쓸 수 있는 Action과 Func이 있다. 이 두개의 차이 점은 반환형이 있는냐 없느냐 이다. 우선 사용하려면 using System을 선언 해야한다.  Func는 선언시 3번째 자리가 반환 타입이다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System; // Action, Func을 사용하기 위해서 필요함 


public class Test : MonoBehaviour
{
    // 내부적으로 델리게이트 선언부가 미리 만들어져 있기 때문에 델리게이트보다 쓰기 편하다.
    // 간편한 델리게이트라고 보면 된다.
    Action<int, int> myAction;

    // 3번째는 리턴 받을 자료형이다.
    // 반환 값이 있는 간편한 델리게이트라고 보면 된다.
    Func<int, int, string> myFunc;

    void Start()
    {
        myAction = (int a, int b) =>
        {
            int sum = a + b;
            print(sum);
        };

        myFunc = (int a, int b) =>
        {
            int sum = a + b; return sum + "이 리턴되었습니다.";
        };

        myAction(10, 20);
        print(myFunc(10, 20));
    }
}

출력 결과:

람다식은 무명 메소드를 단순한 계산식으로 표현한 것이다. 

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

public class Test : MonoBehaviour
{
    delegate void MyDelegate<T>(T a, T b);
    MyDelegate<int> myDelegate;

    void Start()
    {
        // 무명 메소드
        myDelegate += delegate(int a, int b) { print( a + b); };

        // 람다식
        myDelegate += (int a, int b) => print(a + b);

        // 람다식 매개변수 타입 생략도 가능 함 
        myDelegate += (a, b) => print(a + b);

        myDelegate(10, 20);
    }
}

출력 결과: 

형식 매개변수 T는 함수에 형식을 지정하지 않아도 호출 시에 형식만 지정하면 어떤 형식이든지 다 받을 수 있다. 형식만 다른 함수의 중복성을 간편하게 만들 수 있습니다.

public class Test : MonoBehaviour
{
    void Print<T>(T value)
    {
        print(value);
    }

    void Start()
    {
        Print<string>("hello");
        Print<float>(3.14f);
    }
}

출력 결과: 

추가로 원하는 데이타 형식으로도 받을 수 있습니다. where T : struct 이렇게 뒤에 추가하면 struct 타입만 받겠다는 의미가 된다. float은 struct 형태이고 string은 class 형태이기 때문에 에러가 발생한다. 

클래스는 하나의 클래스만 상속 가능하다. 하지만 인터페이스로 구현하면 다중 상속이 가능하다. 

인터페이스의 특징

인터페이스는 기본적인 뼈대와 상속을 제공한다. 뼈대를 제공하기 때문에 기능을 완성 시킬 수 없다. 말그대로 선언만 해야한다. 또한 인터페이스로 구현하고 자식 클래스에서 재정의 할때는 override를 넣지 않는다. 그리고 인터페이스는 변수를 갖지 않는다. 인터페으스는 함수, 프로퍼티, 인덱서, 이벤트 4개만 갖을 수 있다. 더 기억할 건 인터페이스 끼리도 상속이 가능하다.

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

abstract public class A : MonoBehaviour
{
    abstract public void AAA();
}

interface ITest
{
    void BBB();
}

public class Test : A, ITest
{
    public override void AAA()
    {
        print("AAA");
    }

    public void BBB()
    {
        print("BBB");
    }

    void Start()
    {
        AAA();
        BBB();
    }
}

결과 화면: 

인덱서(Indexer)는 인덱스를 이용해서 객체 내의 데이터에 접근하게 해주는 프로퍼티이다. 

class 클래스이름
{
    한정자 인덱서형식 this[형식 index]
    {
        get
        {
            // index를 이용하여 내부 데이터 변환
        }
        set
        {
            // index를 이용하여 내부 데이터 저장
        }
    }
}

코드 예제)

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

public class Record
{
    public int[] temp = new int[5];

    public int this[int index]
    {
        get
        {
            if(index >= temp.Length)
            {
                Debug.Log("인덱스가 너무 큽니다.");
                return 0;
            }
            else
            {
                return temp[index];
            }            
        }
        set
        {
            if(index >= temp.Length)
            {
                Debug.Log("인덱스가 너무 큽니다.");
            }
            else
            {
                temp[index] = value;
            }
        }
    }
}

public class Test : MonoBehaviour
{
    void Start()
    {
        Record record = new Record();
        record[3] = 5;
        record[5] = 5;
    }
}

출력 결과: