Kimi

값형식

 - 형식의 값이 저장됨

 - 새 값을 할당하면 개체 자체의 값이 복사됨

 - System.ValueType에서 파생됨

 - 구조체(숫자형식, bool, 사용자정의), 열거형 등의 형식 제공

참조형식

- 데이터에 대한 참조가 저장됨

- 새 값을 할당하면 개체의 참조가 복사됨

- class, interface, delegate, dynamic, object, string 등의 형식 제공

Boxing

 - 값 형식을 object(혹은 object에서 파생된) 형식으로 변환하는 프로세스

 - 암시적

 - System.Object 내부에서 관리되는 힙에 할당되고 값이 복사됨

UnBoxing

 - object(혹은 object에서 파생된) 형식에서 값 형식으로 변환하는 프로세스

 - 명시적

 - 인스턴스가 지정한 값 형식을 boxing한 값인지 확인 후 인스턴스의 값을 변수에 할당

예시코드

int valueType = 1;

object refType = valueType;

int valueType2 = (int)refType;

주의사항

 * 비용 : 최대한 피하기

  - boxing은 단순 참조보다 20배정도의 소요시간이 걸리고 unboxing의 캐스팅프로세스는 할당의 4배정도의 시간이 걸림

  - ArrayList는 boxing, unboxing을 유발하므로 가능하면 List<T>를 사용하자

  - 힙에 할당이 되었다는 것은 GC가 호출될 가능성이 있다는 것을 유의해야 함

* 예외 : try catch 사용, if로 조건 체크 등

  - null을 unboxing 할 수 없음 => NullReferenceException

  - 호환되지 않는 값 형식에 대한 참조를 unboxing 할 수 없음 => InvalidCastException

Dispose

C# 리소스

관리되지 않는 리소스 : 파일스트림, 네트워크연결, 데이터베이스연결 등 운영체제 리소스를 래핑하는 개체

관리되는 리소스 : 그 외에 리소스

* 관리되는 리소스는 가비지컬렉터가 관리해주지만 관리되지 않는 리소스는 가비지컬렉터가 관여할 수 없음

 => 관리되지 않는 리소스는 프로그래머가 직접 해제

ex) File을 읽고 Close호출(아래 예시대로 사용하면 안됨!!!)

var file = new StreamReader("file.txt");
var content = file.ReadToEnd();
file.Close();

만약 file이 null이어서 오류가 난다면 Close는 호출되지 않음

dispose

Dispose : 관리되지 않는 메모리를 명시적으로 해제

관리되지 않는 리소스는 IDisposable 인터페이스를 구현해둠

위 예제는 다음과 같이 수정할 수 있음

StreamReader file = null;
string content = string.Empty;
try
{
    file = new StreamReader("file.txt");
    content = file.ReadToEnd();
}
finally
{
    if(file != null)
        file.Dispose();
}

dispose 패턴의 구현

public class DisposableClass : IDisposable
{
    private bool disposed;

    public DisposableClass() {}
    ~DisposableClass()
    {
        this.Dispose(false);
    }

    public void Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this); // Finalizer를 호출되지 않게 제한하며 GC Call
    }

    protected virtual void Dispose(bool disposing)
    {
        if(disposed == false)
        {
            if(disposing)
            {
                // 여기서 리소스 해제
            }
        }
        disposed = true;
    }
}

다음과 같은 베이스에서 원하는 로직을 구현 후 StreamReader 예제와 같이 사용하면 됨

using

로직을 수행한 후 자체적으로 Dispose를 호출해주는 명령어

위 예제를 다음과 같이 축소할 수 있음

string content = string.Empty;
using(var file = new StreamReader("file.txt"))
{
    content = file.ReadToEnd();
}

public abstract class FSMState
{
    public Type Key { get; private set; }
    private List nextState;

    public FSMState(Type key)
    {
        Key = key;
    }

    public abstract void OnEnter();
    public abstract void OnStay();
    public abstract void OnExit();

    internal void Link(Type state)
    {
        if (nextState == null)
            nextState = new List();

        nextState.Add(state);
    }

    internal bool IsLinkable(Type state)
    {
        return !nextState.Contains(state);
    }

    internal void EnterPrco()
    {
        OnEnter();
    }

    internal void StayProc()
    {
        OnStay();
    }

    internal void ExitProc()
    {
        OnExit();
    }
}

FSM.cs

public class FSM
{
    private Dictionary> stateDic;
            private FSMState currentState = null;
    public State CurrentState
    {
        get
        {
            return currentState.Key;
        }

        private set
        {
            currentState = FindState(value);
        }
    }

    public void ChangeState(State stateName)
    {
        if (currentState != null)
        {
            currentState.ExitProc();
        }

        CurrentState = stateName;

        if (currentState != null)
        {
            currentState.EnterPrco();
        }
    }

    public void UpdateState()
    {
        currentState.OnStay();
    }

    public bool AddState(FSMState state, bool isDefaultState = false)
    {
        if (stateDic == null)
        {
            stateDic = new Dictionary > ();
        }

        if (stateDic.ContainsKey(state.Key))
        {
            return false;
        }

        if (stateDic.ContainsValue(state))
        {
            return false;
        }

        stateDic.Add(state.Key, state);

        if (currentState == null || isDefaultState)
        {
            currentState = state;
        }

        return true;
    }

    public bool Link(State from, State to)
    {
        if (from.Equals(to))
        {
            return false;
        }

        FSMState fromState = FindState(from);
        if (fromState == null)
        {
            return false;
        }
        FSMState toState = FindState(to);
        if (toState == null)
        {
            return false;
        }

        if (fromState == toState)
        {
            return false;
        }

        if (fromState.IsLinkable(to))
        {
            return false;
        }

        fromState.Link(to);
        return true;
    }

    private FSMState FindState(State key)
    {
        FSMState result = null;
        stateDic.TryGetValue(key, out result);
        return result;
    }
}