전산쟁이의 카피질

뒤로 검색

Visual Studio .NET 및 Microsoft .NET Compact Framework 시작

2009/01/15 00:09

Visual Studio .NET 및 Microsoft .NET Compact Framework 시작

출처 : http://msdn.microsoft.com/en-us/library/ms836776.aspx
Windows CE .NET
Developing Custom Controls in C# with Smart Device Extensions
 

Chris Tacke, Windows Embedded MVP
Applied Data Systems

July 2002

Applies to:
    Microsoft® Windows® CE .NET
    Smart Device Extensions for Microsoft Visual Studio® .NET

Summary: Learn how to create custom controls with the Smart Device Extensions for Microsoft Visual Studio .NET (SDE). (12 printed pages)

Contents

Introduction
The Problem
The Object Model
Building the Custom Connector

Introduction

The Smart Device Extensions for Microsoft Visual Studio .NET (SDE) provide a nice assortment of basic controls for use in applications. Unfortunately, the extremely broad spectrum of embedded device applications makes it almost certain that at some point a developer will be left wanting, and at that point you essentially have two choices: either re-architect your application to use the available controls or roll your own custom control.

The first version of SDE does not have support for design time custom controls, which means that in order to use them, you have to manually write the code that puts them on your forms and sets their size and properties. It just takes a little extra work and a willingness to accept that there is no Form Design Support for custom controls.

The Problem

Recently I was creating class libraries for Visual Studio .NET that wrap the functionality of a lot of our hardware. It is much simpler for a managed code developer to use a class library to access on-board microcontrollers and Microsoft Windows CE ports by using a class library that does all of the P/Invoking and resource management for them. The class library I was working on is for I/O on our Graphics Master, exposing the ability to read from and write to pins on two separate headers.

I wanted a test and sample application that easily allows the user to set or read a digital I/O state as well as read analog I/Os through a reasonably nice graphical interface. I wanted something that looked like a header on a schematic or like the physical plug on the board. Since I was working with two physically different-sized headers, I needed either multiple controls, or preferably, a control that I could define the size of. Not surprisingly, the SDE does not have the control I wanted in the toolbox.

I could have used a large collection of Labels, CheckBoxes, PictureBoxes, and TextBoxes, but I thought that it would be an ugly substitute. Let's look at writing our own control.

The Object Model

The first task is to decide on an overall object model. What "pieces" will we need, how will these pieces fit together and how will they interact with each other as well as their environment?

Figure 1. My concept of the Connector control

We should create a connector that contains a variable-sized collection of pins to allow for the different-sized headers. Each pin should have to have an identifying label that can either be left or right of the displayed "pin", depending on whether it is an even or an odd pin. Each pin can also be either a digital or an analog I/O, so each needs to have an individual value that can range from zero to 0xFFFF. It would be nice to be able to tell at a glance the type and value of each pin, so some color will be necessary. Of course not all pins in a header are usable for I/O, so we need to be able to disable some of them, and to top it off, we want the pins to be interactive, so when we tap one, it can do something like change state.

Figure 1 is a good paper model of what the control should look like on the screen.

Based on these requirements, we come up with an object model like the one shown in Figure 2.

Figure 2. Control Object Model

The overall idea is that we will have a Connector base class, from which we can derive several other custom Connector classes. The Connector will contain a Pins class, which will simply expose a ListArray of Pin objects with an indexer by deriving from CollectionBase.

Implementing the Pin Object

Since the workhorse of the control is the Pin object, let's start with it. The Pin object is going to handle most of the display properties of the control and handle user interaction. Once we can successfully create, display, and interact with a single pin on a form, building a connector to group them together will be simple.

The Pin object has four properties that we must set when the object is created. The default constructor sets each of them, but additional constructors can also be used to allow the creator to pass in non-default values.

The most important property is the Alignment. This property determines the positioning of the text and the pin when the object is drawn, but more importantly, when the property is set, is creates and positions rectangles that will be used for drawing both the pin and the text. The use of these Rectangles will be covered later in the OnDraw explanation.

Listing 1 shows the code for the base constructor and the Alignment property. We are using constants for defined offsets and borders around out pin subcomponents, but these could easily become additional properties of the control as well.

Listing 1. The Pin Constructor and Alignment Property


public Pin()
{
  showValue = false;
  pinValue = 0;
  type = PinType.Digital;
  Alignment = PinAlignment.PinOnRight;
}
public PinAlignment Alignment
{ // determines where the pin rectangle is placed
  set
  {
    align = value;
    if(value == PinAlignment.PinOnRight)
    {
      this.pinBorder = new Rectangle(
        this.ClientRectangle.Width - (pinSize.Width + 10),
        1,
        pinSize.Width + 9,
        this.ClientRectangle.Height - 2);
        this.pinBounds = new Rectangle(
        this.ClientRectangle.Width - (pinSize.Width + 5),
        ((this.ClientRectangle.Height -
        pinSize.Height) / 2) + 1,
        pinSize.Width,
        pinSize.Height);
        this.textBounds = new Rectangle(
        5,
        5,
        this.ClientRectangle.Width - (pinSize.Width + 10),
        20);
    }
    else
    {
      this.pinBorder = new Rectangle(
        1,
        1,
        pinSize.Width + 9,
        this.ClientRectangle.Height - 2);
        this.pinBounds = new Rectangle(
        6,
        this.ClientRectangle.Height - (pinSize.Height + 4),
        pinSize.Width,
        pinSize.Height);
        this.textBounds = new Rectangle(
        pinSize.Width + 10,
        5,
        this.ClientRectangle.Width - (pinSize.Width + 10),
        20);
    }
    this.Invalidate();
  }
  get
  {
    return align;
  }
}

 

Since the Pin object is not going to provide much user interaction or customizability, the heart of the pin is the drawing routine OnDraw that we will override so we can draw the entire pin ourselves.

Each pin will be drawn in three pieces: the pin itself will be a circle (unless it is Pin 1, in which case it will be a square), we will draw a border rectangle around the pin, and then we will have an area either to the left or right of the pin where the pin's text will be drawn.

To draw a pin, first we determine what color we will be using for the circle representing the actual pin. If the pin is disabled, we will color it gray. If it is enabled, then we determine what type it is. We'll color analog pins green, and we'll color digital pins either blue if they're low (off), or orange if they're high (on).

Next we draw the actual pin using FillEllipse for all pins except when the PinNumber = 1, in which case we draw using FillRectangle. By drawing into a rectangle (pinBounds) instead of onto the control's bounds, we are able to set the pin's location (left or right) when the pin is created, and from that point on we can draw without being concerned with the pin placement.

Next we draw the label, which, depending on the ShowValue property, will either be the pin's text or the pin's value.

We use a similar tactic for drawing the text as we did the pin itself, but this time we must calculate both horizontal and vertical offsets because the DrawText method doesn't allow for a TextAlign parameter in the Microsoft .NET Compact Framework.

Finally, we clean up the Brush object we used manually by calling its Dispose method.

The entire OnDraw routine is shown in Listing 2.

Listing 2. The OnDraw() Method


protected override void OnPaint(PaintEventArgs pe)
{
  Brush b;
        // determine the Pin color
  if(this.Enabled)
  {
    if(type == PinType.Digital)
    {
      // digital pins have different on/off color
      b = new System.Drawing.SolidBrush(
      this.Value == 0 ? (digitalOffColor) : (digitalOnColor));
    }
    else
    {
      // analog pin
      b = new System.Drawing.SolidBrush(analogColor);
    }
  }
  else
  {
    // disabled pin
    b = new System.Drawing.SolidBrush(disabledColor);
  }
  // draw the pin
  if(this.PinNumber == 1)
    pe.Graphics.FillRectangle(b, pinBounds);
  else
    pe.Graphics.FillEllipse(b, pinBounds);
  // draw a border Rectangle around the pin
  pe.Graphics.DrawRectangle(new Pen(Color.Black), pinBorder);
  // draw the text centered in the text bound
  string drawstring;
  // are we showing the Text or Value?
  if(showValue)
    drawstring = Convert.ToString(this.Value);
  else
    drawstring = this.Text;

  // determine the actual string size
  SizeF fs = pe.Graphics.MeasureString(
        drawstring,
        new Font(FontFamily.GenericMonospace, 8f,
                 FontStyle.Regular));
  // draw the string
  pe.Graphics.DrawString(
      drawstring,
      new Font(FontFamily.GenericMonospace, 8f,
      FontStyle.Regular),
      new SolidBrush((showValue ? analogColor : Color.Black)),
      textBounds.X + (textBounds.Width - fs.ToSize().Width) / 2,
      textBounds.Y + (textBounds.Height - fs.ToSize().Height) / 2);
  // clean up the Brush
  b.Dispose();
  }
}

The final step to building the Pin class is to add the Click handler. For our Pin class, we'll use a custom EventArg so that we can pass both the pin's text and number to the event handler. To create a custom EventArg, we simply create a class that derives from the EventArgs class:
 
public class PinClickEventArgs : EventArgs
{
  // a PinClick passes the Pin Number and the Pin's Text
  public int number;
  public string text;
  public PinClickEventArgs(int PinNumber, string PinText)
  {
    number = PinNumber;
    text = PinText;
  }
}

Next we add a delegate to our namespace:

public delegate void PinClickHandler(Pin source, PinClickEventArgs args);

 

Now we need to add code to determine when a click occurs, and then raise an event. For our Pin class, we'll define a click logically as when we have both a MouseDown and a MouseUp event inside the pin's border rectangle—so if the user taps the text portion of a pin, the Click event will not fire, but if they tap the area that represents the actual pin, it will.

First we need a public PinClickHandler event, defined like this:


public event PinClickHandler PinClick;

 

We also need a private Boolean variable that we'll set when the MouseDown event occurs, indicating that we are in mid-click. We will then check that variable on the MouseUp event to see if both events occurred in successive order:


bool midClick;

Next we need to add the two event handlers for MouseDown and MouseUp, which are shown in Listing 3.

Listing 3. Event Handlers for Implementing the PinClick event


private void PinMouseDown(object sender, MouseEventArgs e)
{
  if(!this.Enabled)
    return;

  // if the user clicked in the "pin" rectangle, start a click process
  midClick = pinBorder.Contains(e.X, e.Y);
}
private void PinMouseUp(object sender, MouseEventArgs e)
{
  // if we had a mousedown and then up inside the "pin" rectangle,
  // fire a click
  if((midClick) && (pinBorder.Contains(e.X, e.Y)))
  {
    if(PinClick != null)
      PinClick(this, new PinClickEventArgs(
               this.PinNumber, this.Text));
  }
}

And lastly we need to implement the event handler for each pin. The pin base constructor is a good place to add these hooks and we can do so by simply adding the following code to our constructor:

this.MouseDown += new MouseEventHandler(PinMouseDown);
this.MouseUp += new MouseEventHandler(PinMouseUp);

Implementing the Pins Class

Once we have the Pin class, we can create a Pins class that derives from CollectionBase. The purpose of this class is to provide an indexer so we can easily add, remove and manipulate Pin classes within a collection.

Listing 4. The Pins Class


public class Pins : CollectionBase
{
  public void Add(Pin PinToAdd)
  {
    List.Add(PinToAdd);
  }
  public void Remove(Pin PinToRemove)
  {
    List.Remove(PinToRemove);
  }
  // Indexer for Pins
  public Pin this[byte Index]
  {
    get
    {
      return (Pin)List[Index];
    }
    set
    {
      List[Index] = value;
    }
  }
  public Pins(){}
}

Implementing the Connector Class

Now that we've got a Pins class, we need to build a Connector class, which will be a simple wrapper class that holds a Pins class, marshals the PinClick events between each pin and the connector container, and has a constructor for the number of pins on the connector. Listing 5 shows the entire Connector class.

Listing 5. The Connector Class


public class Connector : System.Windows.Forms.Control
{
  public event PinClickHandler PinClick;
  protected Pins pins;
  byte pincount;
  public Connector(byte TotalPins)
  {
    pins = new Pins();
    pincount = TotalPins;
    InitializeComponent();
  }
  private void InitializeComponent()
  {
    for(int i = 0 ; i < pincount ; i++)
    {
      Pin p = new Pin(PinType.Digital,
            (PinAlignment)((i + 1) % 2), 0);
      p.PinClick += new PinClickHandler(OnPinClick);
      p.PinNumber = i + 1;
      p.Text = Convert.ToString(i);
      p.Top = (i / 2) * p.Height;
      p.Left = (i % 2) * p.Width;
      this.Pins.Add(p);
      this.Controls.Add(p);
    }
    this.Width = Pins[0].Width * 2;
    this.Height = Pins[0].Height * this.Pins.Count / 2;
  }
  public Pins Pins
  {
    set
    {
      pins = value;
    }
    get
    {
      return pins;
    }
  }
  private void OnPinClick(Pin sender, PinClickEventArgs e)
  {
    // pass on the event
    if(PinClick != null)
    {
      PinClick(sender, e);
      if(sender.Type == PinType.Digital)
        sender.Value = sender.Value == 0 ? 1 : 0;
      else
        sender.DisplayValue = !sender.DisplayValue;
    }
  }
  protected override void Dispose( bool disposing )
  {
    base.Dispose( disposing );
  }
}

The Connector's InitializeComponent method is where all of the contained Pin classes get created and added to the connector's controls and where the connector itself is sized. InitializeComponent is also the method that will eventually be used by the Form Designer to display our connector.

Building a Custom Connector

The Connector class itself is simple and does not modify any default pin settings. However, we can now build a custom connector and modify individual pins (for example making some analog or disabled) by deriving a new class from the Connector class.

In the sample application I created two connectors for the Applied Data Systems' Graphics Master board, one for J2 and one for J7. The constructors set the pin types as well as the pin text based on the connector. Figure 2 is a screen shot of the sample application with both a J2 and J7 on the Form.

Figure 3. Form using two Connector objects



 =========================


Visual Studio .NET 및 Microsoft .NET Compact Framework 시작

Larry Roof
larryroof.com  

2002년 3월

적용 대상:
    Microsoft .NET Compact Framework 1.0
    Microsoft Visual Studio .NET 2003
    Microsoft Windows CE .NET

요약: .NET Compact Framework 1.0 및 Visual Studio .NET 2003을 사용한 강력한 스마트 클라이언트 장치 응용 프로그램 개발에 대해 설명합니다(34페이지/인쇄 페이지 기준).

목차

소개
공용 언어 런타임
.NET Compact Framework 클래스 라이브러리
아라카르트식 기능
.NET Compact Framework에 없는 기능
Visual Studio .NET 2003을 사용한 개발
IDE 추가 사항
지원되는 언어
온라인 설명서
.NET Compact Framework 응용 프로그램 만들기
Visual Basic .NET 프로젝트 시작
Visual C# .NET 프로젝트 시작
스마트 장치 응용 프로그램 마법사
Pocket PC 프로젝트 유형
Windows CE 프로젝트 유형
프로젝트 속성 설정
인터페이스 만들기
코드 추가
응용 프로그램 테스트
에뮬레이터로 테스트
장치 테스트
응용 프로그램 디버깅
응용 프로그램 배포
필수 사항
CAB 파일 만들기
CAB 파일 출력
데스크톱 설치 프로그램 만들기
요약
추가 정보 사이트

소개

Microsoft가 .NET Compact Framework를 개발하면서 염두에 두었던 한 가지 의도는 응용 프로그램 개발입니다. 여기서 말하는 응용 프로그램이란 정보를 표시, 수집, 처리 및 전달하고 사용자에게 장치를 가지고 다닐 만한 이유를 제시하는 프로그램을 말합니다. 일반적으로 인터페이스를 가지지만 여기서는 필요 없습니다. 작업에 사용하는 데이터는 로컬, 원격 또는 둘 다일 수 있습니다.

.NET Compact Framework를 사용하면 스마트 장치에서 응용 프로그램을 간단하게 개발할 수 있습니다. 현재 Pocket PC, Pocket PC 2002, Pocket PC Phone Edition 및 기타 Windows CE.NET 4.1 이상을 실행하는 장치가 여기에 해당합니다.

Visual Studio .NET 2003이 있어야 .NET Compact Framework를 대상으로 하는 응용 프로그램을 빌드할 수 있습니다. Visual C# .NET, Visual Basic .NET 또는 둘 다 사용하여 응용 프로그램을 빌드할 수 있습니다.

.NET Compact Framework의 두 가지 기본 구성 요소는 공용 언어 런타임과 .NET Compact Framework 클래스 라이브러리입니다.

런타임은 .NET Compact Framework의 기초로, 실행 시간의 코드 관리, 코드 보안과 정확성 구현을 비롯한 메모리 관리 및 스레드 관리와 같은 핵심 서비스를 제공하는 역할을 담당합니다. 런타임을 대상으로 하는 코드는 관리되는 코드라고 하고 eMbedded Visual C++의 경우처럼 런타임을 대상으로 하지 않는 코드는 관리되지 않는 코드 또는 네이티브 코드라고 합니다.

.NET Compact Framework 클래스 라이브러리는 응용 프로그램을 쉽고 빠르게 개발하는 데 사용할 수 있는 재사용 가능한 클래스 컬렉션입니다. 이 프레임워크는 Microsoft 또는 타사 플랫폼에 대한 이식성을 염두에 두고 디자인되었습니다. 이것이 가지는 의미는, 간단히 말해서 Pocket PC에서 실행되도록 만든 코딩 기술과 응용 프로그램을 해당 플랫폼용의 .NET Compact Framework 버전이 만들어진 경우 휴대폰이나 다른 공급업체의 PDA와 같은 다른 플랫폼에서 실행할 수 있다는 것입니다.

공용 언어 런타임

공용 언어 런타임은 .NET Compact Framework를 대상으로 하는 코드를 관리하는 코드 실행 환경을 제공합니다. 코드 관리는 메모리 관리, 스레드 관리, 보안 관리, 코드 확인 및 컴파일, 기타 시스템 서비스 형식을 취할 수 있습니다.

런타임은 성능 향상을 위해 디자인되었으며 관리되는 코드가 응용 프로그램이 실행되는 플랫폼의 기계 언어로 실행되도록 하는 JIT(Just-in-Time) 컴파일링을 사용합니다. 그러면 다양한 플랫폼을 대상으로 하는 응용 프로그램을 만들 수 있고 각 특정 플랫폼을 대상으로 하는 실행 파일을 다시 컴파일하거나 생성하는 것에 대해 걱정하지 않아도 됩니다.

모바일 응용 프로그램이 Visual Basic .NET 또는 C# .NET으로 작성되어 있고 관리되는 코드도 마찬가지라 하더라도 Windows CE API를 포함한 동적 연결 라이브러리(DLL)에 외부적으로 저장된 함수와 서브루틴을 통합할 수 있습니다. .NET Compact Framework는 Windows CE API의 함수를 해당 응용 프로그램에 쉽게 통합할 수 있는 구조를 지원하고 데이터 형식을 제공합니다.

.NET Compact Framework 클래스 라이브러리

.NET Compact Framework 클래스 라이브러리는 공용 언어 런타임을 엄격하게 통합하는 재사용이 가능한 클래스 컬렉션입니다. 응용 프로그램은 이러한 라이브러리를 활용하여 기능을 파생합니다.

개체 지향 클래스 라이브러리에서와 마찬가지로 .NET Compact Framework 형식을 사용해서 인터페이스 디자인, XML 활용, 데이터베이스 액세스, 스레드 관리 및 파일 I/O 등의 작업을 비롯한 다양한 일반 프로그래밍 작업을 수행할 수 있습니다.

다음은 .NET Compact Framework를 통해 사용 가능한 일반 기능 목록입니다.

폼 관련 클래스

.NET Compact Framework는 장치 응용 프로그램용으로 풍부한 Windows CE 기반 사용자 인터페이스를 구축할 수 있도록 System.Windows.Form 및 System.Drawing 클래스의 하위 집합을 구현합니다. Visual Studio.NET의 폼 디자이너가 클래스와의 상호 작용을 상당 부분 관리합니다.

.NET Compact Framework에서의 Windows Form 구현의 예를 들면 폼 지원, NET Framework의 대다수 컨트롤, 타사 컨트롤 호스팅, 비트맵과 메뉴가 있습니다. 표 1은 .NET Compact Framework에 포함된 컨트롤 목록입니다.

표 1. .NET Compact Framework에 포함된 컨트롤

컨트롤 설명
Button 단순 명령 단추
CheckBox 일반 확인란
ComboBox 항목의 드롭다운 목록
ContextMenu 상황에 맞는 메뉴 구현
DataGrid 데이터 소스에 바인딩할 수 있는 모눈
DomainUpDown 스크롤 막대로 탐색이 가능한 항목 목록
HScrollBar 수평 스크롤 막대
ImageList 이미지를 저장하는 컨테이너
InputPanel SIP(Soft Input Panel) 제어
Label 텍스트 표시용 단순 컨트롤
ListBox 항목 목록 표시
ListView 데이터에 대한 네 가지 보기 제공: 큰 아이콘, 작은 아이콘, 목록, 자세히
MainMenu 폼에 메뉴 구현
NumericUpDown 스크롤 막대가 포함된 숫자 입력 필드
OpenFileDialog 기본 파일 열기 대화 상자에 대한 액세스 제공
Panel 기타 컨트롤을 보관하는 데 사용하는 컨테이너
PictureBox 이미지 표시
ProgressBar 작업 진행 상황을 보여주는 표시기
RadioButton 일반 라디오 단추
SaveFileDialog 기본 파일 저장 대화 상자에 대한 액세스 제공
StatusBar 텍스트를 표시하는 단순 패널
TabControl 응용 프로그램용 탭 인터페이스 제공
TextBox 표준 텍스트 입력 필드
Timer 기본 Timer 구성 요소
ToolBar 폼에 도구 모음 구현
TrackBar 숫자 데이터와 함께 사용하는 슬라이더 인터페이스
TreeView 계층 형식으로 데이터 표현
VScrollBar 수직 스크롤 막대

.NET Compact Framework는 전체 .NET Framework의 하위 집합이기 때문에 포함된 컨트롤은 해당 데스크톱 제품군 기능의 하위 집합을 가집니다. 크기와 성능을 고려해서 일부 컨트롤 속성, 메서드 및 이벤트를 .NET Compact Framework 컨트롤에서 생략했습니다. 약간의 코드를 추가하면 필요한 경우 누락된 기능을 직접 구현할 수 있습니다. .NET Compact Framework를 사용하면 기본 컨트롤 클래스로부터 상속을 통해 고유 컨트롤을 만들 수 있기 때문입니다. 이를 기초로 고유 속성, 메서드 및 이벤트를 추가함으로써 정확하게 원하는 컨트롤을 만들 수 있습니다.

데이터 및 XML 클래스

.NET Compact Framework에는 XML 콘텐트를 포함하여 데이터를 관계형 또는 비 관계형 데이터 소스 여부와 상관없이 모바일 응용 프로그램에 쉽게 통합할 수 있는 클래스 세트가 포함되어 있습니다. 이러한 클래스는 System.Data 및 System.Xml 네임스페이스에 정의됩니다. 데이터와 XML 클래스 모두를 .NET Compact Framework에 구현한 것이 .NET Framework의 하위 집합입니다.

웹 서비스

.NET Framework는 웹 서비스와 거의 비슷합니다. .NET Compact Framework System.Web 네임스페이스에서 해당 .NET Framework 네임스페이스에 제공된 기능을 축소한 버전입니다. 가장 중요한 점은 .NET Compact Framework에서 웹 서비스 클라이언트를 만들 수는 있어도 웹 서비스를 호스트는 할 수 없다는 것입니다.

이러한 XML 웹 서비스 클라이언트는 동기적일 수도 있고 비동기적일 수도 있습니다. .NET Compact Framework를 대상으로 하는 XML 웹 서비스 클라이언트를 만드는 것은 쉽습니다. Visual Studio .NET IDE가 대부분의 작업을 수행합니다.

GDI 지원

.NET Compact Framework는 System.Drawing 네임스페이스를 통해 비트맵, 브러시, 글꼴, 아이콘 및 펜을 포함한 기본 GDI 그리기 요소를 지원합니다.

기본 클래스

.NET Compact Framework는 개발자를 위한 다양한 기능을 제공하는 견고한 기본 클래스 세트를 제공합니다. 이 기본 인프라를 사용하여 멀티 스레드 응용 프로그램 만들기(System.Threading), 네트워킹 리소스 활용(System.Net) 및 파일 작업(System.IO)을 비롯한 풍부한 .NET 응용 프로그램을 작성할 수 있습니다.

IrDA 지원

Pocket PC 및 Pocket PC 2002처럼 Windows CE 장치는 적외선(IR) 통신 기능이 있습니다. 이것을 지원하기 위해 .NET Compact Framework는 응용 프로그램 내부에서 IR 통신을 활용할 수 있는 클래스를 포함하고 있습니다. 이러한 클래스는 System.Net.IrDA 네임스페이스에 속해 있습니다. IR을 사용하면 Pocket PC, 프린터 및 기타 IR 기반 장치와 통신할 수 있습니다.

Bluetooth 지원

.NET Compact Framework는 기본적으로 Bluetooth 지원을 제공하지 않습니다. 대부분 타사 Pocket PC의 Bluetooth 구현은 직렬 포트 통신이나 공급자 API를 통해 액세스할 수 있습니다.

Visual Basic 지원

Visual Basic .NET은 Visual Basic 도우미 라이브러리에 위치한 도우미 함수를 자유자재로 사용합니다. .NET Compact Framework에는 이러한 함수의 하위 집합도 들어 있습니다. 이러한 함수는 Visual Basic 개발자 사이에 언어의 핵심으로 여겨지며, 여기에 포함된 이유도 그것 때문입니다.

.NET Compact Framework로 변환하는 Visual Basic 또는 eMbedded Visual Basic 개발자의 경우 작업에 사용하던 다수의 Visual Basic 언어 함수를 Visual Basic .NET에서도 사용할 수 있음을 의미합니다.

아라카르트식 기능

대상 장치의 리소스를 보호하기 위해 Microsoft는 .NET Compact Framework를 논리적 구성 요소로 분할했습니다. 구성 요소를 개별 DLL, 또는 어셈블리(.NET Compact Framework 내부 지칭 용어)로 제공함으로써 Microsoft는 사용자가 필요로 하는 기능과 대상 장치에 저장할 공간이 있는 기능만을 골라서 선택할 수 있도록 해줍니다.

이러한 예로 오류 메시지 문자열을 포함하는 System.SR 어셈블리를 들 수 있습니다. 이 어셈블리를 응용 프로그램에 포함하면 발생한 오류에 대한 자세한 내용을 볼 수 있습니다. 이러한 내용은 디버깅 세션 중에는 도움이 되지만 일단 제품으로 출시되면 필요 없는 경우가 많습니다. 이 어셈블리를 제외한다고 해서 응용 프로그램의 성능이나 기능에 영향을 주는 것은 아니며 다만 상세한 오류 메시지를 볼 수 없을 뿐입니다.

.NET Compact Framework 아라카르트식 접근법의 또 다른 예로는 1MB보다 약간 큰 DLL 세트로 제공되는 SQL Server CE 구성 요소를 들 수 있습니다. System.Data.SqlServerCe 어셈블리에 대한 참조를 명시적으로 추가하지 않는 한 이 DLL은 응용 프로그램에 포함되지 않습니다.

.NET Compact Framework에 없는 기능

Windows CE의 운영 제약에 맞추기 위해 .NET Framework의 중요한 부분이 삭제되었습니다. 이 절에서는 .NET Compact Framework 구현 과정에서 생략된 가장 핵심적인 .NET Framework 기능에 대해 설명합니다.

메서드 오버로드

메서드 오버로드는 해당 메서드를 호출할 수 있는 다른 방식을 제공합니다. 이 기능은 또한 Framework의 크기를 증가시키므로 .NET Compact Framework에서는 거의 모든 메서드로부터 오버로드 기능을 제거했습니다.

여기에는 두 가지 의미가 있습니다. 첫째, .NET Compact Framework 기반 응용 프로그램을 개발할 때는 데스크톱 응용 프로그램에 사용한 특정 메서드 오버로드를 사용하지 못할 가능성이 있습니다. 둘째, 설명서를 읽을 때는 특정 메서드가 .NET Compact Framework에서 지원되는지 여부를 확인해야 합니다.

포함되지 않은 컨트롤

많은 .NET Framework 컨트롤이 .NET Compact Framework에 포함되지 않았습니다. 이 컨트롤 대부분은 모바일 개발자에게 별로 중요하지 않습니다. 인쇄는 모바일 응용 프로그램에서는 극히 역할이 제한되어 있기 대문에 인쇄 관련 컨트롤군을 모두 제거해도 문제가 안됩니다. 그러면 CrystalReportViewer, PageSetupDialog, PrintDialog, PrintDocument, PrintPreviewControl 및 PrintPreviewDialog 컨트롤도 해결됩니다. 포함되지 않는 대화 상자를 고유 대화 상자로 바꾸거나 Windows CE API를 사용해서 직접 시스템 대화 상자에 액세스할 수 있습니다.

이미 사용 가능한 타사 컨트롤을 사용해서 .NET Compact Framework에서 누락된 컨트롤을 보충할 수 있습니다. 타사 .NET Compact Framework 컨트롤 목록을 보려면 이 기사 끝부분에 있는 참조를 확인하십시오.

XML 기능

XML 기능도 .NET Compact Framework에서 제공하는 정도에 맞춰 삭제되었습니다. 누락된 XML 관련 구성 요소 중 핵심되는 것은 System.Xml.XPath 네임스페이스입니다. XPath 네임스페이스를 사용하면 .NET Compact Framework에서 제공된 메서드를 사용하는 경우보다 구문 분석이 훨씬 쉬워집니다. XPath 네임스페이스가 없으면 DOM(Document Object Model)에 대해 회귀 및 반복 검색을 결합해서 사용할 수 있습니다.

.NET Compact Framework에 포함되지 않은 또 한 가지 핵심이 되는 XML 구성 요소는 XSLT(Extensible Stylesheet Language Transformation)입니다. XSLT를 사용하면 XML 문서를 다른 형식으로 변환할 수 있습니다.

XML 관련 참고에서 .NET Compact Framework는 현재 장치 기반 XML Web services 개발을 지원하지 않습니다.

데이터베이스 지원

.NET Compact Framework는 견고한 데이터 관련 도구 세트를 제공합니다. SQL Server CE에 대해 로컬 데이터베이스 지원이 제공됩니다. 서버쪽에서 .NET Compact Framework는 SQL Server 지원을 제공합니다.

Pocket Acess 데이터베이스 작업을 위해 타사에서 제공하는 .NET Compact Framework 구성 요소도 있습니다. 자세한 내용은 이 기사 끝부분의 참조를 확인하십시오.

이진 Serialization

크기와 성능을 고려해서 BinaryFormatter 및 SoapFormatter 클래스를 .NET Compact Framework에서 생략했습니다.

Windows 레지스트리 액세스

.NET Framework에는 응용 프로그램에서 Windows 레지스트리 작업을 용이하게 해주는 Microsoft.Win32.Registry 네임스페이스가 있습니다. 이 네임스페이스가 .NET Compact Framework에 포함되지 않은 이유는 Windows CE가 아니라 Win32와 연관되기 때문입니다. 해당 Windows API를 호출하면 Windows CE 레지스트리에 액세스할 수 있습니다.

COM 구성 요소 활용

COM 개체를 .NET Compact Framework 기반 응용 프로그램에 통합하는 과정은 2단계입니다. 첫째, COM 개체를 제공하는 관리되지 않는(eMbedded Visual C++) DLL 래퍼를 작성해야 합니다. COM 개체의 복잡성에 따라 이 작업은 간단할 수도 있고 매우 복잡할 수도 있습니다. 둘째, Pinvoke를 사용해서 DLL 래퍼에 액세스해야 합니다. 다행히도 개발 커뮤니티에서는 더 일반적으로 사용되는 COM 구성 요소 액세스 작업을 시작했고 그 중 몇 개는 이 기사 끝부분의 참조에 나와 있습니다.

보안

.NET Compact Framework는 관리되지 않는 코드에 대한 액세스를 보호하지 않습니다. 모든 응용 프로그램에서 시스템 또는 비 시스템 API를 모두 호출할 수 있습니다.

현재 .NET Compact Framework에 역할 기반 보안이 없습니다. 주요 개체는 기존의 ID나 기존 역할을 이해하지 못합니다.

XML Web Services

.NET Compact Framework XML Web service에서 제외된 가장 핵심적인 기능은 쿠키를 사용하는 기능입니다. 쿠키는 클라이언트 호출이 수행되는 사이에 서버에서 상태를 유지하는 데 널리 사용됩니다. 웹 서비스에 쿠키를 사용하는 것이 웹 사이트에서 사용하는 것만큼 보편적이지는 않지만 여전히 사용되고 있습니다.

.NET Compact Framework는 웹 서비스에 대해 제한된 암호화 기능을 제공합니다.

인쇄

.NET Compact Framework는 인쇄를 지원하지 않습니다. IR을 통해서 네트워크 프린터나 외부 프린터와 쉽게 상호 작용할 수 있는 방법은 없습니다.

네트워크 프린터를 액세스하는 방법은 모바일 응용 프로그램에서 보내는 작업을 수용하고 인쇄하는 서버 기반 응용 프로그램을 빌드하는 것입니다.

IR 포트를 통해 IR 기반 프린터로 직접 출력을 전송할 수 있습니다. System.Net.IrDA 네임스페이스를 사용해서 장치의 IR 포트를 액세스합니다

GDI+

Windows CE는 기본적으로 GDI+를 지원하지 않으므로 GDI+ 관련 기능을 .NET Compact Framework에서 제거했습니다.

원격 작업

.NET Compact Framework의 첫 번째 릴리스는 원격 작업을 지원하지 않습니다.

Visual Studio .NET 2003을 사용한 개발

Visual Studio .NET 2003은 .NET Compact Framework 대상의 응용 프로그램을 만들기 위한 강력한 개발 환경을 제공합니다. Visual Studio .NET에는 미리 빌드된 장치 프로필 세트가 들어 있습니다. 장치 프로필에는 특정 장치를 대상으로 하는 응용 프로그램을 빌드하는 데 필요한 정보가 들어 있습니다. Visual Studio .NET에는 Pocket PC, Pocket PC 2002 및 Windows CE .NET 4.1 이상을 위한 응용 프로그램을 만들 수 있게 하는 프로필이 있습니다. 이러한 프로필을 사용하여 Windows Form과 ADO.NET을 포함하는 응용 프로그램을 만들 수 있고 웹 서비스를 사용할 수 있습니다.

프로필은 특정 장치(예: Pocket PC)를 대상으로 하는 장치 관련 프로필일 수도 있고, 일반 Windows CE 플랫폼을 대상으로 하는 보다 덜 특정적인 플랫폼에 대한 프로필일 수도 있으며, .NET Compact Framework가 이식된 모든 플랫폼을 대상으로 하는 일반적인 프로필일 수도 있습니다.

Visual Studio .NET은 장치 키트(이전의 SDK)를 지원합니다. 이전 버전에 포함된 도구와 마찬가지로 장치 키트는 Visual Studio .NET과 별도로 제공되므로 따로 설치하고 업데이트해야 합니다.

IDE 추가 사항

Visual Studio .NET에 기본적으로 포함된 기능 외에도 다음과 같은 장치 관련 기능이 있습니다.

  • 템플릿—일반 프로젝트 형식을 위해 미리 정의된 구성입니다. 템플릿은 Pocket PC와 Wndows CE 장치에 모두 제공됩니다.
  • 장치 관련 컨트롤—Pocket PC 및 Windows CE와 함께 사용하도록 특별히 디자인된 컨트롤입니다. 인터페이스, 리소스 사용, 기능 등이 이러한 환경에 맞게 만들어졌습니다.
  • 장치 에뮬레이터—특정 장치를 시뮬레이션하는 테스트 환경입니다. 에뮬레이터를 개발자 PC에 실행하면 장치 없이 테스트가 가능합니다.
  • 응용 프로그램 자동 배치—에뮬레이터나 장치를 쉽게 테스트할 수 있고 개발자를 위해 원활한 테스트 환경을 제공합니다.
  • 원격 디버깅—장치 응용 프로그램과 Visual Studio .NET IDE를 통해 디버깅 도구를 활용할 수 있습니다. 모든 디버깅 도구는 에뮬레이터나 장치에 실행되는 .NET Compact Framework 기반 응용 프로그램에 사용할 수 있습니다.

지원되는 언어

.NET Compact Framework가 지원하는 두 가지 개발 언어는 C# .NET과 Visual Basic .NET입니다. 이전 버전의 Windows CE 개발 도구에서는 .NET Compact Framework에 C 기반 언어(즉, eMbedded Visual C++)를 선호했지만 두 언어 모두 강력하고 기능적이기 때문에 어떤 언어를 선택하더라도 별 차이가 없습니다.

Visual Studio .NET 개발 환경에 최근 추가된 J#은 .NET Compact Framework에서 지원하지 않습니다.

.NET Framework에는 없는 언어 제약이 .NET Compact Framework에는 있다는 것을 알아 두어야 합니다. .NET Framework에서는 단일 프로젝트 내에 여러 언어 구성 요소를 사용할 수 있습니다. 반면에 .NET Compact Framework 프로젝트에서는 C# .NET이나 Visual Basic .NET 중 한 개 언어만 사용할 수 있습니다. .NET Compact Framework의 단일 언어 프로젝트 제한에 대한 해결 방법은 클래스 템플릿을 사용하여 추가 프로젝트를 만드는 것입니다. 대체 언어 코드를 템플릿에 추가한 다음 이러한 클래스에 대한 참조를 응용 프로그램 프로젝트에 추가하면 됩니다.

온라인 설명서

Visual Studio .NET에 포함된 설명서는 .NET Compact Framework와 관련된 정보를 보여 줍니다. "Creating Custom Controls with the .NET Compact Framework"(.NET Compact Framework로 사용자 지정 컨트롤 만들기)와 같은 .NET Compact Framework 관련 항목과 .NET Compact Framework에서 지원되는 기능의 라인 항목 식별을 볼 수 있습니다.

그림 1은 .NET Compact Framework에 지원되는 DataTable 속성의 예를 보여 줍니다. 지원되는 각 속성에는 "Supported by the .NET Compact Framework"(.NET Compact Framework에서 지원됨)라는 메모가 있습니다. 이를 통해 개체가 어떤 기능을 지원하는지 알 수 있고 .NET Framework와 .NET Compact Framework의 차이를 쉽게 이해할 수 있습니다.

그림 1. 온라인 도움말

.NET Compact Framework 응용 프로그램 만들기

Visual Studio .NET을 실행하면 그림 2와 같이 시작 페이지가 표시됩니다. 시작 페이지에서 기존 프로젝트를 열 수도 있고 .NET Compact Framework를 대상으로 하는 프로젝트를 비롯한 새 프로젝트를 만들 수도 있습니다.

그림 2. Visual Studio .NET 시작 페이지

새 프로젝트 단추를 클릭하면 그림 3과 같이 새 프로젝트 대화 상자가 표시됩니다. 이 대화 상자에서 템플릿을 선택하여 .NET Compact Framework 대상의 두 개 형식을 포함한 다양한 프로젝트 형식을 만들 수 있습니다. Visual Basic 프로젝트와 Visual C# 프로젝트 폴더 모두에 스마트 장치 응용 프로그램 템플릿이 들어 있습니다.

그림 3. 새 프로젝트 대화 상자

Visual Basic .NET 프로젝트 시작

Visual Basic .NET 프로젝트를 만들려면

  1. Visual Studio .NET 2003을 시작합니다.
  2. 시작 페이지에서 새 프로젝트 단추를 클릭합니다.
  3. 그림 3과 같이 새 프로젝트 대화 상자가 표시됩니다. 프로젝트 형식 목록에서 Visual Basic 프로젝트 폴더를 선택합니다.
  4. Visual Basic 프로젝트 템플릿이 표시됩니다. 스마트 장치 응용 프로그램 템플릿을 선택합니다.
  5. 이름 필드에 프로젝트의 이름을 입력합니다.
  6. 위치 필드에 프로젝트를 만들 위치를 입력합니다.
  7. 확인을 클릭합니다.

Visual C# .NET 프로젝트 시작

Visual C# .NET 프로젝트를 만들려면

  1. Visual Studio .NET 2003을 시작합니다.
  2. 시작 페이지에서 새 프로젝트 단추를 클릭합니다.
  3. 그림 3과 같이 새 프로젝트 대화 상자가 표시됩니다. 프로젝트 형식 목록에서 Visual C# 프로젝트 폴더를 선택합니다.
  4. Visual C# 프로젝트 템플릿이 표시됩니다. 스마트 장치 응용 프로그램 템플릿을 선택합니다.
  5. 이름 필드에 프로젝트의 이름을 입력합니다.
  6. 위치 필드에 프로젝트를 만들 위치를 입력합니다.
  7. 확인을 클릭합니다.

스마트 장치 응용 프로그램 마법사

스마트 장치 응용 프로그램 템플릿을 선택하면 그림 4와 같이 스마트 장치 응용 프로그램 마법사가 로드됩니다. 이 마법사를 사용하면 응용 프로그램에 맞는 프로젝트 형식을 선택하는 과정을 쉽게 수행할 수 있습니다.

그림 4. 스마트 장치 응용 프로그램 마법사

이 마법사의 인터페이스는 두 목록 상자로 구분됩니다. 상단 목록 상자에서 대상 플랫폼을 선택합니다. Pocket PC 또는 Windows CE의 두 개 옵션이 있습니다. Pocket PC가 특정 장치 플랫폼을 대상으로 할 경우 Windows CE 템플릿을 사용하면 해당 운영 체제를 실행하는 다양한 장치에서 실행할 수 있는 보다 일반적인 응용 프로그램을 만들 수 있습니다.

하단 목록 상자는 선택한 대상 장치에 사용 가능한 프로젝트 형식을 표시합니다(Pocket PC 또는 Windows CE).

Pocket PC 프로젝트 유형

그림 5에서 볼 수 있듯이 Pocket PC와 Pocket PC 2002 플랫폼을 대상으로 하는 프로젝트 형식은 Windows 응용 프로그램, 클래스 라이브러리, 비그래픽 응용 프로그램, 빈 프로젝트 등 네 가지입니다. 각 프로젝트 형식에 대한 설명이 표 2에 나와 있습니다.

그림 5. Pocket PC 프로젝트 유형

이러한 프로젝트 형식을 사용하여 SH3, MIPS 또는 ARM 프로세서를 실행하는 Pocket PC와 ARM 또는 XScale 프로세서를 사용하는 Pocket PC 2002 장치를 대상으로 하는 응용 프로그램을 만들 수 있습니다.

표 2. Pocket PC 프로젝트 형식

프로젝트 형식 설명
Windows 응용 프로그램 Pocket PC 관련 컨트롤을 포함한 Windows Form 기반 프로젝트이며, Windows 기반 응용 프로그램을 생성하기 때문에 가장 많이 사용되는 템플릿입니다.
클래스 라이브러리 클래스 라이브러리를 사용하면 관련 구성 요소를 단일 파일로 패키지화할 수 있으며, 다른 응용 프로그램을 개발하는 데 사용하거나 다른 구성 요소에 대한 상속 기준으로 사용할 수 있습니다. 이 프로젝트 형식은 여러 응용 프로그램에 다시 사용할 수 있는 코드 모듈을 만들 때 가장 적합합니다.
비그래픽 응용 프로그램 사용자 인터페이스가 없는 실행 파일을 만들 때 사용합니다. 사용자 상호 작용이 필요 없는 백그라운드 응용 프로그램이나 유지 관리 응용 프로그램에 사용하기에 가장 적합합니다.
빈 프로젝트 미리 정의된 구성 요소가 없는 프로젝트를 정의하여 처음부터 모든 것을 사용자에 맞게 빌드할 수 있도록 합니다.
참고   Pocket PC 장치는 콘솔 지원을 포함하지 않습니다. 해결 방법은 Platform Builder에 포함된 console.dll을 직접 로드하는 것입니다.

Windows CE 프로젝트 유형

그림 6에서 볼 수 있듯이 Windows CE 플랫폼을 대상으로 하는 프로젝트 형식은 Windows 응용 프로그램, 클래스 라이브러리, 콘솔 응용 프로그램, 빈 프로젝트 등 네 가지입니다. 각 프로젝트 형식에 대한 설명이 표 3에 나와 있습니다.

그림 6. Windows CE 프로젝트 형식

표 3. Windows CE 프로젝트 형식

프로젝트 형식 설명
Windows 응용 프로그램 Windows CE NET 관련 컨트롤을 포함한 Windows Form 기반 프로젝트이며, Windows 기반 응용 프로그램을 생성하기 때문에 가장 많이 사용되는 템플릿입니다.
클래스 라이브러리 클래스 라이브러리를 사용하면 관련 구성 요소를 단일 파일로 패키지화할 수 있으며, 다른 응용 프로그램을 개발하는 데 사용하거나 다른 구성 요소에 대한 상속 기준으로 사용할 수 있습니다. 이 프로젝트 형식은 여러 응용 프로그램에 다시 사용할 수 있는 코드 모듈을 만들 때 가장 적합합니다.
콘솔 응용 프로그램 콘솔 창 내에서 실행되는 실행 파일을 만드는 데 사용됩니다. 사용자 상호 작용이 필요 없는 백그라운드 응용 프로그램이나 유지 관리 응용 프로그램에 사용하기에 가장 적합합니다. Pocket PC와는 달리 Windows CE는 기본적으로 콘솔 응용 프로그램을 지원합니다.
빈 프로젝트 미리 정의된 구성 요소가 없는 프로젝트를 정의하여 처음부터 모든 것을 사용자에 맞게 빌드할 수 있도록 합니다.

프로젝트 속성 설정

모든 Visual Studio .NET 프로젝트와 마찬가지로 .NET Compact Framework 프로젝트도 프로젝트 속성 페이지 대화 상자를 사용하여 구성합니다. 이 대화 상자를 통해 포함하고 싶은 네임스페이스, 시작 폼으로 사용할 폼, 응용 프로그램에 사용할 아이콘, 응용 프로그램 빌드 방법, 응용 프로그램 빌드 위치, 응용 프로그램 배포 방법, 최적화 구성 및 기타 다양한 설정을 구성할 수 있습니다.

속성 페이지 대화 상자에 액세스하는 방법은 다음 두 가지입니다.

  • 솔루션 탐색기 사용—프로젝트를 마우스 오른쪽 단추로 클릭한 다음 속성을 클릭합니다. 그림 7과 같이 속성 페이지 대화 상자가 표시됩니다.
  • 프로젝트 메뉴 사용—먼저 솔루션 탐색기 창에서 프로젝트를 선택합니다. 그런 다음 프로젝트 메뉴에서 속성을 클릭합니다. 속성 페이지 대화 상자가 표시됩니다.

그림 7. 속성 페이지 대화 상자

인터페이스 만들기

Visual Studio .NET에 이미 익숙한 개발자인 경우 .NET Compact Framework를 대상으로 하는 응용 프로그램용 사용자 인터페이스를 만드는 작업에 대한 설명이 거의 필요 없습니다. Visual Studio .NET IDE를 처음 사용하는 경우 그림 8과 같이 Windows 응용 프로그램 템플릿을 기반으로 하는 새 프로젝트가 기본 폼을 자동으로 표시합니다.

이 예에서 프로젝트 형식은 Pocket PC를 대상으로 하는 Windows 응용 프로그램입니다. 이 응용 프로그램 형식의 템플릿에는 Pocket PC 플랫폼에 크기를 맞춘 폼이 들어 있습니다. 대부분의 Pocket PC 응용 프로그램에는 메뉴가 들어 있기 때문에 메뉴 컨트롤(폼 하단에 표시)이 폼에 포함되어 있습니다.

그림 8. 기본 Pocket PC 폼

포함된 컨트롤

.NET Compact Framework에는 데스크톱 Windows 응용 프로그램을 구축하는 데 사용되는 컨트롤의 하위 집합이 들어 있습니다. 대체로 이 컨트롤은 .NET Framework와 동등한 컨트롤 하위 집합을 제공합니다. 이 차이점은 대상 플랫폼에 따른 리소스 제약 때문입니다.

.NET Compact Framework에 제공된 컨트롤은 표 4와 같습니다.

표 4. .NET Compact Framework에 포함된 컨트롤

Button CheckBox ComboBox ContextMenu DomainUpDown
HScrollBar ImageList InputPanel Label ListBox
ListView MainMenu NumericUpDown OpenFileDialog Panel
PictureBox ProgressBar RadioButton SaveFileDialog StatusBar
TabControl TextBox Timer Toolbar TrackBar
TreeView VScrollBar DataGrid    
참고   사용할 수 있는 타사 컨트롤도 많습니다. 자세한 내용은 이 기사 끝부분의 참조 절을 확인하십시오.

사용자 지정 컨트롤 빌드

.NET Compact Framework의 가장 우수한 기능 중의 하나는 제약을 피해 코드화할 수 있는 방식입니다. 컨트롤을 예로 들어 봅니다. .NET Compact Framework에 제공되는 모든 컨트롤은 전체 Framework 컨트롤에 비해 제약이 있습니다. 즉, 속성, 메서드, 이벤트 등이 누락되어 있습니다. .NET Compact Framework를 통해 필요에 맞게 표준 컨트롤의 기능을 수정할 수 있습니다.

사용자 지정 컨트롤은 사용자, 상속, 소유자 위주 등 세 개 범주로 구분됩니다. 사용자 컨트롤은 만들기는 가장 간단하지만 .NET Compact Framework에서 지원하지 않습니다. 상속 컨트롤은 .NET Compact Framework 컨트롤부터 시작하여 해당 기준 컨트롤의 속성, 메서드 및 이벤트를 원하는 대로 추가, 제거 또는 수정합니다. 컨트롤의 복잡성 면에서 본다면 상속 컨트롤은 사용자 컨트롤과 소유자 위주 컨트롤의 중간에 속합니다. 소유자 위주 컨트롤은 인터페이스 방식에서 유연성이 가장 뛰어납니다. 또한 필요한 작업량도 가장 많습니다.

.NET Compact Framework용 사용자 지정 컨트롤을 만드는 과정은 이 기사의 범위를 벗어나지만 .NET Framework에 사용되던 기술과 접근법이 대부분 .NET Compact Framework에 이전됨을 알 수 있습니다.

다음 링크는.NET Compact Framework에 사용하는 사용자 지정 컨트롤 만들기에 관한 추가 내용입니다.

Creating Custom Controls for the .NET Compact Framework  

Developing Custom Controls in C# with Smart Device Extensions  

Design-time Functionality for Custom Controls in Compact Framework and SDE  

Creating Custom Controls with the .NET Compact Framework  

메뉴 만들기

상업적으로 성공한 Pocket PC 응용 프로그램을 보면 메뉴 모음이 있습니다. 적합한 기능을 갖춘 효율성이 높은 Pocket PC 응용 프로그램을 빌드하려면 거의 예외 없이 메뉴 모음을 사용해야 합니다.

메뉴 모음을 사용하는 것은 일반화되어 있기 때문에 기본 Pocket PC Windows 응용 프로그램 템플릿은 처음 폼을 만들 때 메뉴 모음을 자동으로 연결합니다. Visual Studio .NET과 .NET Compact Framework를 사용하면 메뉴를 쉽고 정확하게 만들 수 있습니다. Forms 디자이너에 있는 그래픽 도구를 사용해서 메뉴 계층을 빌드하면 됩니다.

디자인 타임 도구를 사용해서 메뉴를 만드는 것이 가장 쉬운 접근법이기는 하지만 다른 방법도 있습니다. 코드를 사용해서 메뉴를 만들 수도 있습니다. 좀더 복잡하기는 하지만 응용 프로그램을 실행하는 동안 즉석에서 메뉴를 만들고 싶은 경우가 있습니다.

폼에 메뉴 모음을 직접 구현하는 것이 바로 MainMenu 컨트롤입니다. 메뉴 디자이너는 그래픽 인터페이스를 제공하여 MainMenu 컨트롤을 구성합니다. 메뉴 디자이너를 사용하여 전체 메뉴 모음을 구성할 메뉴 및 메뉴 항목을 만들 수 있습니다.

메뉴 디자이너를 활성화하려면

  1. Visual Studio .NET IDE에서 메뉴를 추가할 폼을 엽니다. 폼에 MainMenu 컨트롤이 포함되어 있지 않으면 하나를 추가합니다.
  2. 아이콘 트레이의 MainMenu 아이콘을 클릭합니다. 폼의 메뉴 모음이 활성화됩니다.
  3. 폼에서 메뉴 모음을 클릭합니다. 그러면 메뉴 디자이너가 활성화됩니다. 그림 9와 같이 첫 번째 메뉴 영역이 강조 표시됩니다.

    그림 9. 메뉴 디자이너의 빈 메뉴

  4. 강조 표시된 영역에 첫 번째(가장 왼쪽) 메뉴의 이름을 입력합니다. 그림 10에 보이는 예제와 같이 New(새로 만들기) 메뉴를 정의합니다.
  5. 이제 메뉴를 더 추가하거나 New 메뉴에 표시할 항목을 정의할 수 있습니다. 메뉴를 더 추가하려면 정의된 첫째 메뉴의 바로 오른쪽에 있는 Type Here(여기에 입력하십시오.) 상자에 다음 메뉴의 이름을 입력하면 됩니다. 그림 10을 보면 New의 바로 오른쪽에 해당합니다. 이 예제에서 Edit(편집) 메뉴를 추가할 것입니다.

    그림 10. New 메뉴 추가

  6. Edit 메뉴의 메뉴 항목을 정의하려면 Edit 바로 위의 Type Here 상자를 클릭해서 메뉴 항목의 이름을 입력합니다. 그림 11은 Cut(잘라내기) 메뉴 항목을 Edit 메뉴에 추가하는 것을 보여 줍니다.
  7. 메뉴를 완성할 때까지 메뉴와 항목을 만드는 과정을 계속합니다.

    그림 11. Edit 메뉴에 항목 추가

메뉴 항목 코드

메뉴를 빌드하는 경우 메뉴 항목을 누르거나 클릭하는 동작에 응답해야 합니다. 각 메뉴 항목에는 사용자가 항목을 누르면 실행되는 클릭 이벤트 프로시저가 있습니다. 목록1은 이 프로시저의 한 예를 보여 줍니다.

목록 1. 메뉴 항목용 클릭 이벤트 프로시저

[Visual Basic]

Private Sub mnuEditCut_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles mnuEditCut.Click

MessageBox.Show("잘라내기...")

End Sub

[Visual C#]

private void mnuEditCut_Click(object sender, System.EventArgs e)

{

MessageBox.Show("잘라내기...");

}

도구 모음 만들기

데스크톱 개발자는 Pocket PC 환경의 도구 모음이 표준 데스크톱 응용 프로그램과 함께 배포되는 도구 모음과 다르다는 것을 알아두어야 합니다. 가장 두드러진 점은 Pocket PC 도구 모음은 인터페이스의 위가 아닌 아래에 표시된다는 것입니다. 또한 Pocket PC에서 허용하는 최소 화면 크기에 따라 단추 수도 항상 제한되어 있습니다. 이러한 두 가지 특징을 그림 12에서 볼 수 있습니다.

그림 12. 도구 모음의 예

도구 모음은 응용 프로그램에서 두 가지 주된 역할을 합니다. 첫째, 도구 모음에는 약간의 특징이 가미되어 있습니다. 일반적으로 Pocket PC 응용 프로그램은 제한된 크기로 인해 평이한 외형을 가지고 있습니다. 도구 모음과 거기에 들어 있는 단추는 응용 프로그램의 인터페이스에 시각적 효과를 부여할 수 있습니다.

둘째, 도구 모음은 사용자 상호 작용을 간단하게 만듭니다. 흔히 사용하는 기능과 특징은 메뉴에 포함시키는 대신 도구 모음에 넣을 수 있습니다. 도구 모음 단추를 사용하면 한 번만 누르면 된다는 이점이 있습니다. 반면 메뉴 항목은 최소한 두 번은 눌러야 하고 항목이 하위 메뉴에 속한 경우에는 세 번 눌러야 할 수도 있습니다.

도구 모음을 만드는 과정은 다음 세 단계로 구분됩니다.

  1. ImageList 컨트롤을 추가하고 구성합니다. ImageList 컨트롤은 메뉴의 단추에 최종적으로 표시될 이미지를 보여 줍니다.
  2. ToolBar 컨트롤을 추가하고 구성합니다. ToolBar 컨트롤은 사용자에게 표시될 때 물리적 도구 모음을 구성할 단추를 정의합니다.
  3. 단추를 누르면 응답하도록 이벤트 프로시저를 작성합니다. ToolBar 컨트롤은 단일 이벤트 프로시저를 사용하며 어떤 단추를 눌러도 응답합니다.

도구 모음 코드

도구 모음이 있으면 사용자가 단추를 누를 때 실행되는 이벤트에 대해서만 고려하면 됩니다. 해당 이벤트는 ButtonClick 이벤트입니다. ButtonClick 이벤트용 이벤트 프로시저는 모든 단추에서 공유됩니다.

이 이벤트를 사용할 경우 한 가지 고려할 점은 어느 단추를 눌렀는지 판단하는 것이며 프로시저에 제공된 이벤트 인수를 참조하면 이를 쉽게 판단할 수 있습니다. e.Button.ImageIndex를 참조하면 누른 단추와 관련된 이미지를 확인할 수 있습니다. 이 색인은 ImageList 컨트롤 내부에 저장할 때의 원래 이미지에 할당된 것입니다. 목록 2는 단추 탭을 처리하는 방법을 보여 줍니다.

목록 2. 도구 모음 단추 탭 처리

<[Visual Basic]

Private Sub tlbMain_ButtonClick(ByVal sender As System.Object, _

ByVal e As System.Windows.Forms.ToolBarButtonClickEventArgs} _

Handles tlbMain.ButtonClick

Select Case e.Button.ImageIndex

Case 0

MessageBox.Show("인쇄...")

Case 1

MessageBox.Show("작업...")

End Select

End Sub

[Visual C#]

private void tlBMain_ButtonClick(object sender,

System.Windows.Forms.ToolBarButtonClickEventArgs e)

{

switch (e.Button.ImageIndex)

{

case 0:

MessageBox.Show("인쇄...");

case 1:

MessageBox.Show("작업...");

}

}

코드 추가

지금까지 인터페이스를 만드는 기초를 배웠으므로 이제 응용 프로그램에 코드를 추가하는 방법을 살펴보겠습니다. Visual Studio .NET IDE에서 개발하는 다른 응용 프로그램과 마찬가지로 코드는 코드 창을 통해서 추가됩니다.

Visual Studio .NET을 처음 사용하는 경우에는 사용 환경을 알아야 합니다. 몇 가지 예를 들면 코드 창은 선언문 완성에서 구성원 자동 목록에 이르기까지 다양한 기능을 제공하고 매개 변수 정보와 코드의 축소 가능 영역을 보여 줍니다.

코드를 통해 탐색하는 가장 쉬운 방법은 창 위쪽에 위치한 두 개의 콤보 상자를 사용하는 것입니다. 코드 창의 좌측 상단에 있는 콤보 상자를 사용하여 모듈 안의 클래스를 선택합니다. 창의 우측 상단에 있는 콤보 상자를 사용하여 클래스 안의 메서드를 선택합니다.

응용 프로그램 테스트

사용자 인터페이스를 완성하고 코드를 작성했으면 이제 응용 프로그램을 테스트해보십시오. Visual Studio .NET에서 .NET Compact Framework 대상의 응용 프로그램을 테스트하는 방법은 두 가지로 하나는 에뮬레이터로, 다른 하나는 장치로 테스트하는 것입니다. 에뮬레이터나 장치를 사용하여 Visual Studio .NET은 응용 프로그램과 .NET Compact Framework 및 SQL Server CE를 비롯하여 응용 프로그램에 필요한 모든 구성 요소 배포를 처리합니다.

이 모든 것은 Visual Studio .NET 2003에서 .NET Compact Framework 응용 프로그램을 테스트할 때 처리됩니다. 대상 플랫폼 검사는 .NET Compact Framework가 설치되어 있는지 확인합니다. Visual Studio .NET에 .NET Compact Framework가 없으면 응용 프로그램을 실행하기 전에 .NET Compact Framework를 자동적으로 복사하고 설치합니다. 이 설치 프로세스는 장치나 에뮬레이터를 처음 테스트할 경우 또는 장치나 에뮬레이터를 재설정할 경우에 수행됩니다.

응용 프로그램에서 SQL Server CE를 사용할 경우에도 비슷한 프로세스가 사용됩니다. Visual Studio .NET은 대상 플랫폼을 검사하여 SQL Server CE 구성 요소가 설치되어 있는지 확인합니다. Visual Studio .NET이 구성 요소를 찾지 못하면 응용 프로그램을 실행하기 전에 필요한 SQL Server CE 구성 요소를 자동으로 복사하여 설치합니다.

응용 프로그램에서 필요로 하는 구성 요소가 모두 있는지 확인한 후에 응용 프로그램이 대상 플랫폼으로 복사되어 프로젝트 구성 때 지정했던 디렉터리에 놓인 다음 실행됩니다.

테스트 실행

응용 프로그램 테스트를 실행하는 방법은 몇 가지가 있습니다.

  • Visual Studio .NET 도구 모음에서 시작 단추를 클릭합니다.
  • 디버그 메뉴에서 시작 또는 디버깅하지 않고 시작을 선택합니다.
  • F5 키(디버깅하고 시작) 또는 Ctrl+F5(디버깅하지 않고 시작)를 누릅니다.

에뮬레이터로 테스트

에뮬레이터는 데스크톱 PC 내에서 응용 프로그램을 사용하여 대상 장치 플랫폼의 기능과 운영을 모방하는 환경을 제공합니다. 에뮬레이터는 장치가 없거나 장치를 사용할 수 없는 상황에 유용합니다.

사전 경고: 에뮬레이터로 테스트는 단점이 있습니다. 무엇보다도 에뮬레이터는 대상 장치보다 처리 리소스가 훨씬 많은 데스크톱 PC에서 실행되므로 응용 프로그램의 성능에 대해 잘못된 정보를 줄 수 있습니다. 또한 에뮬레이터 입력은 사용자가 실제 사용할 스타일러스가 아닌 키보드나 마우스로 제공됩니다. 이 차이점에 대해 인식하지 못하는 경우에는 에뮬레이터에서는 사용하기 쉽지만 실제 장치에서는 사용하기 곤란한 응용 프로그램을 만들 수 있습니다. 마지막으로 에뮬레이터는 장치를 정확하게 표현하는 것이 아니라 "비슷하게" 표현합니다. 에뮬레이터마다 약간의 차이가 있습니다.

에뮬레이터 요구 사항

Visual Studio .NET과 함께 제공되는 에뮬레이터는 실행하는 개발 PC에 네트워크 연결이 없는 경우에는 작동되지 않습니다. PC에 네트워크 연결이 없는 경우 Microsoft Loopback Network Adapter를 설치하면 에뮬레이터를 사용할 수 있습니다. 이 어댑터는 네트워크 연결을 시뮬레이션하고 효율적으로 에뮬레이터를 실행합니다.

Windows 2000에 루프백 어댑터 설치

Windows 2000에서 Microsoft Loopback Network Adapter를 설치하는 과정은 아래와 같습니다.

  1. 제어판에서 하드웨어 추가/제거를 클릭합니다.
  2. 하드웨어 추가/제거 마법사의 시작 페이지에서 다음을 클릭합니다.
  3. 장치 추가/문제 해결을 클릭하고 다음을 클릭합니다. 시스템에서 플러그 앤 플레이 장치 검색을 하는 동안 잠시 정지됩니다.
  4. 하드웨어 장치 선택 페이지에서 새 하드웨어 추가를 클릭한 다음 다음을 클릭합니다.
  5. 새 하드웨어 찾기 페이지에서 아니오, 목록에서 하드웨어를 선택합니다를 클릭한 다음 다음을 클릭합니다.
  6. 하드웨어 유형 페이지에서 네트워크 어댑터를 클릭한 다음 다음을 클릭합니다 네트워크 어댑터 목록이 생성되는 동안 잠시 기다립니다.
  7. 네트워크 어댑터 선택 페이지의 제조업체 목록 상자에서 Microsoft를 클릭하고 네트워크 어댑터 목록 상자에서 Microsoft Loopback Adapter를 클릭합니다. 다음 단추를 클릭합니다.
  8. 하드웨어 설치 시작 페이지에서 다음을 클릭합니다. 루프백 어댑터가 설치됩니다.

Windows 2000에 루프백 어댑터 구성

다른 네트워크 어댑터와 마찬가지로 루프백 어댑터를 설치하는 것은 과정의 일부에 불과합니다. 새 어댑터를 구성해야 합니다. 다음 단계를 수행하여 루프백 어댑터를 구성합니다.

  1. 시작 메뉴에서 설정을 클릭하고 네트워크 및 전화 접속 연결을 가리킨 다음 로컬 영역 연결을 클릭합니다 로컬 영역 연결 상태 대화 상자가 표시됩니다.
  2. 등록 정보를 클릭합니다. 로컬 영역 연결 등록 정보 창이 표시됩니다.
    참고   연결이 올바른지 확인합니다. 이 대화 상자의 연결 사용 필드에 "Microsoft Loopback Adapter"가 표시되어야 합니다.
  3. 인터넷 프로토콜(TCP/IP)를 선택한 다음 등록 정보를 클릭합니다. 인터넷 프로토콜 창이 표시됩니다.
  4. IP 주소 등록 정보를 구성합니다.
  5. 확인을 클릭하여 인터넷 프로토콜 창을 닫습니다.
  6. 확인을 클릭하여 로컬 영역 연결 등록 정보 창을 닫습니다.
  7. 닫기를 클릭하여 로컬 영역 연결 상태 창을 닫습니다.

파일을 에뮬레이터로 이동

이전 버전의 Windows CE / Pocket PC 에뮬레이터는 에뮬레이터 환경을 만드는 두 가지 접근법을 제시했습니다. 1세대 에뮬레이터는 개발 PC에 있는 표준 Windows 기반 파일 관리 도구에서는 액세스할 수 없는 폐쇄 환경을 사용했습니다. 에뮬레이터에 필요한 파일은 에뮬레이터에서 만들거나 eMbedded Visual 도구에 포함된 특수 유틸리티를 사용하여 에뮬레이터로 복사해야 했습니다.

2세대 에뮬레이터는 더 개방된 환경을 사용하여 파일 탐색기와 같이 일반 도구를 사용해서 액세스할 수 있었습니다. 에뮬레이터 디렉터리 구조는 개발 PC의 하위 디렉터리에 존재했습니다. 에뮬레이터에 파일을 복사하려면 단순히 끌어서 놓기만 하면 되었습니다.

Visual Studio .NET에 포함된 에뮬레이터에서는 다시 폐쇄 에뮬레이터 환경을 사용하게 되었습니다. 더 복잡한 문제는 이전 버전의 eMbedded Visual 도구와는 달리 Visual Studio .NET에는 에뮬레이터 파일 관리 도구가 없다는 것입니다. 이러한 공백을 보완할 수 있는 독창적인 해결 방법이 필요합니다.

에뮬레이터 환경에 파일을 제공하는 방법은 보통 세 가지가 있습니다. 한 가지 방법은 에뮬레이터에서 실행되는 응용 프로그램을 통해 파일을 만드는 것입니다. 이 접근법에 대해서는 자세히 다루지 않겠습니다. 표준 .NET 프로그래밍 기술을 사용하여 텍스트, XML 또는 데이터베이스 파일을 만들 수 있습니다.

다른 두 가지 방법 즉, 프로젝트에 파일을 추가하는 방법과 공유 위치로부터 파일을 복사하는 방법에 대해서는 추가 설명이 필요합니다.

프로젝트에 파일 추가

파일을 에뮬레이터로 이동하는 가장 쉬운 방법은 프로젝트의 일부로 포함시키는 것입니다. 이 접근법을 사용하는 한 가지 이점은 에뮬레이터에서 하드 리셋을 수행하는 경우 프로젝트를 다시 빌드하기만 하면 테스트를 다시 시작할 수 있다는 것입니다.

이 접근법을 사용하는 과정은 다음과 같습니다.

  1. Visual Studio .NET에서 프로젝트를 엽니다.
  2. 프로젝트 메뉴에서 기존 항목 추가...를 클릭합니다
  3. 기존 항목 추가 대화 상자에서 에뮬레이터에 복사할 파일을 선택합니다.
  4. 열기를 클릭합니다. 파일이 프로젝트에 추가됩니다.
  5. 솔루션 탐색기 창에서 추가한 파일을 선택합니다.
  6. 속성 창에서 빌드 속성이 콘텐트로 설정되어 있는지 확인합니다. "콘텐트"로 구성된 항목은 개별 파일처럼 대상 장치에 복사됩니다. "포함 리소스"로 구성된 항목은 응용 프로그램 실행 파일의 일부가 됩니다.
  7. 프로젝트를 빌드합니다. 파일을 응용 프로그램과 함께 장치로 복사합니다.

공유 위치로부터 파일 복사

두 번째 접근법은 보다 유연성이 높고 최소의 추가 작업을 필요로 합니다. 이 접근법은 Pocket PC 운영 체제에 빌드된 네트워크 파일 공유 기능을 활용하는데 이 기능은 나중에 Visual Studio .NET에 포함된 에뮬레이터를 통해 사용 가능합니다.

이 접근법은 두 부분으로 구분됩니다. 개발 PC에 공유 설정을 한 다음 에뮬레이터의 파일 탐색기를 통해 공유합니다.

공유를 설정하려면 두 개의 구성이 필요합니다. 첫째, 공유가 가능하도록 PC를 구성해야 합니다. 둘째, 개별 폴더를 공유하도록 구성합니다.

Windows 2000 실행 PC에서 공유를 사용하려면

  1. 시작 메뉴에서 설정을 클릭하고 네트워크 및 전화 접속 연결을 가리킨 다음 로컬 영역 연결을 클릭합니다.
  2. 로컬 영역 연결 창에서 등록 정보를 클릭합니다.
  3. 로컬 영역 연결 등록 정보 창에서 Microsoft Network용 파일 및 인쇄 공유를 사용합니다.
  4. 확인을 클릭하여 로컬 영역 연결 등록 정보 창을 닫습니다.
  5. 닫기를 클릭하여 로컬 영역 연결 창을 닫습니다.

이제 파일 공유가 가능하도록 개발 PC를 구성했습니다. 다음에는 에뮬레이터로 복사할 파일을 둘 폴더를 공유해야 합니다.

Windows 2000에서 파일을 공유하려면

  1. 파일 탐색기를 시작합니다.
  2. 파일 탐색기에서 공유할 폴더를 마우스 오른쪽 단추로 클릭한 다음 등록 정보를 클릭합니다.
  3. 등록 정보 창에서 공유 탭을 클릭합니다.
  4. 공유 탭에서 공유할 파일을 선택하고 공유 이름을 부여합니다.
  5. 확인을 클릭하여 등록 정보 창을 닫습니다.

개발 PC를 구성했으면 파일을 복사할 준비가 된 것입니다. 먼저 에뮬레이터에 보낼 파일을 공유된 폴더에 둡니다. 그런 다음 파일을 에뮬레이터로 이동하고 다음 단계를 수행합니다.

  1. 에뮬레이터를 시작합니다.
  2. 에뮬레이터 안에서 파일 탐색기를 시작합니다.
  3. 파일 탐색기 메뉴에서 열기를 클릭합니다.
  4. 열기 대화 상자가 표시됩니다. 다음 형식을 사용하여 개발 컴퓨터의 이름과 공유 이름을 지정합니다. \\mycomputer\myshare
  5. 확인을 누릅니다.

    개발 PC의 보안 설정에 따라 공유 액세스를 허용하기 전에 사용자 이름과 암호를 묻는 메시지가 나올 수 있습니다.

이제 개발 PC와 에뮬레이터에 있는 공유 위치에 파일을 복사할 수 있습니다.

참고   파일을 복사하는 접근법은 장치를 사용할 때 동등하게 작동하지만 한 가지 문제점이 있습니다. Pocket PC 장치는 기본적으로 장치 이름이 "Pocket PC"입니다. 이름을 변경하지 않으면 공유에 액세스할 수 없습니다.

장치 테스트

장치에서 테스트를 하면 응용 프로그램 성능을 직접 경험할 수 있습니다. Visual Studio .NET을 사용하면 USB, 직렬 포트 또는 이더넷을 통해 개발 PC에 연결된 장치를 테스트할 수 있습니다.

참고   이더넷을 사용하여 장치를 개발 PC에 연결하는 것이 테스트와 디버깅을 하는 가장 쉽고 빠른 방법입니다.

장치 배포

다음 방법을 사용하여 장치 배포를 선택할 수 있습니다.

  • Visual Studio .NET 도구 모음의 개발 장치 콤보 상자에서 Pocket PC 장치를 선택합니다.
  • 프로젝트 속성 대화 상자, 장치 페이지의 개발 장치 콤보 상자에서 Pocket PC 장치를 선택합니다.
  • 속성 창에서 프로젝트의 개발 장치 속성을 Pocket PC 장치로 설정합니다.

응용 프로그램 디버깅

Visual Studio .NET IDE를 통해 제공되는 디버깅 환경은 견고합니다. 응용 프로그램을 일시 정지시키고 내부 작업을 보고 코드를 수정하며 값을 검사하고 체계적인 방식으로 응용 프로그램을 확인할 수 있습니다.

디버깅 기능의 핵심은 Visual Studio .NET IDE의 디버그 메뉴에 있습니다. 이 메뉴에서 디버깅 세션을 시작 및 정지하고, 중단점을 설정하고, 디버그 모드의 응용 프로그램을 탐색할 수 있습니다.

참고   중단점은 응용 프로그램 실행을 일시 정지하거나 중단할 때 응용 프로그램의 코드 줄을 확인합니다.

Visual Studio .NET을 사용하여 장치나 개발 PC의 에뮬레이터에서 실행하는 응용 프로그램을 원격으로 디버그할 수 있습니다. 명령 창을 사용하여 선언문을 입력하고 변수를 조회 및 설정하고, 코드 줄 또는 기타 유사한 작업을 실행할 수 있습니다.

참고   최적의 디버깅 환경을 위해 장치를 PC에 연결할 때 이더넷을 사용하는 것이 좋습니다.

응용 프로그램 배포

.NET Compact Framework 응용 프로그램 만들기 단계는 Windows 응용 프로그램에 사용되는 접근법과 유사합니다. .cab 파일 확장명으로 인해 "CAB" 파일로 더 잘 알려진 캐비닛 파일을 사용하여 응용 프로그램 설치가 이루어집니다. CAB 파일의 목적은 두 가지입니다. 1)파일을 압축 저장하여 쉽게 배포할 수 있도록 하고 2)응용 프로그램에 필요한 파일과 설정이 제대로 처리되도록 확인합니다.

필수 사항

Visual Studio .NET과 함께 빌드된 응용 프로그램의 경우 .NET Compact Framework가 대상 장치에 있어야 합니다. 또한 응용 프로그램이 SQL Server CE를 사용하는 경우 SQL Server CE 구성 요소도 설치해야 합니다.

설치 경로는 이 모든 사항을 고려해야 합니다. 여러 개의 CAB 파일을 포함해야 할 수 있습니다. 한 개는 응용 프로그램에 사용하고 두 번째는 .NET Compact Framework와 SQL Server CE CAB에 필요합니다.

CAB 파일 만들기

응용 프로그램의 CAB 파일을 가장 쉽게 만드는 방법은 Visual Studio .NET을 사용하는 것입니다. Visual Studio .NET의 기능 중 하나는 CAB 파일을 생성하는 IDE의 메뉴 항목입니다.

응용 프로그램용 CAB 파일을 빌드하려면

  1. Visual Studio .NET에서 응용 프로그램용 프로젝트를 엽니다.
  2. 그림 13과 같이 솔루션 구성 드롭다운 콤보 상자에서 해제를 선택합니다.

    그림 13. 솔루션 구성 설정

  3. 그림 14와 같이 빌드 메뉴에서 CAB 파일 빌드를 클릭합니다.
  4. 응용 프로그램을 빌드하는 동안 몇 개의 명령 창이 표시됩니다. 이러한 창이 없어지면 CAB 파일이 완성됩니다.
    참고   CAB 파일이 생성됐다고 알려주는 메시지나 알림이 표시되지 않습니다. 마지막 명령 창이 닫히면 Visual Studio .NET 인터페이스로 돌아오게 됩니다.

    그림 14. CAB 파일 빌드 메뉴 항목

CAB 파일 출력

CAB 빌드 프로세스의 출력은 응용 프로그램의 디렉터리에 위치한 디렉터리에 저장됩니다. 하위 디렉터리인 \bin\release에서 각 CAB 파일을 찾습니다. 이 계층의 한 예는 그림 15와 같습니다.

그림 15. Visual Studio .NET을 통해 생성된 CAB 파일의 위치

그림 15의 예에서는 각 대상 플랫폼의 프로세서 형식마다 하나씩 여러 개의 CAB이 생성된 것을 볼 수 있습니다. 이 그림에서는 StrongArm, MIPS, SH3 및 X86 프로세서 형식에 대해 하나씩 모두 네 개의 CAB을 볼 수 있습니다. 배포 장치는 Pocket PC이고 이 장치에 네 개의 프로세서 형식이 지원되기 때문입니다.

이제 해당 CAB 파일을 대상 장치로 복사하고 장치의 파일 탐색기를 열고 CAP 파일을 눌러 응용 프로그램을 설치할 수 있습니다.

참고   응용 프로그램을 실행할 수 있으려면 .NET Compact Framework와 필요하면 SQL Server CE를 설치해야 합니다.

데스크톱 설치 프로그램 만들기

데스크톱 PC에서 응용 프로그램을 설치하는 경우 도킹 크레들에서 장치까지 설치 과정이 약간 더 복잡해집니다. 이 경우 데스크톱 PC와 장치에 대해 두 개의 설치 프로그램이 필요합니다. 장치 설치 프로그램은 CAB 파일이고 데스크톱 설치 프로그램은 다음 두 기능을 수행하는 실행 파일입니다. 첫째, CAB 파일을 데스크톱 PC로 복사합니다. 둘째, 응용 프로그램 관리자(CeAppMgr.exe)를 시작합니다. 응용 프로그램 관리자가 CAB 파일의 장치 복사를 이어 받은 후 설치를 실행합니다.

응용 프로그램 관리자는 장치에 응용 프로그램 추가 및 제거를 수행하고 설치를 시작한 PC에서 응용 프로그램 삭제를 처리합니다. .INI 파일을 사용해서 응용 프로그램 관리자에 설치 지침을 부여할 수 있습니다.

CAB 파일을 PC로 복사한 다음 응용 프로그램 관리자를 실행하는 응용 프로그램을 사용하여 데스크톱 설치 프로그램을 만들 수 있습니다. InstallShield  및 Wise  에서 이 기능을 제공하는 상업용 설치 개발 패키지를 공급합니다.

Spb Software House  는 EZSetup이라는 무료 설치 제품을 공급합니다. 이 응용 프로그램은 InstallShield와 Wise에서 제공하는 제품만큼 견고하지는 않지만 대부분의 설치에 잘 작동됩니다.

참고   고유 데스크톱 설치 프로그램을 작성할 경우 설치 PC에서 응용 프로그램 관리자를 찾아야 합니다. 응용 프로그램 관리자의 전체 이름과 경로는 레지스트리 값 HKLM\software\Microsoft\Windows\CurrentVersion\App Paths\CEAppMgr.exe에 저장되어 있습니다.

요약

.NET Compact Framework는 견고한 모바일 응용 프로그램을 만드는 강력한 도구를 제공하며 Pocket PC와 Windows CE NET 장치를 대상으로 하는 응용 프로그램을 만드는 데 기존 .NET 기술을 활용할 수 있도록 합니다.

.NET Compact Framework는 .NET Framework의 하위 집합입니다. 외형과 기능은 .NET Framework와 유사한 반면 .NET Compact Framework에서 프로그램을 만드는 방법을 배우려면 시간과 노력이 필요합니다. Windows CE 장치에 따른 제약 사항과 모바일 응용 프로그램 생성에 필요한 요구 사항을 숙지해야 합니다.

추가 정보 사이트

기사

시작

Taking Control with C#  : .NET Compact Framework 및 Visual C# 시작 개요

Accessing the Enterprise with Ease  : 기업 데이터에 액세스하는 모바일 응용 프로그램을 만들기 위해 사용하는 .NET Compact Framework 및 SQL Server 개요

Making the Move from C++ to C#  : eMbedded Visual C++를 사용한 응용 프로그램과 Visual C#을 사용한 .NET Compact Framework 개발 비교

Smart Device Extensions, SQLCE and Me  : .NET Compact Framework 및 SQL Server CE를 사용한 응용 프로그램 개발 소개

Getting Started with Smart Device Extensions  : .NET Compact Framework를 이용한 작업 소개

Some Very Smart Software  : .NET Compact Framework 응용 프로그램에서 웹 서비스를 활용하는 방법 소개

사용자 지정 컨트롤 만들기

Creating Custom Controls for the .NET Compact Framework  

Developing Custom Controls in C# with Smart Device Extensions  

Design-time Functionality for Custom Controls in Compact Framework and SDE  

Creating Custom Controls with the .NET Compact Framework  

뉴스 그룹

microsoft.public.dotnet.framework.compactframework—.NET Compact Framework를 사용한 응용 프로그램 개발 정보

microsoft.public.pocketpc—Pocket PC 관련 일반 정보

microsoft.public.pocketpc.developer—Pocket PC 개발자용 정보

microsoft.public.sqlserver.ce—Microsoft SQL Server CE 작업 정보

microsoft.public.webservices—웹 서비스 개발 정보

웹 사이트

개발자 프로그램

Microsoft의 Mobiel Solution Partner Program  은 Microsoft Mobile Software를 사용하여 첨단 솔루션을 개발하고 성공적으로 시장에 출시할 수 있도록 디자인된 국제적인 프로그램입니다.

Microsoft Mobile Software는 언제 어디서든 어떤 장치에도 정보를 전송할 수 있는 좋은 솔루션과 서비스를 구현하고 있습니다.

Microsoft 모바일 혁명에 참여하여 응용 프로그램의 폭을 넓히고 새로운 시장을 개척하고 기존의 생활 및 작업 환경을 혁신하십시오.

Microsoft의 Mobile2Market Program은 Pocket PC와 Smartphone용으로 디자인된 모바일 응용 프로그램의 인증과 구현을 위한 종합 프로그램입니다. 독립 소프트웨어 공급업체를 모바일 운영자 및 소매업체와 연계하도록 디자인된 Mobile2Market은 모바일 응용 프로그램을 위한 새로운 시장 기회를 창출하고 마케팅 시간을 단축하고 고객에게 완벽한 사용자 환경을 제공함으로써 모바일 응용 프로그램의 마켓 플레이스를 강화 및 개발합니다.

교육 및 추진 프로그램

larryroof.com  에서는 모바일 응용 프로그램 디자인 및 개발에 대한 교육 및 프로젝트 상담을 제공하고 있습니다. 제공하는 서비스의 예를 들면 .NET Compact Framework 및 SQL Server CE, 사용자에 맞게 설정된 교육 프로그램 및 교육과 프로젝트 상담을 하면서 효율적인 모바일 응용 프로그램 구현을 지원하고 있습니다.

정보 사이트

gotdotnet.com  은 .NET Framework의 홈 사이트로 .NET Compact Framework 섹션을 포함하고 있습니다.

innovativedss.com  에는 샘플 코드와 개발자 포럼이 있습니다.

devbuzz.com  은 eMbedded Visual Basic과 .NET Compact Framework를 주제로 하는 개발자 사이트로 기사, 샘플 및 포럼을 포함하고 있습니다.

타사 컨트롤과 구성 요소

DateTimePicker-이 컨트롤은 .NET Framework에서 제공하고 .NET Compact Framework에는 없습니다. IntelliProg  에서 사용할 수 있습니다

HTMLViewer—HTML 콘텐트 표시를 지원합니다. IntelliProg  에서 사용할 수 있습니다

RichInk—고급 형식 지정 기능과 함께 텍스트를 입력 및 편집하고 서식 있는 텍스트 형식과 Rich Ink를 지원합니다. IntelliProg  에서 사용할 수 있습니다.

Pocket Outlook—이 라이브러리를 사용하면 .NET Compact Framework로 작성된 응용 프로그램에서 Pocket Outlook 데이터에 쉽게 액세스하여 데이터를 조작할 수 있습니다. 자세한 정보는inthehand.com  을 참조하십시오.

Pocket Access—이 라이브러리를 사용하여 Pocket Access 데이터베이스에 저장된 데이터를 .NET Compact Framework 응용 프로그램에 통합할 수 있습니다. 자세한 내용은 inthehand.com  을 참조하십시오.


출처 : http://cafe.naver.com/dotnetdn.cafe?iframe_url=/ArticleRead.nhn%3Farticleid=7

이 페이지는 Textcube 1.10.0 : beta 1 로 구동됩니다 데스크탑 화면