Visual Basic .NET und Visual Basic 6

1. Visual Basic .NETund Visual Basic 6 Ralf WestphalMSDN Regional Director, freier Fachautor & Berater ralfw@ralfw.de

2. Allgm. Sprachen .NET CLR .NET Sprachen VB.NET Von VB6 zu VB.NET VB6

3. Was macht VB6 aus? • Einfache GUI-Gestaltung • Einfacher DB-Umgang • Einfacher Umgang mit Strings • Einfache APIs • Intrinsische Funktionen, Declare, COM • Einfache Erzeugung von Komponenten • ActiveX-DLLs, UserControls • Einfache Syntax • „dot-Syntax“, keine Zeiger, Kontrollstrukturen • Einfache Semantik • Klassen, Objekt-Destruktor, Eval. Logischer Ausdrücke

4. VB6 allgemein • Syntax • Semantik • GUI RAD • Datenbankzugriff • Typsystem • OO-/Komponententechnologie • Standardbibliothek • APIs

5. Sprachen allgm. .NET CLR .NET Sprachen VB.NET Von VB6 zu VB.NET VB6

6. Programmiersprachen allgemein • Was gehört zu einer Sprache? • Syntax • Semantik • Programmierparadigma • Was gehört nicht zu einer Sprache? • UI-Gestaltung • Datenbankzugriff • Typsystem • Standardbibliothek • APIs

7. Allgm. Sprachen .NET CLR .NET Sprachen VB.NET Von VB6 zu VB.NET VB6

8. Sprach- Integration Kontext Concurrency Transaktionen Class-Loader Remoting Warum eine Runtime?Einheitliches Integrationsmodell Layer (VBRUNxx.DLL) (ATL.DLL) Layer (VBRUNxx.DLL) (ATL.DLL) Common Language Runtime (MSCOREE.DLL) (MSCORLIB.DLL) Microsoft Transaction Server (MTXEX.DLL) COM+ Runtime (OLE32.DLL) COM Runtime (OLE32.DLL)

9. .NET Framework VB C++ C# JScript … Visual Studio.NET Common Language Specification Web Services User Interface Data and XML Base Class Library Common Language Runtime

10. Thread Support COM Marshaler Type Checker Exception Manager Security Engine Debug Engine IL to Native Compilers Code Manager Garbage Collector Common Language Runtime Class Loader

11. BasicsMicrosoft Intermediate Language • Compiler erzeugen keinen native Code sondern eine prozessorunabhängige Zwischensprache • Sprachintegration erfolgt auf IL-Codeebene • MSIL – Microsoft Intermediate Language • IL-Code wird vor der Ausführung immer (!) durch Compiler in echten Maschinencode übersetzt • Unabhängigkeit von Hardwareplattformen • Unter Windows CE bereits mit einemIL-Vorläufer im Einsatz

12. C# using System; namespace HelloWorld { public class Class1 { public static void Main() { Console.WriteLine("Hello, World!"); } } } VB.NET Imports System Namespace HelloWorld Class Class1 Shared Sub Main() Console.WriteLine("Hello, World!") End Sub End Class End Namespace Hello, World! Alternativ: Module Module1 Sub Main() Console.WriteLine("Hello, World!") End Sub End Module

13. Hello, World: VB.NET IL .namespace Project3.HelloWorld { .class private auto ansi Class1 extends [mscorlib]System.Object { .method public specialname rtspecialname instance void .ctor() il managed { .custom instance void [mscorlib]System.Diagnostics.DebuggerStepThroughAttribute::.ctor() = ( 01 00 00 00 ) .maxstack 8 IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: ret } .method public static void Main() il managed { .maxstack 1 .locals init ([0] class System.Object[] _Vb_t_record_0) IL_0000: nop IL_0001: ldstr "Hello, World!" IL_0006: call void [mscorlib]System.Console::WriteLine(class System.String) IL_000b: nop IL_000c: ret } } } .namespace Project3 { .class private auto ansi _vbProject extends [mscorlib]System.Object { .custom instance void [Microsoft.VisualBasic]Microsoft.VisualBasic.Globals/Globals$StandardModuleAttribute::.ctor() = ( 01 00 00 00 ) .method public static void _main(class System.String[] _s) il managed { .entrypoint .maxstack 8 IL_0000: call void Project3.HelloWorld.Class1::Main() IL_0005: ret } } }

14. Hello, World: C# IL .namespace HelloWorld { .class public auto ansi Class1 extends [mscorlib]System.Object { .method public hidebysig static void Main() il managed { .entrypoint .maxstack 8 IL_0000: ldstr "Hello, World!" IL_0005: call void [mscorlib]System.Console::WriteLine(class System.String) IL_000a: ret } .method public hidebysig specialname rtspecialname instance void .ctor() il managed { .maxstack 8 IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: ret } } }

15. Hello, World: VB.NET IL (Alternativ) .namespace HelloWorld { .class private auto ansi Module1 extends [mscorlib]System.Object { .custom instance void [Microsoft.VisualBasic]Microsoft.VisualBasic.Globals/Globals$StandardModuleAttribute::.ctor() = ( 01 00 00 00 ) .method public static void Main() il managed { .maxstack 1 .locals init ([0] class System.Object[] _Vb_t_record_0) IL_0000: nop IL_0001: ldstr "Hello, World!" IL_0006: call void [mscorlib]System.Console::WriteLine(class System.String) IL_000b: nop IL_000c: ret } } .class private auto ansi _vbProject extends [mscorlib]System.Object { .custom instance void [Microsoft.VisualBasic]Microsoft.VisualBasic.Globals/Globals$StandardModuleAttribute::.ctor() = ( 01 00 00 00 ) .method public static void _main(class System.String[] _s) il managed { .entrypoint .maxstack 8 IL_0000: call void ConsoleApplication9.Module1::Main() IL_0005: ret } } }

16. BasicsManaged Code • Sämtlicher Code wird unter Aufsicht der Common Language Runtime ausgeführt • Runtime führt Sicherheitsüberprüfungen aus • Runtime übernimmt Speicherverwaltung und Fehlerbehandlung (Garbage Collection) • Runtime führt Versionsprüfungen aus • Dieser Code wird als Managed Code bezeichnet

17. Allgm. Sprachen .NET CLR .NET Sprachen VB.NET Von VB6 zu VB.NET VB6

18. BasicsCommon Type System • Das Typsystem wandert vom Compiler in die Runtime • Typen werden eindeutig • „ein String unter C# und ein String unter VB.NET sind identisch“ • Sprachen werden interoperabel, da sie das gleiche Typsystem benutzen • CTS – Common Type System

19. Common Type SystemDas Objektmodell Object Value Type Boolean Int64 Byte Enum SByte Char Single Type Currency TimeSpan Typen im Namespace System DateTime String TypedRef. Decimal UInt16 Double Array UInt32 Guid UInt64 Exception Int16 Void Int32 Delegate

20. Dim i as integer = 123 Dim s as string _ = "Hello world" 123 i "Hello world" s Dim j as integer = i Dim t as string = s 123 j t Zwei Arten von Typen

21. 123 i } o System.Int32 “Boxing” 123 } “Unboxing” 123 j Boxing und Unboxing • Jeder Datentyp kann als Objekt gespeichert oder übergeben werden Dim i as integer = 123 Dim o as object = i Dim j as integer = Ctype(o, Integer)

22. .NET Framework Windows API ASP VB Forms MFC & ATL Warum ein Framework?Einheitliches Programmiermodell

23. Base Class Library System.Web System.WinForms Services UI Design ComponentModel Description HtmlControls Discovery WebControls Protocols System.Drawing Caching Security Drawing2D Printing Configuration SessionState Imaging Text System.Data System.Xml ADO SQL XSLT Serialization Design SQLTypes XPath System Collections IO Security Runtime InteropServices Configuration Net ServiceProcess Remoting Diagnostics Reflection Text Serialization Globalization Resources Threading

24. Gemeinsamer Nenner aller .NET Sprachen • Codeerzeugung • Optimierung durch JITer • Common Type System • Garbage Collection • COM-Interop, P/Invoke • Sicherheitsinfrastruktur • Attribute • Ausnahmebehandlung • Multithreading • Standardbibliothek

25. BasicsImplikationen • Sprachen werden gleichwertig, da alle Compiler MSIL-Code erzeugen • „eine C# Klasse kann von einer VB.NET Klasse abgeleitet sein“ • einheitliche Fehlerbehandlung • Compilerbau wird einfacher • kein eigenes Typsystem • Sprachen sind „per Definition“ interoperabel • keine Standardbibliothek • kein Codeoptimierungspass

26. Allgm. Sprachen .NET CLR .NET Sprachen VB.NET Von VB6 zu VB.NET VB6

27. VB.NET Die gute und die schlechte Nachricht •  Mit den .NET Sprachen hat das VB-Konzept „gewonnen“ • dot-Syntax • Einfache Stringbehandlung • uvm. •  Mit VB.NET verliert VB seine Alleinstellungsmerkmale

28. VB.NET • Was gehört zu VB.NET? • Syntax • Semantik • Programmierparadigma • Was gehört zum .NET Framework? • UI-Gestaltung • Datenbankzugriff • Typsystem • Standardbibliothek • APIs

29. Was ist neu durch VB.NET? • Tiefgreifende, „echte“ OO-Konzepte • Namespaces • Strukturierte Ausnahmebehandlung • Multithreading • uvm.

30. Public Class Arbeiter End Interface Inherits Mitarbeiter Public Property Zulage() As Double ... End Property Implementation Inheritance Public Class Mitarbeiter End Interface Public Function Gehalt() As Double ... End Function

31. Implementation Inheritance • Nur Einfachvererbung • Parametrierte Konstruktoren • Instanz- und Klassen-Member (shared) • Alle Methoden virtuell per default • Abstrakte und finale Klassen/Member

32. Overloading • Implementation einer Methode • mehrfach mit dem selben Namen, • aber immer eindeutiger Signatur Overloads Public Sub Display(ByVal theString AsString) Overloads Public Sub Display(ByVal theDouble AsDouble) Overloads Public Sub Display(byVal theInteger AsInteger) Alternative zu optionalen Parametern.

33. Public Class Mitarbeiter End Interface Overridable Public Function Gehalt() As Double Gehalt = Stunden * Stundenlohn End Function Public Class Arbeiter End Interface Inherits Mitarbeiter Overrides Function Gehalt() As Double Gehalt = Stunden * (Stundenlohn + Zulage) End Function Polymorphy

34. Polymorphy • Neudefinition der Implementation einer Basisklassenmethode in einer abgeleiteten Klasse • Muss in Basisklasse zugestanden werden (Overridable) • Signatur bleibt gleich • Verdeckt Basisklassenimplementation • Kann aber über MyBase aufgerufen werden

35. Public Interface Interface1 End Interface Public Sub M1() Public Property P1 As String Public Interface Interface2 End Interface Inherits Interface1 Public Sub M2() Public Property P2 As String Interface InheritanceInterface erbt von Interface

36. Public Interface Mitarbeiter End Interface Public Class Arbeiter End Class Public Sub Gehalt() As Double Implements Mitarbeiter Public Sub Einkommen() As Double Implements Mitarbeiter.Gehalt .... End Sub Interface InheritanceKlasse implementiert und erbt Interface Public Class Vorarbeiter End Class Inherits Arbeiter Erbt auch das Interface und die Implementation von Mitarbeiter

37. Interface Inheritance • „Echte“ Interfaces • Jede Klasse kann beliebig viele Interfaces implementieren • Vererbung von Interfaces • Ableitung neuer Interfaces • Abgeleitete Klassen erben auch Interfaces • Beliebige Zuordnung von Methoden der Klasse an Interface-Methoden

38. Strukturen • Zusammenschluss vonDaten und Code • Werttyp • Keine Vererbung • LeichtgewichtigerDatencontainer Structure Point Private _x, _y As Double Public Sub New(ByVal x As Double, ByVal y As Double) _x = x : _y = y End Sub Public Property x() As Double Get Return _x End Get Set(ByVal Value As Double) _x = Value End Set End Property Public Overrides Function ToString() As String Return "(" & _x & ", " & _y & ")" End Function End Structure

39. Ausnahmebehandlung Try auszuführende Anweisungen Catch e As COMException Fehlerbehandlung Catch e As Exception ... Catch When Err.Number = 5 ... Catch ... Finally Abschließende Behandlung, auch ohne Fehler End Try

40. Ausnahmebehandlung • Basiert auf Exception-Objekt/Klasse • Eigene Exception-Klassen möglich • Blockorientierte Fehlerbehandlung • Garantierte Nachbehandlung (finally) • Fehler während der Fehlerbehandlung (catch) müssen ebenfalls abgefangen werden • Nicht behandelte Fehler werden im Call-Stack hochgereicht

41. Delegates 1:1 Delegate Empfänger MulticastDelegate 1:n Empfänger Empfänger n:1 Delegate Empfänger Delegate MulticastDelegate n:m Empfänger MulticastDelegate Empfänger

42. Delegates Delegate Sub MySubDelegate(ByVal x As Integer) Class MyClass Sub MySub(ByVal x As Integer) MessageBox.Show("Der Wert von X ist:" & CStr(x)) End Sub End Class Sub Test Dim mc As New MyClass Dim msd As New MySubDelegate(AddressOf mc.MySub) msd.Invoke(10) msd(10) End Sub

43. Delegates Dim TB1 As TextBox Dim TB2 As TextBox Protected Sub MyHandler(ByVal Sender As Object, ByVal e As System.EventArgs) Dim TB As TextBox TB = CType(sender, TextBox) End Class AddHandler TB1.TextChanged, New System.EventHandler(AddressOf MyHandler) AddHandler TB2.TextChanged, New System.EventHandler(AddressOf MyHandler)

44. Delegates • Typisierte Funktionszeiger • Sind selbst Typen und damit Objekte • Basis für Ereignisbehandlung • „Reale“ Funktion muss gleiche Signatur haben • WithEvents gibt es weiterhin

45. Attribute <AttributeUsage(AttributeTargets.All)> Public Class AutorAttribute Inherits Attribute Public name As String Public project As String Public Sub New(ByVal name As String) Me.name = name End Sub End Class <Autor("Westphal", project:="Roadshow")> Structure Point ... End Structure

46. Attribute • Runtime/Design-Time Informationen für Typen und deren Elemente • Vollständig erweiterbar • Ein Attribut ist eine Klasse, die von System.Attribute abgeleitet wurde • Attribute werden erst instanziert, wenn darauf zugegriffen wird • Code ist „self contained“ • Keine neuen Schlüsselwörter oder pragma • Keine zusätzlichen Dateien, z.B.: .IDL, .DEF • Zugriff zur Laufzeit über Reflection API • Beispiele • Wird im Framework an vielen Stellen benutzt: XML, Web Services, Security, Serialization, Component Model, COM und P/Invoke Interop … • URL für Dokumentation einer Klasse • „Transaction context“ einer Methode • Wie wird in XML persistiert

47. Multithreading Class Foo Sub Baz() Console.WriteLine("Foo Baz is running on another thread") End Sub End Class Sub main() Dim oFoo As Foo oFoo = New Foo() Dim otter As ThreadStart otter = New ThreadStart(AddressOf oFoo.Baz) Dim oThread As Thread oThread = New Thread(otter) oThread.Start End Sub

48. Multithreading • Thread-Funktionen • Instanz- oder Klassen-Methode • Werden per ThreadStart-Delegate übergeben • Keine Parameter • Kein Funktionsresultat • Cross-Thread-Aufrufe sind transparent • Thread-Kontrolle über Instanz oder Klasse • z.B. myThread.Stop

49. Was ändert sich mit VB.NET? 1/2 • Syntax • Andere Property-Syntax • Structure statt Type • Volle Qualifizierung von Enum-Konstanten • Typzuweisung mit mehreren Vars bei Dim • Klammern bei Sub/Function-Aufrufen • Semantik • Gültigkeitsbereich von Blockvariablen • Indeterministische Finalisation • Keine statischen Sub/Function mehr • ByVal ist default • Gleichstellung von Member-Variablen und Property-Methoden • Default-Methoden müssen Eigenschaften mit einem Param. sein • Variant entfällt

50. Was ändert sich mit VB.NET? 2/2 • Anweisungen/Funktionen • Kein Gosub, On/Gosub, On/Goto mehr • Open/Close etc. jetzt Funktionen • Kein IsMissing mehr • Umgebung • Keine Tag-Eigenschaft mehr bei Steuerelementen • Keine Steuerelementfelder mehr • Keine fensterlosen Steuerelemente mehr • uvm.