visual basic.net und visual basic 6 ralf westphal msdn regional director, freier fachautor &...
TRANSCRIPT
Visual Basic .NETund Visual Basic 6
Ralf WestphalMSDN Regional Director,
freier Fachautor & Berater
Von VB6 zu VB.NET
VB6VB6
Allgm. SprachenAllgm. Sprachen
.NET CLR.NET CLR
.NET Sprachen.NET Sprachen
VB.NETVB.NET
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
VB6 allgemein
Syntax Semantik GUI RAD Datenbankzugriff Typsystem
• OO-/Komponententechnologie
Standardbibliothek APIs
Von VB6 zu VB.NET
VB6VB6
Sprachen allgm.Sprachen allgm.
.NET CLR.NET CLR
.NET Sprachen.NET Sprachen
VB.NETVB.NET
Programmiersprachen allgemein
Was gehört zu einer Sprache?
• Syntax
• Semantik
• Programmierparadigma
Was gehört nicht zu einer Sprache?
• UI-Gestaltung
• Datenbankzugriff
• Typsystem
• Standardbibliothek
• APIs
Von VB6 zu VB.NET
VB6VB6
Allgm. SprachenAllgm. Sprachen
.NET CLR.NET CLR
.NET Sprachen.NET Sprachen
VB.NETVB.NET
COM Runtime(OLE32.DLL)
Microsoft Transaction
Server(MTXEX.DLL)
Layer(VBRUNxx.DLL)
(ATL.DLL)
Class-LoaderClass-LoaderRemotingRemoting
KontextKontextConcurrencyConcurrency
TransaktionenTransaktionen
Sprach-Sprach-IntegrationIntegration
COM+ Runtime(OLE32.DLL)
Layer(VBRUNxx.DLL)
(ATL.DLL)
Common Language Runtime
(MSCOREE.DLL)(MSCORLIB.DLL)
Warum eine Runtime?Einheitliches Integrationsmodell
.NET Framework
Base Class Library
Common Language Specification
Common Language Runtime
Data and XML
VB C++ C#V
isual S
tud
io.N
ET
WebServices
JScript …
UserInterface
Common Language Runtime
Class Loader
IL to NativeCompilers
CodeManager
GarbageCollector
Security Engine Debug Engine
Type Checker Exception Manager
Thread Support COM Marshaler
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
BasicsMicrosoft Intermediate Language
Hello, World!
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
Alternativ:Alternativ:
Module Module1Module Module1
Sub Main()Sub Main()
Console.WriteLine("Hello, World!")Console.WriteLine("Hello, World!")
End SubEnd Sub
End ModuleEnd Module
Hello, World: VB.NET IL.namespace Project3.HelloWorld.namespace Project3.HelloWorld{{ .class private auto ansi Class1.class private auto ansi Class1 extends [mscorlib]System.Objectextends [mscorlib]System.Object {{ .method public specialname rtspecialname .method public specialname rtspecialname instance void .ctor() il managedinstance void .ctor() il managed {{ .custom instance void [mscorlib]System.Diagnostics.DebuggerStepThroughAttribute::.ctor() = ( 01 00 00 00 ) .custom instance void [mscorlib]System.Diagnostics.DebuggerStepThroughAttribute::.ctor() = ( 01 00 00 00 ) .maxstack 8.maxstack 8 IL_0000: ldarg.0IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor()IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: retIL_0006: ret }} .method public static void Main() il managed.method public static void Main() il managed {{ .maxstack 1.maxstack 1 .locals init ([0] class System.Object[] _Vb_t_record_0).locals init ([0] class System.Object[] _Vb_t_record_0) IL_0000: nopIL_0000: nop IL_0001: ldstr "Hello, World!"IL_0001: ldstr "Hello, World!" IL_0006: call void [mscorlib]System.Console::WriteLine(class System.String)IL_0006: call void [mscorlib]System.Console::WriteLine(class System.String) IL_000b: nopIL_000b: nop IL_000c: retIL_000c: ret }} }}}}
.namespace Project3.namespace Project3{{ .class private auto ansi _vbProject.class private auto ansi _vbProject extends [mscorlib]System.Objectextends [mscorlib]System.Object {{ .custom instance void [Microsoft.VisualBasic]Microsoft.VisualBasic.Globals/Globals$StandardModuleAttribute::.ctor() = ( 01 00 00 00 ) .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.method public static void _main(class System.String[] _s) il managed {{ .entrypoint.entrypoint .maxstack 8.maxstack 8 IL_0000: call void Project3.HelloWorld.Class1::Main()IL_0000: call void Project3.HelloWorld.Class1::Main() IL_0005: retIL_0005: ret }} }}}}
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 } }}
Hello, World: VB.NET IL (Alternativ)
.namespace .namespace HelloWorldHelloWorld{{ .class private auto ansi Module1.class private auto ansi Module1 extends [mscorlib]System.Objectextends [mscorlib]System.Object {{ .custom instance void [Microsoft.VisualBasic]Microsoft.VisualBasic.Globals/Globals$StandardModuleAttribute::.ctor() = ( 01 00 00 00 ) .custom instance void [Microsoft.VisualBasic]Microsoft.VisualBasic.Globals/Globals$StandardModuleAttribute::.ctor() = ( 01 00 00 00 ) .method public static void Main() il managed.method public static void Main() il managed {{ .maxstack 1.maxstack 1 .locals init ([0] class System.Object[] _Vb_t_record_0).locals init ([0] class System.Object[] _Vb_t_record_0) IL_0000: nopIL_0000: nop IL_0001: ldstr "Hello, World!"IL_0001: ldstr "Hello, World!" IL_0006: call void [mscorlib]System.Console::WriteLine(class System.String)IL_0006: call void [mscorlib]System.Console::WriteLine(class System.String) IL_000b: nopIL_000b: nop IL_000c: retIL_000c: ret }} }}
.class private auto ansi _vbProject.class private auto ansi _vbProject extends [mscorlib]System.Objectextends [mscorlib]System.Object {{ .custom instance void [Microsoft.VisualBasic]Microsoft.VisualBasic.Globals/Globals$StandardModuleAttribute::.ctor() = ( 01 00 00 00 ) .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.method public static void _main(class System.String[] _s) il managed {{ .entrypoint.entrypoint .maxstack 8.maxstack 8 IL_0000: call void ConsoleApplication9.Module1::Main()IL_0000: call void ConsoleApplication9.Module1::Main() IL_0005: retIL_0005: ret }} }}}}
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
BasicsManaged Code
Von VB6 zu VB.NET
VB6VB6
Allgm. SprachenAllgm. Sprachen
.NET CLR.NET CLR
.NET Sprachen.NET Sprachen
VB.NETVB.NET
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
BasicsCommon Type System
Object Value Type
Enum
Type
String
Array
Exception
Boolean
Byte
Char
Currency
DateTime
Decimal
Double
Guid
Int16
Int32
Int64
SByte
Single
TimeSpan
TypedRef.
UInt16
UInt32
UInt64
Void
Delegate
Typen imNamespaceSystem
Common Type SystemDas Objektmodell
Zwei Arten von Typen
Value (struct) Reference (class)
Variable enthält Wert Referenz
Speicher Stack Heap
Initialisiert mit Alles 0 Konstante: nothing
Zuweisung kopiert Wert kopiert Referenz
Dim Dim i i as integer as integer = 123= 123Dim Dim s s as string _as string _
= = "Hello world""Hello world"
123123ii
ss "Hello world""Hello world"
123123jj
tt
Dim Dim j j as integer as integer = i= iDim Dim t t as string as string = s= s
Boxing und Unboxing
Jeder Datentyp kann als Objekt gespeichert Jeder Datentyp kann als Objekt gespeichert oder übergeben werdenoder übergeben werden
Dim Dim i i as integer as integer = 123= 123DimDim o o as object as object = i= iDim Dim j j as integer as integer = = Ctype(o, Integer)Ctype(o, Integer)
123123i
o
123123
System.Int32System.Int32 }} ““Boxing”Boxing”
123123j }} ““Unboxing”Unboxing”
.NET Framework
ASPVB Forms MFC & ATL
Windows API
Warum ein Framework?Einheitliches Programmiermodell
System
System.Data System.Xml
System.Web
Globalization
Diagnostics
Configuration
Collections
Resources
Reflection
Net
IO
Threading
Text
ServiceProcess
Security
Design
ADO
SQLTypes
SQL
XPath
XSLT
RuntimeInteropServices
Remoting
Serialization
Serialization
Configuration SessionState
Caching Security
ServicesDescription
Discovery
Protocols
UIHtmlControls
WebControls
System.Drawing
Imaging
Drawing2D
Text
Printing
System.WinForms
Design ComponentModel
Base Class Library
Gemeinsamer Nenner aller .NET Sprachen
Codeerzeugung
• Optimierung durch JITer
Common Type System
• Garbage Collection
• COM-Interop, P/Invoke
Sicherheitsinfrastruktur Attribute Ausnahmebehandlung Multithreading Standardbibliothek
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
BasicsImplikationen
Von VB6 zu VB.NET
VB6VB6
Allgm. SprachenAllgm. Sprachen
.NET CLR.NET CLR
.NET Sprachen.NET Sprachen
VB.NETVB.NET
Mit den .NET Sprachen hat das VB-Konzept „gewonnen“
• dot-Syntax
• Einfache Stringbehandlung
• uvm.
Mit VB.NET verliert VB seine Alleinstellungsmerkmale
VB.NETDie gute und die schlechte Nachricht
VB.NET
Was gehört zu VB.NET?
• Syntax
• Semantik
• Programmierparadigma
Was gehört zum .NET Framework?
• UI-Gestaltung
• Datenbankzugriff
• Typsystem
• Standardbibliothek
• APIs
Was ist neu durch VB.NET?
Tiefgreifende, „echte“ OO-Konzepte Namespaces Strukturierte Ausnahmebehandlung Multithreading uvm.
Public Class Mitarbeiter
End Interface
Public Function Gehalt() As Double ...End Function
Public Class Arbeiter
End Interface
Inherits Mitarbeiter
Public Property Zulage() As Double ...End Property
Implementation Inheritance
Implementation Inheritance
Nur Einfachvererbung Parametrierte Konstruktoren Instanz- und Klassen-Member (shared) Alle Methoden virtuell per default Abstrakte und finale Klassen/Member
Overloading
Implementation einer Methode
• mehrfach mit dem selben Namen,
• aber immer eindeutiger Signatur
Overloads Public Sub Display(ByVal theString As String)Overloads Public Sub Display(ByVal theDouble As Double)Overloads Public Sub Display(byVal theInteger As Integer)
Alternative zu optionalen Parametern.
Polymorphy
Public Class Mitarbeiter
End Interface
Overridable Public Function Gehalt() As DoubleGehalt = Stunden * Stundenlohn
End Function
Public Class Arbeiter
End Interface
Inherits Mitarbeiter
Overrides Function Gehalt() As Double Gehalt = Stunden * (Stundenlohn + Zulage) End Function
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
Interface InheritanceInterface erbt von Interface
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 InheritanceKlasse implementiert und erbt Interface
Public Class Arbeiter
End Class
Implements Mitarbeiter
Public Sub Einkommen() As Double Implements Mitarbeiter.Gehalt ....End Sub
Public Interface Mitarbeiter
End Interface
Public Sub Gehalt() As Double
Public Class Vorarbeiter
End Class
Inherits Arbeiter
Erbt auch das Interface und die Implementation von Mitarbeiter
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
Strukturen 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
Zusammenschluss vonZusammenschluss vonDaten und CodeDaten und Code WerttypWerttyp Keine VererbungKeine Vererbung LeichtgewichtigerLeichtgewichtiger
DatencontainerDatencontainer
Ausnahmebehandlung
Try auszuführende AnweisungenCatch e As COMException FehlerbehandlungCatch e As Exception ...Catch When Err.Number = 5 ...Catch ...Finally Abschließende Behandlung, auch ohne FehlerEnd Try
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
Delegates
Delegate Empfänger
Delegate
n:1
Empfänger
MulticastDelegate
MulticastDelegate
n:m
Empfänger
Delegate Empfänger1:1
EmpfängerMulticastDelegate
Empfänger
1:n
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 SubEnd Class
Sub Test Dim mc As New MyClass Dim msd As New MySubDelegate(AddressOf mc.MySub)
msd.Invoke(10) msd(10)End Sub
Delegates
Dim TB1 As TextBoxDim 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)
Delegates
Typisierte Funktionszeiger
• Sind selbst Typen und damit Objekte
Basis für Ereignisbehandlung
• „Reale“ Funktion muss gleiche Signatur haben
• WithEvents gibt es weiterhin
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 SubEnd Class
<Autor("Westphal", project:="Roadshow")>Structure Point...End Structure
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
Multithreading
Class FooSub Baz()
Console.WriteLine("Foo Baz is running on another thread")End Sub
End Class
Sub main()Dim oFoo As FoooFoo = New Foo()
Dim otter As ThreadStart otter = New ThreadStart(AddressOf oFoo.Baz)
Dim oThread As Thread oThread = New Thread(otter)
oThread.StartEnd Sub
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
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
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.
Von VB6 zu VB.NET
Conversion Wizard• Funktioniert in Beta 2 noch unzureichend
• Probleme vor allem mit UI-bezogenem Code
COM-Interop• VB6 COM-Komponenten aus .NET Programmen
nutzen
• .NET Komponenten in VB6-Programmen nutzen
Nur komponentenbasierte Anwendungen werden einigermaßen schmerzfrei migriert werden können.
Haben Sie sich auch so an VB6 gewöhnt?
Dann ist es jetzt Zeit, auf .NET umzusteigen!
Call to Action
.NET lernen• Nehmen Sie sich Zeit, jede Woche ein wenig dazu
zu lernen
Evaluieren Sie gleichermaßen C# und VB.NET Probieren Sie den Conversion Wizard aus Stellen Sie sicher, dass Ihre Anwendungen
komponentenbasiert sind
Fragen!?
Uff...Uff...
Mehr Informationen
http://www.microsoft.com/net http://msdn.microsoft.com/net http://www.microsoft.com/germany/msdn http://www.dotnetgerman.com/ http://www.dotnetjumpstart.net/ http://www.gotDotNet.com/ Dan Appleman: Moving to VB.NET:
Strategies, Concepts, and Code; APress 2001 Ralf Westphal: Bist du es, Visual Basic? Teil
1 bis 4; Artikelserie in BasicPro 6/00 ff
VB.NET Quellen 1/2 What's New in Visual Basic (TechEd Präsentation)
http://www.gotdotnet.com/events/teched/slides/dev300_cdias.ppt Visual Basic .NET: New Programming Model and Language
Enhancements Boost Development Powerhttp://msdn.microsoft.com/msdnmag/issues/01/02/vbnet/vbnet.asp
Visual Studio Enables the Programmable Webhttp://msdn.microsoft.com/vstudio/nextgen/technology/language.asp
Visual Basic .NET Upgrade Roadmaphttp://msdn.microsoft.com/vbasic/technical/upgrade/roadmap.asp
The Transition from Visual Basic 6.0 to Visual Basic .NEThttp://msdn.microsoft.com/vbasic/technical/upgrade/transition/default.asp
10 More Ways to Prepare for VB.NEThttp://www.devx.com/upload/free/features/vbpj/2001/03mar01/bh_0103/bh_0103.asp
Get Your Designs in Gear for VB.NEThttp://www.devx.com/upload/free/features/vbpj/2000/11nov00/pr0011/pr0011.asp
Drill Down on VB.NEThttp://www.devx.com/upload/free/features/vbpj/2001/01feb02/jf0102/jf0102.asp
VB.NET Quellen 2/2
An Introduction to Threading in VB.NETAn Introduction to Threading in VB.NEThttp://www.asptoday.com/content/articles/20010410.asp?WROXEMPTOKEN=934243ZaVjEiid0J0l7LCYvBGK
Object Oriented Features in VB.NETObject Oriented Features in VB.NEThttp://www.asptoday.com/content/articles/20010518.asp?WROXEMPTOKEN=934243ZaVjEiid0J0l7LCYvBGK
VB .NET DelegatesVB .NET Delegateshttp://www.asptoday.com/content/articles/20010619.asp?http://www.asptoday.com/content/articles/20010619.asp?WROXEMPTOKEN=934243ZaVjEiid0J0l7LCYvBGKWROXEMPTOKEN=934243ZaVjEiid0J0l7LCYvBGK
Polymorphism in VB.NETPolymorphism in VB.NEThttp://www.asptoday.com/content/articles/20010627.asp?http://www.asptoday.com/content/articles/20010627.asp?WROXEMPTOKEN=934243ZaVjEiid0J0l7LCYvBGKWROXEMPTOKEN=934243ZaVjEiid0J0l7LCYvBGK
Visual Basic .NET: Tracing, Logging, and Threading Made Easy with .NEVisual Basic .NET: Tracing, Logging, and Threading Made Easy with .NETThttp://msdn.microsoft.com/msdnmag/issues/01/07/vbnet/vbnet.asphttp://msdn.microsoft.com/msdnmag/issues/01/07/vbnet/vbnet.asp
New Features in Visual Basic .NET: Variables, Types, Arrays, and PropertiesNew Features in Visual Basic .NET: Variables, Types, Arrays, and Propertieshttp://msdn.microsoft.com/msdnmag/issues/01/05/Instincts/Instincts0105.asphttp://msdn.microsoft.com/msdnmag/issues/01/05/Instincts/Instincts0105.asp
Exploiting New Language Features in Visual Basic .NET, Part 2Exploiting New Language Features in Visual Basic .NET, Part 2http://msdn.microsoft.com/msdnmag/issues/01/08/Instincts/Instincts0108.asphttp://msdn.microsoft.com/msdnmag/issues/01/08/Instincts/Instincts0108.asp
Visual Basic .NET - 10 More RAD YearVisual Basic .NET - 10 More RAD Yearsshttp://msdn.microsoft.com/msdnnews/2001/may/RAD/RAD.asphttp://msdn.microsoft.com/msdnnews/2001/may/RAD/RAD.asp
Die Qual der Wahl der SpracheDie Qual der Wahl der Sprachehttp://www.microsoft.com/germany/ms/msdnbiblio/kolumne/300401RW.htmhttp://www.microsoft.com/germany/ms/msdnbiblio/kolumne/300401RW.htm
Empower peopleEmpower people
through great through great softwaresoftware
any time, any place,any time, any place,
and on any deviceand on any device