C#/문법

1. 개요

2. 편집 지침

#!syntax csharp
using System;

namespace Namu
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("hello namu!");
        }
    }
}

3. 기본

#!syntax csharp
using System; 
// 여기에 사용할 .NET 네임스페이스를 정의한다.
// 예: 제네릭 컬렉션 -> using System.Collections.Generic;
//     파일 입출력   -> using System.IO;
//     정규표현식    -> using System.Text.RegularExpressions;

namespace CSharpExample
{
    // 모든 C# 클래스는 한 네임스페이스 안에 선언한다.
    class Program
    {
        // 여기에 멤버 변수, 프로퍼티, 메소드 등을 선언한다.
        static void Main(string[] args)
        {
            //여기에 돌아갈 코드를 작성한다.
        }
    }
}

3.1. 최상위 문 (C# 9.0)

#!syntax csharp
using System;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, world!");
        Console.ReadKey();
    }
}

#!syntax csharp
using System;

Console.WriteLine("Hello World!");
Console.ReadKey();

#!syntax csharp
using System;
using Example;

Namu namu = new() { wiki = new() };
namu.wiki.Hello();

namespace Example
{
    class Wiki {
        public void Hello() => Console.Write("Hello World!");
    }
    struct Namu {
        public Wiki wiki;
    }
}

3.2. 변수

#!syntax csharp
int a;

#!syntax csharp
a = 123;

#!syntax csharp
int a = 123;

4. 클래스 (Class)

#!syntax csharp
namespace CSharpExample
{
    public class Person
    {
        public const int EyeCount = 2;

        private string name;

        public int Age { get; set; } = 0;

        public string Name { get => name; set => name = value; }

        public void Run()
        {
            // 달리는 동작
        }

        public override string ToString()
        {
            return $"{name} ({Age})";
        }

        public Person(string name, int age)
        {
            this.name = name;
            Age = age;
        }
    }
}

• 분할 클래스 : Java 클래스는 모든 멤버들을 한 파일에 작성해야 한다. 하지만 C# 클래스는 아래와 같이 partial 지시자를 사용하여 여러 파일에 나누어 작성할 수 있다. 이렇게 하면 나누어 놓은 클래스들이 하나의 클래스로 취급된다. [1]
  {{{#!syntax csharp
  // ...
  public partial class PartialClass
  {

public PartialClass()
{

// 생성자

}

4.1. this, base

4.1.1. this

#!syntax csharp 
public class Employee
{
    private string company;
    private string name;

    public Employee(string name, string company)
    {
        this.name = name;
        this.company = company;
    }
}

#!syntax csharp 
public class Employee
{
    private string _company;
    public string Name { get; set; }

    public Employee(string name, string company)
    {
        Name = name;
        _company = company;
    }
}

4.1.2. base

#!syntax csharp 
public class Person
{
    protected string telephone = "12-5555-6666";
    protected string name = "홍길동";

    public virtual void GetInfo()
    {
        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("Tel: {0}", telephone);
    }
}
class Employee : Person
{
    public string id = "ABC567EFG";
    public override void GetInfo()
    {
        // 본인이 상속 받은 클래스에 있는 GetInfo 메소드를 호출
        base.GetInfo();
        Console.WriteLine("Employee ID: {0}", id);
    }
}

class TestClass
{
    static void Main()
    {
        Employee E = new Employee();
        E.GetInfo();
    }
}

4.2. 생성자

4.2.1. 일반 생성자 (public/private/internal/protected)

#!syntax csharp
public class TestClass
{
    private TestClass()
    {
        Console.WriteLine("Private Constructor");
    }

    internal TestClass(string message)
    {
        Console.WriteLine("Internal Constructor");
        Console.WriteLine("Message: " + message);
    }
    
    protected TestClass(int count)
    {
        Console.WriteLine("Protected Constructor");
        Console.WriteLine("Count: " + count);
    }

    public TestClass(string message, int count)
    {
        Console.WriteLine("Public Constructor");
        Console.WriteLine("Message: " + message);
        Console.WriteLine("Count: " + count);
    }
}

public class Program
{
    public static void Main()
    {
        var cls1 = new TestClass(); // Private 접근이 안되므로 오류
        var cls2 = new TestClass("test"); // 같은 어셈블리가 아닐 경우 오류
        var cls3 = new TestClass(5); // TestClass 또는 TestClass에서 상속받은 클래스가 아닐 경우 오류
        var cls4 = new TestClass("test", 5); // 모든 곳에서 접근 가능
        TestClass cls5 = new("test", 5); // cls5의 타입을 알 수 있으므로 클래스 이름 생략 가능 (C# 9.0부터 지원)
    }
}

#!syntax csharp
public class BaseClass
{
    protected BaseClass()
    {
        Console.WriteLine("[Base Protected Constructor]");
    }
}

public class TestClass : BaseClass
{
    private TestClass() : base()
    {
        Console.WriteLine("[Private Constructor]");
    }

    internal TestClass(string message) : this()
    {
        Console.WriteLine("[Internal Constructor]");
        Console.WriteLine("Message: " + message);
    }
    
    public TestClass(string message, int count) : this(message)
    {
        Console.WriteLine("[Public Constructor]");
        Console.WriteLine("Count: " + count);
    }
}

public class Program
{
    public static void Main()
    {
        var cls = new TestClass("test", 5);
        // 출력:
        // [Base Protected Constructor]
        // [Private Constructor]
        // [Internal Constructor]
        // Message: test
        // [Public Constructor]
        // Count: 5
    }
}

4.2.1.1. 기본 생성자

#!syntax csharp
class Point {
    public int X {get; set;}
    public int Y {get; set;}
    public Point(int x,int y) {
        this.X = x;
        this.Y = y;
    }
}

#!syntax csharp
class Point(int x,int y) {
    public int X {get; set;} = x;
    public int Y {get; set;} = y;
}

4.2.2. static 생성자

#!syntax csharp
class TestClass
{
    static TestClass()
    {
        // 정적 생성자
    }
}

#!syntax csharp
class TestClass
{
    static TestClass()
    {
        // 정적 생성자
    }
    
    public static void Init()
    {
        // Fake Method
    }
}

// TestClass.Init();

4.2.3. const, readonly

#!syntax csharp
class TestClass
{
    static TestClass()
    {
        // 생성자에서 readonly 변수 값 변경이 가능하다.
        TestReadOnly = 1;
    }

    // 한번 선언된 값은 변경이 불가능하고 자동으로 static 변수가 된다.
    public const int TestConst = 4;

    // 초기화가 필요 없으며, 생성자에서 값을 변경할 수 있으며, 자동으로 static 변수가 되지 않는다.
    public readonly int TestReadOnly;
}

class Program
{
    static void Main(string[] args)
    {
        // const 선언 시 자동으로 static 변수가 되기 때문에 public이면 다른 클래스에서 접근할 수 있다.
        Console.WriteLine(TestClass.TestConst);
        // const 변수는 변경이 불가능하기 때문에 오류가 난다.
        TestClass.TestConst = 5;
    }
}

4.3. 속성 (Property)

4.3.1. 속성 정의

#!syntax csharp
public class Person
{
    public string Name { get; set; }
}

#!syntax csharp
public class Person
{
    // Java Style
    private string name;
    
    public void SetName(string name)
    {
        base.name = name;
    }

    public string GetName()
    {
        return base.name;
    }
}

#!syntax csharp
public class Person
{
    public string Name { get; set; } = string.Empty;
}

#!syntax csharp
public class Person
{
    private string _name;
    public string Name
    {
        get
        {
            // logic
            return _name;
        }
        set
        {
            // logic
            _name = value;
        }
    }
}

#!syntax csharp
public class Person
{
    private string _name;
    public string Name
    {
        get => _name;
        set => _name = value;
    }
}

#!syntax csharp
public class Person
{
    public string Name { get; private set; }
}

#!syntax csharp
public class Person
{
    public string Name { get; }
}

#!syntax csharp
public class Person
{
    public string Name { get; init; }
}

4.4. 추상 클래스 (Abstract Class)

4.5. 상속 / 구현 (Inherits / Implementation)

#!syntax csharp
public class DerivedClass : BaseClass, ISomeInterface

#!syntax csharp
public sealed class String

4.6. unsafe

#!syntax csharp
// unsafe는 클래스에도 넣을 수 있다. 그러면 해당 클래스에 속하는 메서드들은 포인터 변수를 다롤수 있다.
public unsafe class Program
{
    static void Main(string[] args)
    {
        unsafe
        {
            int val = 500;

            // 포인터 변수 선언, 이 코드는 unsafe 키워드 안에서 실행해야 한다.
            int* ptr = &val;

            // 포인터 메서드 호출
            PointFun(ptr);

            // 처음에는 500의 값을 가지고 있었지만 포인터 변수 값을 변경하는 메서드를 호출했기 때문에 *ptr : 5 으로 표시된다.
            Console.WriteLine("*ptr : {0}", *ptr);
        }
    }

    // unsafe는 메서드 생성자에 넣을 수 있다. 그러면 해당 메서드는 포인터 변수를 다롤수 있다.
    static unsafe void PointFun(int* pointer)
    {
        // pointer가 가르키는 변수의 값을 5로 변경한다.
        // pointer와 ptr은 같은 주소를 가지고 있어 val의 값이 변경된다.
        *pointer = 5;
    }
}

4.7. checked / unchecked

#!syntax csharp
// 오버플로우/언더플로우 감시 사용
checked
{

}

// 오버플로우/언더플로우 감시 사용 안함
unchecked
{

}

5. 이름공간 (Namespace)

#!syntax csharp 
namespace Namu
{
    class Program
    {

    }
}

#!syntax csharp 
namespace Namu;

class Program
{

}

#!syntax csharp 
namespace Namu.Wiki.Csharp
{
    class Document {
        public static void HelloWorld() => Console.Write("Hello, World!");
    }
}
namespace Namu.Wiki {
    class Program {
        static void Main(string[] args) => Csharp.Document.HelloWorld();
    }
}

5.1. using

#!syntax csharp
using (네임스페이스 이름);

#!syntax csharp
namespace Namu
{
    public class Wiki
    {
        public static void HelloWorld()
        {
            System.Console.WriteLine("Hello, World!");
        }
    }
}

#!syntax csharp
class Program
{
    static void Main(string[] args)
    {
        Namu.Wiki.HelloWorld();
    }
}

#!syntax csharp
using Namu;

class Program
{
    static void Main(string[] args)
    {
        Wiki.HelloWorld();
    }
}

#!syntax csharp
using static Namu.Wiki;

class Program
{
    static void Main(string[] args)
    {
        HelloWorld();
    }
}

5.2. 별칭

#!syntax csharp
using (별칭) = (네임스페이스);

#!syntax csharp
using DataStructure = System.Collections.Generic;

DataStructure.SortedSet<int> set_in_cpp = new();
DataStructure.HashSet<int> unordered_set_in_cpp = new();

6. 인터페이스 (Interface)

#!syntax csharp 
//사람 추가
Person person = new(balance: 614); 
//손전등 추가
FlashLight flashlight = new FlashLight();
//IPurchasable 인터페이스를 상속한 제품이라면?
if (flashlight is IPurchasable item) {
    item.Purchase(person); //구매 가능
}
//IBrighter 인터페이스를 상속한 제품이라면?
if (flashlight is IBrighter flash) {
    flash.Brighten(); //작동 가능
}

public class Person
{
    public uint Balance { get; set; }
    public Person(uint balance) {
        Balance = balance;
    }
}
//인터페이스 선언
public interface IPurchasable
{
    public uint Cost { get; /*프로퍼티의 get, set도 메서드이다.*/}
    public void Purchase(Person person);
}
public interface IBrighter
{
    public void Brighten();
}
//구현
public class FlashLight : IPurchasable, IBrighter
{
    public uint Cost => 300;
    public void Purchase(Person person)
    {
        //구입 기능 구현
        if (person.Balance >= Cost)
            person.Balance -= Cost;
    }
    public void Brighten()
    {
        //불 밝히기 기능 구현
    }
}

#!syntax csharp
public Interface IIntCalculator
{
    int Sum(int left, int right)
    {
        return left + right;
    }
}

#!syntax csharp
interface A
{
    public void Hello();
}
interface B
{
    public void World();
}
interface AB : A , B
{
    public void HelloWorld();
}
class Namu : AB
{
    public void Hello() => Console.Write("Hello,");
    public void World() => Console.Write("World!");
    public void HelloWorld()
    {
        Hello();
        World();
    }
}

7. 구조체 (Struct)

7.1. Ref 구조체 (ref struct)

7.2. Readonly 구조체 (readonly struct)

#!syntax csharp
public readonly struct READONLY_STRUCT
{
    public readonly int Num;
    public readonly string Text;

    public READONLY_STRUCT(int num, string text)
    {
        Num = num;
        Text = text;
    }
}

8. 레코드 (Record)

#!syntax csharp
class Point {
    public int X {get; init;}
    public int Y {get; init;}
    public Point(int x,int y) {
        this.X = x;
        this.Y = y;
    }
    public override bool Equals(object? obj)
    {
        if (obj is Point p) return this.X == p.X && this.Y == p.Y;
        return base.Equals(obj);
    }
}

#!syntax csharp
record Point(int X,int Y);

#!syntax csharp
Point p1 = new(10,20);
Point p2 = new(10,20);

Console.WriteLine(p1 == p2); //출력: True

// p1.X = 20; record는 값을 수정할수 없어 이 코드는 오류가 난다.
Point p3 = p1 with { X = 20 }; //대신 with으로 X를 20으로 바꾼 새 객체를 쉽게 만들수 있다.

(int x,int y) = p1; //Deconstruct 매서드가 존재하여 가능하다.

record Point(int X,int Y) : IComparable<Point> {
    public int CompareTo(Point? other) {
        if (this.Y == other?.Y) return this.X.CompareTo(other.X);
        return this.Y.CompareTo(other?.Y);
    }
}

9. 열거형 (Enum)

10. 자료형 (Type)

10.1. 값 형식

10.1.1. 부울(bool)

#!syntax csharp 
// bool
bool check = true;
Console.WriteLine(check ? "Checked" : "Not checked");  // 출력: Checked
Console.WriteLine(false ? "Checked" : "Not checked");  // 출력: Not checked

// Nullable bool
bool? b1 = true;
bool? b2 = false;
bool? b3 = null;

Console.WriteLine(b1); // 출력: true
Console.WriteLine(b2); // 출력: false
Console.WriteLine(b3); // 출력: 

Console.WriteLine(b1.HasValue); // 출력: true
Console.WriteLine(b2.HasValue); // 출력: true
Console.WriteLine(b3.HasValue); // 출력: false

// Nullable in Condition
if (b1.HasValue)
{
    if (b1)
    {
        // b1은 값이 있으며, true이다.
    }
    else
    {
        // b1은 값이 있으며, false이다.
    }
}
else
{
    // b1은 값이 없다 (null)
}

10.1.2. 숫자(byte, short ...)

10.1.2.1. BigInteger (System.Numerics)

#!syntax csharp 
using System;
using System.Numerics;
// ...

BigInteger bi = new BigInteger(51239932019301293);
BigInteger bi2 = BigInteger.Parse("123456789123456789123456789123456789123456789123456789");

Console.WriteLine(bi);
Console.WriteLine(bi2);

10.1.2.2. Complex (System.Numerics)

#!syntax csharp 
using System;
using System.Numerics;

Complex c1 = new Complex(12, 6); // 12 + 6i
Complex c2 = 3.14;
Complex c3 = (Complex) 12.3m;
Complex c4 = Complex.FromPolarCoordinates(2 * Math.Sqrt(2), Math.PI / 4); // 2 + 2i
Complex c5 = Complex.One - Complex.ImaginaryOne; // 1 - i

Console.WriteLine(c1);
Console.WriteLine(c2);
Console.WriteLine(c3);
Console.WriteLine(c4);
Console.WriteLine(c5);

10.1.2.3. 문자(char)

#!syntax csharp
using System;

public class CharStructureSample
{
    public static void Main()
    {
        char chA = 'A';
        char ch1 = '1';
        string str = "test string";

        Console.WriteLine(chA.CompareTo('B'));        // 결과: "-1" ('A' 문자가 'B' 문자보다 작다는 것을 의미함.)
        Console.WriteLine(chA.Equals('A'));           // 결과: "True"
        Console.WriteLine(Char.GetNumericValue(ch1)); // 결과: "1"
        Console.WriteLine(Char.IsControl('\t'));      // 결과: "True"
        Console.WriteLine(Char.IsDigit(ch1));         // 결과: "True"
        Console.WriteLine(Char.IsLetter(','));        // 결과: "False"
        Console.WriteLine(Char.IsLower('u'));         // 결과: "True"
        Console.WriteLine(Char.IsNumber(ch1));        // 결과: "True"
        Console.WriteLine(Char.IsPunctuation('.'));   // 결과: "True"
        Console.WriteLine(Char.IsSeparator(str, 4));  // 결과: "True"
        Console.WriteLine(Char.IsSymbol('+'));        // 결과: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4)); // 결과: "True"
        Console.WriteLine(Char.Parse("S"));           // 결과: "S"
        Console.WriteLine(Char.ToLower('M'));         // 결과: "m"
        Console.WriteLine('x'.ToString());            // 결과: "x"
    }
}

#!syntax csharp
char ch = '\u0061';    // 'a' 와 동일
char ch2 = '\u0041';   // 'A'와 동일

Console.WriteLine(ch);  // 결과: a
Console.WriteLine(ch2); // 결과: A

10.1.3. 날짜/시간(DateTime)

#!syntax csharp
DateTime dt = new DateTime(); // "01/01/0001 00:00:00"
DateTime dt2 = DateTime.Now;   // 현재 날짜와 시간을 가져옴
DateTime dt3 = DateTime.Parse("2020-05-29"); // 문자열로부터 날짜를 파싱
DateTime dt4 = DateTime.Parse("2020-05-29 15:00:00"); // 문자열로부터 날짜와 시간을 파싱
DateTime dt5 = dt4.Date; // dt4에서 시간을 제외한 날짜만 가져와 대입

#!syntax csharp
Console.WriteLine(DateTime.Now.Date == DateTime.Now) // 결과: false
Console.WriteLine(DateTime.Now.Date != DateTime.Now) // 결과: true

#!syntax csharp
DateTime dt = DateTime.Now.AddDays(1); // 현재 날짜/시간에서 하루를 추가
DateTime dt = DateTime.Now.AddDays(1.5); // 현재 날짜/시간에서 하루 + 12시간을 추가 (소숫점의 경우 가장 가까운 밀리초로 반올림)
DateTime dt = DateTime.Now.AddDays(-1); // 현재 날짜/시간에서 하루를 뺀 값

// AddYears, AddHours, AddMinutes, AddSeconds, AddTicks 등의 함수도 지원

10.2. 참조 형식

10.2.1. object

10.2.2. dynamic

#!syntax csharp
dynamic a = uint.MaxValue;
dynamic b = -2.3;
dynamic c = -long.MaxValue;

Console.Write(
    "{0}\n{1}\n{2}",
    Math.Abs(a), //4294967295
    Math.Abs(b), //-2.3
    Math.Abs(c) // 9223372036854775807
);

10.2.3. 문자열(string)

#!syntax csharp
static void CompareString()
{
    string s1 = "ab";
    string s2 = "abcd".Substring(0, 2);
    object o1 = s2;

    Console.WriteLine($"{s1.Equals(s2)}\t{s1.Equals(o1)}");
    Console.WriteLine($"{s1 == s2}\t{s1 == o1}");

    // 결과:
    // True    True
    // True    False
    // s1 == o1의 경우 string와 object 간의 비교이므로 == 동작이 string에서처럼 동작하지 않는다.
}

10.2.3.1. StringBuilder

#!syntax csharp
public sealed class StringBuilder : System.Runtime.Serialization.ISerializable

10.2.4. 배열

#!syntax csharp
//선언
int[] a;
//초기화
a = new int[123];
//읽기
var n = a[0];
//쓰기
a[0] = 1234;

#!syntax csharp
int size = 100;
int[] arr = new int[size]; //상수가 아닌 값으로 배열의 길이를 지정할수 있다.

10.2.5. 다차원 배열

#!syntax csharp
//선언
int[,,] a;
//초기화
a = new int[10,20,30];
//읽기
var n = a[9,19,29];
//쓰기
a[0,0,0] = 1234;

10.2.5.1. 가변 배열과의 차이점

#!syntax csharp
int[][] mutable_array = new int[10][];
mutable_array[1] = new int[3];
mutable_array[2] = new int[6];
mutable_array[3] = new int[9];

Console.Write(mutable_array[0] == null); // 출력: True

#!syntax csharp
int[,] multi_array = new int[10,20];
multi_array[9,19] = 614;

Console.Write(multi_array[0,0]); // 출력: 0

10.2.6. 참조변수

#!syntax csharp
ref (타입) (이름) = ref (참조대상);

#!syntax csharp
int number = 1234;
ref int refer = ref number; // 'number' 변수를 참조한다.
ref int refer2 = ref refer; // 마찬가지로 'number' 변수를 참조한다.

refer2 = 9876;
Console.Write(number); //'9876' 이 출력된다.

10.3. 리터럴 값 형식

10.4. 제네릭 형식

10.5. 암시적 형식 및 무명 형식

#!syntax csharp 
var i = 10; // 암시적 형식 선언
int i = 10; // 명시적 형식 선언

var s = "namu"; // 암시적 형식 선언
string s = "namu"; // 명시적 형식 선언

#!syntax csharp 
var temp = new {name = "namu", age = 25};
Console.WriteLine($"name: {temp.name}, age: {temp.age}");
// 결과
// name: namu, age: 25

10.6. nullable 형식

#!syntax csharp
public struct Nullable<T> where T : struct

11. 함수 (Function)

11.1. 콘솔 입출력

• void Console.Write(object value) : 매개변수의 값을 출력
• void Console.WriteLine(object value) : 매개변수의 값을 출력하고 줄 바꿈(개행)

• int Console.Read() : 한 문자를 입력받고, 그 문자의 유니코드 값을 반환(문자로 변환하려면 (char)Console.Read())처럼 사용)
• ConsoleKeyInfo Console.ReadKey() : 입력한 키 조합을 반환
• string Console.ReadLine() : 입력받은 한 문자열을 반환(Enter키로 입력)

#!syntax csharp
Console.WriteLine("Hello, world!");

11.1.1. 빠른 입출력

#!syntax csharp
StreamReader reader=new(Console.OpenStandardInput());
StreamWriter writer=new(Console.OpenStandardOutput());

//입력
string input = reader.ReadLine();
//출력
writer.WriteLine("Hello world!");

//버퍼 비우기
writer.Flush();