C# for C++ programmers

C# 문법이 독특한게 좀 있어서 공부도 할 겸 잠시 정리해 봅니다.

Hello, World!

using System;
namespace Hello.World {
    class HelloWorld {
        public static void Main() {
            Console.WriteLine("Hello, World!");
        }
    }
}

변수 생성

int i, j;
float f;
double d;
char ch = 'A';

Console.WriteLine(ch);

i = 1;
Console.WriteLine(i.ToString()); // 기본형도 클래스이다.

문자열

string str1 = "abc";
string str2 = "def";
int i = 5;
string str3 = str1 + str2 + i;

배열

int []a = new int[4];
int []b = new int[]{1, 2, 3, 4};
int []c = {1, 2, 3, 4};

다차원 배열

// 1차원
int []a = new int[3];

// 2차원
int [ , ]b = new[2, 3];
int [ , ]b2 = {
    {10, 20},
    {30, 40},
    {50, 60}
};

// 3차원
int [ , , ]c = new int[2, 3, 4];

배열의 사이즈가 일정하지 않을 수 있다.

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}
};

int []a = new int[4];
int b = a.length;

enum

enum A{a, b, c, d, e};
Console.WriteLine(A.a);

bool

bool a = (x > y);

? :

bool b = false;
int a = b ? 1 : 2;

cast

int a = 3;
int b = 2;
int c = (int) 1 / b;

if else

if (조건)
{
    // 내용
}
else if (조건)
{
    // 내용
}
else
{
    // 내용
}

for

int i;
for(i = 0; i < 3; i++) {
    // 처리
}

break, continue 사용가능

foreach

int []nums = new int[5];
foreach(int a in nums)
{
    Console.WriteLine(a);
}

break, continue 사용가능

while

while (조건)
{
    // 처리
}

break, continue 사용가능

switch

switch(식) {
    case 값1:
        처리
        break;
    case 값2:
        처리
        break;
    default:
        처리
        break;
}

class

class 정의

class A {
    public int a;     // 필드(field)
    int b;            // public 을 생략하면 private

    public int add()
    {
        return a + b;
    }
}

class 생성

A  a;
a = new A();
A  a = new A();

속성(property, getter/setter)

usting System;
class A {
    int _val;            // 내부 변수는 '_' 로 시작하는 것이 암묵적인 규칙
    public int val
    {
        get
        {
            return _val;
        }
        set
        {
            _val = value;
        }
    }

    public val2 { get; set; } // 단순히 getter/setter 의 존재만 표시하는 것도 가능
}

A a = new A();
a.val = 3;
Console.Write(a.val);

인덱서(indexer)

키워드 this 를 사용

using System;
class A {
    int []_a = new int[2];
    public int this[int i]
    {
        get
        {
            return _a[i];
        }
        set
        {
            _a[i] = value;
        }
    }
}

A a = new A();
a[0] = 1;
a[1] = 2;
for(int i = 0; i < 2; i++)
{
    Console.Write(a[i]);
}

상속

생성자가 있는 경우, 부모 클래스의 생성자부터 실행된다.

class A
{
    public A()
    {
        Console.WriteLine("AAA");
    }
}

class B : A
{
    public B()
    {
        Console.WriteLine("BBB");
    }
}

class Program
{
    static void Main(string[] args)
    {
        B b = new();
    }
}

base 키워드를 이용해 부모 클래스에 파라미터 전달

class A
{
    public int x;
    public A(int a, int b)
    {
        x = a + b;
    }
}
class B : A
{
    public B(int c, int d) : base(c, d) { }
}

new 키워드를 이용해 부모 클래스의 필드/속성을 은닉할 수 있다.

class A
{
    public int a = 10;
}
class B : A
{
    new public int a = 30;
    public void print()
    {
        // base 키워드를 이용해 은닉된 맴버에 접근할 수 있다.
        Console.WriteLine(base.a);
    }
}

오버라이드 되는 클래스에 virtual 키워드를,
오버라이드 하는 클래스에 override 키워드를 지정해 오버라이드 할 수 있다.

class A
{
    public virtual void Test() { }
}

class B : A
{
    public override void Test()
    {
        Console.WriteLine("BBB");
    }
}

abstract 키워드를 이용해 추상클래스를 생성할 수 있다.

abstract class A
{
    public abstract void Test();
}

class B : A
{
    public override void Test()
    {
        Console.WriteLine("BBB");
    }
}

sealed 상속 불가 클래스

sealed class A
{
    // ...
}

인터페이스

추상메서드, 추상속성, 추상인덱서, 이벤트만 멤버로 가질 수 있다.
모든 메서드는 public 이기 때문에 public 키워드를 생략할 수 있다.

interface A
{
    public abstract void a();
    abstract int b
    {
        get;
        set;
    }
}
class B : A{
   public void a(){
       ~~
   }
   public int prop{
          get{
               return b;
         }
         set{
              b=value;
         }
    }
}

복수의 인터페이스를 상속할 수 있다.

class X : A, B, C
{
    // ...
}

인터페이스의 상속도 가능하다.

interface A
{
    // ...
}
interface B : A
{
    // ...
}

네임스페이스

namespace A
{
    class Abc
    {
        public void Test()
        {
            Console.WriteLine("AAA");
        }
    }
}

namespace B
{
    class Abc
    {
        public void Test()
        {
            Console.WriteLine("BBB");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        B.Abc b = new();
        b.Test();
    }
}

예외처리

try
{
    // ...
}
catch(예외클래스명  변수명)
{
    // ...
}
finally
{
    // ...
}