readonly

변수 앞에 위치하면 해당 변수는 읽기 전용이 되어 해당 변수가 정의된 클래스나 구조체, 메서드 등에서만 수정이 가능하며 readonly로 선언된 변수는 선언할 때 또는 생성자에서 값을 할당해야한다.

 

public class MyClass
{	
	readonly int myReadOnlyInt;
    public MyClass(int value)
    {
    	myReadonlyInt = value;
    }
}

위 코드에서 myReadOnlyInt는 읽기 전용으로 선언되었기 때문에 생성자에서 값을 할당한 이후에는 변경이 불가능하다.

 

상수를 선언한다는 점에서 const와 비슷한데 둘의 차이를 비교할 필요가 있다.

 

const vs readonly

초기화 방법

const와 readonly는 초기화 방법에서부터 차이가 있다.

// 반드시 선언과 동시에 초기화 필요
const int constNum = 10;

// 선언에서 뿐만 아니라 생성자에서 값을 할당해서 초기화 할 수 있다.
readonly int readonlyNum_1 = 10;
readonly int readonlyNum_2;
public MyClass(int value)
{
	readonlyNum_2 = value;
}

 

사용 범위

const는 클래스 멤버 또는 데이터 형식 멤버로 선언할 수 있지만 클래스 멤버 중에서도 인스턴스 멤버는 const 키워드를 사용할 수 없다. 즉 인스턴스 변수, 인스턴스 메서드 등에서는 const 키워드 사용이 불가능하다.

public class MyClass
{
    public const int number = 10;
    public void Test()
    {
        int test = number;
    }
}

public static class MyStaticClass
{
    public const int number = 20;
    public static void Test()
    {
        int test = number;
    }
}

public class OtherClass()
{
    public void TestMethod()
    {
        MyClass instance = new MyClass();
        // 접근 불가능함
        int test1 = instance.number;
        
		// static 클래스 인스턴스화 안됨
        //MyStaticClass staticInstance = new MyStaticClass();
        // 직접 호출가능
        int test2 = MyStaticClass.number;
    }
}

 

실행시간

const는 컴파일 시간에 값이 결정되기 때문에 런타임 성능이 상대적으로 좋다.

readonly는 런타임에 값을 할당할 수 있기 때문에 const보다는 조금 더 느릴 수 있다. 

그렇기 때문에 런타임에 값을 결정해야할 경우에만 readonly를 사용하고 그 이외에는 const를 사용하는게 낫다.

 

public class MyClass
{
    public const int number = DateTime.Now.Year; // 컴파일 에러 발생
    public readonly int year = DateTime.Now.Year; // 실행 시간에 값이 결정됩니다.
}

 

const와 readonly의 가장 큰 차이점은 값이 결정되는 시점이다.

const는 컴파일 타임 readonly는 런타임

 

따라서 애초에 고정된 값이라면 const를 사용하지만 인스턴스가 생성될 때 값을 할당하고 그 이후에 변경되지 않도록하려면 readonly를 사용하면된다.

728x90
반응형

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 키워드를 사용하면 코드를 작은 단위로 분할하여 작성할 수 있기 때문에 코드 가독성도 좋아지고 유지보수도 편리해진다. 

728x90
반응형

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" 출력

 

 

728x90
반응형

Visual Studio 2022

 

class 생성

멤버변수 int 하나

public class Test
{
	int data_1;
}

public static void Main(string[] args)
{
	Test test = new Test();
}

C# Class Size Test (Field int 1)

int 하나인데 크기가 24 바이트이다.

int = 4byte 인데 왜 6배나 되는걸까?

=>6개 이상일 때 크기 확인 해보기로함

public class Test
{
	public int data_1;
	public int data_2;
	public int data_3;
	public int data_4;
	public int data_5;
	public int data_6;
}

일단 int 6개로 테스트, 기대 결과는 그대로 24byte

C# Class Size Test (Field int 6)

이게 무슨일이지, 40 byte 가 나옴

처음 결과를 기준으로 생각해보면 24 + 16 즉 16 byre가 추가됨.

4(int) * 4(count) 라고 생각해보고 다시 필드를 int * 3으로 테스트

 

public class Test
{
    public int data_1;
    public int data_2;
    //public int data_3;
    //public int data_4;
    //public int data_5;
    //public int data_6;
}

예상한대로면 처음 결과인 24가 나와야함

C# Class Size Test (Field int 2)

결과는 기대한대로 나왔지만 여전히 24라는 크기가 이해가 안감,

혹시나해서 클래스를 인스턴스화 안했을때 한번 확인해봤지만 당연하게 해당 메모리 안잡힘

 

이번엔 하나씩 필드 늘려가면서 확인해보기로함

C# Class Size Test (Field int 3)

int * 4 일때는 동일하게 32

C# Class Size Test (Field int 5)

int * 5 부터 40 으로 잡혔음

 

그럼 그냥 빈 클래스는 얼마로 잡히나 확인했는데

애초에 비어있는 클래스를 인스턴스하면 24 byte 할당됨

여기서 2개씩 int 추가될 때마다 8 byte가 늘어나는데 이 늘어나는 값은 4(int) * 2(count) 맞음

 

비어있는 클래스가 왜 24 byte의 힙을 차지하는지 파악해보면될듯함

일단 Program 외부에 Test_2 클래스, 내부에는 Test_1 선언 후 비교

public class Test_2 { }
public class Program
{
    public class Test_1 { }
    public static void Main(string[] args)
    {
        Test_1 test_1 = new Test_1();
        Test_2 test_2 = new Test_2();
    }
}

C# Class Size Test_1 / Test_2 (empty)

테스트 해본 결과 클래스를 할당하면 기본 크기가 24로 잡히고 이 안에 8byte 까지는 포함시킬 수 있는걸로 보인다.

즉 기본 24 = 16(사용됨) + 8(여유 공간) 이고 크기가 24 byte를 넘을 경우 8byte 단위로 확장되는걸로 파악됨

 

구글링 해본 결과 내가 원하는 정보를 찾을 수 있었다.

 

OF MEMORY AND STRING_Jon Sket

 

본래 글의 취지는 .Net에서 ASCII 문자열의 효율적인 표현에 관한것에 대한 답이다.

위 글에서는 x86과 x64를 모두 비교하고 있는데 이 글에서는 x64를 기준으로 정리한다.

 

그럼 이제 왜 0byte는 될수없는지 그리고 24byte 중 사용할 수 없는 16byte와 사용 가능한 8byte는 무엇 때문인지 정리한다.

 

우선 C#에서 모든 타입은 object 타입을 베이스로한다. 그리고 이 object 타입의 크기는 24byte이다.

이 24byte의 크기는 16byte의 오버헤드와 참조를 위한 8byte로 이루어진다. 

 

오버헤드란 처리를 하기 위해 들어가는 간접적인 처리 시간, 메모리 등을 말한다. 즉 C#의 object를 메모리에 유지시키는데 필요한 메모리 양이 16byte이며 .Net의 CLR은 데이터가 없는 object에서 작업할 수 없기 때문에 오버헤드만 가지고는 object를 사용할 수 없고 여유 공간이 필요하며 이 크기가 8byte이다. 따라서 선언될 수 있는 가장 작은 크기의 메모리는 24byte가 된다.

 

이 중 여유공간인 8byte는 실제 데이터를 저장할 수 있기 때문에 int가 2개 포함된 class역시 24byte였다. 이 8byte는 전체를 사용할 수 있는 공간이기 때문에 1byte로 8를 사용하는것도 가능하다. 그리고 int가 3개가 될때 24byte에서 8byte로 증가했는데 이것은 메모리의 경계인 패딩의 크기가 8byte였기 때문이다. 

 

class 역시 object 타입을 베이스로 하고 있고 빈 class를 인스턴스화 하는것은 object를 생성하는것과 마찬가지이기 때문에 빈 class가 24byte라는것도 이제 납득이 간다. 

 

오버헤드에 대한 내용

overhead - Andrew Hunter
overhead - Stack Overflow

 

왜 이렇게 많은 공간이 필요한지 또 이 공간은 어떤식으로 사용되는지 궁금한데 이 부분은 더 자세히 찾아봐야 될것같다.

 

정리

64bit 기준으로 

1. 비어있는 class 또한 하나의 object이다. 따라서 24byte 메모리를 차지한다.

2. 이 메모리는 16byte의 내부 데이터 참조형으로 사용되는 오버헤드와 8byte의 여유공간으로 구성된다.

3. 여유공간은 모두 사용이 가능하며 메모리는 8byte의 패딩을 가지고 있다.

 

728x90
반응형

'Memo' 카테고리의 다른 글

다국어를 제공하는 방법에 대해서  (0) 2023.05.10

Interoperability(Interop)

상호운용성

unmanaged code에 대한 기존 투자를 보존하고 활용할 수 있게 한다.

즉 CLR을 사용하지 않는 어셈블리를 CLR에서 사용할 수 있게 만드는 것이다.

interop은 managed와 unmanaged를 오고가는 메모리 비용과 코드 작성 비용 때문에 최소화하는게 좋다.

 

COM Interop

Component Object Model(COM) 을 사용하면 개체의 기능을 다른 컴포넌트와 윈도우 플랫폼의 호스트 프로그램에 사용할 수 있다. 사용자가 기존 코드 베이스와 상호 운용할 수 있도록 .Net 프레임워크에서 COM라이브러리를 통해 interop을 지원한다.

 

Platform Invoke(P/Invoke)

P/Invoke는 사용자의 managed code에서 unmanaged 라이브러리의 구조, 콜백 그리고 기능에 접근할 수 있도록 한다. 대부분 P/Invoke API는 SystemSystem.Runtime.InteropServices 두 개의 네임스페이스를 포함한다.

이 두개의 네임스페이스를 사용하면 네이티브 컴포넌트를 사용할 수 있는 도구가 제공된다.

using System;
using System.Runtime.InteropServices;

public class Program
{
	// Import dll (containing the funtion)
    [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)
    // Define
    private static extern int MessageBox(IntPtr hWnd, string IpText, string IpCaption, uint uType);
    
    public static void Main(string[] args)
    {
    	// Invoke the function as a regular managed method
        MessageBox(IntPtr.Zero, "Command-line message box", "Attention!", 0);
    }
}
  1. Attribute
    • [DllImport] attribute은 런타임에 unmanaged DLL을 로드할것을 알린다.
    • "user32.dll" 문자열은 사용할 기능이 포함된 DLL을 대상으로 한다.
    • CharSet = CharSet.Unicode 문자열을 Mashalling하는데 사용할 문자 집합을 지정한다.
    • SetLastError = true 런타임에서 오류가 발생했을때 사용자가 Mashal.GetLastWin32Error()를 통해서 에러코드를 감지할 수 있게한다.
  2. Declare
    • 메서드 선언시 메서드명은 사용할 unmanaged code와 동일한 이름으로 작성한다.
    • 이때 extern 키워드를 통해서 해당 메서드가 외부의 메서드임을 런타임에 알린다.
    • 런타임은 외부 메서드라는것을 알게되면 해당 managed 메서드를 호출할 때 attribute의 설정을 통해 특정된 DLL을 찾아서 실행시킨다.
  3. Main method
    • managed code 즉 현재 작업중인 코드에서 extern으로 선언한 메서드를 호출하여 외부 메서드를 사용한다. 

 

Managed C++(C++/CLI)

Managed Extensions for C++ 또는 Managed C++은 문법적 그리고 구문적 확장, 키워드와 속성을 포함하고 C++의 구문 및 언어를 가져오는 .Net Framework의 C++ 언어 확장 집합이다. 이 확장자는 managed code상에서 C++ 코드가 CLR의 대상이 될 수 있도록 그리고 지속적으로 native code와 상호 운용될 수 있게하려고 마이크로소프트에서 만들었다.

 

2004년 Managed C++은 구문을 명확하고 단순화하고 managed generics을 포함하도록 기능을 크게 개선시켰다. 이렇게 새로운 확장자는 C++/CLI로 지정되었고 Visual Studio 2005 이후에 포함되면서 Managed C++을 대체하였다.

 

SWIG

Simplefied Wrapper and Interface Generator

C 또는 C++로 작성된 컴퓨터 프로그램이나 라이브러리 다른 프로그래밍 언어에서 사용할 수 있도록 연결하는데 사용하는 오픈소스 도구이다. 

주목적은 네이티브 함수의 호출, 복잡한 자료형을 함수에 전달, 메모리 부적절하게 해제하지 못하게 방지, 언어 간에 오브젝트 클래스를 상속할 수 있게 하는것이다.

728x90
반응형

Managed code

.Net Framwork에서 CLR(Common Language Runtime)의 제어하에서 실행되는 코드를 말한다.

이 코드는 Visual Basic.Net이나 C#과 같은 .Net Framework를 지원하는 언어의 컴파일러를 통해서 만들어지는 코드로 컴파일러에 의해 IL(Intermediate Language)이라는 중간 언어로 생성된다. IL은 컴퓨터에서 바로 실행할 수 있는 기계 언어가 아니며 사용자가 생성한 코드의 클래스, 메서드, 속성 등을 나타내는 메타데이터와 함께 어셈블리라는 파일로 저장된다.

 

CLR은 이러한 어셈블리를 실행할 때 코드의 보안, 메모리 관리, 스레딩같은 관리를 담당하는 다양한 서비스를 제공하며 실행 시점에 필요한 코드는 JIT 컴파일로 컴퓨터의 환경에 맞는 기계어로 변환되어 실행된다. 이런 특징 때문에 CLR은 Managed Program이라고도 불리며  Managed Code를 사용하기 때문에 이러한 동작이 가능하다.

 

unmanaged code

CLR 외부에서 실행되는 코드

unmanaged code는 Visaul Studio.Net 2002가 나오기 전에 만든 코드를 말한다. 즉 Visual Basic 6, Visual C++6 과 같은 컴파일러는 unmanaged code를 생성한다. 이 컴파일러들은 managed code처럼 IL 생성과정없이 컴파일이 수행되는 해당 컴퓨터에 적합한 기계 코드를 생성해 낸다. 이렇게 생성된 기계 언어는 동일한 구성의 다른 컴퓨터에서 실행될 수 있을지도 모르지만 다른 구성의 컴퓨터의 경우 실행이 불가능하다. 또한 이렇게 생성된 unmanaged code는 보안 및 메모리 관리 서비스를 실행시에 Runtime으로부터 받을 수가 없고 대신에 COM call의 서비스를 통해 받을 수 있다.

 

정리하자면 managed code의 경우 runtime이 알아서 메모리 관리를 해주는데 반해 unmanaged code의 경우, 사용자가 관리해야하지만 COM과 같은 라이브러리의 경우 스스로 능동적으로 메모리 관리할 수 있다.

 

native code

native code는 unmanaged code와 동일한 의미로 사용된다. 옛날 버전의 컴파일러로 컴파일 되었거나 선택적으로 해당 컴퓨터에 적합하게 생성된 기계 언어를 말하며 실행시 CLR에 의한 서비스를 받을 수 없는 것을 말한다. 이러한 native code는 하나의 완전한 프로그램이거나 COM 컴포넌트 또는 managed code에서 호출된 DLL일 수도 있다. 

 

또 다른 의미로는 JIT 컴파일로부터 생성된 코드를 말한다. JIT은 managed code에만 사용되며 이는 managed code이지만 IL코드가 아니며 해당 컴퓨터에 적합한 기계언어이다. 따라서 native가 무조건 unmanaged는 아니다.

 

 

 

728x90
반응형

'Program Language > C#' 카테고리의 다른 글

C# 인스턴스 생성 키워드 : new  (0) 2023.03.30
Interoperability  (0) 2023.02.02
C# 외부 코드 사용 키워드 : extern  (1) 2023.01.31
C# 키워드 : delegate, event, action  (0) 2023.01.31
C# 상수 키워드 : const  (0) 2023.01.31

extern

'외부의'라는 뜻을 가지는 External의 약자로 외부에 선언된 함수 또는 객체임을 명시하는 역할을 한다.

이때 외부란 C# 코드 이외의 언어로 작성된 코드를 뜻하며 DLL이나 C/C++ 등으로 작성된 함수를 말한다.

이런 외부에서 작성된 코드 즉, C# 및. Net 프레임 워크에서 사용되지 않는 코드 다시 말해서 CLR에서 관리되지 않는 코드를 unmanaged code라고 하는데 이러한 unmanaged code를 불러오기 위해서는 interop 기술이 필요하다.

 

Interop 정리글

 

간략하게 Interop은 다른 언어나 플랫폼에서 작성된 코드를 호출하거나 받는 기술로 COM, P/Invoke, C++/CLI 등이 대표적으로 있는데 extern 키워드는 이러한 함수나 객체가 외부의 것임을 나타내는 역할을 한다.

 

일반적으로 C#에서 많이 사용하는 P/Invoke 방식은 DllImport arttribute와 함께 사용한다.

이 경우 메서드는 반드시 static으로 선언되어야 한다.

// Microsoft AVI File support library
[DllImport("avifil32.dll")] // Interop, P/Invoke
private static extern void AVIFileInit();

 

extern alias

.Net 어셈블리에서 다른 버전의 동일한 어셈블리의 참조가 필요한 경우에 사용할 수 있다.

일반적으로 .Net 프로젝트에서 어셈블리의 참조는 using이나 Imports를 사용하여 참조하는데 만약 서로 다른 버전의 어셈블리를 참조하는 경우에는 컴파일러가 어떤 버전을 사용해야 하는지 구분이 필요하기 때문에 이런 경우 extern alias 키워드를 사용한다.

 

동일한 어셈블리를 버전별로 참조하기 위해서는 각각의 어셈블리를 특정시킬 수 있도록 만드는 작업이 필요하다.

특정시키는 방법으로는 각 어셈블리의 별칭을 지정하는 방법과 이름을 변경하는 방법이 있다.

 

Alias

어셈블리의 별칭을 지정하는 방법은 대표적으로 두 가지 방법이 있다.

 

1. Visual Studio 

비주얼 스튜디오의 솔루션 탐색기에서 별칭을 수정할 수 있다.

Assembly > 우클릭 속성 > Aliases 수정

2. 프롬프트 창

프롬프트에서 어셈블리에 별칭을 부여할 수 있다.

/r:GridV1=grid.dll
/r:GridV2=grid20.dll

 

각각의 어셈블리에 외부에서 사용할 별칭 GridV1과 GridV2가 지정된다.

 

이렇게 별칭을 지정해 주면 extern 키워드를 사용하여 별칭을 참조하면 동일한 어셈블리를 구분해서 참조가 가능해진다.

extern alias GridV1;
extern alias GridV2;
// can using namespace
using Class1V1 = GridV1::Namespace.Class1;
using Class1V2 = GridV2::Namespace.Class1;

 

Name

별칭을 지정하지 않고 이름을 변경하는 방법으로도 참조가 가능하다.

비주얼 스튜디오에서 별칭을 수정했던 설정창을 다시 켜보면 상단에 이름 속성을 확인할 수 있다.

이름을 사용하기 위해서는 별칭이 지정되지 않아야 하므로 별칭을 지우고 이름을 수정한다.

 

그 후에 C#에서 Type.GetType 메서드를 사용하면 어셈블리에서 Type을 가져올 수 있는데 이때 어셈블리의 전체 이름을 사용하여 Type을 가져오면 해당 어셈블리를 특정해서 참조할 수 있게 된다.

Type myType = Type.GetType("MyNamespace.MyType, MyAssembly");

 

728x90
반응형

'Program Language > C#' 카테고리의 다른 글

Interoperability  (0) 2023.02.02
Managed, Unmanaged, Native Code  (0) 2023.02.02
C# 키워드 : delegate, event, action  (0) 2023.01.31
C# 상수 키워드 : const  (0) 2023.01.31
C# 비동기화 키워드 : async, await  (0) 2023.01.31

const

상수라는 뜻을가지는 Constant에서 따온 키워드이다.

상수란 프로그래밍에서 변하지 않는 값을 의미하는데 한번 값이 정해지면 프로그램이 실행되는 동안 그 값은  항상 일정하다. 컴파일 타임에 값이 결정되므로 런타임 시 메모리를 사용하지 않게 되어 상수를 사용하면 메모리 사용을 줄일 수 있다.

 

public class Program
{
	public static void Main(string[] args)
    {
    	const int A = 10;
        A = 10; // Compiler Error CS0131
    }
}

 

const 키워드로 선언된 변수는 상수로 취급되기 때문에 값을 재할당하면 컴파일 에러가 뜬다. 따라서 상수는 코드 흐름에서도 바뀔 필요가 없고 일정하게 사용될 값이 필요할 때 사용한다.

 

literal const

리터럴 상수 또한 상수와 마찬가지로 변하지 않는 값을 표현할 때 사 용는데 두 개념에는 약간의 차이가 있다.

상수는 const 예약어를 사용해서 변수형태로 선언되고 컴파일 시간에 값이 결정되어 프로그램 중에 값이 변경되지 않는 것이라면 리터럴 상수는 컴파일러가 코드에서 직접 사용할 수 있는 값을 의미한다. 예를 들어서 0, 1, 2, 3 등이 모두 정수형 리터럴 상수로 변수나 상수가 아니면서 프로그램 실행 중에도 변경할 수 없는 값이다.

 

// 상수 PI
const double PI = 3.14159265358979;
// 숫자 리터럴 상수
double radius = 3.0;
// 문자 리터럴 상수
char c = 'C';
// 문자열 리터럴 상수
string str = "Str";

리터럴 상수에는 숫자뿐만 아니라 문자 또한 포함된다.

즉 코드 상에서 선언되지 않았으면서 변수에 할당이 가능한 모든 값을 리터럴 상수라고 할 수 있다.

728x90
반응형

'Program Language > C#' 카테고리의 다른 글

C# 외부 코드 사용 키워드 : extern  (1) 2023.01.31
C# 키워드 : delegate, event, action  (0) 2023.01.31
C# 비동기화 키워드 : async, await  (0) 2023.01.31
C# 클래스 추상화 키워드 : abstract  (0) 2023.01.25
Main method  (0) 2023.01.19

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

 

C#의 비동기 프로그래밍

async, await 및 Task를 사용하여 비동기 프로그래밍을 지원하는 C# 언어에 대해 간략히 설명합니다.

learn.microsoft.com

 

 

728x90
반응형

'Program Language > C#' 카테고리의 다른 글

C# 키워드 : delegate, event, action  (0) 2023.01.31
C# 상수 키워드 : const  (0) 2023.01.31
C# 클래스 추상화 키워드 : abstract  (0) 2023.01.25
Main method  (0) 2023.01.19
테스트 환경  (0) 2023.01.17

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

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

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

728x90
반응형

'Program Language > C#' 카테고리의 다른 글

C# 상수 키워드 : const  (0) 2023.01.31
C# 비동기화 키워드 : async, await  (0) 2023.01.31
Main method  (0) 2023.01.19
테스트 환경  (0) 2023.01.17
.Net Framework  (0) 2023.01.17

+ Recent posts