기록

Partial

클래스, 구조체, 인터페이스 등의 선언에 사용된다.

partial 제한자로 선언된 클래스, 구조체, 인터페이스 등은 여러 파일에 나누어 작성할 수 있다.

public class Person
{
	public string FirstName { get; set; }
    public string LastName { get; set; }
    
    public void SayHello()
    {
    	Console.WriteLine($"Hello, my name is {FirstName} {LastName}.");
    }
}

Person이라는 클래스가 하나의 파일에 선언되고 작성되어 있다. 이 클래스를 여러 파일로 나누어 선언하기 위해 partial 키워드를 사용하면 다음과 같이 사용할 수 있다.

// Person.cs
public partial class Person
{
	public string FirstName { get; set; }
    public string LastName { get; set; }
}

// Person_SayHello.cs
public partial class Person
{
	public void SayHello()
    {
    	Console.WriteLine($"Hello, my name is {FirstName} {LastName}.");
    }
}

Person.cs 파일과 Person_SayHello.cs 파일은 같은 네임스페이스 안에 있으며 partial 키워드를 사용해 클래스를 선언하였기 때문에 다른 파일에서 Person 클래스를 동일하게 partial 키워드를 사용해 선언하면 이 클래스는 하나의 클래스로 인식된다. partial로 선언된 클래스는 컴파일 시점에 자동으로 하나의 클래스로 합쳐지기 때문에 별도의 참조가 필요하지 않다.

이러한 기능은 특히 협업에서 용이하게 사용이 가능하다.

큰 규모의 코드를 개발하기 위해서 여러 개발자가 협업을 하게 된다면 동시에 하나의 클래스나 구조체를 작성하는 상황이 있다. 이런 상황에서 partial 키워드를 사용하여 하나의 클래스를 여러 파일에 나누어 각자 작성할 수 있고 이렇게 하면 동시에 작성을 각자가 코드를 작성하더라도 서로 영향을 주지 않고 작업을 진행할 수 있다.

양이 많은 코드의 경우 하나의 파일에 모두 작성하게 되면 보기나 수정이 힘들어진다. 이때 partial 키워드를 사용하면 코드를 작은 단위로 분할하여 작성할 수 있기 때문에 코드 가독성도 좋아지고 유지보수도 편리해진다. 

new

Instance

객체를 생성할때 사용한다.

C#에서는 내장 클래스인 string, int, double 등을 포함한 모든 클래스 object를 상속받기 때문에  new 키워드를 사용해서 객체를 생성할 수 있다. 

int n = new int();
string s = new string();
MyStruct structInstance = new MyStruct();
MyClass classInstance = new MyClass();

하지만 내장 클래스들은 구조체로 정의되어 있기 때문에 구조체 변수를 생성할 때 new를 사용하지 않고 객체를 바로 생성할 수 있다.

int n = 0;
float f = 1.0f;

string의 경우 .Net에서 특별히 내부적으로 string literal로 정의되어 있는데 때문에 일반적인 참조 타입과는 다르게 직접 변수를 할당하여 객체가 생성이 가능하다.  

* string literal : 문자열 상수는 소스 코드 상에 고정된 문자열 값이다.

Inherit

new 키워드는 상속과 관련해서도 사용이된다.

상속 관계에 있는 클래스에서 메서드, 프로퍼티, 이벤트 등의 멤버를 재정의할 때 사용되는데 일반적으로 멤버의 재정의에는 override 키워드를 사용하지만 new키워드를 통해서도 멤버의 재정의가 가능하다.

class BaseClass
{
	public void Print()
    {
    	Console.WriteLine("Base class");
    }
}

class DerivedClass : BaseClass
{
	public new void Print()
    {
    	Console.WriteLine("Derived class");
    }
}

여기서 new 키워드를 사용하여 재정의된 메서드는 부모 클래스에서 정의된 멤버와 자식 클래스에서 정의된 멤버가 모두 유지되는데 이는 덮어쓰는 override와 다르게 두 개의 멤버가 서로 다른 것으로 재정의된 메서드는 부모 클래스의 멤버와는 관계가 없는 새로운 멤버로 취급된다.

DerivedClass obj = new DerivedClass();
obj.Print();
// "Derived class" 출력

BaseClass obj = new DerivedClass();
obj.Print();
// "Base class" 출력

async

메서드, 람다 표현식 또는 무명 메서드를 비동기로 특정할 수 있다.

메서드나 표현식에 async 제한자가 붙으면 비동기식 메서드라고 한다.

public async Task<T> ExampleMethodAsync()
{
	string contents = await NetworkManager.GetData(url);
}

async만 사용한다고 메서드가 비동기로 작동하는 것은 아니며 첫 번째 await 표현식을 만날 때까지 동기적으로 실행된다. 

await의 동작이 완료될 때까지 메서드는 대기하게 되고 메서드 호출자는 다음 동작을 진행하게 된다.

async 키워드로 선언된 비동기 메서드가 await 표현식이나 구문이 포함되어있지 않으면 컴파일러는 경고를 띄우게 된다.

비동기 메서드의 반환형은 Task <T>, Task(void) 형태로 정의되고 return T와 같이 해당 타입만 반환한다.

컴파일러는 return T을 자동으로 Task <T>로 변환한다. 특히 async 메서드는 이벤트핸들러를 위해 void의 반환을 허용하고 있다.

awiat은 일반적으로 Task 또는 Task <T> 객체와 함께 사용되는데 Task 이외에 awaitable 클래스도 함께 사용할 수 있다.

* awaitable : GetAwaiter() 메서드를 갖는 클래스

About sync and async

Example

    class Program
    {
        public static void Main(string[] args)
        {
            TaskTest(10);
            Console.WriteLine("============Call Main============");

            Console.ReadLine();
        }
        private static async void TaskTest(int count)
        {
            Console.WriteLine("============Call Task1============");

            for (int i = 0; i < count; i++)
            {
                var message = String.Format("Count {0}", i);
                Console.WriteLine(message);
                await Task.Delay(1000);
            }

            Console.WriteLine("============End Task1============");
        }
    }

Main 함수가 실행되면서 TaskTest를 호출한다.

그리고 곧이어 비동기적으로 Main 함수의 다음 코드가 실행되면서 TaskTest의 다음 동작이 진행된다.

 메인함수 또한 비동기로 정의하여 사용할 수 있다.

    class Program
    {
        public static async Task Main(string[] args)
        {
            await TaskTest(10);
        }
        private static async Task TaskTest(int count)
        {
            Console.WriteLine("============Call Task1============");

            for (int i = 0; i < count; i++)
            {
                var message = String.Format("Count {0}", i);
                Console.WriteLine(message);
                await Task.Delay(1000);
            }

            Console.WriteLine("============End Task1============");
        }
    }

메인함수는 await 기준으로 비동기적으로 작업이 처리된다.

요약

async 메서드 내부에서 await을 만날게 되면 다음과 같은 경우의 수 가 있다.

1. awaitable이 예외를 발생시킨다면 await은 throw exception 한다.

2. awaitable이 이미 종료됐다면 메서드는 일반 메서드와 같이 동기적으로 실행된다.

3. awaitable이 종료된 상태가 아니라면 종료될 때 await 다음 코드가 실행되도록 대기 큐에 등록하고 async 메서드의 호출자에게 Task를 반환한다.

microsoft document 비동기 프로그래밍 예제

https://learn.microsoft.com/ko-kr/dotnet/csharp/programming-guide/concepts/async/#final-version

abstract

추상적인

구현이 완전하지 않은 상태임을 타나내는 키워드이다.

클래스, 메서드, 프로퍼티, 인덱서, 이벤트와 함게 사용될 수 있다. 

일반적으로 추상 클래스를 구현하는데 사용되며 자체적으로는 인스턴스화 되지 않고 파생된 비추상 클래스에 의해 구현되어 사용된다. 

    abstract class Person
    {
        public abstract int GetInfo();
    }

    class Joon : Person
    {
        private int m_age;
        public Joon(int age) => m_age = age;
        public override int GetInfo() => m_age;
    }

    public class Program
    {
        static void Main(string[] args)
        {
            // Error, cannot create an instance of the abstract type.
            Person person = new Person(); 

            Joon joon = new Joon(30);
            Console.WriteLine(joon.GetInfo());
        }
    }

Feature

- 추상 클래스는 인스턴스화할수없다.

- 추상 클래스는 추상 메서드와 접근자를 포함할 수 있다.

- abstract 제한자는 sealed 제한자와 반대의미이므로 같이 사용할 수 없다.

  (abstract : 상속을 필요로하는 제한자, sealed : 상속을 방지하기위한 제한자)

- 추상 클래스로부터 파생된 클래스는 반드시 추상 메서드와 접근자의 구현이 필요하다.

메서드와 프로퍼티의 선언에서 abstract 제한자의 사용은 구현을 포함하지 않는것을 나타낸다.

- 추상 메서드는 암묵적으로 가상 메서드이다.

- 추상 메서드는 오직 추상 클래스 내에서만 선언이 허용된다.

- 추상 메서드는 구현이 없어야하므로 선언시 중괄호가 필요하지 않다.

Derived abstract class

추상 클래스를 파생 클래스로 만들어 특정 가상 메서드의 상속하여 추상 메서드로 가상 메서드를 재정의할 수 있다.

    public class BaseClass
    {
        public virtual void VirtualMethod(int i) { }
    }

    public abstract class AbstractClass : BaseClass
    {
        public abstract override void VirtualMethod(int i);
    }

	//DerivedClass.ViertualMethod는 BaseClass.VirtualMethod에 접근할 수 없다.
    public class DerivedClass : AbstractClass
    {
        public override void VirtualMethod(int i)
        {
            throw new NotImplementedException();
        }
    }

추상 클래스로부터 파생된 클래스는 메서드의 원래 구현에 접근할 수 없다. 

이러한 방식으로 추상 클래스는 파생 클래스로부터 가상 메서드의 구현을 강제할 수 있다.