오브젝트 풀

오브젝트 풀(Object Pool)은 게임 개발에서 자주 사용되는 디자인 패턴 중 하나로, 오브젝트의
생성과 소멸을 최소화하여 성능을 향상시키는 방법입니다. 주로 게임 내에서 빈번하게 생성되고
삭제되는 오브젝트를 미리 생성해두고, 필요할 때마다 재활용하여 메모리 할당 및 해제 오버레드를 줄입니다.

오브젝트 풀의 구성 요소:
1. 풀(Pool): 미리 생성된 오브젝트들을 보관하고 있는 컨테이너입니다.
2. 오브젝트 생성 및 초기화: 초기에 풀에 포함될 오브젝트를 생성하고 초기화합니다.
3. 오브젝트 재사용: 오브젝트가 필요한 경우, 풀에서 빼내서 사용하고 필요한 상태로 초기화합니다.
4. 오브젝트 반환: 사용이 끝난 오브젝트를 다시 풀에 반환합니다.

오브젝트 풀 패턴의 예시 코드:

C# 유니티 기준으로 오브젝트 풀.

public class ObjectPool : MonoBehaviour
{
    public GameObject prefab;
    public int initialPoolSize = 10;

    private List<GameObject> objectPool;

    private void Start()
    {
        objectPool = new List<GameObject>();

        for (int i = 0; i < initialPoolSize; i++)
        {
            GameObject obj = Instantiate(prefab);
            obj.SetActive(false);
            objectPool.Add(obj);
        }
    }

    public GameObject GetObjectFromPool()
    {
        foreach (GameObject obj in objectPool)
        {
            if (!obj.activeInHierarchy)
            {
                obj.SetActive(true);
                return obj;
            }
        }

        GameObject newObj = Instantiate(prefab);
        objectPool.Add(newObj);
        return newObj;
    }

    public void ReturnObjectToPool(GameObject obj)
    {
        obj.SetActive(false);
    }
}

위의 코드는 오브젝트 풀을 구현한 예시입니다. 주요 요소는 다음과 같습니다:

prefab: 풀에 사용될 오브젝트의 프리팹입니다.
initialPoolSize: 초기에 풀에 생성될 오브젝트의 개수입니다.
objectPool: 실제 오브젝트들을 저장하는 리스트입니다.
Start(): 초기에 풀에 오브젝트들을 생성하고 비활성화합니다.
GetObjectFromPool(): 오브젝트 풀에서 사용 가능한 오브젝트를 가져옵니다. 비활성화된 오브젝트를 찾아 활성화시키고 반환합니다.
ReturnObjectToPool(GameObject obj): 사용이 끝난 오브젝트를 다시 비활성화하여 풀에 반환합니다.
이제 위와 같은 오브젝트 풀을 사용하면 빈번한 오브젝트 생성과 삭제로 인한 성능 저하를 줄일 수 있습니다.

싱글톤 패턴


싱글톤(singleton)패턴의 정의는 단순하다.
객체의 인스턴스가 오직 1개만 생성되는 패턴을 의미한다.

싱글톤 패턴을 구현하는 방법은 여러가지가 있지만, 
여기서는 객체를 미리 생성해두고 가져오는 가장 단순하고 안전한 방법을 소개하겠다.

    public class Singleton
    {
        private static Singleton instance = new Singleton();
       
        private Singleton()
        {
            //생성자는 외부에서 호출을 하지 못하게 private으로 지정.
        }
        public static Singleton getInstance()
        {
            return instance;
        }
        public void Say()
        {
            Console.WriteLine("Hello");
        }
    }

싱글톤 패턴은 객체의 인스턴스가 오직 하나만 생성되는 디자인 패턴을 의미합니다. 객체의 인스턴스가 전역적으로 접근 가능하고 재사용되는 장점을 가지며, 주로 자원의 공유나 중복 생성을 피하기 위해 사용됩니다. 하지만 싱글톤 패턴은 구현에 따른 다양한 문제점을 가지고 있습니다.

장점:

메모리와 성능 효율: 싱글톤 패턴을 통해 객체 인스턴스가 한 번만 생성되므로 메모리 사용을 줄이고, 생성 및 소멸 과정에서 오버헤드를 줄일 수 있습니다.

전역적인 접근 가능성: 다른 클래스에서 해당 인스턴스에 쉽게 접근할 수 있어서 데이터나 메서드를 공유하기 용이합니다.

단점:

복잡한 구현: 싱글톤 패턴은 멀티스레드 환경에서 동시성 문제를 해결하기 위해 추가 코드가 필요한 경우가 있습니다. Lazy initialization이나 멀티스레딩에 대한 고려가 필요합니다.

테스트 어려움: 싱글톤은 전역적으로 접근 가능하므로 테스트에서 문제를 일으킬 수 있습니다. 테스트할 때마다 인스턴스 상태를 초기화해주거나 테스트 더블을 사용해야 합니다.

의존성과 유연성 문제: 클라이언트 코드는 싱글톤 클래스의 구체적인 구현에 의존하게 됩니다. 이로 인해 SOLID 원칙 중 DIP와 OCP를 위반할 가능성이 높습니다.

상속 문제: 일반적인 싱글톤 패턴은 상속이 어렵거나 복잡하게 됩니다. 싱글톤 자체를 상속받는 클래스를 만들어도 싱글톤 특성을 유지하기 어렵습니다.

내부 상태 변경 어려움: 다른 객체와 공유되는 싱글톤 인스턴스의 내부 상태를 변경하기 어려울 수 있습니다.

결론적으로, 싱글톤 패턴은 메모리와 성능 측면에서 이점을 가지지만, 복잡한 구현과 테스트 어려움, 의존성 문제 등 다양한 단점을 가지고 있어서 사용 시 신중한 고려가 필요합니다. 따라서 싱글톤 패턴을 선택할 때는 해당 상황과 요구사항을 잘 고려하고, 필요한 경우 대안적인 디자인 패턴이나 접근 방식을 고려하는 것이 좋습니다.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _1주차_복습
{
    class Program
    {
        #region 주사위게임
        public void diceGame()
        {
            Random Ran = new Random();

            Console.WriteLine("컴퓨터와 랜덤 주사위 게임");
            Console.WriteLine();

            bool gam = true;
            int sel = 0;
            int cumcount = 0;
            int mecount = 0;

            while (gam)
            {
                int medice = Ran.Next() % 6 + 1;
                int cumdice = Ran.Next() % 6 + 1;

                Console.WriteLine("0번 - 주사위 굴리기");
                Console.WriteLine("1번 - 현재 스코어 확인");
                Console.WriteLine("2번 - 종료");
                Console.Write("선택 : ");
                sel = Int32.Parse(Console.ReadLine());
                Console.WriteLine();
                switch (sel)
                {
                    case 0:
                        Console.WriteLine("컴퓨터 {0} , 나 {1}", cumdice, medice);
                        if(cumdice > medice)
                        {
                            Console.WriteLine("컴퓨터 승");
                            cumcount = cumcount + 1;
                            Console.WriteLine();
                        }
                        else if(cumdice == medice)
                        {
                            Console.WriteLine("무승부");
                            Console.WriteLine();
                        }
                        else
                        {
                            Console.WriteLine("나 승");
                            Console.WriteLine();
                            mecount = mecount + 1;
                        }
                        break;
                    case 1:
                        Console.WriteLine("컴퓨터 스코어 - {0}", cumcount);
                        Console.WriteLine("나 스코어 - {0}", mecount);
                        Console.WriteLine();
                        break;

                    case 2:
                        Console.WriteLine("게임 종료");
                        gam = false;
                        break;
                }
            }

        }
        #endregion

        static void Main(String[] args)
        {
            Program Pro = new Program();

            Pro.diceGame();

        }


    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _1주차_복습
{
    class Program
    {
        #region 칸 이동 게임
        public void canGame()
        {
            Console.WriteLine("게임을 시작하겠습니다.");

            Console.Write("이름을 입력해주세요: ");
            string name = Console.ReadLine();
            Console.WriteLine();
            Console.WriteLine("당신의 이름은 {0} 입니다.", name);
            Console.WriteLine();
            Console.WriteLine();

            int sel = 0;
            int up = 0;
            int down = 0;
            int right = 0;
            int left = 0;
            bool gam = true;

            while (gam)
            {
                Console.WriteLine("0번은 오른쪽으로 한칸");
                Console.WriteLine("1번은 왼쪽으로 한칸");
                Console.WriteLine("2번은 위쪽으로 한칸");
                Console.WriteLine("3번은 아래쪽으로 한칸");
                Console.WriteLine("4번은 종료");
                Console.Write("번호를 선택해주세요: ");
                sel = Int32.Parse(Console.ReadLine());
                Console.WriteLine();
                Console.WriteLine();
                switch (sel)
                {
                    case 0:
                        Console.WriteLine("오른쪽으로 한 칸 이동합니다.");
                        if(left > 0)
                        {
                            left = left - 1;
                        }
                        else
                        {
                            right = right + 1;
                        }
                        break;
                    case 1:
                        Console.WriteLine("왼쪽으로 한 칸 이동합니다.");
                        if (right > 0)
                        {
                            right = right - 1;
                        }
                        else
                        {
                            left = left + 1;
                        }
                        break;
                    case 2:
                        Console.WriteLine("위쪽으로 한 칸 이동합니다.");
                        if (down > 0)
                        {
                            down = down - 1;
                        }
                        else
                        {
                            up = up + 1;
                        }
                        break;
                    case 3:
                        Console.WriteLine("아래쪽으로 한 칸 이동합니다.");
                        if (up > 0)
                        {
                            up = up - 1;
                        }
                        else
                        {
                            down = down + 1;
                        }
                        break;
                    case 4:
                        Console.WriteLine("게임종료");
                        gam = false;
                        break;
                }
                Console.WriteLine("현재 이동한 칸 - 오른쪽 {0}, 왼쪽 {1}, 위쪽{2}, 아래쪽{3}", right, left, up, down);
                Console.WriteLine();
                Console.WriteLine();
            }

        }
        #endregion

        static void Main(String[] args)
        {
            Program Pro = new Program();
            
            Pro.canGame();

        }


    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _1주차_복습
{
    class Program
    {
        #region 구구단
        public void GuGuDan()
        {
            Console.Write("시작 단을 입력하세요: ");
            int start = Int32.Parse(Console.ReadLine());
            Console.Write("끝 단을 입력하세요 : ");
            int end = Int32.Parse(Console.ReadLine());

            for(int i=start; i<=end; i++)
            {
                for(int j=1; j<=9; j++)
                {
                    Console.WriteLine("{0} x {1} = {2}", i, j, i * j);
                }
                Console.WriteLine();
            }
            Console.WriteLine("{0}단 부터 {1}단 까지", start, end);
        }
        #endregion

        static void Main(String[] args)
        {
            Program Pro = new Program();

            Pro.GuGuDan();

        }


    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _1주차_복습
{
    class Program
    {
        #region 사칙연산
        public void math()
        {
            Console.Write("a값을 입력하세요: ");
            int a = Int32.Parse(Console.ReadLine());
            Console.Write("b값을 입력하세요: ");
            int b = Int32.Parse(Console.ReadLine());
            Console.WriteLine("0번 - 더하기");
            Console.WriteLine("1번 - 빼기");
            Console.WriteLine("2번 - 곱하기");
            Console.WriteLine("3번 - 나누기");
            Console.Write("선택 : ");
            int c = Int32.Parse(Console.ReadLine());

            switch (c)
            {
                case 0:
                    Console.WriteLine("값 : {0}", a + b);
                    break;
                case 1:
                    Console.WriteLine("값 : {0}", a - b);
                    break;
                case 2:
                    Console.WriteLine("값 : {0}", a * b);
                    break;
                case 3:
                    Console.WriteLine("값 : {0}", a / b);
                    break;
            }
        }
        #endregion

        static void Main(String[] args)
        {
            Program Pro = new Program();

            Pro.math();

        }


    }
}

C# 기본 문법정리

C# 기본구조
ex)
using System;
namespace abc{
    class Hello{
          public static void Main(){
                 Console.WriteLine("HelloWorld");
           }
    }
}


문자열 표시-Console.Write(), Console.WriteLine() 사용
ex)
Console.Write("aaa");
Console.WriteLine("aaa");     //뒤에 Line은 줄바꿈을 나타냄, 자바에서 println에서 'ln'과 같음


변수의 선언 - 다른 프로그래밍 언어랑 유사하다
ex)
int a;
float b;
double c;
int d, e;


변수의 표시
ex)
Console.Write(a);


문자 - 유니코드 1개, char(발음'차')형에 저장
ex)
char a='A';    //문자는 ''로 묶는다.
                  // ""는 문자열을 묶을때 사용한다. ""를 쓸경우 null문자가 자동으로 삽입되어 두글자가 된다.
                     그러면 컴파일 에러 발생

문자의 표시
ex)
Console.Write('A');


문자열 - string형에 저장
ex)
string a="abc";     //문자열은 ""로 묶는다


문자열의 결합 - + 연산자를 사용하여 연결한다.
ex)
string a="abc";
int b=3;
string c=a+b+"abc";



배열 선언 - new연산자 이용
ex)
int []a=new int[4];
int []a=new int[]{1, 2, 3, 4};   //선언과 동시에 초기화
int []a={1, 2, 3, 4};               //선언과 동시에 초기화



다차원 배열
ex)
-1차원
int []a=new int[3];

-2차원
int [ , ]a=new[2,3];    //쉼표로 차원을 구분

-3차원
int [ , , ]a=new int[2, 3, 4];



다차원 배열 초기화
ex)
int [ , ]a={
       {10, 20},
       {30, 40},
       {50, 60}
};



재그 배열 - 2차원 이상의 배열에서 각 방향의 요소 수가 일정하지 않은 배열
ex)
int [][]a=new int[3][];
a[0]=new int[3]{1, 2, 3};
a[1]=new int[2]{4, 5};
a[2]=new int[1]{6};


int [][]a=new int[][]{
      new int[]{1, 2, 3}.
      new int[]{4, 5},
      new int[]{6}
};



length - 배열의 요소 수 구하기
ex)
int []a=new int[4];
int b=a.length;      // ()안 붙여도 됨


열거형 선언 - enum(발음 '이념') 사용
ex)
enum A{a, b, c, d, e};
Console.WriteLine(A.a);


bool형 - true 또는 false 중 한개의 값을 가지는 변수의 형
ex)
bool a=(x>y);


조건 연산자 - '조건식 ? a : b; ' 조건식이 참이면 a, 거짓이면 b
ex)
bool bo;
int a= bo ? 100 : 10;   //bo가 참이면 100을, 거짓이면 10을 a에 대입


캐스트 연산자 - 형명을 (0로 묶은것. 값이나 변수 앞에 쓰면 지정한 형으로 변환할 수 있다.
ex)
int a = 3;
int b = 2;
int c = (int) 1/b ;