Sie sind hier: Startseite | Wissen

 

 

Zweck

Visual Basic 2005/2008

C# 2005/2008

Einsprungpunkt

Sub Main(ByVal args() As String)

static void Main(string[] args)

Namensraum

Namespace X
 
End Namespace

Namespace X {

}

Klasse

Class 

End Class

Class {

}

Öffentliche Klasse

Public Class

public class

Klasse nur innerhalb der Assembly sichtbar

Friend Class

internal class

Partielle Klasse

Partial Class

partial class

Variablendeklaration/
Attributdefinition als Field

Dim x as Typ

Typ x

Attributdefinition als Property

Property X() As String

   Get

    Return _X

   End Get

   Set(ByVal value As String)

    _X = value

   End Set

End Property

public string X

  {

   get { return x; }

   set { x = value; }

  }

oder kurz:

public Type Name { get; set; }

Array

Dim x as Byte()

byte[] x;

Array-Größenveränderung

ReDim Preserve

Array.Resize()

Methode mit Rückgabewert

Function f() as Typ


End Function

Typ f()

{

}

Methode ohne Rückgabewert

Sub f() as Typ


End Sub

void f()

{

}

Überladene Methode

Overloads

(keine Zusatzangabe)

Methode verlassen

Return

return

Methode verlassen und beim nächsten Aufruf danach fortsetzen

n/a

yield

Bezug auf Basisklasse

MyBase

base

Bezug auf aktuelle Klasse

MyClass

(Name der Klasse)

Bezug auf das aktuelle Objekt

Me

this

Implementierungsvererbung

Inherits

class C1 : C2

Deklaration einer Schnittstelle

Interface

interface

Schnittstellenvererbung

Implements

class C1 : I1

Konstantes Mitglied

Const

const

Methoden ohne Rückgabewert

Sub

void

Statisches Mitglied

Shared

static

Enumeration

Enum <members> End Enum

enum

Abstrakte Klasse

MustInherit

abstract

Finale Klasse

NotInheritable

sealed

Überschreiben einer Methode

Overrides

override

Abstrakte Methode

MustOverride

abstract

Versiegelte Methode

NotOverridable

sealed

Überschreibbare Methode

Overridable

virtual

Verdeckendes
Mitglied

Shadows

(keine Zusatzangabe)

Konstruktor

Sub New() … End Sub

public Klassenname()  { … }

Desktruktor/Finalizer

Sub Finalize() … End Sub

~Person() { … }

 

Referenz auf eine Methode

Delegate

delegate

Mitglied mit Ereignissen

WithEvents

n/a

Bindung einer Ereignisbehandlungsroutine

Handles
AddHandler
RemoveHandler

+=

-=

Blockbildung für Objekte

With obj … End With

n/a

Datumsliteral

#12/20/2008#

New DateTime(2008,12,20)

Zeilenumbruch

vbCrLf

"\n"

Wertlose Werttypen

Nullable(Of Typ)

Typ? Oder
Nullable<Typ>

Generische Klasse

Klasse(of Typ)

Klasse<Typ>

Typermittlung

obj.GetType()

typeof(obj)

obj.GetType()

Typkonvertierung

CType()
DirectCast
TryCast

(Typ) Variable
Variable as Type

Typvergleich

TypeOf k1 Is Kunde

k1 is Kunde

Anonyme Methoden

n/a

+= delegate(){ … }

Zeigerprogrammierung

n/a

unsafe, &x, *x

LINQ-Abfrageausdruck (nur 2008)

From m In Menge Where m.Feld < 1000 Select m;

from m in Menge where m.Feld < 1000 select m

Implizit typisierte Variable (nur 2008)

Dim x = Wert

var x = Wert

Lambda-Ausdruck

Dim f3 As Func(Of String, Integer) = Function(s) s.Length

Func<string, int> f3 = s => s.Length;

XML-Literale (nur 2008)

TODO

(nicht verfügbar)

 

 


Datentypen:

 

 

Visual Basic

C#

Ganzzahl
1 Byte

Byte

byte

Ganzzahl
Boolean

Boolean

bool

Ganzzahl
2 Bytes

Short

short

Ganzzahl
4 Bytes

Integer

int

Ganzzahl
8 Bytes

Long

long

Zahl
4 Bytes

Single

float

Zahl
8 Bytes

Double

double

Zahl
12 Bytes

Decimal

decimal

Zeichen
1 Byte oder 2 Bytes

Char

char

Zeichenkette

String

string

Datum/Uhrzeit

Date

DateTime

 

Operatoren:

 

 

Visual Basic

C#

Mathematik

Addition

+

+

Subtraktion

Multiplikation

*

*

Division

/

/

Ganzzahldivision

\

/

Modulus

Mod

%

Potenz

^

n/a

Negation

Not

~

Inkrement

n/a

++

Dekrement

n/a

--

Zuweisung

Einfache Zuweisung

=

=

Addition

+=

+=

Subtraktion

-=

-=

Multiplikation

*=

*=

Division

/=

/=

Ganzzahl-Division

\=

/=

Zeichenkettenverbindung

&=

+=

Modulus (Divisionsrest)

n/a

%=

Bit-Verschiebung nach links

<<=

<<=

Bit-Verschiebung nach rechts

>>=

>>=

Bit-weises UND

n/a

&=

Bit-weises XOR

n/a

^=

Bit-weises OR

n/a

|=

Vergleich

Kleiner

< 

< 

Kleiner gleich

<=

<=

Größer

> 

> 

Größer gleich

>=

>=

Gleich

=

==

Nicht gleich

<>

!=

Objektvergleich

Is

==

Objektvergleich (negativ)

IsNot

!=

Objekttypvergleich

TypeOf x Is Class1

x is Class1

Zeichenkettenvergleich

=

==

 

Zeichenkettenverbindung

&

+

Logische Operatoren

UND

And

&&

ODER

Or

||

NICHT

Not

!

Short-circuited UND

AndAlso

&&

Short-circuited ODER

OrElse

||

Bit-Operatoren

Bit-weises UND

And

&

Bit-weises XOR

Xor

^

Bit-weises OR

Or

|

BitVerschiebung nach links

<<

<< 

Bit-Verschiebung nach rechts

>>

>> 

Sonstiges

Bedingt

IIF- Funktion und If-Operator

?:

Bedingt (für Nullable Types)

n/a

?? :