In this article I will explain some of the concepts behind object-oriented programming in C#, including objects and classes. To read this article you should have some basic understanding of the C-Sharp language.

Read the whole article because there are some concepts you may not fully understand until you finish the article. And we will revisit all the concepts more than once when I see it's appropriate in future articles; so don't worry at all.

Introduction to Objects and Classes in C# - Introduction
(Page 2 of 9 )

OOP stands for Object-Oriented Programming. OOP is relatively a new way to program computer applications. In the past, OOP programmers used to create computer applications using procedural-programming (or structured-programming). But, when OOP solved a lot of the problems of the procedural-programming, most programmers and developers began using OOP languages. In procedural- programming all the program functionality is written in a few modules of code or maybe one module (depending on the program). These modules depend on one another and sometimes changing a line of code requires you to rewrite the whole module again and maybe the whole program. 

In Object-Oriented Programming programmers write independent parts of a program called classes. Each class represents a part of the program functionality and these classes can be assembled to form a program. When you need to change some of the program functionality all you have to do is to replace the target class which may contain the problem that needs change. So, OOP applications are created by the use of classes and these applications can contain any number of classes. This will get us to discuss the Class and Object concept.

Classes and objects

You may find it a little difficult to understand the class and object story; but, I will try to do my best in explaining it. Actually the class and object concept is related to each other. Some beginners don't care about understanding it clearly so I think they will have a hard time learning C#.

Object-Oriented concepts take most of their functionality from the real-life concepts. For example, I will discuss the concept of Classes and Objects of the world first and then you will understand the computer's Classes and Objects before I even write anything about it.

Introduction to Objects and Classes in C# - World's Classes and Objects
(Page 3 of 9 )

In our world we have classes and objects for those classes. Everything in our world is considered to be an object. For example, people are objects, animals are objects too, minerals are objects; everything in the world is an object. Easy, right? But what about classes?

In our world we have to differentiate between objects that we are living with. So we must understand that there are classifications (this is how they get the name and the concepts of the Class) for all of those objects. For example, I'm an object, David is object too, Maria is another object. So we are from a people class (or type). I have a dog called Ricky so it's an object. My friend's dog, Doby, is also an object so they are from a Dogs class (or type).

A third example: I have a Pentium 3; this is an object.  My friend has a Pentium 4, so this is another object and they are from a Computers class (or type). Now I think you understand the concept of the Class and Object, but let me crystallize it for you. In our world we have classifications for objects and every object must be from some classification. So, a Class is a way for describing some properties and functionalities or behaviors of a group of objects. In other words, the class is considered to be a template for some objects. So maybe I will create a class called person which is a template of the functionality and the properties of persons.

Introduction to Objects and Classes in C# - Programmer’s Classes and Objects
(Page 4 of 9 )

A C# Class is considered to be the primary building block of the language. What I mean by the primary building block is that every time you work with C# you will create classes to form a program. We use classes as a template to put the properties and functionalities or behaviors in one building block for a group of objects and after that we use the template to create the objects we need.

For example, we need to have persons objects in our program so the first thing to do here is to create a class called Person that contains all the functionalities or behaviors and properties of any person and after that we will use that class (or template) to create as many objects as we need. Creating an object of a specific class type is called "an instance of the class". Don't worry if you didn't grasp it 100% and don't worry if you don't know what the class and object's properties and functionalities or behaviors are because we are still in the beginning.  Until now I haven’t provided any code examples. So let's take a brief of what is a class and what is an object:

The class: A building block that contains the properties and functionalities that describe some group of objects. We can create a class Person that contains:

1. The properties of any normal person on the earth like: hair color, age, height, weight, eye color.
2. The functionalities or behaviors of any normal person on the earth like: drink water, eat, go to the work.

Later we will see how we can implement the functionalities or behaviors and properties.

There are 2 kinds of classes: The built-it classes that come with the .NET Framework, called Framework Class Library, and the programmer defined-classes which we create ourselves.

The class contains data (in the form of variables and properties) and behaviors (in the form of methods to process these data). We will understand this concept later on in the article.

When we declare a variable in a class we call it member variables or instance variables. The name instance come from the fact that when we create an object we instantiate a class to create that object.  So instance of a class means an object of that class and instance variable means variable that exists in that class.

The object: It's an object of some classification (or class, or type) and when you create the object you can specify the properties of that object. What I mean here is: I, as an object, can have different properties (hair color, age, height, weight) than you as another object. For example, I have brown eyes and you have green eyes.  When I create 2 objects I will specify a brown color for my object's eye color property and I will specify a green color for your object's eye color property.

So to complete my introduction to classes we must discuss properties and variables.

Introduction to Objects and Classes in C# - Properties and Variables
(Page 5 of 9 )

Variables declared in a class store the data for each instance.  What does this mean? It means that when you instantiate this class (that is, when you create an object of this class) the object will allocate memory locations to store the data of its variables. Let's take an example to understand it well.

class Person
{
   public int Age;
   public string HairColor;
}

This is our simple class which contains 2 variables. Don't worry about public keyword now because we will talk about it later. Now we will instantiate this class (that is, when you create an object of this class).

static void Main(string[] args)
{
   Person Michael = new Person();
   Person Mary = new Person();

   // Specify some values for the instance variables
   Michael.Age = 20;
   Michael.HairColor = "Brown";
   Mary.Age = 25;
   Mary.HairColor = "Black";
   // print the console's screen some of the variable's values
   Console.WriteLine("Michael's age = {0}, and Mary's age = {1}",Michael.Age,
       Mary.Age);
   Console.ReadLine();
}

So we begin our Main method by creating 2 objects of type Person. After creating the 2 objects we initialize the instance variables for object Michael and then for object Mary. Finally we print some values to the console.  Here, when you create the Michael object, the C# compiler allocates a memory location for the 2 instance variables to put the values there. Also, the same thing with the Mary object; the compiler will create 2 variables in memory for Mary object. So each object now contains different data. Note that we directly accessed the variables and we put any values we wanted, right?  But wait there is a solution to this problem. We will use properties.

Introduction to Objects and Classes in C# - Properties
(Page 6 of 9 )

Properties are a way to access the variables of the class in a secure manner. Let's see the same example using properties.

class Person
{
   private int age;
   private string hairColor;
   public int Age
   {
       get
       {
       return age;
       }
       set
       {
           if(value <= 65 && value >= 18)
           {
               age = value;
           }
           else
               age = 18;
       }
   }
   public string HairColor
   {
       get
       {
           return hairColor;
       }
       set
       {
           hairColor = value;
       }
   }
}

I made some modifications, but focus on the new 2 properties that I created. So the property consists of 2 accessors. The get accessor, responsible of retrieving the variable value, and the set accessor, responsible of modifying the variable's value. So the get accessor code is very simple. We just use the keyword return with the variable name to return its value. So the following code:

get
  {
   return hairColor;
  }

returns the value stored in hairColor.

[Note]

The keyword value is a reserved keyword by C# (that is, reserved keywords means that these keywords are owned only by C# and you can't create it for any other purposes. For example, you can't create a variable called value .If you did, the C# compiler would generate an error. To make things easier, Visual Studio.NET will color the reserved keywords in blue.)

[/Note]

Let's put this code to work and then discuss the set accessor..

Introduction to Objects and Classes in C# - Reworked
(Page 7 of 9 )

static void Main(string[] args)
{
   Person Michael = new Person();
   Person Mary = new Person();

   // Specify some values for the instance variables
   Michael.Age = 20;
   Michael.HairColor = "Brown";
   Mary.Age = 25;
   Mary.HairColor = "Black";

   // print the console's screen some of the variable's values
   Console.WriteLine("Michael's age = {0}, and Mary's age = {1}",Michael.Age,
       Mary.Age);
   Console.ReadLine();
}

Here I created the same objects from the last example, except that I used only properties to access the variable instead of accessing it directly. Look at the following line of code

Michael.Age = 20;

When you assign a value to the property like that C# will use the set accessor. The great thing with the set accessor is that we can control the assigned value and test it; and maybe change to in some cases. When you assign a value to a property C# changes the value in a variable and you can access the variable's value using the reserved keyword value exactly as I did in the example. Let's see it again here.

set
  {
      if(value <= 65 && value >= 18)
      {
          age = value;
      }
      else
          age = 18;
  }

Here in the code I used if statement to test the assigned value because for some reason I want any object of type Person to be aged between 18 and 65. Here I test the value and if it is in the range then I will simply store it in the variable age. If it's not in the range I will put 18 as a value to age.

Introduction to Objects and Classes in C# - Creating Objects and Classes
(Page 8 of 9 )

We create a class by defining it using the keyword class followed by the class name:

class Person

Then we open a left brace "{" and write our methods and properties.  We then close it with a right brace "}". That's how we create a class. Let's see how we create an instance of that class.

In the same way as we declare a variable of type int we create an object variable of Person type with some modifications:

int age;
Person Michael = new Person();

In the first line of code we specified integer variable called age. In the second line we first specified the type of Object we need to create, followed by the object's name, followed by a reserved operator called new.  We end by typing the class name again followed by parentheses "()".

Let's understand it step-by-step. Specifying the class name at the beginning tells the C# Compiler to allocate a memory location for that type (the C# compiler knows all the variables and properties and methods of the class so it will allocate the right amount of memory). Then we followed the class name by our object variable name that we want it to go by. The rest of the code "= new Person();" calls the object's constructor. We will talk about constructors later but for now understand that the constructor is a way to initialize your object's variable while you are. For example, the Michael object we created in the last section can be written as following :

Person Michael = new Person(20, "Brown");

Here I specified the variable's values in the parameter list so I initialized the variables while creating the object. But for this code to work we will need to specify the constructor in the Person class -- I will not do that yet as constructors will come in a later article.

Introduction to Objects and Classes in C# - Conclusion
(Page 9 of 9 )

In this article, I gave you a concise introduction to classes and objects. I will complete the discussion in my next article, as well as discuss constructors and building block scope. I hope you’ve learned something new thing from this first article.

The concept of Objects & Classes helps you hide your code implementation from the user of your class. In other words, if you develop a class for your friend to use, he doesn't have to know how you created the methods of that class in order to use it; he'll just need to know how to use it, and what functionality is offered by your class members. The point here is that you don't have to know how another developer developed a certain class; you just have to know how to interface with it. And I said in the first part, when you develop programs with C# you will develop classes. Note that this is not like C programming, where the programming primary building block was the function (or methods, in C#). Finally, remember that C# defines other types like structures, enumerations. We'll learn about these in future articles.

In C programming language, programmers develop functions to form their applications. These functions contain the code of the program. The problem is that in large programs, if you have to modify just one line of code you may have to modify many functions to fit in the new modifications. (In procedural languages, functions depend on each other.) But in C#, we write classes as our primary building blocks, and because classes hide their code implementation -- and only the methods of these classes are accessible to the applications that use them -- if we must change something inside the class, we will do it without changing the code of the applications that uses our classes.

Introduction to Objects and Classes in C#, Part 2 - Comments
(Page 2 of 4 )

When you write applications in C# try to use comments to describe exactly how your application performs and why; try to make your application easy to understand and easy to maintain. Think about it this way: if you were to come back to your application five years after you wrote it, would you know what every line of code meant and did? What if someone was developing an application and they were trying to read through your code? Without documentation, this is difficult even for the most experienced programmers.  

I think that you want to know more about classes so let's write a class and then discuss  new concepts.

The Person Class

Here's a simple class called Person


class Person


Let's break this down:

You're probably curious about private string firstName, private string lastName, and private int age. These are called instance variables, and as you know from the first part of that article, when you create objects from a given class (for example, the person class) you create an instance of that class. That's why we call the variables declared the body of the class (but not inside any method of that class) an instance variable. When you create an objects of that class C# compiler will allocate separate memory locations for the instance variables of each object. Thus, the object named Michael (of type Person) will contain its own values for these instance members, as will the object Prakhar (of type Person). You can say that the consumer application (the application that will use your class) will provide the values of these instance variables for each object created of that type.

NOTE About the keywords private and public in the class, they called access modifier keywords. When developing C# class you will use the access modifier keywords to specify the scope of the member. Each instance variable, method, or any other type you create inside a class called a member. C# gives you the power to specify the scope of the member using these access modifiers.

Introduction to Objects and Classes in C#, Part 2 - What's a Scope?
(Page 3 of 4 )

Simply, the scope of a type (a variable, a method, or a class) is where you can use that type in your program. In other words, the scope defines the area of the program where that type can be accessible and referenced.

When you declare a variable inside a block of code (like a method or an if statement structure), it will have a local scope, and it will be called a local-variable. Local scope means that you can't refer to that variable outside that block of code. Consider the next example.


class Test


Try to instantiate this class and you will get a compile-time error inside method Test2() telling you that the name x doesn't exist and that's because x is a local variable to the method Test1() and method Test2() doesn't know anything about it. So x has a local score to method Test1() only. Consider the next example.


class Test


Here, the method Test1() declares a local variable x (now x has a local-scope to the method). Try to instance this class and compile the code. It will work! Some beginners think that because I said that x has a local scope to method Test1() it will not be referenced from nested block (like the one we have here, the If statement) but that's not true because any nested block inside Test1() method can refer x because x is local for the method and its all blocks of code.

NOTE  There are 2 kinds of scopes: block scope (the one that we just finished), and a class scope (which we will talk about later in this article). Now, about the keywords private and public in the class person, you can use these access modifier keywords to define the scope of your variables, methods, or even your classes. There are other access modifiers but I will talk about them in a later article when I will explain the concepts of inheritance.

Instance variables declared using the access modifier keyword private will be accessible to the methods between the opening left brace "{" and the closing right brace "}" (which define the body of the class) only. In other words, when you declare an instance variable like in the following example:


public

In this example, you will get a compile-time error telling you that you that the name X doesn't exist inside the Class3. Using the keyword private, you explicitly tell the compiler "Don't show this member to any other class." (So you are hiding it inside the class.)

Introduction to Objects and Classes in C#, Part 2 - Private Members Only?
(Page 4 of 4 )

What about objects of that class? Can they access the members declared as private?

In short, no, the objects of this class will not see the private member, but it will have it's own copy because as we said before the class is just a template for the contents of its object. I prefer to discuss it using an example:


public

And then I will instance 2 objects of that class inside the Main method


static void Main

c2 and c3 are objects of type Class2() but look what happened when I typed the "." operator (which will get us all the accessible members of that class).

There is no x here because it's private to the class. You may wonder why this feature exists. Sometimes you need to hide some values inside the class (ie. you don't want other classes or objects of that class to see these values), maybe because it's complex information, or it's private to your work, or the developers that will use your class (after it's compiled) will simply not benefit if they saw these variables or methods.

You can use the access modifier keyword public while you declare your variables to specify that you want your variable to be accessed by the other classes or any objects of this class. let's revise the the x variable in Class2 and check if we can see it or not (from objects of this class or other classes).


public

Now let's see the result:

Oh, yes we can see the x variable now because we made it public. And I will talk about Class Scope in a later article. For now, just play around with scopes. I think you'll have a lot of fun with these.

출처 : http://www.developerfusion.co.uk/show/2137

Introduction

In this article I discuss the event handling model in .NET using C#. The discussion starts with an introduction to the concept of delegates and then it extends that concept to events and event handling in .NET. Finally, I apply these concepts to GUI event handling using windows forms. Complete code is provided in each step of the discussions.

Event handling is familiar to any developer who has programmed graphical user interfaces (GUI). When a user interacts with a GUI control (e.g., clicking a button on a form), one or more methods are executed in response to the above event. Events can also be generated without user interactions. Event handlers are methods in an object that are executed in response to some events occurring in the application. To understand the event handling model of .Net framework, we need to understand the concept of delegate.

Delegates in C#

A delegate in C# allows you to pass methods of one class to objects of other classes that can call those methods. You can pass method m in Class A, wrapped in a delegate, to class B and Class B will be able to call method m in class A. You can pass both static and instance methods. This concept is familiar to C++ developers who have used function pointers to pass functions as parameters to other methods in the same class or in another class. The concept of delegate was introduced in Visulal J++ and then carried over to C#. C# delegates are implemented in .Net framework as a class derived from System.Delegate. Use of delegate involves four steps.

1. Declare a delegate object with a signature that exactly matches the method signature that you are trying to encapsulate.
2. Define all the methods whose signatures match the signature of the delegate object that you have defined in step 1.
3. Create delegate object and plug in the methods that you want to encapsulate.
4. Call the encapsulated methods through the delegate object.

The following C# code shows the above four steps implemented using one delegate and four classes. Your implementation will vary depending on the design of your classes.

Event Handlers in C#

An event handler in C# is a delegate with a special signature, given below.

public delegate void MyEventHandler(object sender, MyEventArgs e);

The first parameter (sender) in the above declaration specifies the object that fired the event. The second parameter (e) of the above declaration holds data that can be used in the event handler. The class MyEventArgs is derived from the class EventArgs. EventArgs is the base class of more specialized classes, like MouseEventArgs, ListChangedEventArgs, etc. For GUI event, you can use objects of these specialized EventArgs classes without creating your own specialized EventArgs classes. However, for non GUI event, you need to create your own specialized EventArgs class to hold your data that you want to pass to the delegate object. You create your specialized EventArgs class by deriving from EventArgs class.

public class MyEventArgs EventArgs{    public string m_myEventArgumentdata; }

In case of event handler, the delegate object is referenced using the key word event as follows

public event MyEventHandler MyEvent;</code><code class="pre">

Now, we will set up two classes to see how this event handling mechanism works in .Net framework. The step 2 in the discussion of delegates requires that we define methods with the exact same signature as that of the delegate declaration. In our example, class A will provide event handlers (methods with the same signature as that of the delegate declaration). It will create the delegate objects (step 3 in the discussion of delegates) and hook up the event handler. Class A will then pass the delegate objects to class B. When an event occurs in Class B, it will execute the event handler method in Class A.

using System; //Step 1 Create delegate object public delegate void MyHandler1(object sender,MyEventArgs e); public delegate void MyHandler2(object sender,MyEventArgs e); //Step 2 Create event handler methods class A {    public const string m_id="Class A";    public void OnHandler1(object sender,MyEventArgs e){        Console.WriteLine("I am in OnHandler1 and MyEventArgs is {0}", e.m_id);    }    public void OnHandler2(object sender,MyEventArgs e){        Console.WriteLine("I am in OnHandler2 and MyEventArgs is {0}", e.m_id);    }    //Step 3 create delegates, plug in the handler   //and register with the object that will fire the events    public A(B b) {        MyHandler1 d1=new MyHandler1(OnHandler1);        MyHandler2 d2=new MyHandler2(OnHandler2);        b.Event1 +=d1;        b.Event2 +=d2;    } } //Step 4 Calls the encapsulated methods through the delegates (fires events) class B {    public event MyHandler1 Event1;    public event MyHandler2 Event2;    public void FireEvent1(MyEventArgs e) {        if(Event1 != null){            Event1(this,e);        }    }    public void FireEvent2(MyEventArgs e){        if(Event2 != null){            Event2(this,e);        }    } } public class MyEventArgs : EventArgs{    public string m_id; } public class Driver {    public static void Main(){        B b= new B();        A a= new A(b);        MyEventArgs e1=new MyEventArgs();        MyEventArgs e2=new MyEventArgs();        e1.m_id ="Event args for event 1";        e2.m_id ="Event args for event 2";        b.FireEvent1(e1);        b.FireEvent2(e2);        } }

GUI Event Handling



Event handling in Windows Forms (.NET frame work that supports GUI application) employ the .NET event handling model described earlier. We will now apply that model to write a simple application. The application has one class, MyForm, derived from System.Windows.Forms.Form class. Class MyForm is derived from Form class. If you study the code and the three comment lines, you will observe that you do not have to declare the delegates and reference those delegates using event keyword because the events (mouse click, etc.) for the GUI controls (Form, Button, etc.) are already available to you and the delegate is System.EventHandler. However, you still need to define the method, create the delegate object (System.EventHandler) and plug in the method, that you want to fire in response to the event (e.g. a mouse click), into the delegate object.

using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Data; public class MyForm  Form{    private Button m_nameButton;    private Button m_clearButton;    private Label  m_nameLabel;    private Container m_components = null;        public MyForm(){        initializeComponents();    }    private void initializeComponents(){        m_nameLabel=new Label();        m_nameButton = new Button();        m_clearButton = new Button();        SuspendLayout();        m_nameLabel.Location=new Point(16,16);        m_nameLabel.Text="Click NAME button, please";        m_nameLabel.Size=new Size(300,23);        m_nameButton.Location=new Point(16,120);        m_nameButton.Size=new Size(176, 23);        m_nameButton.Text="NAME";        //Create the delegate, plug in the method,       //and attach the delegate to the Click event of the button        m_nameButton.Click += new System.EventHandler(NameButtonClicked);        m_clearButton.Location=new Point(16,152);        m_clearButton.Size=new Size(176,23);        m_clearButton.Text="CLEAR";        //Create the delegate, plug in the method,       //and attach the delegate to the Click event of the button        m_clearButton.Click += new System.EventHandler(ClearButtonClicked);        this.ClientSize = new Size(292, 271);        this.Controls.AddRange(new Control[] {m_nameLabel,m_nameButton,m_clearButton});        this.ResumeLayout(false);    }    //Define the methods whose signature exactly matches   //with the declaration of the delegate    private void NameButtonClicked(object sender, EventArgs e){        m_nameLabel.Text="My name is john, please click CLEAR button to clear it";    }    private void ClearButtonClicked(object sender,EventArgs e){        m_nameLabel.Text="Click NAME button, please";    }    public static void Main(){        Application.Run(new MyForm());    } }

Conclusion

Other popular object oriented languages like, Java and Smalltalk do not have the concept of delegates. It is new to C# and it derives its root from C++ and J++. I hope that the above discussions will clear this concept to programmers who are starting out C# as their first object oriented language. If you are using Visual Studio IDE for your C# GUI development, attaching your delegate methods to the events generated by GUI controls (like mouse click on a button) can be done without you writing the code. Still, it is better to know what is going on under the hood.

// C#
public class MQListen
{   
   private string m_MachineName;
   private string m_QueueName;
      
   // 생성자는 필요한 대기열 정보를 적용합니다.
   public MQListen(string MachineName, string QueueName)
   {
      m_MachineName = MachineName;
      m_QueueName = QueueName;
   }
    

   // 각 스레드에서 MQ 메시지를 수신하는 데 사용하는 유일한 메서드입니다. 
   public void Listen()
   {
      // MessageQueue 개체를 만듭니다.    
	System.Messaging.MessageQueue MQ  = new 
	System.Messaging.MessageQueue();

      // MessageQueue 개체의 경로 속성을 설정합니다.       
	MQ.Path = m_MachineName + "\\private$\\" + m_QueueName;
            
      // Message 개체를 만듭니다.
	System.Messaging.Message Message = new    
	System.Messaging.Message();        
      // 인터럽트가 수신될 때까지 반복합니다.
      while (true)
      {
         try
         {
	// 인터럽트가 throw된 경우 catch하기 위해 대기합니다. 
	System.Threading.Thread.Sleep(100);
	// Message 개체를 receive 함수의 결과와 동일하게 설정합니다. 
	// Timespan(일, 시간, 분, 초).             
	Message = MQ.Receive(new TimeSpan(0, 0, 0, 1));
                             
            // 받은 메시지의 레이블을 표시합니다.
	System.Windows.Forms.MessageBox.Show(" Label: " + Message.Label);
                  
         }
         catch (ThreadInterruptedException e)
         {
		// 기본 스레드에서 ThreadInterrupt를 catch하고 끝냅니다.             
		Console.WriteLine("Exiting Thread");
            Message.Dispose();
            MQ.Dispose();
            break;
         }
         catch (Exception GenericException)
         {
            // receive에서 throw된 예외를 catch합니다.             
		Console.WriteLine(GenericException.Message);
         }
      }
   }
}

// C#
private void StartThreads()
{
   int LoopCounter; // 스레드 수
   StopListeningFlag = false; // 작업자가 중지될지 여부를
                               // 추적하는 플래그입니다.

   	// 작업자 스레드가 될 5개의 스레드 배열을 선언합니다.    
	Thread[] ThreadArray = new Thread[5];

	// 작업자 스레드의 모든 코드를 포함하는 클래스를 선언합니다.    
	MQListen objMQListen = new
	MQListen(this.ServerName.Text,this.QueueName.Text); 

   for (LoopCounter = 0; LoopCounter < NUMBER_THREADS; LoopCounter++)
   {
      // Thread 개체를 만듭니다.       
	ThreadArray[LoopCounter] = new Thread(new
	ThreadStart(objMQListen.Listen));
      // 스레드를 시작하면 ThreadStart 대리자를 호출합니다.       
	ThreadArray[LoopCounter].Start();
   }

   statusBar1.Text = LoopCounter.ToString() + " listener threads started";

   while (!StopListeningFlag)
   {
      // 사용자가 중지 단추를 누를 때까지 대기합니다.
      // 대기하는 동안 시스템에서는 다른 이벤트를 처리할 수 있습니다.      
	System.Windows.Forms.Application.DoEvents();
   }

   statusBar1.Text = "Stop request received, stopping threads";
   // 인터럽트 요청을 각 스레드에 보냅니다.
   for (LoopCounter = 0;LoopCounter < NUMBER_THREADS; LoopCounter++)
   {      
      ThreadArray[LoopCounter].Interrupt();
   }

   statusBar1.Text = "All Threads have been stopped";
}

// C#
statusBar1.Text = "Starting Threads";
StartThreads();

// C#
StopListeningFlag = true;

// C#
private bool StopListeningFlag = false;

[이 자료는 MSDN 라이브러리에서 가져왔습니다.]

고수닷넷 - 디버깅전문가님

Microsoft는 Office 2003을 출시한 이후로 VSTO에 대한 많은 내용들을 소개하였다. 필자는 지난 1월에 있었던 Office 기술 관련 세미나에 참석하여 처음으로 VSTO에 대해서 알게 되었다. 그 세미나에서 여러 가지 데모를 볼 수 있었는데, 대부분은 주로 엔터프라이즈 환경을 위한 예제였다. 하지만 아이러니 하게도 필자는 그 데모를 보면서 90년대 초반 인기를 끌었던 Tetris라는 게임이 머리를 스쳤다. ‘아! 딱딱하지 않으면서도 사용자들에게 VSTO의 가능성을 보여주기에는 게임만큼 쉬운 방법이 없지!’ 그렇게 해서 Excel Tetris 게임을 만들게 되었다.

정보 구하기

여러분도 알고 있듯이, VSTO는 Visual Studio .NET 2003과 함께 설치되지 않는다. VSTO는 Microsoft Office System을 위한 확장 기능일 뿐, .NET Platform을 위한 개발 도구는 아니기 때문이다. VSTO는 현재 일반 유저에게 공개되어 있지 않으며, MSDN Subscription Download 사이트에서 다운로드할 수 있다. VSTO를 설치하기 위해서는 다음과 같은 프로그램들이 여러분의 운영체제에 미리 설치되어 있어야 한다.

- Visual Studio .NET 2003

- Microsoft Office System

또한 Office System의 경우, 전체 설치를 하거나 custom 설치를 눌러서 Excel이나 Word에서 .NET Programmability Support를 선택하도록 한다. 또한 VSTO를 사용하여 개발한 솔루션을 배포하기 위해서는 다음과 같은 프로그램들을 순서대로 설치해야 한다.

- Microsoft .NET Framework 1.1

- Microsoft Office Excel 2003(앞서 말한 것과 같이 필요한 요소들을 설치해야 한다)

현재 VSTO는 언어별로 제공하고 있기 때문에, 만약 여러분이 영문 운영 체제에서 작업하는 것이 아니라면 반드시 언어 환경과(Culture) 일치하는 VSTO를 설치해야 한다. VSTO에 대한 개괄적인 정보들을 얻기 위해서 다음 사이트를 방문해 보는 것이 좋을 것이다. http://msdn.microsoft.com/office/unders ··· ntro.asp 또한 Office 홈페이지(http://msdn.microsoft.com/office/)에 가면 간단한 예제부터 시작해서 VSTO에 대한 최근의 정보를 확인할 수 있다. 만약 여러분이 Visual Studio .NET 2003 을 설치했다면(이에 대한 정보는 VSTO 설치 파일의 도움말 html에서 확인 해야 함), 로컬 컴퓨터에 설치되어 있는 MSDN 도움말에서 간단한 정보를 얻을 수 있다. 하지만 충분한 내용을 제공한다고 볼 수 없기 때문에 여러분이 구체적이고 실질적인 작업을 진행하기에는 다소 어려움이 따를 것으로 보인다. 그리고 이 글에서 설치나 배포, 그리고 VSTO의 작동 방법에 대해서는 자세하게 소개하고 싶지만, 이 글은 VSTO를 활용하는 실질적인 예를 보여주기 위한 것이기 때문에 관련 정보에 대한 링크를 걸어두는 것으로 만족하도록 하겠다.

시작은 Windows Forms부터

이번 글에서 소개하는 Excel Tetris를 작성하기 전에 필자는 다음과 같은 기능들을 보여주고자 했다.

- 기본적인 Tetris 게임 진행

- 타이머 객체를 활용

- 엑셀의 Row와 Column을 다루는 방법

- 이벤트 처리

이 예제를 작성하기 전에 필자도 여러분처럼 VSTO에 익숙하지 않았기 때문에 VSTO를 기본 테스트 프로젝트로 사용하고 싶지는 않았다. 코드의 작성도 용이하고 디버깅도 쉬워야 했기 때문에 VSTO를 사용하는 대신 Windows Forms에서 간단한 게임을 구현하고 난 후, 이를 VSTO에 적용하는 방법을 선택하기로 하였다. 여러분이 Tetris를 한번이라도 해 본적이 있다면, 이 게임이 굉장히 직관적이며 아주 간단한 조작만이 요구되기 때문에 누구나 쉽게 접근할 수 있다는 것을 알고 있을 것이다. 그렇기 때문에 프로그래밍을 시작하는 많은 사람들이 이 게임을 통해서 알고리즘에 대해서 이해하고 코드를 작성하는 방법에 대해서 이해하려고 한다. 사실 Tetris를 구현하는 소스는 이미 일반에게 많이 공개되었으며, 굉장히 많은 알고리즘이 사용되고 있다. 이 책에서 제공하는 소스도 필자가 나름대로 고민하고 생각하여 구현한 소스로 최고의 알고리즘을 사용했다고 단언할 수는 없다. 또한 필자는 이 소스를 구현함에 있어서 어느 누구의 소스도 참고하지 않았다는 점을 미리 말해둔다.

Tetris 게임을 한번도 해보지 않은 사람을 위해서 게임 진행 방법에 대해서 간단히 소개하자면, 이 게임은 총 4개의 블록으로 구성된 7가지 형태의 바(bar)가 존재한다. 각 바들은 각자의 특성에 따라서 여러 가지 형태로 변형이 되며 여러분이 Row에 빈 곳이 없도록 Bar를 채우는 것이 목표이다. 이번 글이 테트리스 소스 자체에 설명하기 위함이 아니기 때문에 보다 자세한 내용은 소스 코드를 참고하도록 한다. 필자가 이 소스를 구현하면서 가장 중점적으로 생각했던 부분은 이 소스를 VSTO 프로젝트에서 사용해야 하기 때문에 각 블록을 화면에 그리기 위한 코드를 VSTO에 적용하기 쉽도록 정리하는 부분이었다. 이 소스 코드는 FillCell 이라는 이름으로 정리하였다. 이 함수에 대해서는 뒤에서 자세하게 소개할 것이다. Windows Forms에서 만든 예제의 실행 화면은 다음과 같으며, 뒤에서 이 화면에 어떻게 Excel에서 표현되는지 확인할 수 있을 것이다.

간단한 예제 만들기

이 글은 VSTO에 이미 익숙한 개발자보다는 VSTO에 익숙하지 않은 개발자 혹은 VSTO에 대해서 들어본 적이 없는 개발자를 위한 글이기 때문에 VSTO가 무엇인지에 대한 기본적인 개념을 얻을 수 있도록 간단한 프로젝트를 만드는 것부터 시작하겠다. VSTO를 설치하고 난 후 새 프로젝트를 생성하면 다음 <Figure 3>과 같이 새로운 템플릿이 추가된 것을 확인할 수 있다. 여러분은 사용하는 언어에 따라서 C# 또는 VB.NET으로 프로젝트를 생성할 수 있다. 우선 C# 프로젝트를 선택하고 엑셀 문서를 선택한 다음 프로젝트 이름을 입력하면 프로젝트 이름의 엑셀 문서와 엑셀 문서에서 사용할 DLL을 만들기 위한 C# 프로젝트가 생성된다.

프로젝트를 생성하자 마자, 디버그-시작 메뉴를 클릭하거나 Ctrl+F5를 클릭하여 프로젝트를 시작해보자. 여러분이 그 동안 접해왔던 Windows Forms나 익스플로어(Web Forms를 위한 호스트) 창이 아니라 엑셀 문서가 열린다. 프로젝트 마법사가 생성한 코드에는 여러분이 아무것도 추가한 내용이 없기 때문에 여러분이 앞으로 어떻게 해야 할지 전혀 알 수 없는 백지 상태의 엑셀 문서가 열린다. 여러분이 무엇을 해도 상관없지만 엑셀 문서를 닫기 전에 저장하지는 않도록 한다. 나중에 이 문서는 C# 프로젝트에서 다루기 위해서 수정할 것이다. 일단 문서를 닫고 이번에는 디버그-디버깅 모드로 시작 또는 F5를 클릭하여 디버깅 모드로 프로젝트를 시작해보자. Visual Studio .NET이 디버깅 모드로 전환되고 이전과 마찬가지로 엑셀 파일이 열린다. 이번에는 엑셀 파일을 닫지 말고 Visual Studio .NET에서 디버그-디버깅 중지를 눌러보자. 기존에 여러분이 작업했던 것과 마찬가지로 엑셀 문서가 닫힐 것이다.

이번에는 백지 상태의 엑셀 문서에 버튼을 추가해보자. 지금까지 살펴본 모든 작동 방법들이 Windows Forms과 거의 동일하기 때문에 여러분은 엑셀에서 버튼을 추가하고 이벤트 핸들러는 연결하는 작업이 Windows Forms의 작업에서처럼 간단할 것이라고 예상하겠지만, 불행하게도 VSTO는 이러한 작업을 위한 마법사 기능을 제공하고 있지 않다. 결론적으로 볼 때 C# 소스에 추가되는 코드는 동일하지만, 여러분이 이 모든 작업을 수작업을 해야 한다는 사실이 불편할 뿐이다. VSTO 팀에서 다음 버전에서는 엑셀을 Windows Forms처럼 사용할 수 있는 마법사를 제공해주기를 바란다.

UI 구현하기

엑셀에서 버튼을 추가하기 위해서는 Toolbar에서 Control Toolbox를 선택하여 Control Toolbox를 띄우도록 한다. 다음 <Figure 4>에서 확인할 수 있듯이 엑셀 문서에 여러 가지 컨트롤들을 추가할 수 있으며, More Controls를 클릭하여 <Figure 4>에 있는 컨트롤 이외에도 훨씬 많은 컨트롤들을 포함시킬 수 있다. <Figure 5>와 같이 버튼을 추가하고 속성 버튼을 눌러 Text에 Click Here를 입력하고 ID는 btnClick으로 설정한다. 이 버튼을 누르면 Sheet1의 A1에 ‘Hello, Excel’이라는 텍스트를 입력하도록 할 것이다. 버튼을 추가하였다면 Control Toolbox와 Property 창을 닫고 엑셀 문서를 저장하도록 한다.

이번에는 C# 프로젝트로 돌아와서 엑셀 문서에 추가한 버튼 객체를 찾고 이벤트 핸들러를 설치해야 한다. 여러분이 C# 소스 코드를 살펴보았다면 이미 알고 있겠지만, 엑셀 문서에 있는 컨트롤을 찾기 위하여 FindControl 이라는 함수를 사용할 것이다. 이 함수는 다음 <Figure 6>과 같이 구현되어 있다.

기본적으로 생성되는 C# 소스 코드에는 <Figure 6>과 같이 두개의 오버로드된 FindControl 메서드가 존재한다. 매개 변수가 2개인 메서드는 찾고자하는 컨트롤의 ID 이름과 컨트롤이 있는 Sheet를 매개 변수로 넘긴다. 매개 변수가 1개인 메서드는 현재 작업 중인 Sheet를 구해서 또 다른 FindControl 메서드를 호출한다. FindControl 메서드에서는 Sheet의 OLEObjects 메서드를 호출하여 OLE 객체를 구한 다음 반환하고 있다. FindControl이 반환하는 OLEObjects는 MSForms에서 제공하는 컨트롤과 1:1 매칭이 되는데, 예를 들면 Command Button은 CommandButton과 Text Control은 TextBox와 매칭된다. 또한 소스 코드에서 확인할 수 있는 것처럼 FindControl이 컨트롤을 찾지 못할 경우 null을 반환하기 때문에, FindControl을 사용할 때에는 항상 리턴값이 null인지를 비교한 다음 리턴된 객체를 사용하도록 해야 한다. 따라서 다음과 같이 코드를 작성하여 엑셀 문서에 추가한 컨트롤을 찾을 수 있다.

MSForms.CommandButton btnClick = (MSForms.CommandButton) FindControl("btnClick");

그리고 다음과 같이 이벤트 핸들러를 생성할 수 있다. 이벤트 핸들러를 작성하는 방법은 Wizard가 제공되지 않을 뿐, 여러분이 지금까지 Windows Forms이나 Web Forms에서 해왔던것과 동일한 방법으로 추가한다.

btnClick.Click += new Microsoft.Vbe.Interop.Forms.CommandButtonEvents_ClickEventHandler(btnClick_Click);

하지만 다행스럽게도 Visual Studio .NET의 IntelliSense 덕분에 이 긴 코드를 직접 입력하지 않고 <Tab> 키만 눌러도 자동으로 코드가 추가된다. 이제 앞서 말했듯이, 버튼을 클릭했을 때 발생하는 핸들러에서 엑셀 영역에 텍스트를 설정하는 코드를 작성해야 한다. 코드를 작성하기 전에 Excel의 구조에 대해서 간단히 살펴보도록 하자. 엑셀의 구조는 크게 Application과 Worksheet, Sheet 그리고 Range(또는 Cell)로 나눌 수 있다. Application은 Excel 응용 프로그램 자체를 나타내며, Worksheet는 여러분이 작성하거나 다루고 있는 문서를 나타낸다. Sheet는 하나의 문서 안에 들어 있는 각 페이지를 나타내고 마지막으로 Range는 각 페이지에 있는 Cell의 영역을 나타낸다. Range의 범위가 하나일 경우를 Cell이라고 한다. 이러한 구조 때문에 각 단위들은 자신들에게 고유한 이벤트와 속성들을 제공한다. 예를 들어, 여러분이 프로그램을 실행할 때 발생하는 이벤트들은 모두 Application에 존재하며, 문서를 열거나 닫을 때 발생하는 이벤트들은 모두 Worksheet에 존재한다. 따라서 Excel을 제대로 다루기 위해서는 이러한 구조를 이해하고 여러분이 원하는 이벤트와 속성이 어떤 범위에 속할 것인지를 판단할 필요가 있다.

< Figure 7>에서와 같이 Range는 하나 이상의 Cell을 포함하고 있다. 하지만 Excel에서는 주요작업 단위를 Range로 사용하기 때문에 A1에 문자열을 출력하기 위해서 A1에 해당하는 Range를 구하도록 한다. Cell 이름을 통해서 Range를 얻는 방법은 간단한다. 다음 코드와 같이 원하는 영역의 이름을 매개 변수로 전달하면 해당 영역 만큼 Range를 반환한다.

private void btnClick_Click ( )

{

       Excel.Worksheet sheet = (Excel.Worksheet) ThisApplication.Sheets.get_Item(1);

       Excel.Range rng = sheet.get_Range ( "A1", "A1" );

       rng.Value2 = "Hello, Excel";

}

필자가 이 예제를 작성할 때 텍스트를 설정하기 위한 메서드나 속성이 당연히 Text와 같은 이름의 이름을 갖고 있을 것이라고 생각했지만, 결국 Value2라는 속성이었다(Text 속성은 읽기 전용이다). VSTO 팀에서 Value2를 지원하는지 모르겠지만, 다음 버전에서는 이러한 부분들이 수정되었으면 하는 바람이다.

작성된 코드를 테스트하기 위해서 디버그-시작 메뉴를 클릭하여 엑셀 문서를 띄운 후, 버튼을 클릭보자. A1에 ‘Hello, Excel’이라는 문자열이 출력될 것이다. 이제 여러분은 내가 더 이상 설명할 필요도 없이 엑셀 문서를 다루는 방법을 알고 있을 것이다.

Let’s get started!

이미 VSTO에 대해서 알고 있는 독자라면 지루한 설명을 보느라 수고가 많았다. 이제부터 본격적으로 엑셀에서 작동하는 게임을 만들어보도록 하겠다. 가장 먼저 앞서 설명한 것과 같은 방법으로 ExcelTetris라는 이름으로 C#용 엑셀 프로젝트를 생성하도록 한다. 그리고 앞에서 작성한 예제의 테트리스 클래스(MyTetris)를 새로운 프로젝트에 추가하도록 한다. 아무런 문제없이 빌드되는지 확인하도록 한다. 앞으로 추가해야 하는 부분들이 다소 복잡할 수 있기 때문에 많은 문제점들이 한꺼번에 발생하지 않도록 틈틈히 빌드 오류를 수정하면 진행하도록 하겠다. 아마도 몇몇 독자들은 Windows Forms에서 사용한 코드를 그대로 사용할 수 있는가에 대해서 의문을 갖고 있을것이다. 물론, 코드를 전혀 수정하지 않고 MyTetris 클래스를 그대로 사용할 수는 없다. 가장 큰 이유는 MyTetris 클래스가 화면을 그리는 부분과 관련된 코드를 포함하고 있기 때문에 엑셀 문서에 블록을 그려주기 위해서는 이 부분을 수정해야 한다. 하지만 크게 걱정할 필요는 없다. 여러분이 해야 할 일은 FillCell 이라는 메서드를 Graphics 객체를 사용하지 않고 Excel.Sheet를 사용하도록 수정하는 것이다. 물론 여러분은 MyTetris 클래스를 상속 받은 새로운 ExcelTetris 클래스를 구현한 후, FillCell 메서드를 오버라이드 할 수 있다. 하지만 필자는 될 수 있으면 예제를 간단하게 유지하기 위해서 MyTetris 클래스의 FillCell 부분과 UI에 관련된 몇몇 코드를 수정하였다. 몇가지 코드를 수정한다면, 이 클래스를 Excel 프로젝트와 Windows Forms 프로젝트 모두에서 쉽게 사용할 수 있을 것이다. 또한 이 글이 테트리스 게임 자체가 아니라, VSTO의 활용법에 중점을 두고 있기 때문에 MyTetris 클래스에 몇가지 논리적인 오류가 있음을 알아두도록 한다.

MyTetris 클래스를 사용하는 외부에서는 MyTetris 클래스가 화면에 게임의 진행 상태를 그릴 수 있도록 Draw 메서드를 호출하며, Draw 메서드는 다음과 같이 구현되어 있다.

/// <summary>

/// This is the only drawing method that client can call.

/// </summary>

/// <param name="sheet">Excel.Sheet object that will be used to draw</param>

public void Draw ( ref Excel.Worksheet sheet )

{

       // Game over?

       //

       if ( IsEnd == false )

       {

              DrawBlock ( ref sheet );

              DrawNextBlock ( ref sheet  );

       }

}

Draw 메서드는 게임의 진행 상태를 그려야 하는 Sheet에 대한 reference 객체를 매개 변수로 받고, 게임이 종료되지 않았다면 전달받은 매개 변수를 이용하여 DrawBlock과 DrawNextBlock 메서드를 호출한다. DrawBlock과 DrawNextBlock 메서드의 코드는 첨부된 파일에서 확인할 수 있다. 이 두 메서드는 좌표를 계산한 후, FillCell 메서드를 호출한다. FillCell 메서드에 대해서는 뒤에서 보다 자세하게 살펴보도록 한다.

ExcelTestris 프로젝트를 생성한 후, 가장 먼저 해야 할 일은 엑셀 문서를 열고 UI를 구현하는 것이다. 엑셀 문서를 여는 방법은 ExcelTetris를 실행시키거나 프로젝트 폴더에 가서 직접 열 수 있다. 어느 방법을 통해서든지 문서를 수정하고 저장하면 된다. 엑셀 문서를 다음 < Figure 8>과 같이 같이 버튼들을 배치하도록 하고, 각 버튼들의 속성은 다음 <표 1>과 같다. 컨트롤들을 배치할 때 버튼의 위치가 Cell의 크기를 조절하는 부분(InitSheet 메서드)과 겹치게 되면 컨트롤의 크기가 변경되기 때문에 적절하게 배치해야 한다.

<표 1 ? UI 컨트롤 속성>

나중에 이 버튼들에 대한 Click 이벤트를 C# 소스에 추가할 것이다. < Figure 8>에서 확인할 수 있는 것처럼 밑 부분에는 텍스트 박스가 위치하고 있다. 여러분이 게임을 진행하기 위해서는 키보드 조작을 위한 입력을 받아야 하는데, Sheet 자체 내에서 키보드 입력을 직접 받을 수 없었기 때문에, 아무 내용도 출력하지 않는 텍스트 상자를 만든 후 이 텍스트 상자를 통해서 입력을 받을 수 있도록 처리하였다. 또한 < Figure 8>에는 프로그램 정보를 출력하는 텍스트 상자들이 있다. <Figure 8>과 같은 형태로 UI를 구성한 후에 엑셀 문서를 닫고 C# 프로젝트로 이동한다. 우선 이 컨트롤들을 사용하기 위해서 변수를 다음과 같이 선언해야 한다.

// Excel controls...

//

private MSForms.CommandButton btnGameStart;

private MSForms.CommandButton btnGameStop;

private MSForms.CommandButton btnGamePause;

private MSForms.CommandButton btnAbout;

private MSForms.TextBox txtInput;

private MSForms.TextBox txtClearLined;

변수를 선언하고 난 후, 엑셀 문서에서 해당 컨트롤들을 찾아서 할당해야 한다. 이와 같은초기화 작업은 엑셀 문서가 열리는 시점에서 수행해야 하며 이에 대한 이벤트 핸들러가ThisWorkbook_Open 이벤트 핸들러이다. 이 핸들러는 엑셀 프로젝트 생성시 자동으로 생성되며 문서에 대한 초기화 작업을 수행하기에 적당한 곳이다. 초기화에 관련된 모든 코드가 ThisWorkbook_Open 이벤트 핸들러에 있지만, 뒤에서 소개할 Sheet 자체에 대한 초기화나 Style에 관련된 내용은 별도의 메서드로 분리하였다. ThisWorkbook_Open 이벤트 핸들러의 전체 소스는 <Figure 9>와 같다.

FindControl 메서를 이용하여 컨트롤을 얻고 각각의 Command Button에 대해서 Click 이벤트를 Text Box에 대해서 KeyDown 이벤트 핸들러를 추가한다. 이벤트 핸들러를 추가할 때 어려웠던 점은 핸들러의 매개 변수가 무엇을