기록

volatile

변수의 값을 캐시에 저장하지 않고 항상 메모리에서 값을 읽어오도록 한다.

멀티 스레딩 환경에서 여러 스레드가 동시에 하나의 변수에 접근할 때 캐시에 저장된 값과 메모리의 실제 값이 일치하지 않아서 오류가 발생할 수 있다.

int counter = 0;

void IncrementCounter()
{
    for (int i = 0; i < 100000; i++)
    {
        counter++;
    }
}

void DecrementCounter()
{
    for (int i = 0; i < 100000; i++)
    {
        counter--;
    }
}

void Main()
{
    Thread t1 = new Thread(IncrementCounter);
    Thread t2 = new Thread(DecrementCounter);

    t1.Start();
    t2.Start();

    t1.Join();
    t2.Join();

    Console.WriteLine("Counter value: " + counter);
}

위 코드에서 counter변수에 서로 다른 스레드에서 거의 동시에 접근하여 값을 변경하고 있다.

이때 counter는 항상 0이 아니며 일정하지 않은 값들로 출력된다.

이러한 상황에서 volatile 키워드로 변수를 선언하면 항상 일정한 값이 들어오게 된다.

int volatile counter = 0;

unsafe

뜻 그대로 안전하지 않은 코드를 명시할 때 사용하는 키워드이다.

C#에서 모든 메모리 영역은 가비지 컬렉터에 의해서 관리되는데 관리를 벗어난 영역에 작업을 수행하기 위해서 사용한다.

따라서 C#에서 관리하는 기능을 사용하지 않고 직접 관리하는 코드를 사용하겠다는 것을 명시하여 해당 코드를 GC관리로부터 벗어나도록 할 수 있기 때문에 더 자유롭게 메모리 컨트롤이 가능하게 된다. 자유로워진 만큼 메모리 할당과 해제를 모두 직접 구현해야 하며 해당 문제로 에러가 발생하면 메모리 누수, 버퍼 오버플로, 세그먼트 폴트 등 치명적인 결함이 발생하게 된다.

발생하는 문제가 치명적인만큼 이를 다루기 위해서 unsafe 키워드를 통해서 반드시 명시된 경우에만 제어권을 얻게 한다. 

기본적으로 unsafe를 사용하게 되면 c# 내부에서는 문제로 인식하고 콘솔에 경고를 보내게 된다.

사용처

사용할일이 거의 없는 키워드로 사용하는 상황도 일반적이지 않다.

포인터 사용

C#에서는 포인터 사용을 허용하지 않기 때문에 unsafe를 통해서만 직접 사용이 가능하도록 한다.

빠른 코드 실행

외부 알고리즘의 경우 빠른 코드 실행이 필요하기도 하는데 이럴 때 unsafe코드를 사용하면 성능을 향상할 수 있다.

외부 라이브러리와 상호 작용

일부 외부 라이브러리는 C#의 안전한 기능을 사용할 수 없기도 한데 이때 unsafe코드를 사용하여 외부와 상호 작용이 가능하도록 할 수 있다.

클래스 멤버를 정의할 때 사용된다.

static으로 정의된 멤버는 객체 인스턴스에 속하는 것이 아닌 클래스 자체에 속하게 된다.

즉, 객체가 인스턴스화되기 전에도 해당 멤버에 접근이 가능한데 클래스 자체에 속하기 때문에 클래스 이름을 통해서 직접 호출이 가능하다.

class MyClass
{
	public static int myStaticVariable;
    public static void myStaticMethod(){}
}

class OtherClass
{
	public void SomeFunc()
    {
    	MyClass.myStaticVariable = 10;
    	MyClass.mySaticMethod();
    }
}

static 멤버는 모든 인스턴스에 공유되기 때문에 한 객체에서 static 멤버에 대한 수정이 있는 경우 다른 객체에서도 동일한 값을 가지게 된다. 따라서 static 멤버는 클래스의 인스턴스와 관련이 없는 작업을 수행할 때 사용되며 일반적으로 유틸리티 클래스의 메서드나 상수 특정 클래스에서 공통으로 사용하는 변수 등을 정의할 때 static 키워드가 사용된다.

주의할 점은 모든 객체에서 공유되므로 서로 다른 스레드에서 동시에 static 멤버를 수정하는 상황이 발생할 수 있는 즉, thread-safe 하지 않기 때문에 멀티스레드 환경에서는 문제가 발생할 수 있다.

이러한 특징 때문에 static을 사용할 때는 몇가지 당연한 규칙이 있다.

우선 static 클래스의 모든 멤버는 static으로 선언되어야 한다.

클래스가 static이라는 것은 별도의 인스턴스를 생성하지 않아도 해당 클래스를 어디서든 사용이 가능하고 항시 메모리에 올라가 있는 상태라는 뜻이므로 인스턴스가 생성될 때 변수 할당이 이루어지는 일반 변수의 선언은 허용되지 않게 된다.

public static class MyStaticClass
{
	// 불가능
    public int number_1;
    // 가능
    public static int number_2;
    static int number_3;
}

하지만 반대로 static 클래스가 아니어도 내부의 멤버가 static으로 선언되는 것은 가능하다. 

public class MyClass
{
	public static int MyStaticVar = 0;
    public int MyVar = 0;
}

정리

static은 처음 선언된 이후 메모리에 상주하기 때문에 언제든 접근 가능하다.

따라서 빈번하게 사용되는 공통적인 변수의 경우 정적으로 선언해서 사용하는 것이 좋을 수 있지만 너무 많은 static을 사용하게 되면 그만큼 상주하는 메모리가 많아지는 것이기 때문에 적절한 사용이 필요하다.

sealed

클래스나 메서드를 상속하지 못하도록 하여 오버라이딩을 방지한다.

sealed로 선언된 클래스는 다른 클래스에서 상속받을 수 없으며 메서드의 경우 해당 클래스에서만 사용이 가능하다.

sealed 클래스 선언

sealed class MyClass
{
	//
}

이 클래스는 다른 클래스에서 상속받을 수 없으며 이 클래스를 파생 클래스로도 사용할 수 없다.

 sealed 메서드 선언

class MyBaseClass
{
	public virtual void MyMethod() {}
}

class MyDerivedClass : MyBaseClass
{
	public sealed override void MyMethod() {}
}

MyMethod 함수는 MyDerivedClass에서 오버라이딩되고 이후 sealed로 선언된다. 따라서 MyDerivedClass를 상속하는 다른 파생 클래스에서 MyMethod를 오버라이딩할 수 없게 된다.

일반적으로 클래스를 마지막으로 봉할 때 사용하는 키워드로 최종적인 구현을 제공하는 클래스에서 사용된다.

파생되어 추가되는 내용이 필요하지 않게 하거나 해당 기능을 변경하거나 확장하려는 경우를 방지해 클래스의 안정성을 보장한다.

예를 들어 C#의 String 클래스의 경우 sealed로 선언되어 있어 개발자가 해당 클래스를 상속하거나 수정할 수 없도록 만들어 클래스의 안정성을 보장하도록 한다.

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를 사용하면된다.

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

virtual

가상 메서드를 정의할 때 사용되는데 이 키워드를 통해서 메서드를 재정의할 수 있도록 허용한다.

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

override

상속 관계에서 부모 클래스에 정의된 메서드를 자식 클래스에서 다시 정의할 때 사용된다.

class Derived
{
	public override void Print()
    {
    	Console.WriteLine("Derived class");
    }
}

override 키워드를 사용하여 부모 클래스에서 정의한 메서드를 자식 클래스에서 재정의하면 자식 클래스의 인스턴스에서 호출할 때 부모 클래스와 자식 클래스의 구현 차이를 쉽게 반영할 수 있다.

Base base = new Base();
base.Print();
// "Base class"

Derived derived = new Derived();
derived.Print();
// "Derived class"

Base base2 = new Derived();
base2.Print();
// "Derived class"

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

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는 System 과 System.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++로 작성된 컴퓨터 프로그램이나 라이브러리 다른 프로그래밍 언어에서 사용할 수 있도록 연결하는데 사용하는 오픈소스 도구이다. 

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

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는 아니다.