• zum Ariadnefaden springen
• zum Textbeginn springen
• zum Menü springen

• Startseite /
• Sitemap /
• VB(A) /
• VB(A) allgemein /
• Von VB(A) zu C#

• 42 |
• Kontakt

Von VB(A) zu C# - Stolpersteine vermeiden

Stand: Dezember 2004, überarbeitet September 2007

• Sprungmarken:
• Spickzettel |
• Operatoren

Der folgende Spickzettel bezieht sich auf das »Umsetzen« von Quellcode von VB(A) zu C#, wodurch er auch entstanden ist. Vorgehensweise: »Paste and Copy« von Editorfenster zu Editorfenster und anschließendes schrittweises Ersetzen in C# Code.

Es kann hilfreich sein, sich vorab im VB(A) Code einige Notizen zu machen oder Abschnitte mit einem Kommentarhinweis zu kennzeichnen. Beim späteren Umschreiben überliest man aus Gewohnheit doch das eine oder andere und vergisst, es zu ersetzen. Mit der folgenden Punkteliste kann man sich somit ein paar Fehlermeldungen ersparen. Oder, was schlimmer ist, die ausbleibende Fehlermeldung...

• Verkettung durch das & : Der & Operator wird ersetzt durch das +
• = Operator: Handelt es sich um eine Zuweisung oder eine Prüfung auf Gleichheit
• Datentyp Boolean: Prüfen, ob sich nicht doch ein Abfragen des Zahlenwertes -1 eingeschlichen hat und artig ein True daraus machen^^
  • Dies muss auch für ArgListe einer Prozedur berücksichtigt werden, wenn sie Konstrukte wie Cancel As Integer enthält und diese später als bool verarbeitet werden sollen
• Array und der Frauenschalter : Wenn Option Base 1 gesetzt wurde, die festgelegte untere Grenze auf 0 setzen, das Array dementsprechend anpassen
• Select Case -> switch-Anweisung
  • Die switch-Anweisung unterstützt keine zusammenhängenden Konstantenbereiche, wie zum Beispiel Case 1 To 6, Case IS < 5. Hier bietet sich als Alternative in C# die Verwendung eines if an
  • Probleme kann auch ein leeres case (ohne folgenden Anweisungsblock) bereiten. switch benötigt ein explizites break; um die Programmausführung mit der Anweisung fortzusetzen, die dem switch Block folgt. (Stichpunkt: Fall Through). Wird ein leerer case Zweig benötigt sollte man vorab ein auskommentiertes 'break; als Gedankenstütze im Code hinterlegen
• Prozeduren - ArgListe:
  • Kontrolle und gegebenenfalls fehlende Schlüsselwörter ByVal | ByRef bereits im Originalquellcode setzen. Das erspart einem mehr als nur ein *OHA*. VB(A) und C# (übrigens auch VB.NET) haben bei der Parameterübergabe ein genau umgekehrtes Standardverhalten. In VB(A) werden Parameter, für die kein ByVal|ByRef angegeben sind, implizit auf By Reference gesetzt, in C# und VB.NET auf By Value
  • Optional-Parameter: In C# gibt es keine optionalen Parameter, existierende Parameter müssen gesetzt werden! Dadurch entstehen dann Konstrukte wie: Excel.Workbook wb = ThisApplication.Workbooks.Open(@"c:\YourPath\YourWorkbook.xls", Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
    So weit, so schlecht... - Um es kurz zu machen: Eine Träne der Trauer verdrücken und sich von optionalen Parametern verabschieden. Klären, welche Parameter gebraucht werden, Variablen definieren und feste Grössen bzw. den Missing-Wert zuweisen, Fertig!
  • ParamArray : kann in C# mit dem params-Schlüsselwort ausgeführt werden

Seitenanfang

Spickzettel - Syntaxunterschiede

Die aufgezählten Punkte der Liste bezeichnen (meistens) nur den VB(A) Syntax und nicht den Lösungsansatz beziehungsweise das Äquivalent in C#. Ausnahmen hiervon sind am Ende der Liste angefügt.

1. Variablen und Felder
   1. Deklaration und Dimensionierung, Gültigkeitsbereiche
   2. Groß- und Kleinschreibung, Stichpunkt: »Case Sensitive«
   3. Verwendung von Schlüsselwörtern, Stichpunkt: Let und Set
   4. Objectvariablen
   5. Array:
      • Dim arr(10) As Integer deklariert ein Array mit 11 Elementen, von 0 bis 10
      • Redim und Redim Preserve kein Äquivalent, aus Performancegründen ist das auch gut so, Stichpunkt: ArrayLists
   6. Choose-Funktion kein Äquivalent
   7. Switch-Funktion kein Äquivalent
2. Konstanten und Enumaration
3. Datentypen
   1. Unterschiede COM und CTS
   2. Datentypen vorab auf implizite und explizite Konvertierung überprüfen
   3. Datentyp Variant und »Untertype«
   4. Datentyp Boolean: False Wert 0, True Wert -1
4. Operatoren
   1. Zuweisungen, Wertprüfungen und Zustände - Äquivalenzen überprüfen
   2. Zeichenfolgenverkettung: & Operator
   3. Schlüsselwörter Like, Is, Nothing
   4. Logische und Bit Operatoren
      • Kein Potenz ^ (Circumflex)-Operator in C#: Wenn 2^8 nicht mehr 256 sondern 10 ist. *Huch*
      • Zu Eqv und Imp gibt es in C# kein Äquivalent. Wer`s jemals benutzt hat, hier ist ein Beispiel zu einer Ersatzkonstruktion
5. Blöcke und Kontrollstrukturen
   1. Generelles Beenden, Begrenzen von Verzweigungen und Schleifen
   2. With-Anweisung kein Äquivalent
6. Prozeduren
   1. Deklaration Anweisungen Function, Sub, Property
   2. Gültigkeitsbereiche Public, Private, Friend, Static
   3. Eigenschaften Unterscheidung Property Get, Property Let(primitive Datentypen) und Property Set(Objekte)
   4. Keine CallByName-Funktion vorhanden
   5. Parameterübergabe
      • byVal (ByValue) und byRef (ByReference), optionale Parameter
7. Frühes und spätes Binden von Objekten, Schwerpunkt Automation
8. Events (Ereignisse)
9. Fehlerbehandlung On Error

Seitenanfang

Schlüsselwort Me

Me in VB(A) entspricht nicht this in C#!

In VB(A) verhält sich Me wie eine implizit deklarierte Variable. Bei Verwendung in einem Klassenmodul steht Me allen Prozeduren zu Verfügung. Weiter stellt Me eine Möglichkeit dar, sich auf eine von mehreren Instanzen einer Klasse zu beziehen, in der aktuell der Code ausgeführt wird.

In VB.NET stellt Me ein Bezug auf die eigene Klasseninstanz dar. In C# entspricht dies dem Schlüsselwort this.

Gültigkeitsbereiche und Lebensdauer (von was und für wen eigentlich?)

Nichts kann so verwirrend sein wie das Deklarieren in VB(A). Dim, New, WithEvents aber nur ohne New und anders rum. Die Anweisung Static und/oder das Schlüsselwort Static. »Deklaratoren« für Variablen aber nicht Konstanten, »Modifikatoren« für »Deklarationen«, Typen und Prozeduren und ja auch für Konstanten *g*. Nicht mehr gültige Modifikatoren, die aber »abwärtskompatibel«, wie wir das von MS gewöhnt sind, noch funktionieren und so weiter.

Wer denkt, daß er dieses Thema jemals richtig in VB(A) durchschaut hat, klopft sich jetzt auf die Schulter :p. Allen Anderen sei dieser Link empfohlen Gültigkeitsbereiche.

Sicher wissen wir^^: Wenn Variablen mit Dim auf Prozedurebene (ohne Static Deklaration), also »lokal« deklariert wurden, sind sie ab der Zeile, die die Deklaration enthält, bis zum Ende der Prozedur gültig.

In C# ergeben sich die Gültigkeitsbereiche eindeutig aus der durch die geschweiften Klammern eingegrenzte Blockstruktur.

Methoden und Klassendefinition

C# kennt nur Methoden mit und ohne (void) Rückgabewert.

In VB(A) entspricht dies, ungefähr, den Function- und Sub-Prozeduren.

Bei Methoden in C# steht der Datentyp des Rückgabewertes vorne, gefolgt vom Namen und der Parameterliste

public double anyMethod(double value1, double value2) { ... - Nochmal ByVal|ByRef : Die Parameter sind standardmäßig auf ByVal gesetzt. Um eine Parameterübergabe By Reference zu erzwingen, muss das Schlüsselwort ref verwendet werden.

Property- Prozeduren in VB(A), können für eine Eigenschaft unterschiedliche Zugriffsebenen deklarieren. Public Property Get - Private Property Let|Set -> in C# müssen beide, Get und Set, die gleiche Zugriffsebene besitzen.

   'VB(A) Class clsPath
   Private sPath As String

   Public Property Get pPath() As String
      pPath = sPath
   End Property

   Private Property Let pPath(ByVal Value As String)  
      sPath = Value 'aus einer Prozedur, innerhalb des Klassenmoduls
   End Property
   ...
   
   'Objekt erzeugen
   Private oPath as clsPath
   ...
   If IsObjectNothing(oPath) Then Set oPath = New clsPath
   
   oPath.pPath = 'irgendein Pfad
   
   // C#
   public class CPath {
      private string path;
      ...
      public string Path {
         get
         {return path;}
         set
         {path = value;}
      {
      ...
   {

   // Objekt erzeugen
   private CPath myPath = new CPath("irgendein Pfad");
   

Seitenanfang

Nochmal Array

Dimensionierung:

   Dim arr(10) As Integer 'VB(A)

   int[]arr = new int[11]; // C#

Redim und ReDim Preserve existieren nicht in C#. Ein möglicher Workaround wäre:

   'VB(A)
   Dim arr() As Integer, i As Integer
   ...
   ReDim Preserve arr(i)

   // C#
   int[] arr;
   int i;
   ...
   int[] arrCopy = new int[i + 1];
   if (arr != null)
      Array.Copy(arr, arrCopy, Math.Min(arr.Length, arrCopy.Length));
   arr = arrCopy;

Aber die bessere Lösung ist ArrayList. Ab >= C# 2005 bietet sich auch die Array.Resize-Methode an.

Nochmal Blöcke

With-Anweisung:

   'VB(A)
   With IrgendeineKlasse
      .EineEigenschaft = EinWert
      .NochEineEigenschaft = EinWert
      .EineAndereEigenschaft = EinWert
      .EineMethode(ArgListe)      
   End With

   // C#
   IrgendeineKlasse.EineEigenschaft = EinWert;
   IrgendeineKlasse.NochEineEigenschaft = EinWert;
   IrgendeineKlasse.EineAndereEigenschaft = EinWert;
   IrgendeineKlasse.EineMethode(ArgListe);
   

Püh? ehm...

Seitenanfang

Tabellarischer Vergleich der Operatoren in VB(A), VB und C#

• Sprungmarken Operatoren:
• Arithmetische |
• Vergleichs- |
• Logische |
• Bitweise |
• Verschiebungs- |
• Verknüpfungs- |
• Zuweisungs- |
• Sonstige

Seitenanfang

Seitenanfang

Nochmal Eqv-Operator und Imp-Operator, umgebaut für VB und C#, (hier gehts weiter zu Bitweise Operatoren).

   'VB(A)
   Private Sub Sequence()
      Debug.Print bEqv(3 > 2, 2 > 1) 'Liefert True
      Debug.Print bEqv(2 > 3, 2 > 1) 'Liefert False
      Debug.Print bEqv(2 > 3, 1 > 2) 'Liefert True
      Debug.Print
      Debug.Print bImp(3 > 2, 2 > 1) 'Liefert True
      Debug.Print bImp(3 > 2, 1 > 2) 'Liefert False
      Debug.Print bImp(2 > 3, 1 > 2) 'Liefert True      
   End Sub
   Public Function bEqv(byVal x As Boolean, byVal y As Boolean) As Boolean
      bEqv = x Eqv y 'alternativ, gegenteiliges »XOR« bEqv = Not (x Xor y) 
                     'oder bitweiser Vergleich bEqv = (x = y) 
   End Function   
   Public Function bImp(byVal x As Boolean, byVal y As Boolean) As Boolean
      bImp = x Imp y 'alternativ bImp = (Not x) Or y
   End Function
   
   'VB
   Sub Main()
      Console.WriteLine(Eqv(3 > 2, 2 > 1))
      Console.WriteLine(Eqv(3 > 3, 2 > 1))
      Console.WriteLine(Eqv(2 > 3, 1 > 2))
      Console.WriteLine
      Console.WriteLine(Imp(3 > 2, 2 > 1))
      Console.WriteLine(Imp(3 > 2, 1 > 2))
      Console.WriteLine(Imp(2 > 3, 1 > 2))
   End Sub
   Public Function Eqv(ByVal x As Boolean, ByVal y As Boolean) As Boolean
      Return Not (x Xor y) 'x = y
   End Function
   Public Function Imp(ByVal x As Boolean, ByVal y As Boolean) As Boolean
      Return (Not x) Or y
   End Function
   
   // C#  
   class MyClass {
      public static void Main(string[] args) {
         Console.WriteLine(Eqv(3 > 2, 2 > 1));
         Console.WriteLine(Eqv(2 > 3, 2 > 1));
         Console.WriteLine(Eqv(2 > 3, 1 > 2));
         Console.WriteLine();
         Console.WriteLine(Imp(3 > 2, 2 > 1));
         Console.WriteLine(Imp(3 > 2, 1 > 2));
         Console.WriteLine(Imp(2 > 3, 1 > 2));
      }
      public static bool Eqv(bool x, bool y) {
         return !(x ^ y); // x == y;
      }
      public static bool Imp(bool x, bool y) {
         return !(x) | y;
      }
   }
   

Seitenanfang

Ausdruck 3 -> Binär 00000011 
Ausdruck 9 -> Binär 00001001 
Ergebnis 1 -> Binär 00000001

Ausdruck 3  -> Binär 00000011 
Ausdruck 9  -> Binär 00001001 
Ergebnis 11 -> Binär 00001011

Ausdruck 3  -> Binär 00000011
Ausdruck 9  -> Binär 00001001
Ergebnis 10 -> Binär 00001010

Seitenanfang

'Um 3 Stellen nach links verschieben 
Ausdruck << 3
Ausdruck 9  -> Binär 00001001
Ergebnis 72 -> Binär 01001000

'Um 3 Stellen nach rechts verschieben 
Ausdruck >> 3
Ausdruck 72 -> Binär 01001000
Ergebnis 9  -> Binär 00001001

Seitenanfang

Seitenanfang

Seitenanfang

Seitenanfang