Freigeben über

Zehn Codeversionen für VBA, Visual Basic .NET und C#

  • Artikel

Veröffentlicht: 23. Apr 2003 | Aktualisiert: 22. Jun 2004

Von Paul Cornell

Dieser Artikel soll den Entwicklern von Microsoft Office Visual Basic für Applikationen (VBA)-Anwendungen anhand eines parallelen Codesyntaxvergleichs eine Einführung in Microsoft Visual Basic .NET und Microsoft C# geben.

Auf dieser Seite

Kommentare Kommentare
Einrichten von Verweisen Einrichten von Verweisen
Deklarieren und Initialisieren von Variablen Deklarieren und Initialisieren von Variablen
Arrays Arrays
Auflistungen Auflistungen
Do Do
If If
Select Case Select Case
Dateiein- und ausgabe Dateiein- und ausgabe
Fehlerbehandlung Fehlerbehandlung

Weitere Codesyntaxbeispiele finden Sie unter:
Converting Microsoft Office VBA Macros to Visual Basic .NET and C# (in Englisch)
Developing Microsoft Office Solutions Using C# (in Englisch)
Microsoft Office and .NET Interoperability (in Englisch)
Introducing .NET to Office Developers (in Englisch)

Kommentare

VBA und Visual Basic .NET verwenden einfache Anführungszeichen (') für Kommentare.
In C# werden Kommentare bis zum Ende der Zeile durch einen doppelten Schrägstrich (//) gekennzeichnet. Sie können auch einen mehrzeiligen Kommentar mit einem Schrägstrich gefolgt von einem Sternchen (/*) beginnen und mit einem Sternchen gefolgt von einem Schrägstrich (*/) abschließen.

' VBA und Visual Basic .NET 
' Alle Zeichen in dieser Zeile sind Kommentar. 
Dim strAge As String ' Alle Zeichen hier sind Kommentar  
' Dies ist ein 
' mehrzeiliger Kommentar. 
// C# 
// Alle Zeichen in dieser Zeile sind Kommentar. 
string strAge; // Alle Zeichen hier sind Kommentar. 
/* Dies ist ein 
mehrzeiliger Kommentar. */

 

Einrichten von Verweisen

In VBA, Visual Basic .NET und C# richten Sie Verweise auf ähnliche Weise ein. In VBA zeigen Sie im Menü Extras des Office Visual Basic-Editors auf Verweise und wählen dann die einzelnen Verweise zu externen Codekomponenten aus. In Visual Studio .NET klicken Sie im Menü Projekt auf Verweis hinzufügen und wählen dann die einzelnen Verweise zu externen Codekomponenten aus.
Sie verringern die Gefahr von Konflikten zwischen Objekt- und Auflistungsnamen in VBA, indem Sie gegebenenfalls vor jede Objekt- oder Auflistungsdeklaration den entsprechenden Bibliotheksanzeigenamen stellen. Sie müssen den Objekt- oder Auflistungsdeklarationen diesen Anzeigenamen voranstellen, wenn bei externen Bibliotheken mit mehreren Verweisen Typkonflikte auftreten (z.B. DAO.Recordset und ADO.Recordset, wenn zugleich auf Data Access Objects [DAO] und ActiveX Data Objects [ADO] im Projekt verwiesen wird).
In Visual Basic .NET und C# müssen Sie jeder Klassendeklaration einen entsprechenden Namespace voranstellen. Mithilfe der Anweisungen Imports oder using (Visual Basic .NET bzw. C#) können Sie Namespaceverweise verkürzen. Alternativ können Sie auch Aliase für Namespaceverweise verwenden.

' VBA 
' Angenommen, es wird auf die Word 10.0-Objektbibliothek verwiesen. 
... 
Dim wdApp As Word.Application ' Dem Bibliotheksanzeigenamen vorangestellt. 
Dim docMain As Document ' Ohne Bibliotheksanzeigename. 
... 
' Visual Basic .NET 
' Angenommen, es wird auf die Word 2002-PIA verwiesen. 
... 
Dim wdApp As Microsoft.Office.Interop.Word.Application 
' Sie können die vorherige Codezeile wie folgt abkürzen: 
Imports Microsoft.Office.Interop.Word 
... 
Dim wdApp As Application 
' Sie können auch einen Namespacealias verwenden. 
Imports Word = Microsoft.Office.Interop.Word 
... 
Dim wdApp As Word.Application 
... 
// C# 
// Angenommen, es wird auf die Word 2002-PIA verwiesen. 
... 
Microsoft.Office.Interop.Word.Application wdApp; 
... 
// Sie können auch einen Namespacealias verwenden. 
using Word = Microsoft.Office.Interop.Word; 
... 
Word.Application wdApp; 
...

Wenn Sie in .NET auf zwei oder mehr Klassen mit demselben Namen in zwei oder mehr Assemblys verweisen, müssen Sie diese Klassen mit den vollständigen Namespaces spezifizieren oder Namespacealiase verwenden. Sie möchten zum Beispiel auf die Namespaces Microsoft.Office.Interop.Excel und Microsoft.Office.Interop.Word verweisen und schreiben dazu folgenden Code in Visual Basic .NET:

Imports Microsoft.Office.Interop.Word 
Imports Microsoft.Office.Interop.Excel 
... 
Dim wdApp As Application 
Dim xlApp as Application

Sie erhalten dann die Fehlermeldung 'Application' ist nicht eindeutig. Importiert aus den Namespaces oder Typen 'Microsoft.Office.Interop.Excel, Microsoft.Office.Interop.Word'.
Wenn Sie diesen Fehler beheben möchten, müssen Sie einen vollständigen Verweis oder einen Namespacealias angeben, z.B.:
Dim wdApp As Microsoft.Office.Interop.Word.Application
Dim xlApp as Microsoft.Office.Interop.Excel.Application
Oder:

Imports Word = Microsoft.Office.Interop.Word 
Imports Excel = Microsoft.Office.Interop.Excel 
... 
Dim wdApp As Word.Application 
Dim xlApp As Excel.Application

 

Deklarieren und Initialisieren von Variablen

Das Deklarieren von Variablen erfolgt in Visual Basic .NET auf die gleiche Weise wie in VBA. In Visual Basic .NET und C# können Sie jedoch Variablen in denselben Zeilen initialisieren, in denen Sie sie auch deklarieren. Bei der Variablendeklaration in C# geben Sie den Datentyp (der C#-Datentyp int entspricht z.B. dem Visual Basic-Datentyp Integer) gefolgt vom Variablennamen an. Sie verwenden keine Dim- oder As-Anweisungen.
Ebenso existiert die Set-Anweisung nicht mehr in Visual Basic .NET. Beachten Sie auch, dass Sie nach Code ein Klammernpaar setzen müssen: z.B. Word.Application(). In Visual Basic .NET und C# können Sie unmittelbar bei der Initialisierung eine Klasseninstanz anpassen. Dies funktioniert nicht in COM-basierten Sprachen wie VBA. Sie geben keinen Code in das Klammernpaar ein, wenn Sie anzeigen möchten, dass das Word.Application-Objekt keine Initialisierungsargumente verarbeitet.

' VBA 
... 
Dim wdApp As Word.Application 
Dim docMain As Document 
Dim intDocuments As Integer 
Set wdApp = New Word.Application 
Set docMain = wdApp.ActiveDocument 
intDocuments = 0 
... 
' Visual Basic .NET 
Imports Word = Microsoft.Office.Interop.Word 
... 
Dim wdApp As New Word.Application() 
Dim docMain As Word.Document = wdApp.ActiveDocument 
Dim intDocuments As Integer = 0 
... 
// C# 
using Word = Microsoft.Office.Interop.Word; 
... 
Word.Application wdApp = new Word.Application(); 
Word.Document docMain = wdApp.ActiveDocument; 
int intDocuments = 0; 
...

 

Arrays

In VBA und Visual Basic .NET ist die Arraysyntax vergleichbar. In Visual Basic .NET können Sie jedoch die Werte eines Arrays in derselben Zeile initialisieren und deklarieren. Beachten Sie auch, dass Sie in VBA die Debug.Print-Methode, in Visual Basic .NET die Debug.WriteLine-Methode und in C# die Console.WriteLine-Methode verwenden. Außerdem müssen Sie in Visual Basic .NET und in C# alle Argumentlisten in Klammern einschließen (in VBA können diese Klammern bei einfachen Anweisungen entfallen). In VBA und Visual Basic .NET verwenden Sie eine Leerstelle plus Unterstrich ( _), um Zeilenfortsetzungen und Wagenrückläufe am Ende von Codeanweisungen und Codeblöcken anzuzeigen. In C# hingegen gibt es keine Zeichen für Zeilenfortsetzungen. Hier markieren Semikolons das Ende von Codeanweisungen bzw. geschwungene Klammern das von Codeblöcken. Beachten Sie auch die for-Schleife in C#. Sie verwenden nicht das Wort Next, und die Syntax der for-Schleifenbedingungen ist kompakter. In Visual Basic verwenden Sie das kaufmännische Und-Zeichen (&), um Zeichenfolgen zu verketten. In C# verwenden Sie dazu das Plus-Symbol (+).

' VBA 
... 
Dim intAge(4) As Integer 
Dim intPerson As Integer 
intAge(1) = 35 
intAge(2) = 34 
intAge(3) = 29 
intAge(4) = 30 
For intPerson = 1 To UBound(intAge) 
 Debug.Print "Person #" & intPerson & " ist " & _ 
  intAge(intPerson) & " Jahre alt." 
Next intPerson 
... 
' Visual Basic .NET 
... 
Dim intAge() As Integer = {35, 34, 29, 30} 
Dim intPerson As Integer 
For intPerson = 0 To UBound(intAge) 
 Debug.WriteLine(value:="Person #" & intPerson + 1 & " ist " & _ 
  intAge(intPerson) & " Jahre alt.") 
Next intPerson 
... 
// C# 
... 
int[] intAges = {35, 34, 29, 30}; 
int intPerson; 
for(intPerson = 0; intPerson < intAges.Length; intPerson++) 
{ 
 Console.WriteLine("Person #" + (intPerson + 1) + " ist " +  
  intAges[intPerson] + " Jahre alt."); 
} 
...

 

Auflistungen

VBA und Visual Basic .NET verwenden beide dieselbe Collection-Auflistung. Dazu gibt es keine Entsprechung in C#. Sie können beispielsweise die System.Collections.ArrayList-Klasse verwenden, um eine Objektgruppe zu erstellen, die sich ähnlich wie die Collection-Auflistung in Visual Basic verhält.

' VBA 
... 
Dim colNames As Collection 
Dim intName As Integer 
Set colNames = New Collection 
With colNames 
 .Add Item:="Paul" 
 .Add Item:="Frank" 
 .Add Item:="Lisa" 
 .Add Item:="Dirk" 
 For intName = 1 To .Count 
  ' Verwenden Sie Debug.WriteLine für Visual Basic .NET. 
  Debug.Print "Element #" & intName & " = " & _ 
   .Item(intName) 
 Next intName 
End With 
... 
' Visual Basic .NET 
Imports Microsoft.VisualBasic 
... 
Dim colNames As New Collection() 
Dim intName As Integer 
With colNames 
 .Add(Item:="Paul") 
 .Add(Item:="Frank") 
 .Add(Item:="Lisa") 
 .Add(Item:="Dirk") 
 For intName = 1 To .Count 
  Debug.WriteLine(message:="Element #" & intName & " = " & _ 
   .Item(intName)) 
 Next intName 
End With 
... 
// C# 
using System.Collections; 
... 
ArrayList colNames = new ArrayList(); 
colNames.Add("Paul"); 
colNames.Add("Frank"); 
colNames.Add("Lisa"); 
colNames.Add("Dirk"); 
for(int intName = 0; intName < colNames.Count; intName++) 
{ 
 Console.WriteLine("Element #" + (intName + 1) + " = " +  
  colNames[intName]); 
} 
...

Mit der For Each.Next-Anweisung können Sie die Objekte in einer Collection-Auflistung in VBA durchlaufen, da die Collection-Auflistung eine verborgene _NewEnum-Methode unterstützt.
Sie können mit der For Each.Next-Anweisung die Objekte in einer Microsoft.VisualBasic.Collection-Klasseninstanz durchlaufen, da die Collection-Klasse die System.Collection.IEnumerable-Schnittstelle implementiert.
Und Sie können schließlich die foreach-Anweisung in C# verwenden, um die Objekte einer System.Collections.ArrayList-Klasseninstanz zu durchlaufen, da die ArrayList-Klasse die System.Collections.IEnumerable-Schnittstelle implementiert.
Auf diese Weise unterstützen VBA, Visual Basic .NET und C# den Durchlauf durch Auflistungen, die die _NewEnum -Methode (COM) und Klasseninstanzen unterstützen, die die IEnumerable-Schnittstelle (.NET) implementieren.

' VBA 
... 
Dim colNames As Collection 
Dim vntName As Variant 
Set colNames = New Collection 
With colNames 
 .Add Item:="Paul" 
 .Add Item:="Frank" 
 .Add Item:="Lisa" 
 .Add Item:="Dirk" 
 For Each vntName In colNames 
  Debug.Print vntName 
 Next vntName 
End With 
... 
' Visual Basic .NET 
... 
Dim colNames As New Collection() 
Dim objName As Object 
With colNames 
 .Add(Item:="Paul") 
 .Add(Item:="Frank") 
 .Add(Item:="Lisa") 
 .Add(Item:="Dirk") 
 For Each objName In colNames 
  Debug.WriteLine(objName) 
 Next objName 
End With 
... 
// C# 
... 
ArrayList colNames = new ArrayList(); 
colNames.Add("Paul"); 
colNames.Add("Frank"); 
colNames.Add("Lisa"); 
colNames.Add("Dirk"); 
foreach(object objName in colNames) 
{ 
 Console.WriteLine(objName); 
} 
...

 

Do

Do.Loop verhält sich in VBA und in Visual Basic .NET gleich. In C# wird hingegen ein while-Block verwendet. Beachten Sie im folgenden Visual Basic .NET-Beispielcode, dass der VBA-Code intCounter = intCounter + 1 in intCounter += 1 abgekürzt wurde. In C# schreiben Sie intCounter++;.

' VBA 
... 
Dim intNumber As Integer, intCounter As Integer 
intNumber = 10 
intCounter = 1 
Do While intCounter <= intNumber 
 Debug.Print intCounter 
 intCounter = intCounter + 1 
Loop 
... 
' Visual Basic .NET 
Dim intNumber As Integer = 10, intCounter As Integer = 1 
Do While intCounter <= intNumber 
 Debug.WriteLine(value:=intCounter) 
  intCounter += 1 
Loop 
... 
// C# 
... 
int intNumber = 10, intCounter = 1; 
while(intCounter <= intNumber) 
{ 
 Console.WriteLine(intCounter); 
 intCounter++; 
} 
...

 

If

If-, ElseIf- und Else-Anweisungen verhalten sich in VBA und Visual Basic .NET gleich. In C# ändert sich die Visual Basic-Anweisung If in if und ElseIf in else if. Es gibt in C# keine Then-Anweisung.

' VBA 
... 
Dim strTarget As String, strTry1 As String, strTry2 As String 
strTarget = "Paul" 
strTry1 = "Frank" 
strTry2 = "Lisa" 
If strTry1 = strTarget Then 
 MsgBox strTry1 & " entspricht " & strTarget & "." 
ElseIf strTry2 = strTarget Then 
 MsgBox strTry2 & " entspricht " & strTarget & "." 
Else 
 MsgBox Prompt:="Weder " & strTry1 & " noch " & _ 
  strTry2 & " entspricht " & strTarget & "." 
End If 
... 
' Visual Basic .NET 
... 
Dim strTarget As String = "Paul", strTry1 As String = "Frank", _ 
 strTry2 As String = "Lisa" 
 If strTry1 = strTarget Then 
  MsgBox(Prompt:=strTry1 & " entspricht " & strTarget & ".") 
 ElseIf strTry2 = strTarget Then 
  MsgBox(Prompt:=strTry2 & " entspricht " & strTarget & ".") 
 Else 
  MsgBox(Prompt:="Weder " & strTry1 & " noch " & _ 
   strTry2 & " entspricht " & strTarget & ".") 
 End If 
... 
// C# 
using System.Windows.Forms; 
... 
string strTarget = "Frank", strTry1 = "Paul", strTry2 = "Lisa"; 
if(strTry1==strTarget) 
{ 
 MessageBox.Show(strTry1 + " entspricht " + strTarget + "."); 
} 
else if(strTry2==strTarget) 
{ 
 MessageBox.Show(strTry2 + " entspricht " + strTarget + "."); 
} 
else 
{ 
 MessageBox.Show("Weder " + strTry1 + " noch " +  
  strTry2 + " entspricht " + strTarget + "."); 
} 
...

 

Select Case

Select Case-Anweisungen funktionieren in VBA und Visual Basic .NET auf die gleiche Weise. In C# verwenden Sie switch.case-Anweisungen. Nach jeder case-Anweisung müssen Sie das break-Schlüsselwort verwenden. Die Anweisung Case Else in Visual Basic wird zu default in C#.

' VBA 
... 
Dim strGrade As String 
strGrade = "A" 
Select Case strGrade 
 Case "A" 
  MsgBox Prompt:="Hervorragend" 
 Case "B" 
  MsgBox Prompt:="Sehr gut" 
 Case "C" 
  MsgBox Prompt:="Gut" 
 Case "D" 
  MsgBox Prompt:="Ausreichend" 
 Case "F" 
  MsgBox Prompt:="Ungenügend" 
 Case Else 
  MsgBox Prompt:="Welches Bewertungssystem " & _ 
   "verwenden Sie?" 
 End Select 
' Visual Basic .NET 
Dim strGrade As String = "A" 
Select Case strGrade 
 Case "A" 
  MsgBox(Prompt:="Hervorragend") 
 Case "B" 
  MsgBox(Prompt:="Sehr gut") 
 Case "C" 
  MsgBox(Prompt:="Gut") 
 Case "D" 
  MsgBox(Prompt:="Ausreichend") 
 Case "F" 
  MsgBox(Prompt:="Ungenügend") 
 Case Else 
  MsgBox(Prompt:="Welches Bewertungssystem " & _ 
   "verwenden Sie?") 
End Select 
// C# 
using System.Windows.Forms; 
... 
string strGrade = "A"; 
switch(strGrade) 
{ 
 case "A": 
  MessageBox.Show("Hervorragend"); 
  break; 
 case "B": 
  MessageBox.Show("Sehr gut"); 
  break; 
 case "C": 
  MessageBox.Show("Gut"); 
  break; 
 case "D": 
  MessageBox.Show("Ausreichend"); 
  break; 
 case "F": 
  MessageBox.Show("Ungenügend"); 
  break; 
 default: 
  MessageBox.Show("Welches Bewertungssystem " +  
   "verwenden Sie?"); 
  break; 
} 
...

 

Dateiein- und ausgabe

Die Visual Basic-Sprache lässt die Anweisungen Close, Input, Open, Print und Write für die Dateiein- und -ausgabe zu. Das VBA-Modul FileSystem stellt zusätzliche Funktionen (z.B. ChDir, CurDir, FileCopy, SetAttr usw.) zum Navigieren in einem Dateisystem und zum Arbeiten mit Dateien bereit. Microsoft Scripting Runtime (scrrun.dll) hält weitere Zusatzfunktionen für die Dateiein- und -ausgabe bereit: CreateTextFile, OpenTextFile, ReadLine und WriteLine. In Visual Basic .NET und Visual C# .NET verwenden Sie die Klassen und Elemente des System.IO-Namespace.

' VBA 
' Verwenden der Anweisungen Open, Write und Close. 
... 
Dim objFile As Variant 
Dim strText As String 
objFile = "javascript:void(null);" 
strText = "Dieser Text wurde geschrieben auf " & Now & "." 
Open objFile For Output As #1 
Write #1, strText 
Close #1 
' Verwendung von Microsoft Scripting Runtime. 
... 
Dim objFSO As Scripting.FileSystemObject 
Dim objTS As Scripting.TextStream 
Set objFSO = New Scripting.FileSystemObject 
Set objTS = objFSO.CreateTextFile("javascript:void(null);") 
objTS.WriteLine "Dieser Text wurde geschrieben auf " & Now & "." 
objTS.Close 
... 
' Visual Basic .NET 
Imports System.IO 
... 
Dim objSR As StreamWriter 
objSR = File.CreateText("javascript:void(null);") 
objSR.WriteLine("Dieser Text wurde geschrieben auf " & Now & ".") 
objSR.Close() 
... 
// C# 
using IO = System.IO; 
... 
IO.StreamWriter objSR; 
objSR = IO.File.CreateText("javascript:void(null);"); 
objSR.WriteLine("Dieser Text wurde geschrieben auf " + 
 System.DateTime.Now + "."); 
objSR.Close(); 
...

 

Fehlerbehandlung

VBA verwendet Fehlerbehandlungsanweisungen wie On Error GoTo Line, On Error GoTo 0 und On Error Resume Next. Diese Anweisungen können Sie auch in Visual Basic .NET verwenden. Sie können Fehler aber auch mit den Try/Catch/Finally-Anweisungen (try/catch/finally in C#) beheben, die den zu schreibenden Code erheblich verringern, wie das folgende Beispiel zeigt:

' VBA 
Private Sub DivideByZero() 
 On Error GoTo DivideByZero_Err 
 Dim intNumber As Integer 
 intNumber = 1 
 MsgBox "Hier ist ein allgemeiner Fehler: " & intNumber / 0 
DivideByZero_End: 
 Exit Sub 
DivideByZero_Err: 
 Select Case Err.Number 
  Case 11 ' Teilung durch 0. 
   MsgBox "Sie können" & intNumber & " nicht durch 0 teilen." 
  Case Else ' Unvorhersehbarer Fehler. 
   MsgBox "Fehler " & Err.Number & " in Prozedur DivideByZero: " & _ 
 Err.Description & "." 
 End Select 
 Resume Next 
End Sub 
' Visual Basic .NET 
Private Sub DivideByZero() 
 Dim intNumber As Integer = 1 
 Try 
  intNumber /= 0 
  MsgBox("Hier ist ein allgemeiner Fehler: " & intNumber) 
 Catch e As System.OverflowException 
  MsgBox("Sie können " & intNumber & " nicht durch 0 teilen.") 
 Catch e As System.Exception ' Unvorhersehbarer Fehler. 
  MsgBox("Fehler in " & e.Source & ": " & e.Message) 
 Finally 
  ' Hier Wiederherstellungscode eingeben. 
 End Try 
End Sub 
// C# 
private void DivideByZero() 
{ 
 int intNumber = 1; 
 try 
 { 
  intNumber /= 0; 
  MessageBox.Show("Hier ist ein allgemeiner Fehler: " + intNumber); 
 } 
 catch(System.OverflowException e) 
 { 
  MessageBox.Show("Sie können " + intNumber + " nicht durch 0 teilen."); 
 } 
 catch(System.Exception e) // Unvorhersehbarer Fehler  
 { 
  MessageBox.Show("Fehler in " + e.Source + ": " + e.Message); 
 } 
 finally 
 { 
  // Hier Wiederherstellungscode eingeben. 
 } 
}

© 2003 Microsoft Corporation. Alle Rechte vorbehalten. Rechtliche Hinweise.