Debuggen und Emulieren von Geräten in Visual Studio 2005

Artikel
12/21/2007

Veröffentlicht: 23. Feb 2006

Von Alex Feinman

Hier finden Sie Informationen zur Verwendung des Geräteemulators und Debuggers von Visual Studio 2005 für verwaltete, systemeigene und gemischte Projekte für intelligente Geräte (19 gedruckte Seiten).

Laden Sie vom Microsoft Download Center die Datei Device_Debug_VS2005.msi herunter.

Auf dieser Seite

Übersicht über neue Debugger-Features in Visual Studio 2005
Geräteemulator
Systemeigenes Debuggen: Anhängen an Prozesse
Verwaltetes Debuggen: Anhängen an Prozesse
Verwaltetes Debuggen: Debuggen von Interop-Projekten
Geräteemulator-Manager: ActiveSync-DMA-Transportunterstützung
Schlussbemerkung
Der Autor

Übersicht über neue Debugger-Features in Visual Studio 2005

Microsoft Visual Studio 2005 schließt durch mehrere neue Features im Bereich Geräteentwicklung die Lücke, die vorher zwischen den Tools im Entwicklungssystem Microsoft eMbedded Visual C++ und den Produkten im Entwicklungssystem Visual Studio bestand. Bisher waren zum Entwickeln von systemeigenem Gerätecode das Installieren von eMbedded Visual C++ und deren veralteter Benutzeroberfläche erforderlich. Entwickler von verwalteten Gerätecode konnten sich jedoch an der neueren und erweiterten integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) von Microsoft Visual Studio .NET 2003 erfreuen. Ernsthafte Probleme traten dann auf, wenn ein Entwickler an einem gemischten Geräteprojekt arbeitete, das sowohl aus verwaltetem als auch aus systemeigenem Code bestand. In eMbedded Visual C++ und Visual Studio .NET 2003 werden sogar unterschiedliche Emulatoren verwendet. So konnte beispielsweise ein Entwickler bei der Untersuchung des Emulator-Betriebssystems, unter dem ein Debuggen einer verwalteten Anwendung ausgeführt wurde, nicht die mit eMbedded Visual C++ gelieferten Remotetools verwenden.

Die Situation wurde noch komplizierter, wenn ein Benutzer einen nicht verwalteten Wrapper erstellen musste, um die Verwendung eines COM-Objektes in einem verwalteten Projekt zu ermöglichen. Das Debuggen eines solchen Wrappers gestaltete sich sogar noch schwieriger.

In Visual Studio 2005 wurde die gesamte Anwendungsentwicklung für Geräte innerhalb einer einzigen, mit den neuesten austauschbaren Compilern und einem integrierten Debugger ausgestatteten IDE zusammengefasst. Gemischte Projektmappen werden unterstützt. Der Debugger kann ausgeführten Prozessen auf dem Gerät oder Emulator angehängt werden, und der Entwickler kann auswählen, ob er verwalteten oder nicht verwalteten Code debuggen möchte (der Übergang von verwaltetem zu nicht verwaltetem Code wird jedoch nicht unterstützt).

Geräteemulator

Visual Studio 2005 stellt einen neuen Emulator vor ? den Geräteemulator. Im Gegensatz zu den x86-basierten Geräteemulatoren emuliert der neue Geräteemulator ein ARM-Gerät. Der neue Emulator bietet für die Entwicklung von Pocket PCs und Smartphones einen bedeutenden Vorteil: Sie können im Emulator dieselben Binärdateien installieren, die Sie auf Ihrem Gerät ausführen. Die durch den verwalteten Compiler erstellten ausführbaren Dateien und Bibliotheken sind nicht vom Prozessor abhängig. Dies gilt jedoch nicht für die systemeigenen Module. Die systemeigenen Module werden entsprechend den einzelnen zu unterstützenden Prozessortypen kompiliert ? MIPS, ARM, x86 usw. Es überrascht nicht, dass auf dem Markt kaum Anwendungen für x86-Mikroprozessoren erhältlich sind ? diese Architektur wurde von den vor Visual Studio 2005 vorhandenen Geräteemulatoren verwendet. Wenn Sie beispielsweise wissen möchten, wie Ihre Anwendung mit einem kommerziellen Plug-In für den Bildschirm Home funktioniert, können Sie dies im Emulator testen. Bisher konnten solche Tests nur direkt auf dem jeweiligen Gerät durchgeführt werden.

Das Bereitstellen eines Geräts mit der neuesten Software, bspw. Microsoft Windows Mobile 5.0, ist möglicherweise schwierig. Der Emulator verfügt jedoch nun über die meisten Features des tatsächlichen Geräts, einschließlich der Simulation von Speicherkarten. Darüber hinaus unterstützt der Emulator den DMA-Transport (DMA - direkter Speicherzugriff), durch den eine Verbindung mit Microsoft ActiveSync 4.0 hergestellt werden kann, die einer Verbindung eines realen Geräts mit dem Desktop-PC exakt entspricht.

So simulieren Sie eine Speicherkarte

Klicken Sie im Menü Datei des Emulators auf Konfigurieren.
Wählen Sie im Dateisystem Ihres Computers einen Ordner aus, den der Emulator als Speicherkarte erkennen soll, und klicken Sie dann auf OK, wie in der folgenden Abbildung dargestellt. Der ausgewählte Ordner sollte nicht zu viele Dateien enthalten. Beachten Sie außerdem, dass verschiedene Geräteanwendungen (bspw. Pocket Word), in denen die Auswahl eines Dokuments zulässig ist, über ein DocList-Steuerelement verfügen, das die gesamte Ordnerhierarchie der Speicherkarte durchsucht. Wenn ein Stammverzeichnis auf einem Ihrer Datenträger freigegeben ist, kann die Suche umfangreiche Ressourcen und viel Zeit beanspruchen.

Wenn Sie nach der Konfiguration des freigegebenen Ordners im Emulator den Datei-Explorer starten, wird ein Ordner für die Speicherkarte angezeigt. Der Speicherkartenordner befindet sich unter dem Stammverzeichnis des Dateisystems. Sie müssen daher beim erstmaligen Öffnen des Datei-Explorer eine Ebene nach oben wechseln, damit der Speicherkartenordner sichtbar wird. Mithilfe dieses Ordners können Sie Autorun-Features und andere von der Speicherkarte abhängige Funktionen ohne Verwendung der jeweiligen Hardware testen. Zudem können Sie unter Verwendung dieses Ordners auf einfache Weise Dateien zwischen dem Dateisystem des Geräts und dem Desktop-PC verschieben, auf dem der Emulator ausgeführt wird. Die Debugausgabe kann beispielsweise an eine im Speicherkartenordner vorhandene Datei geleitet und auf dem Desktop-PC überwacht werden.

Das Device Command Shell-Tool

Das von Microsoft-Ingenieur Ori Amiga entwickelte Tool Device Command Shell (in englischer Sprache) ist beim Arbeiten mit dem Emulator nahezu unentbehrlich. Beim Installieren registriert sich das Device Command Shell-Tool als Plug-In für Visual Studio. Es wird nicht unterstützt, wurde aber bisher regelmäßig erweitert und an Änderungen in Visual Studio angepasst. Das Tool vereinfacht die Verwaltung und Interaktion mit dem Gerät, da viele der üblichen geräteorientierten Aufgaben über das Eingabeaufforderungsfenster von Visual Studio 2005 ausgeführt werden können. Zu diesen Aufgaben gehören das Kopieren von Dateien zwischen dem Desktop-PC und dem Gerät, das Erstellen von Ordnern auf dem Gerät und das Entfernen von Ordnern vom Gerät, das Ändern der Geräteregistrierung, das Starten von Anwendungen auf dem Gerät usw. Wenn Sie CE in das Eingabeaufforderungsfenster von Visual Studio 2005 eingeben, wird über das AutoComplete-Feature eine Liste der unterstützten Befehle angezeigt. Weitere Informationen zur Verwendung dieses Tools finden Sie in der Dokumentation zu Device Command Shell.

Systemeigenes Debuggen: Anhängen an Prozesse

Visual Studio 2005 bietet hervorragende Unterstützung für systemeigene Entwicklung und entsprechendes Debuggen. Es arbeitet im Allgemeinen schneller als eMbedded Visual C++ und bietet dieselbe umfangreiche Debugger-Unterstützung für nicht verwaltete Projekte wie für Desktopcomputer-Projekte, einschließlich des Zugriffs auf die ARM-Disassembly. Visual Studio 2005 ermöglicht das Anhängen an einen ausgeführten Prozess sowie das Trennen von einem solchen, ohne den Prozess zu beenden.

Debuggen des Plug-Ins für den Bildschirm "Heute" auf einem Pocket PC

Als Beispiel für den nicht verwalteten, systemeigenen Debugger werden Sie in diesem Artikel durch eine Bildschirmroutine des Beispiel-Plug-Ins für den Bildschirm Heute geführt, das im Pocket PC 2003-SDK enthalten ist. Für diesen Artikel habe ich das Beispiel zur Verwendung mit Visual Studio 2005 konvertiert. Die mit Visual Studio 2005 kompatible Projektmappe steht als Beispiel zum Herunterladen zur Verfügung.

So bereiten Sie die Projektmappe für das Debuggen vor

Das Erstellen und Bereitstellen der Projektmappe sollte unter Verwendung der Debug-Konfiguration erfolgen. Klicken Sie zum Bereitstellen der Projektmappe auf Erstellen und anschließend auf Bereitstellen.
Registrieren Sie das Element für den Bildschirm Heute unter Verwendung von CeRegEdit folgendermaßen:
- Klicken Sie auf Start, zeigen Sie zunächst auf Alle Programme, dann auf Microsoft Visual Studio 2005 sowie Visual Studio Remote Tools und klicken Sie dann auf Remote Registry Editor.
- Wenn Sie zur Auswahl eines Geräts aufgefordert werden, wählen Sie das im zu debuggenden Projekt als Bereitstellungsziel verwendete Gerät aus und klicken Sie auf OK.
  
  An dieser Stelle sollte der Registrierungsinhalt des Zielgeräts bzw. des Emulators angezeigt werden, wie in der folgenden Abbildung dargestellt.
- Erweitern Sie die Registrierungsteilstruktur des Geräts bzw. des Emulators, indem Sie auf das benachbarte Pluszeichen (+) klicken, und navigieren Sie dann zu HKEY_LOCAL_MACHINE\Software\Microsoft\Today\Items.
- Klicken Sie mit der rechten Maustaste auf Elemente, zeigen Sie auf Neu und klicken Sie dann auf Schlüssel. Geben Sie als Schlüsselnamen Beispiel ein. Klicken Sie auf OK, um den neuen Schlüssel zu erstellen.
- Klicken Sie mit der rechten Maustaste in den rechten Bereich, zeigen Sie auf Neu und klicken Sie anschließend auf Zeichenfolge. Geben Sie als Namen DLL und als Wert \Programme\TodayPlugin\TodayPlugin.dll ein. Klicken Sie auf OK, um den neuen Wert zu speichern.
- Klicken Sie mit der rechten Maustaste in den rechten Bereich, zeigen Sie auf Neu und klicken Sie auf DWORD-Wert. Geben Sie als Namen Flags und als Wert 4 ein. Klicken Sie auf OK, um den neuen Wert zu speichern.
- Klicken Sie mit der rechten Maustaste in den rechten Bereich, zeigen Sie auf Neu und klicken Sie auf DWORD-Wert. Geben Sie als Namen Typ und als Wert 4 ein. Klicken Sie auf OK, um den neuen Wert zu speichern.
  
  Wenn Sie diesen Vorgang abgeschlossen haben, sollte der Registrierungs-Editor der folgenden Abbildung entsprechen.
Klicken Sie im Emulator zunächst auf Start, dann auf Einstellungen und anschließend auf Heute, wie in den folgenden Abbildungen dargestellt.
Wählen Sie in der Registerkarte Elemente die Option Beispiel aus, wie in der folgenden Abbildung dargestellt.
Schließen Sie die Seite Einstellungen, indem Sie auf OK klicken.
Überprüfen Sie, ob im Bildschirm Heute das neue Beispielelement angezeigt wird, wie in der folgenden Abbildung dargestellt.
Klicken Sie in Visual Studio im Menü Debug auf An den Prozess anhängen.
Wählen Sie im Dialogfeld An den Prozess anhängen in der Liste Transport die Option Intelligentes Gerät aus.
Klicken Sie neben der Liste Qualifizierer auf Durchsuchen.
Wählen Sie im Dialogfeld Mit Gerät verbinden unter Geräte aus der Liste den geeigneten Emulator aus (bzw. das Gerät, falls der Emulator sich in der Basisstation befindet) und klicken Sie dann auf Verbinden, wie in der folgenden Abbildung dargestellt.

Zum Debuggen des Plug-Ins für den Bildschirm Heute ist das Anhängen an den Prozess mstli.exe erforderlich. Alle Elemente des Bildschirms Heute werden im Kontext des Prozesses mstli.exe ausgeführt.
Wählen Sie in der unter Verfügbare Prozesse angezeigten Liste den Prozess mstl.exe aus und klicken Sie dann auf Anhängen, wie in der folgenden Abbildung dargestellt.

Im letzten Schritt wird überprüft, ob die Symbole geladen wurden.
Zeigen Sie im Menü Debug auf Windows und klicken Sie dann auf Module.
Suchen Sie in der Liste der geladenen Module die Datei TodayPlugin.dll, wie in der folgenden Abbildung dargestellt.

Beachten Sie, dass neben der Datei TodayPlugin.dll die Meldung Keine Symbole geladen angezeigt wird.
Klicken Sie mit der rechten Maustaste auf das Modul und wählen Sie die Option Symbole laden aus.
Navigieren Sie zum Projektausgabeverzeichnis (Pocket PC 2003 (ARMV4)\Debug).

Visual Studio wird die Symbolinformationen laden und das Modul entsprechend markieren.
Sie können nun im Code des Plug-Ins einen Haltepunkt festlegen und beobachten, wie dieser erreicht wird.

Verwaltetes Debuggen: Anhängen an Prozesse

Ein Debugger kann einer verwalteten Anwendung angehängt werden, die gerade ausgeführt wird. Beachten Sie, dass die folgende Anleitung gleichermaßen für echte Geräte und für Emulatoren gilt.

So hängen Sie einen Debugger in Visual Studio 2005 an

Öffnen Sie ein verwaltetes Projekt für intelligente Geräte.
Starten Sie die Anwendung mit der Tastenkombination STRG+F5.
Klicken Sie im Menü Debug auf An den Prozess anhängen.
Klicken Sie im Dialogfeld An den Prozess anhängen auf die Liste Transport und wählen Sie dann die Option Intelligentes Gerät aus, wie in der folgenden Abbildung dargestellt.
Klicken Sie auf Durchsuchen, um Ihr Zielgerät zu finden. Das Dialogfeld Mit Gerät verbinden wird geöffnet, wie in der folgenden Abbildung dargestellt.
Wählen Sie im Dialogfeld Mit Gerät verbinden das geeignete Gerät aus und klicken Sie dann auf Verbinden.
Wählen Sie im Dialogfeld An den Prozess anhängen aus der Liste Verfügbare Prozesse den Prozess für das Debugging aus und klicken Sie dann auf Anhängen.

Hinweis In der Standardeinstellung ist das Anhängen an einen verwalteten Prozess geräteseitig deaktiviert. Beim Versuch des Anhängens an einen verwalteten Prozess erhalten Sie eine das Problem beschreibende Fehlermeldung, wie in der folgenden Abbildung dargestellt.

Zum Aktivieren des Anhängens an verwaltete Prozesse müssen Sie die Geräteregistrierung ändern. Die Geräteregistrierung lässt sich mithilfe der Tools Device Command Shell oder CeRegEdit ändern.

Device Command Shell
- CE Open <Gerätenummer>
- CE NETCFAttach Enable
  
  CeRegEdit
  
  Verwenden Sie das Tool CeRegEdit wie im vorhergehenden Abschnitt dieses Artikels zum Debuggen des Pocket PC-Plug-Ins für den Bildschirm Heute beschrieben, um den folgenden Registrierungswert festzulegen.
```
[HKLM\Software\.NetCompactFramework\Managed Debugger] 
AttachEnabled=1
```

Verwaltetes Debuggen: Debuggen von Interop-Projekten

Eines der komplexeren Debug-Szenarios, die beim Schreiben von verwaltetem Code für intelligente Geräte eintreten können, besteht in der Fehlersuche innerhalb eines so genannten Interop-Aufrufs ? dem Aufruf eines systemeigenen Moduls durch den verwalteten Code. In Visual Studio 2005 gestaltet sich die Suche nach derartigen Fehlern relativ unkompliziert.

So debuggen Sie Interop-Projekte

Erstellen Sie in Visual Studio 2005 ein neues C#-Geräteprojekt für Pocket PC 2003 und fügen Sie dann den Menübefehl Test hinzu.
Fügen Sie der Projektmappe folgendermaßen ein neues Projekt hinzu:
- Zeigen Sie im Menü Datei auf Neu und klicken Sie dann auf Projekt. Das Dialogfeld Neues Projekt wird geöffnet.
- Wählen Sie folgende Optionen nacheinander aus: C++, Projekt für intelligente Geräte und Win32-Projekt für intelligente Geräte.
- Wählen Sie im Feld Projektmappe die Option Hinzufügen aus.
- Geben Sie als Namen des Projekts InteropDLL ein und klicken Sie dann auf OK, um den Win32-Projekt-Assistenten für intelligente Geräte zu starten.
- Klicken Sie im Begrüßungsbildschirm des Assistenten im linken Bereich auf die Verknüpfung Anwendungseinstellungen. Über diese Verknüpfung wird die Seite Projekteinstellungen geöffnet.
- Wählen Sie auf der Seite Projekteinstellungen den Typ DLL als Anwendungstyp aus und aktivieren Sie dann unter Zusätzliche Optionen das Kontrollkästchen Symbole exportieren.
- Klicken Sie auf Fertig stellen.
- Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das InteropDLL-Projekt und klicken Sie dann auf Hinzufügen sowie anschließend auf Neues Element.
- Wählen Sie im Dialogfeld Neues Element hinzufügen unter Kategorien die Option Code und anschließend unter Vorlagen die Option Moduldefinitionsdatei aus.
- Geben Sie als Namen der Moduldefinitionsdatei InteropDLL.def ein und klicken Sie dann auf Hinzufügen.
- Fügen Sie der Datei InteropDLL.def nach der die Zeichenfolge LIBRARY ."InteropDLL" enthaltenden Zeile die beiden folgenden Zeilen hinzu.
- ```
EXPORTS
```
- ```
fnInteropDLL
```
- Passen Sie die Datei InteropDLL.h an, indem Sie den folgenden Code
- ```
INTEROPDLL_API int fnInteropDLL(void);
```
  ändern zu
```
extern "C" INTEROPDLL_API int fnInteropDLL(void);
```
  Durch diesen Schritt lässt sich eine ungewollte Namensänderung in C++ verhindern. Wenn dieser Schritt nicht ausgeführt wird, werden an den Funktionsnamen beim Exportieren zusätzliche Symbole angehängt (z. B. "?fnInteropDLL@@YAHXZ"), so dass der Marshallingcode die Funktion während der Laufzeit nicht finden kann und daher die Ausnahme MissingMethodException auslöst.
- Erstellen Sie das DLL-Projekt.
- Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das C#-Geräteprojekt und dann auf Vorhandenes Element hinzufügen. Wählen Sie aus der Liste Dateityp die Option Ausführbare Dateien (*.exe,*.dll,*.ocx) aus.
- Wählen Sie die von Ihnen erstellte Datei InteropDLL.dll aus. Wenn Sie eine Ordnerebene nach oben wechseln, finden Sie die DLL-Datei im Ordner InteropDLL\Pocket PC 2003 (ARMV4)\Debug. Klicken Sie nicht auf die Schaltfläche Hinzufügen, sondern auf den Pfeil daneben, und wählen Sie die Option Als Verknüpfung hinzufügen aus. Dadurch stellen Sie sicher, dass die aktuelle Version der DLL für das Projekt übernommen wird.
- Klicken Sie in der Projektstruktur des Geräts mit der rechten Maustaste auf InteropDLL.dll und dann auf Eigenschaften.
- Wählen Sie unter Eigenschaften für die Eigenschaft In Ausgabeverzeichnis kopieren die Option Immer kopieren aus und stellen Sie dann sicher, dass die Eigenschaft Buildvorgang auf Inhalt festgelegt wurde.
- Fügen Sie in der Klasse Form1 des Geräteprojekts die folgende Interop-Definition hinzu.
- ```
[DllImport("InteropDLL")]
```
- ```
extern static int fnInteropDLL();
```
- Öffnen Sie den Formular-Designer für die Klasse Form1 des Geräteprojekts, und doppelklicken Sie auf den von Ihnen in Schritt 1 erstellten Befehl Test.
- Fügen Sie dem generierten Ereignishandler die folgende Zeile hinzu.
- ```
private void menuItem1_Click(object sender, EventArgs e)
{
   MessageBox.Show(fnInteropDLL().ToString());
}
```
  Damit Visual Studio die Symbole für die nicht verwaltete DLL laden kann, müssen Sie der Symboldatei einen Pfad hinzufügen.
- Klicken Sie im Menü Extras auf Optionen.
- Erweitern Sie im Dialogfeld Optionen das Feld Debuggen und klicken Sie dann auf Symbole.
- Fügen Sie unter Speicherorte für Symboldateien (.pdb) einen neuen Speicherort hinzu ? das Debugverzeichnis Ihres DLL-Projekts.
- Setzen Sie innerhalb der Datei InteropDLL.cpp in der die Zeichen return 42 enthaltenden Zeile der Funktion fnInteropDLL einen Haltepunkt.
- Starten Sie das verwaltete Projekt ohne Debuggen (STRG+F5).
- Vergewissern Sie sich, dass die Anwendung im Emulator ausgeführt wird. Klicken Sie im Visual Studio 2005-Menü auf Debug und anschließend auf An den Prozess anhängen.
- Wählen Sie zunächst im Dialogfeld An den Prozess anhängen aus der Liste Transport die Option Intelligentes Gerät und anschließend aus der Liste Qualifizierer den Namen des Emulators aus.
- Wählen Sie aus der Liste der verfügbaren Prozesse die ausführbare Datei des Geräteprojekts aus.
  
  Hinweis Das Wechseln von verwaltetem zu nicht verwaltetem Code ist nicht möglich. Außerdem können Sie jeweils nur einen Debugger an den Prozess anhängen.
- Stellen Sie sicher, dass im Feld Anhängen an der Eintrag Systemeigener Code (Intelligentes Gerät) angezeigt wird. Wenn dies nicht der Fall ist, klicken Sie auf die Schaltfläche Auswählen und wählen Sie dann im Dialogfeld Codetyp auswählen zunächst die Option Diese Codetypen debuggen und anschließend die Option Systemeigen (Intelligentes Gerät) aus, wie in der folgenden Abbildung dargestellt. Klicken Sie im Dialogfeld Codetyp auswählen auf OK, um zum Dialogfeld An den Prozess anhängen zurückzukehren, wie in der folgenden Abbildung dargestellt.
- Klicken Sie auf Anhängen.
- Klicken Sie im Formular der Anwendung auf den Befehl Test.
  
  An dieser Stelle sollte der Haltepunkt erreicht worden sein.

Geräteemulator-Manager: ActiveSync-DMA-Transportunterstützung

Der Geräteemulator-Manager ist ein neues Tool, mit dem Sie bequem zahlreiche Geräteemulatorinstanzen von einem einzigen Speicherort aus verwalten können. Sie können in Visual Studio 2005 über das Menü Extras auf das Tool zugreifen. Nachdem der Geräteemulator-Manager gestartet wurde, werden alle innerhalb des Systems registrierten Emulatoren angezeigt. Wenn Sie ein neues SDK installieren, bspw. das Windows Mobile 5.0-SDK, wird ein neuer Satz von Geräteemulatoren angezeigt.

In der folgenden Abbildung wird der Geräteemulator-Manager dargestellt.

Geräteemulator-Manager

So starten Sie eine Geräteemulatorinstanz manuell

Klicken Sie in der Liste des Geräteemulator-Managers mit der rechten Maustaste auf die gewünschte Emulatorplattform sowie anschließend auf Verbinden.

Der Emulator wird gestartet. Wenn neben der die Emulatorbeschreibung enthaltenden Zeile ein von einem Kreis umschlossener Pfeil angezeigt wird, ist der Emulator aktiv und verbunden.

So verbinden Sie eine Instanz des Emulators mit ActiveSync

Achten Sie darauf, dass in den Verbindungseinstellungen von ActiveSync der DMA-Transport aktiviert ist. Klicken Sie zu diesem Zweck mit der rechten Maustaste auf das ActiveSync-Symbol im Infobereich der Taskleiste und wählen Sie dann die Option Verbindungseinstellungen aus, wie in der folgenden Abbildung dargestellt.

Das Dialogfeld Verbindungseinstellungen wird geöffnet, wie in der folgenden Abbildung dargestellt. Stellen Sie sicher, dass die Option Verbindungen zu einem der folgenden Ziele zulassen markiert ist.
Klicken Sie im Geräteemulator-Manager mit der rechten Maustaste auf den Emulatoreintrag und dann auf In Basisstation.

Daraufhin sollte angezeigt werden, dass eine ActiveSync-Verbindung hergestellt wird. Der Emulator wird mit In Basisstation gekennzeichnet, wie in der folgenden Abbildung dargestellt.

Hinweis Wenn Sie mit der Installation und Verwendung von ActiveSync nicht vertraut sind, finden Sie unter ActiveSync FAQs (in englischer Sprache) allgemeine Informationen zum Arbeiten mit ActiveSync.

Device Emulator Manager

Verwenden eines verbundenen Emulators mit Remotegerätetools

Eine interessante Auswirkung der Möglichkeit, eine Verbindung zwischen dem Emulator und ActiveSync herzustellen, ist folgende: Remotetools wie Remote Registry Editor können nun mit dem Emulator verwendet werden, indem anstelle des Emulators einfach das Gerät als Verbindungsziel ausgewählt wird. Wenn Sie ein Remotetool starten und das Dialogfeld Gerät auswählen angezeigt wird, können Sie die Option Pocket PC-Gerät auswählen ? als ob ein reales Gerät verbunden wäre.

Sie können sogar ein beliebiges RAPI-(Remote API-)basiertes Tool mit dem Emulator verwenden, einschließlich CECopy, RapiConfig und anderer SDK-Tools sowie der unter Windows Mobile Developer Power Toys (in englischer Sprache) beschriebenen Tools. Bei der Verwendung von RAPI-Tools mit dem neuen Emulator sollte dieser immer mithilfe des Geräteemulator-Managers verbunden werden. Wählen Sie Pocket PC oder Smartphone-Gerät als Ziel für das Tool aus, da über die alten Tools nicht auf den neuen Emulator zugegriffen werden kann.

Schlussbemerkung

Der Debugger von Visual Studio 2005 ist ein äußerst leistungsfähiges Tool, mit dem verwaltete und nicht verwaltete Anwendungen während der Anzeige von Speicherinhalten, bei der Disassembly und beim Auswerten von Ausdrücken ausgeführt werden können.

Mit dem Geräteemulator können Softwareentwickler schnell Anwendungsprototypen erstellen sowie Anwendungen entwickeln und debuggen. Dabei können sehr viele Vorgänge wie mit einem echten Gerät ausgeführt werden.

Der Autor

Alex Feinman ist als Softwareentwickler bei Corrigo Incorporated tätig (einem Technologieunternehmen in Nordkalifornien) und ist zudem ein Microsoft Certified Solution Provider. Außerdem gehört er dem Beirat von OpenNETCF.org an.