제너릭 프로그래밍

장점은 하단에..

C# Using 문 

블락  벗어나면 자동 Dispose()되고 예외 상황에서도 Dispose 처리가 된다

근대 번역이 뭔가 되게 이상한데..;

예제

다음 예제에서는 using 문을 사용하는 방법을 보여 줍니다.

using (Font font1 = new Font("Arial", 10.0f)) 
{
    byte charset = font1.GdiCharSet;
}

주의

File 및 Font는 관리되지 않는 리소스에 액세스하는 관리되는 형식의 예입니다(이 경우 파일 핸들 및 장치 컨텍스트). 다른 많은 종류의 관리되지 않는 리소스 및 이를 캡슐화하는 클래스 라이브러리 형식이 있습니다. 그러한 모든 형식은 IDisposable 인터페이스를 구현해야 합니다.

일반적으로 IDisposable 개체를 사용할 경우 using 문에서 선언 및 인스턴스화해야 합니다. using 문은 올바른 방법으로 개체에서 Dispose 메서드를 호출하며, (앞서 설명한 대로 사용하는 경우) Dispose가 호출되자마자 개체 자체가 범위를 벗어나도록 만듭니다. using 블록 내에서 개체는 읽기 전용이며 수정하거나 다시 할당할 수 없습니다.

using 문을 사용하면 개체에서 메서드를 호출하는 동안 예외가 발생하더라도 Dispose가 호출됩니다. try 블록 내부에 개체를 배치하고 finally 블록에서 Dispose를 호출해도 동일한 결과를 얻을 수 있습니다. 실제로 컴파일러는 이 방법으로 using 문을 변환합니다. 이전의 코드 예제는 컴파일 시 다음 코드로 확장됩니다(개체의 제한된 범위를 만드는 여분의 중괄호 참고).

{
  Font font1 = new Font("Arial", 10.0f);
  try
  {
    byte charset = font1.GdiCharSet;
  }
  finally
  {
    if (font1 != null)
      ((IDisposable)font1).Dispose();
  }
}

확장 메서드를 사용하기 위해서 클래스를 만드는데 이때 클래스명이 문법적의 컴파일 오류에 있어서 중요한것은 아니고 

using System;
using System.Text;

namespace MySystem
{
   // static class를 정의
   public static class ExClass
   {
      // static 확장메서드를 정의. 첫번째 파라미터는
      // 어떤 클래스가 사용할 지만 지정. 
      public static string ToChangeCase(this String str)
      {
         StringBuilder sb = new StringBuilder();
         foreach (var ch in str)
         {
            if (ch >= 'A' && ch <= 'Z')
               sb.Append((char)('a' + ch - 'A'));
            else if (ch >= 'a' && ch <= 'x')
               sb.Append((char)('A' + ch - 'a'));
            else
               sb.Append(ch);
         }
         return sb.ToString();
      }

      // 이 확장메서드는 파라미터 ch가 필요함
      public static bool Found(this String str, char ch)
      {
         int position = str.IndexOf(ch);
         return position >= 0;
      }
   }

   class Program
   {
      static void Main(string[] args)
      {
         string s = "This is a Test";
         
         // s객체 즉 String객체가
         // 확장메서드의 첫 파리미터임
         // 실제 ToChangeCase() 메서드는
         // 파라미터를 갖지 않는다.
         string s2 = s.ToChangeCase();

         // String 객체가 사용하는 확장메서드이며
         // z 값을 파라미터로 사용
         bool found = s.Found('z');
      }
   }
}

프로퍼티 value

키워드 value는 일반 속성 선언의 set 접근자에 사용되며, 메서드의 입력 매개 변수와 비슷합니다. 단어 value는 클라이언트 코드에서 속성에 할당하는 값을 참조합니다. 다음 예제에서 MyDerivedClass에는 Name이라는 속성이 있습니다. 이 속성은 value 매개 변수를 사용하여 지원 필드 name에 새 문자열을 할당합니다. 클라이언트 코드 측면에서 연산은 단순 할당으로 작성됩니다.

class MyBaseClass
{
    // virtual auto-implemented property. Overrides can only
    // provide specialized behavior if they implement get and set accessors.
    public virtual string Name { get; set; }

    // ordinary virtual property with backing field
    private int num;
    public virtual int Number
    {
        get { return num; }
        set { num = value; }
    }
}


class MyDerivedClass : MyBaseClass
{
    private string name;

   // Override auto-implemented property with ordinary property
   // to provide specialized accessor behavior.
    public override string Name
    {
        get
        {
            return name;
        }
        set
        {
            if (value != String.Empty)
            {
                name = value;
            }
            else
            {
                name = "Unknown";
            }
        }
    }

}

https://msdn.microsoft.com/library/a1khb4f8(v=vs.110).aspx

• 정적 생성자는 액세스 한정자를 사용하지 않고 매개 변수를 갖지 않습니다.

• 정적 생성자는 첫 번째 인스턴스가 만들어지기 전이나 정적 멤버가 참조되기 전에 클래스를 초기화하기 위해 자동으로 호출됩니다.

• 정적 생성자는 직접 호출할 수 없습니다.

• 사용자는 프로그램에서 정적 생성자가 실행되는 시기를 제어할 수 없습니다.

• 정적 생성자는 일반적으로 클래스에서 로그 파일을 사용할 때 이 파일에 항목을 쓰기 위해 사용됩니다.

• 정적 생성자는 생성자에서 LoadLibrary 메서드를 호출할 수 있는 경우 비관리 코드에 대한 래퍼 클래스를 만들 때도 유용합니다.

• 정적 생성자에서 예외를 throw하면 런타임은 다시 이 생성자를 호출하지 않으므로 해당 형식은 프로그램이 실행되는 응용 프로그램 도메인의 수명 동안 초기화되지 않은 상태로 남아 있게 됩니다.

  class test

    {

        public static test tt;

        static test()

        {

            Console.WriteLine("정적 생성자");

            tt = new test();

        }

        public test()

        {

            Console.WriteLine("생성자");

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

1.  test asdf1 = new test();        //  기본 생성자가 불리기 이전에 static test() 정적 생성자가 한번 불린다

또는

2. test asdf = test.tt;  // 위 1. 구분을 주석처리했을때는 이 처럼 정적멤버 tt 가 참조 되기 이전에 static test()

 가 호출된다

reference

https://msdn.microsoft.com/ko-kr/library/windows/apps/xaml/k9x6w0hc(v=vs.100).aspx

AssemblyInfo.cs

이 파일은 프로젝트와 관계되는 어셈블리의 정보가 담겨 있는 CS 파일입니다. 어셈블리는 하나의 기능을 생성하는 타입과 리소스의 집합체입니다. 하나의 프로젝트를 만든다는 것은 하나의 어셈블리를 만드는 것을 의미합니다.

[assembly: ...]는 어셈블리의 정보를 설정하기 위해 사용됩니다. AssemblyInfo.cs에서 설정되는 내용들은 다음과 같습니다.

프로젝트를 빌드하여 실행 파일을 만든 후 탐색기를 통해 어셈블리의 정보를 확인할 수 있습니다. 방법은 다음과 같습니다.

1. 탐색기를 실행한 후 프로젝트 폴더로 갑니다.

2. bin 폴더를 열고, Release 폴더를 선택합니다.

3. 실행 파일의 아이콘을 마우스 오른쪽 버튼으로 누릅니다.

4. 팝업 메뉴의 최하단에 있는 속성을 택합니다.

5. 속성 대화상자가 뜬 후 '자세히' 탭을 선택합니다.

6. 5를 실행한 후 나타나는 테이블이 어셈블리 정보의 일부를 보여 줍니다.

어셈블리 정보를 보여주는 위 그림에서 속성들이 어떤 어셈블리 항목들과 관계되는지 아래 표로 정리합니다.

http://netrance.blog.me/110091707935

// 추상함수(abstract 를 쓴, c++ 로 치면 순수 가상함수)가 하나라도 있는 클래스는

// 추상클래스(class 앞에 abstract 를 붙인)가 되어야 한다.

// cf) abstract 함수나 virtual 함수를 override 할 때 접근 제한자는 바꿀 수 없으며
// 생각해 보면 당연하겠지만, 추상/가상 함수는 protected 와 public 만 가능하다.
// 또한 추상클래스를 상속받은 경우 모든 추상함수를 '반드시' override 해야만 한다.

abstract class Emotion
{
 public float deep;

 // 추상함수
 protected abstract void Feel();

 public virtual void Express()
 {
 }
}

class Pleasure : Emotion
{
 protected override void Feel()
 {
 }

 public override void Express()
 {
 }
}
[출처] 14. c# 추상함수(abstract)|작성자 그냥

http://blog.naver.com/herbbread/220000818153

http://rintiantta.blog.me/40114652444

Console 프로젝트를 만들어줍니다 ㅎㅎ 

우선 ㅇㅅㅇ, int 로 리스트를 만들어주었습니다. ㅎㅎ

만약 여기서 ㅇㅅㅇ, 30 이상인 녀석들만 뽑겠다면 아래와 같이 해야겠지요 ?
 

이렇게 걸리적 거리게 무엇을 하는 것을 막고자 ㅇㅅㅇ

무언가를 더 짧고 명료하게 쓰고자, Linq 라는 녀석이 나온 것이랍니다. ㅎㅎ

SQL 과 비슷한 문장입니다.

우선 살펴보죠 ㅇㅅㅇ, from A in B 는 foreach 와 비슷한 녀석입니다.

반복을 돌릴 것인데, B 에 있는 녀석을 A 에 넣고 그 녀석을 돌릴 거라는 이야기지요 ㅎㅎ

where 은 다음에 보구요 ㅇㅅㅇ, select 는 그렇게 반복이 된 것중에서 우리가 원하는 것을 뺀다는 얘기입니다.

아래의 경우 list 에 있는 숫자들이 하나하나 item 에 들어가서 30이 넘는지 확인을 하고

하나하나 item 으로 나가면서 IEnumerator 가 만들어 진답니다.

결과적으로 ㅇㅅㅇ, numQuery 라는 곳에는 list 중 30이 넘는 녀석들이 다시 배열로 만들어지겠죠.

그럼 아래와 같이 foreach 를 사용해서 출력을 해보겠습니다.
 

하고나니 느낀건데.. 30 이하가 애초부터 없었다능 ㅇㅅㅇ...

어찌하였거나, Linq 라고 하는 것은 foreach 와 if 등을 사용해 모두 구현이 가능하지만

Linq 를 사용하면 훨씬 짧게 구현이 가능하답니다 >_<

또한 XML 과 SQL 과 연동되어 더욱더 강력한 성능을 발휘하는 Linq..!

차근차근 알아보도록 합시다 ㅎㅎ
 

 
끝 ~

http://hongjinhyeon.tistory.com/87

C#에서는 KEY 와 VALUE를 사용해서 자료를 저장하는 타입이 2가지가 있습니다.

해시테이블과 딕셔너리인데 사용법은 거의 동일하지만 내부적으로 처리하는 기술이 다릅니다.

이 두가지 타입의 기본적인 사용법과 장단점에 대해서 알아보겠습니다.

1.해시테이블 ( Hashtable)

[해시테이블의 특징]

1.Non-Generic

2.Key 와 Value 모두 Object를 입력받는다.

3.박싱/언박싱(Boxing/Un-Boxing) (참고: http://hongjinhyeon.tistory.com/90) 을 사용한다. 

즉, 제네릭을 이용하지 않고 Object를 사용하기 때문에 모든 데이터 타입을 다 받고 처리 할 수 있는 장점이 있지만

자료의 입력에 내부적으로 박싱이 일어나고 사용하는 곳에서도 다시 언박싱을 해줘야 사용이 가능합니다.

2.딕셔너리 ( Dictionary )

[딕셔너리의 특징]

http://rintiantta.blog.me/40115267806

프로젝트를 만듭니다. ㅎㅎ 
 

똑같습니다. Queue 를 만드시면됩니다. ㅇㅅㅇ

종이컵 리필할때는 Enqueue() 를 사용하시면 댑니다 ~_~

반대로, 빼낼때는 Dequeue() 를 쓰시면 됩니다. ㅎㅎ

결과입니다. ~_~

아래와 같이 foreach 로 하시면요 ㅇㅅㅇ...

내용물을 볼 수는 있어도 실질적으로 종이컵이 빠지는 것이 아닙니다.

(저번 Stack 도 마찬가지 ㅇㅅㅇ..)

아래와 같이 Dequeue() 를 쓰시면 내용물도 뺄 수 있답니다. ㅎㅎ

(뺀다는 것이 get 을 의미하는 것이 아니에요. 해당 컬렉션에서 실질적으로 없애버린다는 겁니다.)

결과입니다. >ㅅ< 

역시나, Stack 과 마찬가지로 내용물이 없는데 계속 빼려고 하면요.

익셉션이 뜹니다. ㅎㅎ...

 

 
그럼 오늘 강의도 끝 ~_~

http://rintiantta.blog.me/40115267727

자, 배고프지만 시작합시다 ㅎㅎ...!

프로젝트를 만듭니다. ㅇㅅㅇ ... ! 
 

오늘부터 중급강의에서 볼 내용은 Stack 입니다.

Stack 은 아래와 같이 만듭니다. ㅇㅅㅇ ...!

스택에란 스택스택 쌓아두는 곳이지요. (스테이크 쌓듯이 ㅎㅎ)

오늘 이대를 다녀왔는데 거기 떡갈비 디게 맛있어요 ㅎㅎ...

떡갈비를 아주머니가 만드시면 타지 않게 앞에 올려두죠 ?

   ㅁ

   ㅁ

   ㅁ

   ㅁ

-------

위의 떡갈비(...) 4개 중에서 어떤게 가장 먼저 만들어진 걸까요?

"맨 아래꺼요 >ㅆ<"

『넴 ㅎㅎ, 그렇습니다. ㅇㅅㅇ...! 그리고 아주머니가 파실 때는 윗쪽 것부터 훅훅 파시지요 ㅇㅅㅇ... 그게 Stack 입니다 >ㅆ<』

아래와 같이 객체를 만들어서, 스택스택 쌓아두시면 됩니다.

아래와 같이 출력이 가능하지만요 ㅇㅅㅇ..

이럼 List 와 다를 빠가 없지요 =_= ...

어쨌건 출력입니다. ㅇㅅㅇ...

"List와 다를바가 있기는 한데요 ... ?"

『역으로 출력되요 ㅇㅅㅇ... 떡갈비 윗쪽 부터 훑는 것이지요 ㅎㅎ』

근데 떡갈비를 보기만 하면 아주머니가 화내시겠죠..

팔아서 없애야죠 ㅇㅅㅇ !!!

아래와 같이 Pop 을 사용해서 없애주시면 됩니다. ㅎㅎ

결과입니다. ㅇㅅㅇ ... !

스택에서 주의하실 것은 아래와 같이 팔거 없는데

계속 팔라고하면

익셉션 뜹니다. ~_~

주의해 주세요 ㅎㅎ...

 
그럼 오늘 강의 끝 >ㅅ<

Stack 과 같은 녀석을 잘 쓰지 않지요 ㅇㅅㅇ..

근데, 아이폰 공부하신 분은 아시겠지만 하다보면 Push() 와 Pop() 이 나옵니다.

직접적으로 관련은 없어도, 다른 것을 이해하는데 도움을 줄 수 있는 부분입니다. ㅎㅎ

http://rintiantta.blog.me/40113858529

Yield 라는 키워드는 Break 와 Return 과 함께 쓰인답니다.

음.. Break 는 자주 활용이 되지는 않는 것 같습니다만, 강의이니 뭐 알아봐야죠 ㅎ..! 

간단하게, Yield 라는 키워드는 일반적인 것을 IEnumerable 로 변환을 시켜줍니다..

뭔소린지, 해보면서 봅시다..!

우선 프로젝트를 만듭니다. 이름은 EnumYieldLesson 입니다..!

원래, 강의중에 클래스를 따로 만드는 타입이잖습니까..

일반 교재에는 다 합치지만.. 실제로 안 그러니... 연습도 되시라구 하는데...

오늘건 나누면 조금 길어지는 관계로 합쳤습니다... 죄송합니다 =_=...

어찌하였거나, YieldTest 라는 이름의 클래스를 만들어주었습니다 ㅇㅅㅇ..!

그리고 아래와 같이 days 라는 이름으로 만들어주었습니다.

참고로, MSDN 에 있는 내용인데요. 음... 그냥 Yield Return 과 GetEnumerator 에 대한 설명밖에 없길래

추가하고 합쳐보았습니다. ㅎㅎ.... (MSDN은 저작권이.. 교육용으로는 안 걸리지...)

다음과 같은 IEnumerator 로 리턴하는 GetEnumerator라는 메소드를 만듭니다.

using 하라는 말이 뜨니 using 해줍시다.

참고로, 이름을 바꿔서 예제를 따라해보는 분들이 계실텐데요. (제가 그런 타입이라..)

GetEnumerator 라는 이름은 고정하셔야 합니다. 잠시후 뒤에서 언급할게요.

그리고 아래와 같이 메소드를 작성했는데요.

일단 리턴값이 IEnumerator 고, 리턴시 yield 라는 것을 쓴 것을 보실 수 있답니다.

리턴이 분명 string 으로 될텐데, yield 라는 키워드를 붙임으로써, IEnumerable 로 바뀌게 됩니다.

"어라... 리턴이 IEnumerator 인테.. 왜... IEnumerable.. ㅇㅅㅇ ... ?"

『잠시후 봅시다...ㅎ』

근데 왜 이름이 고정이냐면요 ㅇㅅㅇ

원래 IEnumerable 인터페이스의 상속을 받아서 구현해야합니다. ㅇㅅㅇ

인터페이스 구현버튼을 누르시면 아래와 같이 GetEnumerator 라는 메소드가 구현되는데요.

원래는 이렇게 해서 해야하지만... region 때문에 길이가 길어서 그냥 하고 있습니다...

어찌하였거나, 이어서 메소드를 만드는데요.

OtherGetEnum() 이라고 만들었습니다. 내부의 for 문을 foreach도, for 도 된다는 뜻으로 해본거구요.

주의하실것은.. IEnumerable 로 리턴한다는 것입니다...

"ㅇㅅㅇ...."

자, 그럼 이제 만들었으니, 사용해봅시다~!

아래와 같이 인스턴스를 만들었답니다.

그리고 아래와 같이 실행이가능합니다.

그냥 꼽으시면, foreach 에서 알아서 "아, GetEnumerator() 실행하라는 거구나."

하고 GetEnumerator 를 실행합니다.

근데 문제가 있습니다. foreach 에는 IEnumerator 값을 꼽을 수 없습니다.

따라서, 내부에서 한번 더 변형이 일어나서 IEnumerable 로 바뀐답니다.

실행 결과입니다. 간단하죠 ?

이어서, 아래와 같이 우리가 만든 녀석을 써보았습니다.

위와 실행 결과가 같답니다 ㅎㅎ

또한 아래와 같이 따로 뺀다음 꼽을 수도 있는 것을 생각하시기 바랍니다.

"오오, 그럼 IEnumerator 로 GetEnumerator 뽑아서 꼽아도 되는거 아닌가요?"

『해보시길 바랍니다. 에러날겁니다. ㅇㅅㅇ... IEnumerator 는 꼽을 수 없다구요 ㅎ...』

이어서, yield break; 를 보도록 합시다.

아래와 같이 메소드를 수정했는데요.

yield break; 는 yield return 을 끝내라는 말입니다.

즉, 지금 한데까지만 IEnumerable 로 바꾸라는 이야기지요.

그래서 아래와 같이 것을 실행하시면

이렇게 됩니다. yield return 이 중간에 끊긴 것을 확인하실 수 있습니다.

 자... 그럼 마지막으로 무언가 하나를 또 보기위해서 AnotherGetEnum 을 만듭니다.

『...복사해서.. AnOtherGetEnum 이 되었다는 설이..』.... 죄송합니다.

이어서, 다음과 같이 써주었습니다.

"ㅇㅅㅇ ?!"

실행결과를 보시는 편이 이해가 빠를 것이라고 생각됩니다 ㅎㅎ....

아래와 같이 메인에 써주었어요 ㅇㅅㅇ..!

자, 출력결과가 보이시나요 ㅇㅅㅇ ?

하나, 하나, 하나 출력되었습니다.

이와같이 yield 키워드는 IEnum 계열과 foreach 와 함께쓰이는 녀석입니다.

그럼 오늘 강의 끝 ~

오늘건 약간 길었지요 ㅇㅅㅇ....?

음.. 아직 베이직에서 아직 인터페이스도 안했는데.... 중급강의에서 나오니 조금 그렇지만..

아직 보신 분이 많지 않으니 괜찮을듯 ~ ㅎㅎ;; 

http://wwwi.tistory.com/316

C#에서 DLL만들고 사용하기

개발환경은 Visual C# 2010 Express에서의 예제이다.
이 내용은 Visual Studio 2010에서 해도 문제가 없다.

메뉴 표시는 대신 한글이여서 조금은 이해하기 편할 것 같다.

먼저 DLL을 사용할 프로젝트를 만든다.
먼저 File > New Project를 선택한다.

Console Application을 선택하고 적당한 이름을 입력한 후 OK를 누른다.
여기서 입력한 이름으로 프로젝트가 만들어지고 이 이름의 네임스페이스가 생긴다.

그러면 아래와 같이 자동으로 소스가 조금 만들어진다.

사용할 DLL 프로젝트 만들기

솔루션에서 왼쪽 클릭을 하고 Add > New Project를 선택한다.

Class Library를 선택하고 DLL의 이름을 적고 OK를 누른다.

DLL에 대한 내용을 적어둔다.

DLL을 Build한다.

작성된 DLL을 참조하기 위해서는 DLL을 사용하려는 프로젝트의 References(참조)에서 오른쪽 클릭을 하여 Add Reference를 선택한다.

그리고 Projects 탭을 선택하면 지금 작성한 DLL의 프로젝트를 선택하고 OK를 누른다.

정상적으로 Dll이 참조되면 References 밑에 추가한 DLL의 이름이 표시된다.

그리고 아래와 같이 코드를 작성한다.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace TestE
{

    class User
    {
        public User(string name) { _name = name; }
        public string Name{ get{ return _name;} }
        string _name;
    }


    class DBManager : IEnumerable
    {
        public DBManager()
        {
            _onlineUsers.Add (new User ("tom"));
            _onlineUsers.Add (new User ("Krista"));
            _onlineUsers.Add (new User ("Emma"));
        }

        public IEnumerator GetEnumerator()                //이 함수를 불릴때 원소를 복사하는 방식 => 메모리 측면에서 효율적인 방법은 아님
        {
            return new Enumerator (_onlineUsers);
        }
            
        ArrayList _onlineUsers = new ArrayList();

        class Enumerator : IEnumerator
        {
            const string INVALID_RECORD = "use ss";

            public Enumerator(ArrayList onlineUsers)
            {
                foreach(User user in onlineUsers)
                {
                    this._onlineUsers.Add(user);
                }
                Reset();
            }

            public bool MoveNext()
            {
                return ++_index < _onlineUsers.Count;
            }

            public object Current
            {
                get
                {
                    if (_index == -1) 
                        throw new InvalidOperationException (INVALID_RECORD);

                    if (_index < _onlineUsers.Count)
                        return _onlineUsers [_index];
                    else
                        return null;
                    
                }
            }

            public void Reset(){ _index = -1; }

            int _index;
            ArrayList _onlineUsers = new ArrayList();
        }
    }

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

            DBManager db = new DBManager ();

            IEnumerator e = db.GetEnumerator ();

            while (e.MoveNext ()) {
                User user = (User)e.Current;
                Console.WriteLine ("{0}", user.Name);
            }


            foreach (User user in db) {
                Console.WriteLine ("{0}", user.Name);
            }

            Console.ReadLine ();
        }
    }


}

http://www.gpgstudy.com/forum/viewtopic.php?p=95504&sid=3186560b92d188fe3fab7bef907f0c67

delegate하고 event하고 뭐가 다른지 잘 몰라서 그러는데요. 

이 코드를 보면 event나 delegate이나 차이가 없어 보이는데 
혹시 제가 모르는 차이점이 있나요?

저도 예전에 차이점이 궁금했었는데요.. 
겉으로 보기에 용법이 같아서 그렇지 event와 delegate는 다른 놈입니다. 

event와 delegate를 
property와 멤버 변수의 관계랑 비슷하다고 생각하시면 됩니다. 

event는 property가 get, set을 갖는 것 처럼 add, remove함수를 가져야 합니다. 
근데 사용하기 쉽게 add, remove를 생략하실수 있습니다. 

public event Handler Event;  // 생략형

그냥 이렇게 하면 아래와 같은 코드가 만들어집니다. 

이 Event 이벤트 변수에다가 +=을 써주면 add가 불리고 -=을 써주면 remove가 불리는 겁니다. 
그래서 겉에서 봤을땐 delegate랑 사용법이 똑같이 보이게 됩니다. 

근데 이것도 약간 다른 점이 이벤트 호출시에 Event("event");를 사용하는데 
이건 클래스 안에서만 사용 가능합니다. 클래스 밖에서 test.Event("event"); 하면 에러가 나지요 
생략형으로 쓰면 c#이 자동으로 Event() 호출을 _Event 대리자의 호출로 치환해 줍니다. 
_Event는 내부 변수이므로 밖에서 호출이 불가능합니다. 

add, remove를 명시적으로 쓸 경우에는 Event("event"); 이런식으로 호출을 못합니다(자동으로 대리자 변수를 만들어내지 않기 때문에) 
직접 _Event("event"); 이런식으로 대리자를 호출해 주거나 그에 상응하는 작업을 구현해야 합니다. 

이러한 차이점이 있기 때문에 event는 interface에서 선언해 줄수 있고요.. delegate는 그렇지 못합니다. 

event변수가 넘쳐나는걸 막기 위해 winforms에서는 메시지 이벤트를 add, remove를 직접 구현하고 dictionary에 event를 저장하는 방식을 쓴다고 합니다. 
http://msdn2.micros...ibrary/z4ka55h8.aspx 

여기 Events 부분에 자세한 설명이 있습니다. 
http://www.yoda.ara...m/csharp/events.html

https://msdn.microsoft.com/ko-kr/library/z4ka55h8.aspx

방법: 사전을 사용하여 이벤트 인스턴스 저장(C# 프로그래밍 가이드)

다른 버전

public delegate void EventHandler1(int i);
public delegate void EventHandler2(string s);

public class PropertyEventsSample
{
    private System.Collections.Generic.Dictionary<string, System.Delegate> eventTable;

    public PropertyEventsSample()
    {
        eventTable = new System.Collections.Generic.Dictionary<string, System.Delegate>();
        eventTable.Add("Event1", null);
        eventTable.Add("Event2", null);
    }

    public event EventHandler1 Event1
    {
        add
        {
            lock (eventTable)
            {
                eventTable["Event1"] = (EventHandler1)eventTable["Event1"] + value;
            }
        }
        remove
        {
            lock (eventTable)
            {
                eventTable["Event1"] = (EventHandler1)eventTable["Event1"] - value;
            }
        }
    }

    public event EventHandler2 Event2
    {
        add
        {
            lock (eventTable)
            {
                eventTable["Event2"] = (EventHandler2)eventTable["Event2"] + value;
            }
        }
        remove
        {
            lock (eventTable)
            {
                eventTable["Event2"] = (EventHandler2)eventTable["Event2"] - value;
            }
        }
    }

    internal void RaiseEvent1(int i)
    {
        EventHandler1 handler1;
        if (null != (handler1 = (EventHandler1)eventTable["Event1"]))
        {
            handler1(i);
        }
    }

    internal void RaiseEvent2(string s)
    {
        EventHandler2 handler2;
        if (null != (handler2 = (EventHandler2)eventTable["Event2"]))
        {
            handler2(s);
        }
    }
}

public class TestClass
{
    public static void Delegate1Method(int i)
    {
        System.Console.WriteLine(i);
    }

    public static void Delegate2Method(string s)
    {
        System.Console.WriteLine(s);
    }

    static void Main()
    {
        PropertyEventsSample p = new PropertyEventsSample();

        p.Event1 += new EventHandler1(TestClass.Delegate1Method);
        p.Event1 += new EventHandler1(TestClass.Delegate1Method);
        p.Event1 -= new EventHandler1(TestClass.Delegate1Method);
        p.RaiseEvent1(2);

        p.Event2 += new EventHandler2(TestClass.Delegate2Method);
        p.Event2 += new EventHandler2(TestClass.Delegate2Method);
        p.Event2 -= new EventHandler2(TestClass.Delegate2Method);
        p.RaiseEvent2("TestString");

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    2
    TestString 

*/

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace TestE
{
    class DBConnection {

        protected static int NextConnectionNbr = 1;

        protected string connectionName;
        public string ConnectionName{ get { return connectionName; } }

        public DBConnection()
        {
            connectionName = "Database Connection " + DBConnection.NextConnectionNbr++;
        }

    }


    class DBManager
    {
        protected ArrayList activeConnetions;
        public DBManager()
        {
            activeConnetions = new ArrayList ();
            for (int i = 0; i < 6; ++i) {
                activeConnetions.Add (new DBConnection ());

            }
        }

        public delegate void EnumConnectionsCallback(DBConnection connection);            

//delegate 선언, 이 함수 타입과 동일한 함수를  나중에 담을 수 있게 된다

        public void EnumConnections(EnumConnectionsCallback callback)                     
        {
            foreach(DBConnection connection in activeConnetions)
            {
                callback(connection);
            }
        }
    }



    class Program {

        public static void PrintConnections(DBConnection connection)
        {
            Console.WriteLine ("[InstanceDelegate.PrintConnections] {0}", connection.ConnectionName);
        }

        static int Main(string[] args)
        {

            DBManager dbMsanager = new DBManager ();

            DBManager.EnumConnectionsCallback printConnections = new DBManager.EnumConnectionsCallback

//delegate 와 동일한 함수 타입의 함수인  PrintConnections 를 담는다

            dbMsanager.EnumConnections (printConnections);

            Console.ReadLine ();

            return 0;
        }
    }
}

결과

[InstanceDelegate.PrintConnections] Database Connection 1

[InstanceDelegate.PrintConnections] Database Connection 2

[InstanceDelegate.PrintConnections] Database Connection 3

[InstanceDelegate.PrintConnections] Database Connection 4

[InstanceDelegate.PrintConnections] Database Connection 5

[InstanceDelegate.PrintConnections] Database Connection 6

- 참고 inside c# second

http://pullthelever.tistory.com/332

- Case 1

class A
{
   B b;       //당연히 된다.
   B.C c;    //클래스 B 안에 클래스 C가 public이므로 가능하다.
                 //public이 아니면 아래와 같은 오류가 나온다.
                 //오류 CS0122: 보호 수준 때문에 '_namespace.B.C'에 액세스할 수 없습니다.

}

class B
{
    public class C//public말고도 private, protected도 가능하다.
    {
       //...
    }
}

- Case 2
class A          //기본으로 internal이다.
{
   //...
}

public class B//private, protected는 못 오고 internal, public만 올 수 있다.
{
   public A a;
// 오류 CS0052: 일관성 없는 액세스 가능성:
// '_namespace.A' 필드 형식이 '_namespace.B.a' 필드보다 액세스하기 어렵습니다.

   public A func1() { return a; }
// 오류 CS0050: 일관성 없는 액세스 가능성:
// '_namespace.A' 반환 형식이 '_namespace.B.func1()' 메서드보다 액세스하기 어렵습니다.

   public void func2(A a) { this.a = a; }
// 오류 CS0051: 일관성 없는 액세스 가능성:
// '_namespace.A' 매개 변수 형식이 '_namespace.B.func2(_namespace.A)' 메서드보다
//  액세스하기 어렵습니다.
}


- 이유
   A는 internal로 외부로 공개되지 않았는데 외부로 공개하는 B에서 A를 외부로 공개하려고 하니 오류가 발생한다.

- Case 2 처방전
첫 번째 방법)
   class A 를 public class A로 바꾼다

두 번째 방법)
   public class B를 class B로 바꾼다

세 번째 방법)
   public A a, public A func1(), public void func2(A a) 를
   A a, A func1(), void func2(A a) 로 바꾼다

- public과 internal란
public으로 선언된 경우 다른 어셈블리에서도 접근할 수 있다.
internal으로 선언된 경우 동일한 어셈블리의 파일 내에서만 접근할 수 있다.
아무것도 안 넣으면 internal이다.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace TestE
{


    class Employee
    {
        public string _name;
        public Employee(string name)
        {
            this._name = name;
            Console.Write ("Employee.CalculatePay:\n\t");
            CalculatePay ();
        }
        public virtual void CalculatePay()
        {
            Console.WriteLine ("Employee.CalculatePay called for {0}", _name);
        }
    }

    class SalariedEmployee : Employee
    {
        public decimal _salary;    
        public SalariedEmployee(string name, decimal salary) : base(name)
        {
            this._salary = salary;
            Console.Write ("SalariedEmployee.CalculatePay:\n\t");
            CalculatePay ();
        }
        public override void CalculatePay()
        {
            Console.WriteLine ("{0}, SalariedEmployee.CalculatePay, salary={1:C}", _name, _salary);
        }
    }

    class ContractEmployee : Employee
    {
        public double _rate;
        public ContractEmployee(string name, double rate) : base(name)
        {
            this._rate = rate;
            Console.Write ("ContractEmployee.CalculatePay:\n\t");
            this.CalculatePay ();

        }

        public override void CalculatePay()
        {
            Console.WriteLine ("{0}, ContractEmployee.CalculatePay, salary={1:C}", _name, _rate);
        }
    }

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

            Employee[] employee = new Employee[2];
            employee[0] = new ContractEmployee("Ada" +
                "m Barr", 123.45);

            Console.WriteLine ("");


            employee[1] = new SalariedEmployee(
                "Max Benson", 67890m);

        }
    }
}

c++ 과는 다른 결과를 보인다, 생성자가 호출된 클래싀의 함수가 불리지 않고 virtual 로 선언된 경우 자식 함수가 불리게 된다

Employee.CalculatePay:

Adam Barr, ContractEmployee.CalculatePay, salary=₩0

ContractEmployee.CalculatePay:

Adam Barr, ContractEmployee.CalculatePay, salary=₩123

Employee.CalculatePay:

Max Benson, SalariedEmployee.CalculatePay, salary=₩0

SalariedEmployee.CalculatePay:

Max Benson, SalariedEmployee.CalculatePay, salary=₩67,890