Visual-Basic-6.0-Anwendungen für das Update auf Visual Basic.NET vorbereiten

Veröffentlicht: 06. Mrz 2002 | Aktualisiert: 16. Jun 2004

Microsoft Corporation
Oktober 2000

Zusammenfassung: Dieses Dokument stellt Empfehlungen für Microsoft Visual Basic-Entwickler bereit, die ihre Anwendungen auf Visual Basic.NET aktualisieren möchten. Es enthält Informationen zum Visual Basic.NET Upgrade Tool und erläutert architektonische Richtlinien, mit denen ein problemloses Update von Visual Basic 6 auf Visual Basic.NET gewährleistet wird (26 Seiten gedruckt).

Auf dieser Seite

Was ist Visual Basic.NET? Was ist Visual Basic.NET?
Warum ist Visual Basic.NET nicht zu 100 % kompatibel? Warum ist Visual Basic.NET nicht zu 100 % kompatibel?
Aktualisieren auf Visual Basic.NET Aktualisieren auf Visual Basic.NET
Arbeiten mit Visual Basic 6.0 und mit Visual Basic.NET Arbeiten mit Visual Basic 6.0 und mit Visual Basic.NET
Architekturempfehlungen Architekturempfehlungen
Aktualisieren Aktualisieren
Aktualisierungsbericht und Kommentare Aktualisierungsbericht und Kommentare
Programmierempfehlungen Programmierempfehlungen

Übersicht
Dieses Dokument enthält Empfehlungen für Microsoft Visual Basic-Entwickler, die ihre Anwendungen auf Microsoft Visual Basic.NET aktualisieren möchten.

Visual Basic 6.0-Projekte werden von Visual Basic.NET geöffnet und auf Visual Basic.NET-Technologien aktualisiert; in den meisten Fällen müssen Sie jedoch einige Änderungen an Ihren Projekten vornehmen, wenn Sie diese in Visual Basic.NET übertragen haben. Dieses Dokument soll Ihnen Empfehlungen für den Entwurf und die Implementierung Ihrer aktuellen Visual Basic-Projekte geben, so dass nur eine geringe Anzahl von Änderungen beim Update auf Visual Basic.NET erforderlich werden. Falls erforderlich, werden neue Sprachkonstrukte verwendet. Dieses Dokument ist jedoch nicht als Visual Basic.NET-Sprachreferenz gedacht.

Anmerkung Visual Basic.NET befindet sich noch in der Entwicklung, so dass es vor der Einführung des Produkts noch zu Änderungen bei den Kompatibilitätsanforderungen kommen kann. Die Berücksichtigung der Richtlinien in diesem Dokument ist keine Gewährleistung dafür, dass Sie den Code nicht verändern müssen. Die Richtlinien sollen lediglich dazu beitragen, den für die Konvertierung erforderlichen Arbeitsaufwand zu reduzieren.

Der Aktualisierungs-Assistent und die Tools für die Befehlszeilenaktualisierung in Visual Basic.NET befinden sich noch in einem frühen Entwicklungsstadium und verfügen somit über eine begrenzte Funktionalität. Sie wurden in die Betaversion aufgenommen, um einen Eindruck davon zu vermitteln, wie der Updateprozess funktioniert, und um Ihnen zu zeigen, wie der VB 6.0-Code für VB.NET geändert wurde. Die meisten aktuellen Projekte können jedoch in Beta1 wahrscheinlich nicht erfolgreich migriert werden.

Was ist Visual Basic.NET?

Visual Basic.NET ist die nächste Visual Basic-Version. Anstatt Visual Basic 6.0 einfach nur um einige neue Features zu erweitern, hat Microsoft das Produkt neu konzipiert. So wird das Schreiben verteilter Anwendungen, wie Webanwendungen und mehrschichtige Unternehmenssysteme, so einfach wie nie zuvor. Visual Basic.NET verfügt über zwei neue Formularpakete (WinForms und WebForms) und eine neue ADO-Version (ActiveX Data Objects, ADO) für den Zugriff auf Datenquellen ohne Netzwerkverbindung. Außerdem enthält es eine optimierte Sprache ohne Legacyschlüsselwörter, welche die Typsicherheit verbessert und fortgeschrittenen Entwicklern die Konstrukte auf Systemebene offen legt.

Durch diese neue Features eröffnen sich Visual Basic-Entwicklern neue Möglichkeiten. Mit WebForms und ADO.NET können Sie jetzt skalierbare Websites schnell entwickeln; durch die Vererbung bietet die Sprache jetzt wirkliche Unterstützung für die objektorientiertes Programmierung, WinForms bietet systemeigenen Unterstützung für Eingabehilfen und visuelle Vererbung. Die Bereitstellung Ihrer Anwendungen ist jetzt so einfach wie das Kopieren von ausführbaren Dateien und Komponenten zwischen Verzeichnissen.

Visual Basic.NET ist jetzt vollständig mit den anderen Sprachen von Microsoft Visual Studio.NET integriert. Sie können nicht nur Anwendungskomponenten in anderen Programmiersprachen entwickeln, sondern Klassen können mithilfe der sprachübergreifenden Vererbung jetzt auch von Klassen erben, die in anderen Sprachen geschrieben wurden. Mit dem einheitlichen Debugger können Sie jetzt mehrere Sprachanwendungen debuggen, unabhängig davon, ob diese lokal oder auf Remotecomputern ausgeführt werden. Außerdem stellt Microsoft .NET Framework unabhängig von der verwendeten Sprache, eine umfassende Reihe von APIs für Microsoft Windows und das Internet bereit.

 

Warum ist Visual Basic.NET nicht zu 100 % kompatibel?

Beim Entwurf von Visual Basic.NET gab es zwei Optionen: das Anpassen (Retrofit) der vorhandenen Codebasis zur Ausführung auf dem .NET-Framework oder das komplette Neuerstellen unter voller Nutzung aller Vorteile der Plattform. Um die von den Kunden am häufigsten nachgefragten Features (z. B. Vererbung und Threading) und den umfassenden und uneingeschränkten Zugriff auf die Plattform bereitzustellen und den Übergang von Visual Basic zur nächsten Generation von Webanwendungen zu gewährleisten, konnte die richtige Entscheidung nur darin bestehen, auf der neuen Plattform alles vollständig neu zu erstellen.

Viele der neuen Features in WinForms hätten beispielsweise als neue Steuerelemente oder zusätzliche Eigenschaften zur bestehenden Codebasis hinzugefügt werden können. Dies wäre jedoch zu Lasten der anderen leistungsfähigen Features in WinForms gegangen, z. B. auf Kosten der Sicherheit und der visuellen Vererbung.

Eines der Hauptziele bestand darin, sicherzustellen, dass der Visual Basic-Code mit Code aus anderen Sprachen, wie Microsoft Visual C#" oder Microsoft Visual C++, vollständig zusammenarbeiten kann. Weiterhin sollte sichergestellt werden, dass Visual Basic-Entwickler die Leistung des .NET-Framework nutzen können, ohne sich der Problemumgehungen für die Programmierung bedienen zu müssen, die meist für das ordnungsgemäße Ausführen der Windows-APIs erforderlich sind. Visual Basic verfügt jetzt über dieselben Variablentypen, Arrays, benutzerdefinierten Typen, Klassen und Schnittstellen wie Visual C++ und andere Sprachen, die auf die Common Language Runtime ausgerichtet sind. Einige Features, z. B. Zeichenfolgen fester Länge und nicht auf Null basierende Arrays, mussten jedoch aus der Sprache entfernt werden.

Visual Basic ist jetzt eine echte objektorientierte Sprache: Einige nicht intuitive und inkonsistente Funktionen, wie z. B. GoSub/Return und DefInt, wurden aus der Sprache entfernt.

Das Resultat ist ein mit neuer Energie ausgestattetes Visual Basic, das auch weiterhin das produktivste Tool zum Erstellen Windows-basierter Anwendungen darstellt und nun das beste Tool zum Erstellen von Websites der nächsten Generation bildet.

 

Aktualisieren auf Visual Basic.NET

Visual Basic.NET ermöglicht einen grundlegenden Wechsel von der herkömmlichen Windows-Entwicklung zum Erstellen von Web- und mehrschichtige Anwendungen der nächsten Generation. Damit Ihr Code die Vorteile von Visual Basic.NET nutzen kann, muss er also aktualisiert werden.

Dies geschieht automatisch, wenn Sie ein Visual Basic 6.0-Projekt in Visual Basic.NET öffnen: Der Aktualisierungs-Assistent führt Sie durch den Updateprozess und erstellt ein neues Visual Basic.NET-Projekt (das vorhandene Projekt bleibt unverändert). Dieser Prozess ist einseitig – das neue Visual Basic.NET-Projekt kann nicht in Visual Basic 6.0 geöffnet werden.

Bei der Aktualisierung des Projekts wird die Sprache im Hinblick auf Syntaxänderungen geändert und die Visual Basic 6.0-Formulare werden in WinForms konvertiert. In den meisten Fällen müssen Sie nach der Aktualisierung noch einige Änderungen an Ihrem Code vornehmen. Dies ist notwendig, weil bestimmte Objekte und Sprachfunktionen entweder keine Entsprechung in Visual Basic.NET haben oder die Entsprechung zu unterschiedlich ist, um automatisch aktualisiert zu werden. Nach der Aktualisierung sollten Sie außerdem Ihre Anwendung ändern, um einige der neuen Features in Visual Basic.NET zu nutzen.

WinForms unterstützt beispielsweise Anker für Steuerelemente, so dass Sie alten Visual Basic 6.0-Größenänderungscode für Formulare zum größten Teil entfernen können:

VB.NET-Unterstützung für Steuerelementanker

Abbildung 1: VB.NET-Unterstützung für Steuerelementanker

Um Ihnen nach der Aktualisierung eines Projekts bei den Änderungen zu helfen, fügt Visual Basic.NET dem Projekt einen Aktualisierungsbericht hinzu, der möglichen Probleme auflistet, und fügt Kommentare in den aktualisierten Code ein, um Sie auf zu ändernde Anweisungen aufmerksam zu machen. Da diese Kommentare im neuen Tasklistenfenster als "ZU ERLEDIGEN" angezeigt werden, können Sie erforderliche Änderungen leicht erkennen. Wechseln Sie einfach zur Codeanweisung, indem Sie auf den Task doppelklicken. Alle Tasks und Elemente im Aktualisierungsbericht sind jeweils mit einem Online-Hilfethema verbunden, das Ihnen weitere Informationen zu den Gründen der Codeänderung und zu den notwendigen Verfahren bietet.

Wenn Sie die Empfehlungen in diesem Dokument berücksichtigen, können Sie die nach der Projektaktualisierung auf Visual Basic.NET erforderlichen Änderungen minimieren oder möglicherweise ganz vermeiden. In den meisten Fällen stellen die Empfehlungen lediglich die beste Vorgehensweise bei der Programmierung dar. Es werden jedoch auch die Objekte und Methoden identifiziert, für die es keine Entsprechung gibt und die deshalb bei der Aktualisierung eines Projekts auf Visual Basic.NET nur selten verwendet werden sollten.

 

Arbeiten mit Visual Basic 6.0 und mit Visual Basic.NET

Visual Basic.NET unterstützt die Aktualisierung von Visual Basic 6.0-Projekten. Wenn Sie ein Projekt in den Visual Basic-Versionen 1 bis 5 geschrieben haben, sollten Sie dieses in VB6 laden (und sich für das Update von Microsoft ActiveX-Steuerelementen entscheiden), kompilieren und dann speichern, bevor Sie es auf Visual Basic.NET aktualisieren.

Visual Basic.NET und Visual Basic 6.0 können auf demselben Computer installiert und auch gleichzeitig ausgeführt werden. Ebenso können in Visual Basic.NET und in Visual Basic 6.0 geschriebene Anwendungen auf demselben Computer installiert und ausgeführt werden. In Visual Basic.NET geschriebene Komponenten können mit COM-Komponenten (Component Object Model, COM) zusammenarbeiten, die in vorherigen Versionen von Visual Basic und anderen Sprachen geschrieben wurden. So können Sie beispielsweise ein in Visual Basic 6.0 geschriebenes ActiveX-Steuerelement in einem WinForm von Visual Basic.NET ablegen, ein COM-Objekt in Visual Basic 6.0 aus einer Visual Basic.NET-Klassenbibliothek verwenden oder einen Verweis auf eine Visual Basic.NET-Bibliothek zu einer ausführbaren Visual Basic -Datei hinzufügen.

Komponenten, die mit Visual Basic.NET kompiliert wurden, besitzen leichte Laufzeitunterschiede im Vergleich zu Komponenten, die mit Visual Basic 6.0 kompiliert wurden. Zunächst einmal liegt dies daran, dass Visual Basic.NET-Objekte über die Garbagecollection freigegeben werden und es so bei der expliziten Zerstörung von Objekten zu einer Zeitverzögerung kommen kann, bevor diese tatsächlich aus dem Speicher entfernt werden. Es gibt noch weitere Unterschiede, z. die Variant/Objekt-Änderungen, die weiter unten in diesem Dokument beschrieben werden. Als Resultat all dieser Unterschiede verfügen Visual Basic.NET-Anwendungen über ein ähnliches, jedoch kein identisches Laufzeitverhalten wie Visual Basic 6.0-Anwendungen.

Zudem macht Visual Basic.NET die binäre Kompatibilität zwischen Komponenten in Visual Basic.NET und denen in Visual Basic 6.0 überflüssig. Die Komponenten verfügen jetzt über ein stärkeres Versions- und Bereitstellungssystem als je zuvor – Dateien können durch einfaches Kopieren in ein Verzeichnis bereitgestellt werden (ohne RegSvr32), und das Aktualisieren auf eine neue Version einer Komponente ist so einfach wie das Ersetzen einer alten durch eine neue Datei. Sie müssen lediglich sicherstellen, dass Klassen und Methoden mit der vorherigen Version kompatibel sind.

 

Architekturempfehlungen

Die .NET-Plattform stellt eine Verbesserung gegenüber früheren Architekturen dar und bietet größere Unterstützung für Skalierbarkeit und verteilte Anwendungen über getrennten Datenzugriff, HTTP-basierten Nachrichtentransport sowie Bereitstellung auf der Basis von Dateikopien (die Komponentenregistrierung ist nicht mehr erforderlich). Den größten Nutzen bieten diese Features, wenn Sie Anwendungen mit einer ähnlichen Architektur erstellen, wie Sie sie in Visual Basic.NET verwenden würden.

Browserbasierte Anwendungen

Visual Basic 6.0 und Microsoft Visual Studio 6.0 boten die folgenden Technologien zum Erstellen browserbasierter Internet- und Intranetanwendungen:

  • WebClasses

  • DHTML-Projekte

  • ActiveX-Dokumente

  • Active Server Pages (ASP)

Visual Basic.NET verwendet erstmalig ASP.NET, eine erweiterte Version von ASP, und fügt zur Architektur WebForms hinzu, HTML-Seiten mit Visual Basic-Ereignissen. Die Architektur ist serverbasiert.

Unten finden Sie eine Liste der Empfehlungen und architektonischen Vorschläge für die Entwicklung browserbasierter Visual Basic 6.0-Anwendungen, die nahtlos in Visual Basic.NET-Projekte integriert werden können:

  • Es wird empfohlen, die Microsoft-Richtlinien für mehrschichtige Architekturen zu verwenden (siehe "Building Solutions Today With Microsoft's Web Solution Platform" (englischsprachig), um Ihre Anwendungen und die Schnittstelle zu ASP zu erstellen und COM-Objekte in Visual Basic 6.0 oder Visual C++ 6.0 für Ihre Geschäftslogik zu verwenden. ASP wird in Visual Basic.NET vollständig unterstützt, und Sie können Ihre Anwendung weiter mit ASP, ASP.NET und WebForms erweitern. Die Visual Basic 6.0- und Visual C++ 6.0-Geschäftsobjekte können ohne Änderung verwendet oder auf Visual Studio.NET aktualisiert werden.

  • DHTML-Anwendungen enthalten DHTML-Seiten und clientseitige DLLs. Diese Anwendungen können nicht automatisch auf Visual Basic.NET aktualisiert werden. Es wird empfohlen, die Anwendungen in Visual Basic 6.0 zu belassen.

  • ActiveX-Dokumente werden in Visual Basic.NET nicht unterstützt und können, wie DHTML-Projekte, nicht automatisch aktualisiert werden. Sie sollten ActiveX-Dokumentanwendungen in Visual Basic 6.0 belassen oder, falls möglich, ActiveX-Dokumente durch Benutzersteuerelemente ersetzen.

  • ActiveX-Dokumente und DHTML-Anwendungen in Visual Basic 6.0 können mit Visual Basic.NET-Technologien zusammenarbeiten. Sie können beispielsweise von einem WebForm in Visual Basic.NET zu einer DHTML-Seite in Visual Basic 6.0 wechseln und umgekehrt.

  • In Visual Basic.NET gibt es keine WebClasses mehr. WebClass-Anwendungen werden auf ASP.NET aktualisiert; allerdings müssen Sie nach der Aktualisierung einige Änderungen vornehmen. Vorhandene WebClass-Anwendungen können mit WebForms und ASP-Anwendungen in Visual Basic.NET zusammenarbeiten, für neue Projekte wird jedoch die Verwendung der Windows DNA-Plattform von ASP mit Visual Basic 6.0-Geschäftsobjekten empfohlen.

Weitere Informationen zum Erstellen von Anwendungen mit der mehrschichtigen Architektur von Microsoft finden Sie in der Microsoft Windows DNA-Website (englischsprachig).

Client/Server-Projekte

In Visual Basic 6.0 standen mehrere Technologien zum Erstellen von Client/Server-Anwendungen zur Verfügung:

  • Visual Basic-Formulare

  • Microsoft Transaction Server (MTS)/COM+-Zwischenschichtobjekte

  • Benutzersteuerelemente

In Visual Basic.NET gibt es ein neues Formularpaket: WinForms. WinForms verfügt über anderes Objektmodell als Visual Basic 6.0-Formulare, ist jedoch zum größten Teil kompatibel. Bei der Aktualisierung Ihres Projekts werden Visual Basic-Formulare in WinForms konvertiert.

Visual Basic.NET bietet verbesserte Unterstützung für die Entwicklung von Zwischenschichtkomponenten mit MTS- und COM+-Komponentendiensten. Mit dem einheitlichen Debugger können Sie von einer Clientanwendung in eine MTS/COM+-Komponente und zurück zum Client wechseln. Sie können den einheitlichen Debugger auch verwenden, um durch in Visual Basic 6.0 erstellte MTS/COM+Komponenten zu gehen (vorausgesetzt, diese sind in systemeigenem Code kompiliert, mit symbolischen Debuginformationen und ohne Optimierungen).

Visual Basic.NET verwendet außerdem zum ersten Mal die neue Zwischenschichtkomponente Webdienste. Webdienste werden von ASP.NET gehostet und verwenden HTTP-Transport, so dass Firewalls von Methodenanfragen passiert werden können. Webdienste verwenden für die Über- und Rückgabe von Daten den Industriestandard XML und erlauben anderen Sprachen bzw. Plattformen den Zugriff auf ihre Features. Auch wenn diese keine Unterstützung für MTS-Transaktionen bieten, sollten Sie Ihre MTS/COM+Komponenten für den Fall in Webdienste ändern, dass Sie keine verteilten Transaktionen benötigen und trotzdem mit anderen Plattformen zusammenarbeiten möchten. Hierfür gibt es keine automatisierte Methode, allerdings ist die Aufgabe einfach und lässt sich mit einer Drag & Drop-Aktion in Minutenschnelle durchführen, nachdem Ihr Projekt auf Visual Basic.NET aktualisiert wurde.

Nach der Aktualisierung Ihres Projekts werden die Benutzersteuerelemente auf Windows-Steuerelemente aktualisiert. Es erfolgt jedoch keine Aktualisierung benutzerdefinierter Einstellungen von Eigenschaftentags und Zugriffstastenzuordnungen.

Anwendungen auf einer Schicht

Visual Basic 6.0 unterstützte das Erstellen mehrerer Arten von Anwendungen auf einer Schicht:

  • Datenbankanwendungen auf einer Schicht

  • Visual Basic-Add-Ins

  • Dienstprogramme und Spiele

Datenbankanwendungen auf einer Schicht werden verkörpert durch eine Visual Basic-Anwendung, die Daten in einer Microsoft Access-Datenbank speichert. Diese Anwendungen werden mit einigen Einschränkungen auf Visual Basic.NET aktualisiert (siehe Abschnitt "Daten" weiter unten in diesem Dokument).

Da die Visual Basic.NET-IDE jetzt ein vollständig integrierter Bestandteil der Visual Studio.NET-IDE ist, verfügt Visual Basic.NET über ein neues, sprachneutrales Erweiterungsmodell. Visual Basic.NET-Add-Ins sind jetzt Visual Studio.NET-Add-Ins, und Sie können alle Sprachen in Visual Studio.NET automatisieren und diesen Features hinzufügen. Sie können beispielsweise ein Visual Basic.NET-Add-In schreiben, das ein Visual C#-WinForm neu färbt oder Kommentare zu einer Visual Basic-Klasse hinzufügt. Um diese Features bereitstellen zu können, hat sich Visual Basic.NET von dem alten Erweiterungsmodell gelöst, so dass Sie die Erweiterungsobjekte in Ihrer Anwendung ändern müssen, um die neuen Features nutzen zu können.

Viele Anwendungen fallen in die Kategorie der Dienstprogramme. Dienstprogramme zum Bearbeiten von Dateien und Registrierungseinstellungen u. ä. lassen sich häufig ohne weitere Änderungen aktualisieren. Nach der Aktualisierung stehen Ihnen viele neue Features zur Verfügung, z. B. die Ausnahmebehandlung innerhalb der Sprache, um Dateisystemfehler aufzuzeichnen, sowie die Verwendung von .NET Framework-Registrierungsklassen zum Bearbeiten der Registrierung. Sie sollten berücksichtigen, dass Anwendungen, die auf bestimmten Leistungseigenschaften von Visual Basic 6.0 beruhen, z. B. Arcade-Spiele, wahrscheinlich einige Änderungen erfordern, da Visual Basic.NET andere Leistungseigenschaften besitzt. Für die Unterstützung von Spielen in Visual Basic.NET können Sie Microsoft DirectX 7 oder die neue GDI-Version verwenden. GDI+ verfügt über viele neue Features, darunter Alphablendingunterstützung für alle einfachen 2D-Grafiken, Anti-Aliasing und erweiterte Unterstützung für Grafikdateiformate.

Daten

In Visual Basic 6.0 wurden verschiedene Arten des Datenzugriffs zur Verfügung gestellt:

  • ActiveX Data Objects (ADO)

  • Remote Data Objects (RDO)

  • Data Access Objects (DAO)

Visual Basic.NET verwendet erstmalig eine erweiterte ADO-Version namens ADO.NET. ADO.NET wurde im Hinblick auf getrennte Daten entwickelt und bietet bei der Verwendung in verteilten Umgebungen Leistungsverbesserungen im Vergleich zu ADO. ADO.NET bietet Schreib/Lese-Datenbindung an Steuerelemente für WinForms sowie schreibgeschützte Datenbindung für WebForms.

DAO, RDO und ADO können weiterhin in Code von Visual Basic.NET verwendet werden, es sind allerdings einige kleine Änderungen erforderlich (diese werden im Sprachabschnitt dieses Dokument erläutert). Visual Basic.NET bietet jedoch keine Unterstützung für die DAO- und RDO-Datenbindung an Steuerelemente, Datensteuerelemente oder RDO-Benutzerverbindungen. Falls Ihre Anwendungen DAO- oder RDO-Datenbindungen enthalten, sollten Sie diese entweder in Visual Basic 6.0 belassen oder die DAO- und RDO-Datenbindung auf ADO aktualisieren, bevor Sie Ihr Projekt auf Visual Basic.NET aktualisieren, da die ADO-Datenbindung in WinForms unterstützt wird. Informationen hierzu erhalten Sie in der Hilfe zu Visual Basic 6.0.

Insgesamt wird empfohlen ADO in Visual Basic 6.0-Projekten zu verwenden.

 

Aktualisieren

Beim Aktualisieren Ihres Codes erstellt Visual Basic.NET ein neues, aktualisiertes Projekt und übernimmt die meisten der erforderlichen Sprach- und Objektänderungen. In den folgenden Abschnitten finden Sie einige Beispiele dafür, wie der Code aktualisiert wird.

Von "Variant" auf "Object"

In den vorherigen Version von Visual Basic wurde der Variant-Datentyp unterstützt, der allen primitiven Typen zugewiesen werden konnte (außer Zeichenfolgen fester Länge), Empty, Error, Nothing und Null. In Visual Basic.NET werden die Funktionen der Datentypen Variant und Object in einem neuen Datentyp kombiniert: Object. Der Object-Datentyp kann primitiven Datentypen - Empty, Nothing und Null - sowie als Zeiger auf ein Objekt zugewiesen werden.

Wenn Ihr Projekt auf Visual Basic.NET aktualisiert wird, werden alle als Variant deklarierten Variablen in Object geändert. Außerdem wird beim Einfügen von Code in den Editor das Variant-Schlüsselwort durch Object ersetzt.

Von "Integer" auf "Short"

In Visual Basic.NET ist der Datentyp für ganze 16-Bit-Zahlen jetzt Short, und der Datentyp für ganze 32-Bit-Zahlen ist jetzt Integer (Long verfügt jetzt über 64-Bit-Zahlen). Beim Aktualisieren des Projekts werden die Variablentypen wie folgt geändert:

Dim x As Integer 
dim y as Long

wird aktualisiert auf:

Dim x As Short 
dim y as Integer

Eigenschaftensyntax

Visual Basic.NET verwendet jetzt eine intuitivere Syntax für Eigenschaften, in der Get und Set zusammengefasst werden. Ihre Eigenschaftenanweisungen werden wie folgt aktualisiert:

Property Get MyProperty() As Integer 
    MyProperty = m_MyProperty 
End Property 
Property Let MyProperty(NewValue As Integer) 
    m_MyProperty = NewValue 
End Property

wird aktualisiert auf:

Property MyProperty() As Short 
    Get 
        MyProperty = m_MyProperty 
    End Get 
    Set 
        m_MyProperty = Value 
    End Set 
End Property 

Von Visual Basic-Formularen auf WinForms

Visual Basic.NET enthält ein neues Formularpaket, WinForms, das über systemeigene Unterstützung für Eingabehilfen und über einen direkten Menü-Editor verfügt. Vorhandenen Visual Basic-Formulare werden auf WinForms aktualisiert.

Direkter Menü-Editor in WinForms.

Abbildung 2: Direkter Menü-Editor in WinForms.

Schnittstellen

In früheren Visual Basic-Versionen waren die Schnittstellen für öffentliche Klassen stets für den Benutzern ausgeblendet. In Visual Basic.NET können diese angezeigt und im Code-Editor bearbeitet werden. Beim Aktualisieren des Projekts wählen Sie aus, ob Schnittstellendeklarationen für Ihre öffentlichen Klassen automatisch erstellt werden sollen.

 

Aktualisierungsbericht und Kommentare

Nach der Aktualisierung des Projekts wird diesem ein Aktualisierungsbericht hinzugefügt, der alle am aktualisierten Code vorzunehmenden Änderungen auflistet. Außerdem werden zum Code Kommentare hinzugefügt, um Sie auf mögliche Probleme hinzuweisen. Diese Kommentare werden automatisch in der Visual Studio.NET-Taskliste angezeigt.

Aktualisierungskommentare werden zum Visual Basic-Code sowie zur Taskliste hinzugefügt.

Abbildung 3: Aktualisierungskommentare werden zum Visual Basic-Code sowie zur Taskliste hinzugefügt.

 

Programmierempfehlungen

Dieser Abschnitt bietet Empfehlungen zum Schreiben von Code, um die nach der Aktualisierung Ihres Projekts auf Visual Basic.NET erforderlichen Änderungen möglichst gering zu halten.

Verwenden von frühen Datenbindungen

Sowohl Visual Basic 6.0 als auch Visual Basic.NET unterstützen spät gebundene Objekte, ein Verfahren, bei dem eine Variable als Object-Datentyp deklariert und zur Laufzeit einer Klasseninstanz zugewiesen wird. Während des Updateprozesses können spät gebundene Objekte jedoch Probleme verursachen, z. B. beim Auflösen von Standardeigenschaften, oder wenn das zugrundeliegende Objektmodell sich geändert hat und Eigenschaften, Methoden und Ereignisse konvertiert werden müssen. Wenn beispielsweise ein Formular namens Form1 mit der Bezeichnung Label1 vorhanden ist, würde die Beschriftung der Bezeichnung durch den folgenden Visual Basic -Code auf "SomeText" festgelegt:

Dim o As Object 
Set o = Me.Label1 
o.Caption = "SomeText" 

In Visual Basic.NET-WinForms wird die Caption-Eigenschaft eines Bezeichnungssteuerelements jetzt Text genannt. Bei der Aktualisierung Ihres Codes werden alle Instanzen der Caption-Eigenschaft in Text geändert. Da ein spät gebundenes Objekt jedoch keinen Typ besitzt, kann Visual Basic nicht erkennen, um welchen Objekttyp es sich handelt oder ob Eigenschaften übersetzt werden sollten. In diesem Fall müssen Sie den Code nach der Aktualisierung selbst ändern.
Wenn Sie den Code mit früh gebundenen Objekten neu schreiben, wird dieser automatisch aktualisiert.

Dim o As Label 
Set o = Me.Label1 
o.Caption = "SomeText" 

Falls möglich, sollten Sie Variablen des entsprechenden Objekttyps deklarieren, anstatt diese einfach als Object-Datentyp zu deklarieren.
Wenn Sie Object- und Variant-Variablen in Ihrem Visual Basic 6.0-Code verwenden, sollten Sie beim Zuweisen der Variablen, beim Durchführen von Aktionen an den Variablen oder beim Übergeben der Variablen an eine Funktion explizite Konvertierungen verwenden. So ist beispielsweise der Zweck der Operation "+" im folgenden Code unklar:

Dim Var1 As Variant 
Dim Var2 As Variant 
Dim Var3 As Variant 
Var1 = "3" 
Var2 = 4 
Var3 = Var1 + Var2   'UNCLEAR: What is the intention? 

Sollten Var1 und Var2 als Zeichenfolgen oder als Ganzzahlen hinzugefügt werden?

Das Beispiel oben kann zu einem Laufzeitfehler in Visual Basic.NET führen. Das Neuschreiben der letzten Zeile unter Verwendung expliziter Konvertierungen stellt sicher, dass der Code ausgeführt werden kann:

Var3 = CInt(Var1) + CInt(Var2)   'GOOD: explicit conversion 

Visual Basic.NET unterstützt Überladungsfunktionen basierend auf dem Parametertyp. So verfügt die Environ-Funktion jetzt über zwei Formen:

Environ( Expression As Integer) As String 
Environ( Expression As String ) As String 

Visual Basic.NET bestimmt auf der Basis des Parametertyps, welche Funktion aufgerufen wird. Wenn Sie eine Ganzzahl an Environ() übergeben, wird die Ganzzahlversion aufgerufen; übergeben Sie eine Zeichenfolge, wird die Zeichenfolgenversion aufgerufen. Code, der einen Variant- oder Object-Datentyp an eine überladene Funktion übergibt, kann einen Kompilierungs- oder Laufzeitfehler verursachen. Wenn Sie, wie im folgenden Beispiel gezeigt, eine explizite Konvertierung verwenden, bedeutet dies, dass der Code nach der Aktualisierung auf Visual Basic.NET wie beabsichtigt ausgeführt wird:

Dim a As String 
Dim v As Variant 
v = "Path" 
a = Environ(CStr(v))   'GOOD: explicit conversion 

Das Verwenden expliziter Konvertierungen von spät gebundenen Objekten stellt eine gute Codierungsmethode dar. Dadurch lässt sich der Zweck des Codes leicht feststellen, und Sie können das Projekt einfacher in Visual Basic.NET übertragen.

Verwenden von "Date" zum Speichern von Datumsangaben

Frühere Visual Basic-Versionen unterstützten den Double-Datentyp, um Datumsangaben zu speichern und zu bearbeiten. Dies sollten Sie in Visual Basic.NET unterlassen, da Datumsangaben nicht intern als Double gespeichert werden. So ist der folgende Code zwar in Visual Basic 6.0 gültig, kann jedoch in Visual Basic.NET einen Kompilierungsfehler verursachen:

Dim dbl As Double 
Dim dat As Date 
dat = Now 
dbl = dat      'VB.NET: Double can't be assigned to a date 
dbl = DateAdd("d", 1, dbl)   'VB.NET: Can't use Double in date functions 
dat = CDate(dbl)   'VB.NET: CDate can't convert double to date 

Das .NET Framework stellt die Funktionen ToOADate und FromOADate bereit, um zwischen Double und Date zu konvertieren. Bei der Aktualisierung eines Projekts auf Visual Basic.NET ist es jedoch schwierig, den Zweck von Code festzustellen, der zum Speichern von Datumsangaben den Double-Datentyp verwendet. Um unnötige Codeänderungen in Visual Basic.NET zu vermeiden, sollten Sie stets den Date-Datentyp zum Speichern von Datumsangaben verwenden.

Auflösen parameterloser Standardeigenschaften

In Visual Basic 6.0 legen viele Objekte Standardeigenschaften offen, die als Programmiershortcuts ausgelassen werden können. Beispielsweise verfügt TextBox über die Standardeigenschaft Text, so dass Sie anstatt:

MsgBox Form1.Text1.Text 

folgenden Shortcut verwenden können:

MsgBox Form1.Text1 

Die Standardeigenschaft wird beim Kompilieren des Codes aufgelöst. Sie können Standardeigenschaften auch mit spät gebundenen Objekten verwenden, wie im folgenden Beispiel gezeigt:

Dim obj As Object 
Set obj = Form1.Text1 
MsgBox obj 

Im Beispiel des spät gebundenen Objekts wird die Standardeigenschaft zur Laufzeit aufgelöst und MsgBox zeigt den Wert der Standardeigenschaft von TextBox als Text1 an.

Visual Basic.NET unterstützt keine parameterlosen Standardeigenschaften und lässt diesen Shortcut somit nicht zu. Beim Aktualisier eines Projekts werden die parameterlosen Standardeigenschaften von Visual Basic.NET aufgelöst, Allerdings ist im Falle spät gebundener Objekte, die die Auflösung zur Laufzeit verwenden, eine automatische Auflösung nicht möglich. In diesem Fall müssen Sie den Code selbst ändern. Eine weitere Schwierigkeit liegt darin, dass viele Bibliotheken Standardeigenschaften mithilfe einer Eigenschaft namens _Default implementieren. _Default fungiert als Proxy und übergibt Aufrufe an die tatsächliche Standardeigenschaft. Bei der Aktualisierung Ihres Projekts werden also einige Standardeigenschaften in _Default aufgelöst. Der Code kann ganz normal ausgeführt werden, ist jedoch weniger verständlich als Code, der explizit mit der eigentlichen Eigenschaft geschrieben wurde. Aus diesem Grund sollten Sie in Ihrem Visual Basic 6.0-Code möglichst keine parameterlosen Standardeigenschaften verwenden. Statt des folgenden Codes:

Dim obj As Object 
Set obj = Me.Text1 
MsgBox obj   'Relying on default property 
MsgBox Me.Text1   'Relying on default property 

sollten Sie diesen Code schreiben:

Dim obj As Object 
Set obj = Me.Text1 
MsgBox obj.Text   'GOOD: Default property is resolved 
MsgBox Me.Text1.Text   'GOOD: Default property is resolved 

Im Gegensatz zu parameterlosen Standardeigenschaften werden Standardeigenschaften mit Parametern in Visual Basic.NET unterstützt. Zum besseren Verständnis des Unterschiedes zwischen diesen beiden Typen sollten Sie bedenken, dass Standardeigenschaften mit Parametern stets über einen Index verfügen. Ein Beispiel ist die Standardeigenschaft des Recordset-Objekts von ADO: the Fields-Auflistung. Der folgende Code:

Dim rs As ADODB.Recordset 
rs("CompanyName") = "SomeCompany" 
rs!CompanyName = "SomeCompany" 

ist eigentlich ein Shortcut für:

Dim rs As ADODB.Recordset 
rs.Fields("CompanyName").Value = "SomeCompany" 
rs.Fields!CompanyName.Value = "SomeCompany" 

In diesem Fall besitzt die Fields-Eigenschaft Parameter, so dass die Verwendung in Visual Basic.NET gültig ist; die Standardeigenschaft der Fields-Eigenschaft, Value, besitzt jedoch keine Parameter, so dass die richtige Verwendung in Visual Basic.NET wie folgt aussieht:

Dim rs As ADODB.Recordset 
rs("CompanyName").Value = "SomeCompany" 
rs!CompanyName.Value = "SomeCompany" 

Dieses Beispiel sowie die meisten anderen Standardeigenschaften werden bei der Aktualisierung des Projekts automatisch aufgelöst, so dass ihre Auflösung in Visual Basic 6.0 lediglich eine gute Programmierübung darstellt. Sie sollten die Verwendung von Standardeigenschaften mit den Datentypen Object und Variant jedoch vermeiden, da diese nicht aufgelöst werden können und Sie den Code dann im aktualisierten Projekt selbst korrigieren müssen.

Vermeiden der Null-Übergabe

In früheren Visual Basic-Versionen wurde die Null-Übergabe unterstützt. Die Null-Übergabe setzt voraus, dass bei der Verwendung von Null in einem Ausdruck das Ergebnis des Ausdrucks ebenfalls Null ist. In allen Fällen des folgenden Beispiels ist das Ergebnis von "V" stets Null.

Dim V 
V = 1 + Null 
V = Null + Right$("SomeText", 1) 
V = Right("SomeText", 0) 

Die Null-Übergabe wird in Visual Basic.NET nicht unterstützt. Die Anweisung 1+Null erzeugt in Visual Basic.NET einen Typenkonflikt. Außerdem verfügte Visual Basic 6.0 zwei Versionen der Left-Funktion – Left$ gab eine Zeichenfolge zurück, Left eine Variante, die Null sein konnte –, während Visual Basic.NET nur über eine Funktion verfügt, Left, die stets eine Zeichenfolge zurückgibt.

Um die Kompatibilität mit Visual Basic 6.0 und Visual Basic.NET zu gewährleisten, sollten Sie Code stets so schreiben, dass er auf Null testet, und sich nicht auf die Null-Übergabe verlassen. Außerdem geben die folgenden Funktionen in Visual Basic.NET nicht länger Null zurück:

Chr
Mid
Command
Oct
CurDir
Right
Date
RTrim
Environ
Space
Error
Str
Hex
Time
LCase
Trim
LTrim
UCase

Die Null-Übergabe wird im Allgemeinen in Datenbankanwendungen verwendet, weil dort überprüft werden muss, ob ein Datenbankfeld Null enthält. In diesem Fall sollten Sie die Ergebnisse mithilfe der IsNull()-Funktion überprüfen und die entsprechende Aktion durchführen.

Ein ähnliches Problem besteht bei der Verkettung einer Zeichenfolge mit einem Null-Wert. Beim Programmieren mit Datenbankobjekten ist es allgemein üblich, eine "leere Zeichenfolge" mit einem Feld zu verketten, um sicherzustellen, dass Null-Werte in eine leere Zeichenfolge umgewandelt werden. Beispiel:

MyString = rs!Field1 & "" 

Dieses Verfahren wird auch in Visual Basic.NET unterstützt. Wenn ein Null-Wert mit einer leeren Zeichenfolge verkettet wird (mithilfe des &Operators), ist das Ergebnis eine leere Zeichenfolge.

Verwenden von Arrays mit der Untergrenze Null

In Visual Basic 6.0 konnten Sie Arrays mit unteren und oberen Grenzen in einer beliebigen ganzen Zahl definieren. Außerdem konnten Sie ReDim verwenden, um eine Variante neu als Array zuzuweisen. Um die Zusammenarbeit mit anderen Sprachen zu gewährleisten, müssen Arrays in Visual Basic.NET die Untergrenze Null besitzen, und ReDim kann nur dann verwendet werden, wenn die Variable vorher mit Dim As Array deklariert wurde. Auf diese Weise werden die Möglichkeiten zur Definition von Arrays zwar beschränkt, Sie können jedoch Arrays zwischen Visual Basic.NET und anderen .NET-Sprachen übergeben. Das folgende Beispiel veranschaulicht die Einschränkung:

Dim a(1 To 10) As Integer   'LBound must be 0 in VB.NET 
Dim v 
ReDim v(10)   'Can't use ReDim without Dim in VB.NET 
Dim b(10) As Integer   'GOOD: Creates an array of 10 integers 
ReDim b(5) As Integer   'GOOD: Can ReDim previously Dimed var 

Ein Nebeneffekt besteht darin, dass Option Base 0|1 aus der Sprache entfernt wird.

Bei der Aktualisierung Ihres Projekts auf Visual Basic.NET werden alle Option Base-Anweisungen aus dem Code entfernt. Besitzt das Array die Untergrenze Null, bleibt es unverändert. Ist die Untergrenze des Arrays jedoch nicht Null, wird die untere Grenze entfernt und eine Warnung in den Code eingefügt, wie im folgenden Beispiel dargestellt:

Dim a(1 To 10) As Integer 

wird geändert zu: zu:

'UPGRADE_WARNING: Lower Bound of array a was changed from 1 to 0 
Dim a(10) As Integer 

In vielen Fällen kann der aktualisierte Code wie vorher ausgeführt werden. Wenn die Logik Ihrer Anwendung jedoch darauf basiert, dass die Untergrenze 1 ist, müssen Sie einige Änderungen vornehmen. Die Anweisungen Dim,ReDim und LBound sind durch Warnungen gekennzeichnet, um Ihnen beim Überprüfen der Änderungen zu helfen.

Aus diesem Grund sollten Sie im Visual Basic 6.0-Code Arrays mit der Untergrenze Null verwenden. Vermeiden Sie die Verwendung von ReDim als Array-Deklaration und die Verwendung von Option Base 1.

Verwenden von Konstanten anstelle von zugrundeliegenden Werten

Versuchen Sie Verwenden Sie beim Schreiben von Code möglichst Konstanten anstelle von ihnen zugrundeliegenden Werten. Verwenden Sie zum Beispiel folgenden Code, wenn Sie ein Formular zur Laufzeit maximieren:

Me.WindowState = vbMaximized   'Good: Constant name used 

anstatt:

Me.WindowStyle = 2   'Avoid using underlying value 
Me.WindowStyle = X   'Avoid using variables 

Verwenden Sie außerdem True und False anstelle von -1 und 0.

In Visual Basic.NET haben sich die Werte und auch die Namen einiger Eigenschaften und Konstanten geändert. Bei der Aktualisierung von Projekten auf Visual Basic.Net werden die meisten Konstanten automatisch für Sie geändert. Wenn Sie jedoch anstatt der Konstantennamen zugrundeliegende Werte oder Variablen verwenden, können viele Fälle nicht automatisch aktualisiert werden. Durch die Verwendung von Konstantennamen wird die Anzahl der von Ihnen durchzuführenden Änderungen minimiert.

Arrays und Zeichenfolgen fester Länge in benutzerdefinierten Typen

Aufgrund von Änderungen, die die vollständige Kompatibilität von Visual Basic.NET-Arrays und Strukturen mit anderen Visual Studio.NET-Sprachen gewährleisten, werden Zeichenfolgen fester Länge in der Sprache nicht mehr unterstützt. Dies ist jedoch meistens kein Problem, weil das Verhalten von Zeichenfolgen fester Länge von einer Kompatibilitätsklasse bereitgestellt wird, so dass der Code:

Dim MyFixedLengthString As String * 100 

wie folgt aktualisiert wird:

Dim MyFixedLengthString As New VB6.FixedLengthString(100) 

Zeichenfolgen fester Länge verursachen jedoch ein Problem, wenn sie in Strukturen verwendet werden (auch bekannt als benutzerdefinierte Typen). Das Problem entsteht dadurch, dass die Klasse für Zeichenfolgen fester Länge nicht automatisch beim Erstellen des benutzerdefinierten Typs erstellt wird. Ein weiteres Problem besteht darin, dass Arrays fester Größe ebenfalls nicht erstellt werden, wenn der benutzerdefinierte Typ erstellt wird.

Bei der Aktualisierung Ihres Codes werden benutzerdefinierte Typen mit Zeichenfolgen oder Arrays fester Länge durch einen Kommentar gekennzeichnet, der Sie darauf hinweist, die Zeichenfolge fester Länge bzw. das Array zu initialisieren, bevor Sie den benutzerdefinierten Typ verwenden. Sie können diese Änderung jedoch vermeiden, indem Sie die benutzerdefinierten Typen in Visual Basic 6.0 so ändern, dass sie Zeichenfolgen anstatt Zeichenfolgen fester Länge und nicht initialisierte Arrays anstatt Arrays fester Größe verwenden. Zum Beispiel kann dieser Code:

Private Type MyType 
    MyArray(5) As Integer 
    MyFixedString As String * 100 
End Type 
Sub Bar() 
    Dim MyVariable As MyType 
End Sub 

in den folgenden Code geändert werden:

Private Type MyType 
    MyArray() As Integer 
    MyFixedString As String 
End Type 
Sub Bar() 
    Dim MyVariable As MyType 
    ReDim MyVariable.MyArray(5) As Integer 
    MyVariable.MyFixedString = String$(100, " ") 
End Sub 

Vermeiden von Legacyfunktionen

Sie sollten die folgenden Schlüsselwörter vermeiden, da diese aus der Sprache entfernt wurden:

  • Def<type>

  • Computed GoTo/GoSub

  • GoSub/Return

  • Option Base 0|1

  • VarPtr, ObjPtr, StrPtr

  • LSet

Diese Schlüsselwörter werden weiter unten noch detaillierter beschrieben.

Def<type>

In früheren Versionen von Visual Basic wurden DefBool, DefByte, DefInt, DefLng, DefCur, DefSng, DefDbl, DefDec, DefDate, DefStr, DefObj und DefVar im Deklarationsabschnitt eines Moduls verwendet, um einen Reihe von Variablen als bestimmten Typ zu definieren. Beispiel:

DefInt A-C 

definierte alle Variablen beginnend mit den Buchstaben A, B oder C als Ganzzahl. Anstatt Def<type>-Anweisungen zu verwenden, sollten Sie Variablen explizit deklarieren.

Computed GoTo/GoSub

Computed GoTo/GoSub-Anweisungen haben folgende Form:

On x GoTo 100, 200, 300 

Sie werden in Visual Basic.NET nicht unterstützt. Stattdessen sollten Sie If-Anweisungen und Select Case-Konstrukte verwenden.

GoSub/Return

Die Anweisungen GoSub und Return werden in Visual Basic.NET nicht unterstützt. Sie lassen sich in den meisten Fällen durch Funktionen und Prozeduren ersetzen.

Option Base 0|1

Option Base 0|1 wurde verwendet, um die Standarduntergrenze eines Arrays anzugeben. Wie bereits erwähnt, wurde diese Anweisung aus der Sprache entfernt, da Visual Basic.NET nur Arrays mit der Untergrenze Null unterstützt. Arrays mit unteren Begrenzungen, die nicht Null sind, werden über eine Wrapperklasse unterstützt.

VarPtr, ObjPtr, StrPtr

VarPtr, VarPrtArray, VarPtrStringArray, ObjPtr und StrPtr waren nichtdokumentierte Funktionen, die verwendet wurden, um die zugrundeliegende Speicheradresse von Variablen abzurufen. Diese Funktionen werden in Visual Basic.NET nicht unterstützt.

LSet

In Visual Basic 6.0 konnte die LSet -Anweisung verwendet werden, um eine Variable eines benutzerdefinierten Typs einer anderen Variable eines anderen benutzerdefinierten Typs zuzuweisen. Diese Funktion wird in Visual Basic.NET nicht unterstützt.

Windows-APIs

Viele APIs können genau so verwendet werden wie in Visual Basic 6.0, mit der Einschränkung, dass Sie die Datentypen entsprechend anpassen müssen. The Long-Datentyp in Visual Basic 6.0 ist in Visual Basic.NET jetzt der Integer-Datentyp, und der Integer-Datentyp in Visual Basic 6.0 ist in Visual Basic.NET jetzt der Short-Datentyp. Während des Updates werden diese Änderungen für Sie durchgeführt, und einfache APIs funktionieren genauso wie in Visual Basic 6.0. Beispiel:

Private Declare Function GetVersion Lib "kernel32" () As Long 
Function GetVer() 
    Dim Ver As Long 
    Ver = GetVersion() 
    MsgBox ("System Version is " & Ver) 
End Function 

wird geändert zu:

Private Declare Function GetVersion Lib "kernel32" () As Integer 
Function GetVer() 
    Dim Ver As Integer 
    Ver = GetVersion() 
    MsgBox("System Version is " & Ver) 
End Function 

Neben der Aktualisierung numerischer Datentypen wird der Datentyp für Zeichenfolgen fester Länge in Visual Basic 6.0, der in Visual Basic.NET nicht unterstützt wird, auf eine Wrapperklasse für Zeichenfolgen fester Länge aktualisiert. Häufig können Sie in Visual Basic 6.0 dieselbe Aktion mit einer normalen Zeichenfolge durchführen. Beispiel:

Private Declare Function GetUserName Lib "advapi32.dll" Alias _ 
"GetUserNameA" (ByVal lpBuffer As String, ByRef nSize As Long) As Long 
Function GetUser() 
    Dim Ret As Long 
    Dim UserName As String 
    Dim Buffer As String * 25 
    Ret = GetUserName(Buffer, 25) 
    UserName = Left$(Buffer, InStr(Buffer, Chr(0)) - 1) 
    MsgBox (UserName) 
End Function 

lässt sich mit einer normalen Zeichenfolge, die explizit auf die Länge 25 festgelegt ist, besser schreiben als mit einer Zeichenfolge fester Länge:

    Dim Buffer As String 
    Buffer = String$(25, " ") 

Dieser Code wird wie folgt auf Visual Basic.NET aktualisiert:

Declare Function GetUserName Lib "advapi32.dll" Alias _ 
"GetUserNameA" (ByVal lpBuffer As String, ByRef nSize As Integer) As Integer 
Function GetUser() 
    Dim Ret As Integer 
    Dim UserName As String 
    Dim Buffer As String 
    Buffer = New String(CChar(" "), 25) 
    Ret = GetUserName(Buffer, 25) 
 UserName = Left(Buffer, InStr(Buffer, Chr(0)) - 1) 
 MsgBox(UserName) 
End Function 

In einigen Fällen kann Visual Basic.NET die Übergabe von Zeichenfolgen an APIs besser verarbeiten, da Sie mithilfe der Schlüsselwörter ANSI und UNICODE optional deklarieren können, wie Zeichenfolgen übergeben werden sollen.

Es gibt drei Fälle, in denen Sie unter Umständen Änderungen vornehmen müssen. Dies gilt zunächst einmal für das Übergeben benutzerdefinierter Typen mit Zeichenfolgen fester Länge oder Bytearrays an APIs. Sie müssen in Visual Basic.NET möglicherweise den Code ändern und das MarshallAs-Attribut (aus System.Runtime.InteropServices) allen Zeichenfolgen fester Länge bzw. allen Bytearrays im benutzerdefinierten Typ hinzufügen. Der zweite Fall ist das Verwenden des As Any-Variablentyps in einer Declare-Anweisung. Diese wird in Visual Basic.NET nicht unterstützt. Variablen vom Typ As Any wurden häufig verwendet, um eine Variable als Zeichenfolge oder Null zu übergeben; Sie können diese Verwendungsart in Visual Basic 6.0 dadurch ersetzen, dass Sie zwei Formen der API deklarieren. Deklarieren Sie die eine Form mit Long, die andere mit String. Die GetPrivateProfileString-API hat z. B. einen Parameter lpKeyName vom Typ As Any:

Private Declare Function GetPrivateProfileString Lib "kernel32" Alias 
   "GetPrivateProfileStringA" (ByVal lpApplicationName As String, ByVal 
      lpKeyName As Any, ByVal lpDefault As String, ByVal 
         lpReturnedString As String, ByVal nSize As Long, ByVal 
            lpFileName As String) As Long 

Sie können den As Any-Parameter entfernen, indem Sie die Declare-Anweisung durch zwei Versionen ersetzen – eine, die Long akzeptiert, und eine, die String akzeptiert:

Private Declare Function GetPrivateProfileStringKey Lib "kernel32" Alias 
   "GetPrivateProfileStringA" (ByVal lpApplicationName As String, ByVal 
      lpKeyName As String, ByVal lpDefault As String, ByVal 
         lpReturnedString As String, ByVal nSize As Long, ByVal 
            lpFileName As String) As Long 
Private Declare Function GetPrivateProfileStringNullKey Lib "kernel32" 
   Alias "GetPrivateProfileStringA" (ByVal lpApplicationName As String, 
      ByVal lpKeyName As Long, ByVal lpDefault As String, ByVal 
         lpReturnedString As String, ByVal nSize As Long, ByVal 
            lpFileName As String) As Long 

Wenn Sie den Wert Null an die API übergeben wollen, verwenden Sie die GetPrivateProfileStringNullKey-Version. Auf diese Weise wird gewährleistet, dass die Funktion auf Visual Basic.NET aktualisiert wird.

Der letzte Bereich, in dem Änderungen erforderlich werden können, ist die Verwendung von APIs, die das Erstellen von Threads, die Windows-Klassifizierung, das Verbinden von Nachrichtenwarteschlangen etc. durchführen. Einige dieser Funktionen verursachen in Visual Basic.NET einen Laufzeitfehler. Viele dieser APIs verfügen über Entsprechungen in Visual Basic.NET oder im .NET.Framework. Sie müssen hierbei von Fall zu Fall vorgehen.

Überlegungen zu Formularen und Steuerelementen.

Visual Basic.NET besitzt ein neues Formularpaket, WinForms. WinForms ist mit dem Formularpaket in Visual Basic 6.0 weitgehend kompatibel. Die wichtigsten Unterschiede werden unten erläutert:

  • WinForms bietet keine Unterstützung für das OLE-Containersteuerelement, so dass Sie dessen Verwendung in Ihren Visual Basic 6.0-Anwendung vermeiden sollten.

  • In WinForms gibt es kein Shape-Steuerelement. Quadratische und rechteckige Shape-Steuerelemente werden auf Label-Steuerelemente aktualisiert; ovale und kreisförmige Steuerelemente können nicht aktualisiert werden. Sie sollten ihre Verwendung in Anwendungen vermeiden.

  • In WinForms gibt es kein Line-Steuerelement. Horizontale und vertikale Linien werden auf Label-Steuerelemente aktualisiert. Diagonale Linien werden nicht aktualisiert, so dass Sie auf ihre Verwendung verzichten sollten.

  • WinForms verfügt über eine Reihe neuer Grafikbefehle als Ersatz für die Formularmethoden Circle, CLS, PSet, Line und Point. Da sich das neue Objektmodell stark von Visual Basic 6.0 unterscheidet, können diese Methoden nicht aktualisiert werden.

  • Was das Timer-Steuerelement anbetrifft, so wird der Timer nicht deaktiviert, wenn die Interval-Eigenschaft auf 0 festgelegt wird; stattdessen wird das Intervall auf 1 zurückgesetzt. Sie sollten in Ihren Visual Basic 6.0-Projekten Enabled auf False festlegen, anstatt das Intervall auf 0 festzulegen.

  • WinForms verfügen über zwei Menüsteuerelemente, MainMenu und ContextMenu, während Visual Basic 6.0 nur ein Menüsteuerelement besitzt, Menu, das sich als Menu oder ContextMenu öffnen lässt. Menu-Steuerelemente werden auf MainMenu-Steuerelemente aktualisiert, Sie können diese jedoch nicht als ContextMenus verwenden – dazu müssen Sie Ihre ContextMenus neu erstellen.

  • WinForms bieten keine Unterstützung für Dynamic Data Exchange (DDE).

  • WinForms bietet keine Unterstützung für die Form.PrintForm-Methode.

  • Obwohl WinForms Drag & Drop-Funktionen unterstützt, unterscheidet sich das Objektmodell sehr stark von Visual Basic 6.0. Aus diesem Grund können die Drag & Drop-Eigenschaften und –Methoden in Visual Basic 6.0 nicht aktualisiert werden.

  • Das .NET-Framework besitzt ein verbessertes Clipboard-Objekt (System.Windows.Clipboard), das mehr Funktionen bietet und mehr Zwischenablageformate unterstützt als das Clipboard-Objekt in Visual Basic 6.0. Aufgrund der unterschiedlichen Objektmodelle können Clipboard-Anweisungen jedoch nicht automatisch aktualisiert werden.

  • Um sicherzustellen, dass Ihre Formulare auf die richtige Größe aktualisiert werden, sollten Sie stets Twips als ScaleMode-Standardeinstellung in Ihren Anwendungen verwenden. Während der Aktualisierung transformiert Visual Basic.NET Ihre Formularkoordinaten von Twips in Pixel.

  • WinForms unterstützt nur TrueType- und OpenType-Schriftarten. Wenn Sie in Ihrer Anwendung andere Schriftarten verwenden, werden diese in die Standardschriftart des Systems geändert und alle Formatierungen (Schriftgrad, fett, kursiv, unterstrichen) gehen verloren. Dies gilt für die VB6-Standardschriftart MS Sans Serif. Es wird deshalb empfohlen, für formatierten Text Arial anstatt MS Sans Serif zu verwenden.