Kettermann / Rohde Spiele effektiv programmieren mit VB.net und DirectX

2005
ISBN: 978-3-540-27111-6
Verlag: Springer Berlin Heidelberg
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Deutsch, 545 Seiten

Reihe: Xpert.press

Bevor Sie in die aufregende Welt der Programmierung einsteigen, müssen Sie sich für eine Programmiersprache entscheiden. In der klassischen Sichtweise werden Programmiersprachen in Compiler- und Interpret- sprachen unterschieden. Mit den neuen .NET-Sprachen ändert sich das. Hier wird ein vorkompilierter Sourcecode erstellt, welche dann per Mic- soft Framework interpretiert und final kompiliert wird. Die wesentliche Vorteile dieser Handhabung liegen auf der Hand. Eine außergewöhnlich hohe Performance sowie eine plattformunabhängige Kompatibilität sind die Merkmale dieses Konzepts. VB.NET ist der Nachfolger von Visual Basic 6. Visual Basic ist vor allem durch die leichte Syntax sowie einer benutzerfreundlichen Entwicklun- umgebung bekannt geworden. Die Einfachheit dieser Sprache forderte aber einen hohen Preis. Visual Basic-Programme waren langsam und in Ihrer Funktionalität eingeschränkt. Dies änderte sich bereits mit der Version 5 und wurde in der Version 6 nochmals verbessert. Die perfekte Symbiose zwischen Leichtigkeit und Leistungsfähigkeit wird aber mit VB.NET - zielt. Neben den Vorzügen, welche VB.NET für die Entwicklung von Office- plikationen bietet, fordern wir aber mehr. Wir wollen DirectX beherrschen. Wir müssen uns die Frage stellen: Ist VB.NET zur Programmierung mit DirectX geeignet? Die Antwort lautet: JA! VB.NET bietet zum einen die notwendige Performance und zum anderen eine ideale Integration von Managed DirectX. Managed DirectX ist speziell auf die neuen Progr- miersprachen C# und VB.NET zugeschnitten. Diese Programmiersprachen sind feste Bestandteile der Microsoft Visual Studio.NET-Philosophie und werden kontinuierlich gefördert und weiterentwickelt.

Zum beruflichen Werdegang von Herrn Uwe Kettermann:1989 - 1997 Programmierer bei Berlet 1997 - 2000 Selbstständiger Programmierer bei SK-Software (Schnittstellen-Programmierung MX-512, Visualisierungssoftware, Lichtsteuerung für Discotheken und mobile Bands) Seit dem Jahr 2000 Software-Engineer bei der Firma Actebis / Peacock Zum beruflichen Werdegang von Herrn Andreas Rohde:Ausbildung zum Informationstechnischen Assistent 1995 - 2002 Leiter der Abteilung Software-Engineering bei Actebis / Peacock Seit dem Jahr 2002 Software-Engineer bei MAXDATA

Autoren/Hrsg.

Kettermann, Uwe

Rohde, Andreas

Inhaltsverzeichnis

1;Danksagung;6
2;Vorwort;7
3;Inhaltsverzeichnis;9
4;1 Die Buchstruktur;20
5;2 Was ist VB.NET?;22
5.1;2.1 Unterschiede zu Visual Basic 6;22
5.1.1;2.1.1 Rapid Application Development;23
5.1.2;2.1.2 Vererbung;23
5.1.3;2.1.3 Ausnahmebehandlung;23
5.1.4;2.1.4 Überladung;23
5.1.5;2.1.5 Overrides: Überschreiben von Methoden und Eigenschaften;24
5.1.6;2.1.6 Konstruktoren und Destruktoren;25
5.1.7;2.1.7 Datentypen;25
5.1.8;2.1.8 Verweise;26
5.1.9;2.1.9 Namespaces;26
5.1.10;2.1.10 Assemblies;26
5.1.11;2.1.11 Multithreading;26
5.1.12;2.1.12 Common Language Runtime (CLR);26
5.1.13;2.1.13 Garbage Collection;27
6;3 Die Entwicklungsumgebungen von VB.NET;30
6.1;3.1 Das Visual Studio .NET;32
6.1.1;3.1.1 Formdesigner;34
6.1.2;3.1.2 Werkzeugfenster;35
6.1.3;3.1.3 Eigenschaftenfenster;35
6.1.4;3.1.4 Projektexplorer;36
6.1.5;3.1.5 Pin-Nadel-Symbol;36
6.2;3.2 SharpDevelop;37
6.2.1;3.2.1 Code-Competion-Datenbank;37
6.2.2;3.2.2 Der erste Start;39
7;4 „Hello World“ das erste .NET-Programm;42
7.1;4.1 Ein einfaches Programm mit einem einfachen Editor;42
7.1.1;4.1.1 Der Sourcecode;42
7.1.2;4.1.2 Der Compiler;43
7.2;4.2 Ein Projekt im Visual Studio.NET;44
8;5 Variablen;48
8.1;5.1 Deklaration;49
8.2;5.2 Datentypen und Konstanten;49
8.2.1;5.2.1 Der richtige Datentyp;51
8.2.2;5.2.2 Konstanten;53
8.2.3;5.2.3 Strukturen;56
8.3;5.3 Typensicherheit;57
8.4;5.4 Ermitteln des Variablentyps;60
9;6 Operatoren;62
9.1;6.1 Arithmetische Operatoren;62
9.2;6.2 Vergleichsoperatoren;64
9.2.1;6.2.1 Mit dem Gleich-Operator Werte zuweisen!;64
10;7 Verzweigungen;66
10.1;7.1 Verzweigungen oder Entscheidungen?;66
10.2;7.2 If-Then-Else-Anweisung;66
10.2.1;7.2.1 Notationsunterschiede!;69
10.2.2;7.2.2 Verschachtelungen oder ElseIf:ElseIf;69
10.3;7.3 Select-Case-Anweisungen;72
11;8 Schleifen;76
11.1;8.1 For-Next-Schleife;77
11.2;8.2 Do-Loop-Schleife;78
11.2.1;8.2.1 Endlosschleifen;81
11.3;8.3 While-End-While-Schleife;81
11.4;8.4 For-Each-Schleife;82
12;9 Arrays;86
12.1;9.1 Statische Arrays;86
12.2;9.2 Dynamische Arrays;87
12.2.1;9.2.1 GetUpperBound;88
12.3;9.3 Mehrdimensionale Arrays;89
13;10 Funktionen und Subroutinen;92
13.1;10.1 Subroutinen;92
13.1.1;10.1.1 ByVal oder ByRef;94
13.2;10.2 Funktionen;94
13.2.1;10.2.1 Return;95
13.2.2;10.2.2 Optionale Parameter;96
13.3;10.3 Rekursives Programmieren;97
14;11 Klassen;100
14.1;11.1 Was ist eine Klasse?;100
14.2;11.2 Nothing;101
14.3;11.3 Felder;102
14.4;11.4 Subroutinen und Funktionen;103
14.5;11.5 Eigenschaften: Property;105
14.5.1;11.5.1 Parameter in Properties;106
14.5.2;11.5.2 Eingeschränkte Properties;107
14.6;11.6 Enumerationen in Klassen;108
14.7;11.7 Events;109
14.8;11.8 Ein umfassendes Beispiel;111
14.8.1;11.8.1 Erstellen der Klasse;112
14.8.2;11.8.2 Klasse mit Daten füllen;114
14.8.3;11.8.3 Daten aus der Klasse lesen;114
14.9;11.9 Shared-Mitglieder;115
14.10;11.10 Vererbung;116
14.10.1;11.10.1 Overrides;118
14.10.2;11.10.2 MyBase;120
14.10.3;11.10.3 MustOverride und MustInherit;121
15;12 Namespaces;122
15.1;12.1 Namespaces ansprechen;123
15.1.1;12.1.1 Imports;123
16;13 Assemblies;126
16.1;13.1 Arbeitsweise von Assemblies;127
16.2;13.2 Shared Assembly;127
17;14 Fehlerbehandlung;128
17.1;14.1 Try-Catch-Finally-Anweisung;128
17.1.1;14.1.1 Ausnahmebehandlung (Beispiel);129
17.2;14.2 OnError-GoTo-Befehl;130
18;15 Was ist DirectX;132
18.1;15.1 Die Säulen von DirectX;132
18.2;15.2 Die Einsatzgebiete für DirectX;134
19;16 DirectX-Grundlagen;136
19.1;16.1 Das Koordinatensystem;136
19.2;16.2 Primitives;138
19.2.1;16.2.1 Primitives rendern;140
19.2.2;16.2.2 Vorder- und Rückseite;144
20;17 Mein erstes DirectX-Programm;146
20.1;17.1 Ein Visual Studio .NET-Projekt erstellen;146
20.2;17.2 Direct3D-Device erzeugen;148
20.3;17.3 Rendern;150
21;18 Mein erstes Objekt im 3D-Raum;154
21.1;18.1 Vertexbuffer erstellen;155
21.2;18.2 Vertexbuffer mit Objektdaten füllen;156
21.3;18.3 Vertexbuffer rendern;158
22;19 World-, View- und Projektionsmatrix;160
22.1;19.1 Worldmatrix;160
22.2;19.2 Viewmatrix;161
22.3;19.3 Projektionsmatrix;162
23;20 Device Enumeration;164
23.1;20.1 DXSettings;164
23.1.1;20.1.1 Display-Adapter;167
23.1.2;20.1.2 Hardwarebeschleunigung (DeviceTyp);168
23.1.3;20.1.3 Videomodus;169
23.1.4;20.1.4 Backbuffer-Format;171
23.1.5;20.1.5 Z-Stencilbuffer-Format (Depth-Stencilbuffer-Format);173
23.1.6;20.1.6 Multisample-Typ;174
23.1.7;20.1.7 Vertex-Processing;176
23.2;20.2 DXSettings im praktischen Einsatz;178
23.2.1;20.2.1 Preset-Struktur;179
23.2.2;20.2.2 DXSettings initialisieren;181
24;21 Matrizen;184
24.1;21.1 Was ist eine Matrix;184
24.1.1;21.1.1 Einheitsmatrix;185
24.1.2;21.1.2 Addition;185
24.1.3;21.1.3 Subtraktion;185
24.1.4;21.1.4 Multiplikation;186
24.1.5;21.1.5 Division;186
24.1.6;21.1.6 Berechnen der invertierten Matrix M-;187
24.2;21.2 Transformation;188
24.2.1;21.2.1 Bewegt sich die Welt oder bewegt sich das Objekt?;189
24.2.2;21.2.2 Translation (Bewegung, Positionsveränderung);189
24.2.3;21.2.3 Skalieren (Größenänderung);190
24.2.4;21.2.4 Rotation (Drehung);191
24.2.5;21.2.5 Grad vs Radiant;193
24.2.6;21.2.6 Beispielprogramm für Matrizen;194
25;22 Texturen;200
25.1;22.1 Texturkoordinaten;200
25.2;22.2 Kacheln einer Textur;202
25.3;22.3 Das passende Vertexformat;203
25.4;22.4 Größe einer Textur;204
25.4.1;22.4.1 Auslesen der maximalen Texturbreite und Höhe;205
25.5;22.5 Laden einer Textur;205
25.6;22.6 Texturfilter;207
25.6.1;22.6.1 MinFilter und MagFilter;207
25.6.2;22.6.2 Nearest Point Sampling;207
25.6.3;22.6.3 Linearer Texturfilter;208
25.6.4;22.6.4 Anisotropic Filter (uneinheitlicher Filter);208
25.6.5;22.6.5 Bilineare und uneinheitliche Filterung;209
25.6.6;22.6.6 Mipmaps;209
25.7;22.7 Beispielprogramm für Texturen;210
25.7.1;22.7.1 Ermitteln der maximalen Texturbreite und -höhe;211
25.7.2;22.7.2 Erstellen des Vertexbuffers;212
25.7.3;22.7.3 Erstellen und Laden einer Textur;214
25.7.4;22.7.4 Rendern;215
25.8;22.8 Multitexturing (Multi Texture Mapping);216
25.8.1;22.8.1 Mischparameter;217
25.8.2;22.8.2 Multi-Pass-Technik vs. Single-Pass-Technik;220
25.8.3;22.8.3 Texturkoordinaten, Vertexformat und Vertexbuffer;221
25.8.4;22.8.4 Beispielprogramm für Multitexturing;223
25.9;22.9 Alpha-Textur-Blending;230
25.9.1;22.9.1 Texturfaktor;230
26;23 Licht: Beleuchtung;232
26.1;23.1 Licht und Material;233
26.2;23.2 Direct3D.Lights;233
26.3;23.3 Normalvektor;234
26.3.1;23.3.1 Berechnung des Normalvektors;236
26.4;23.4 Lichttypen;237
26.4.1;23.4.1 Ambient-Light;238
26.4.2;23.4.2 Point-Light;239
26.4.3;23.4.3 Directional-Light;240
26.4.4;23.4.4 Spot-Light;241
26.4.5;23.4.5 Welcher Lichttyp ist der beste?;243
26.5;23.5 Licht, Schatten und Polygone;244
26.5.1;23.5.1 Flat-Shading;244
26.5.2;23.5.2 Gouraud-Shading;245
26.5.3;23.5.3 Phong-Shading;246
26.6;23.6 Licht und Polygone;246
26.7;23.7 Beispielprogramm für Licht und Polygone;247
26.7.1;23.7.1 Erstellen der Flächen;248
26.7.2;23.7.2 Erstellen der Lichter;251
26.8;23.8 Beispielprogramm für Lichttypen;253
26.8.1;23.8.1 Boden und Wände erstellen;255
26.8.2;23.8.2 Lichtquellen initialisieren;258
26.9;23.9 Licht und Mesh;261
26.9.1;23.9.1 Beispielprogramm für Licht und Mesh;262
27;24 Material;264
27.1;24.1 Zusammenspiel zwischen Material und Licht;264
27.1.1;24.1.1 Die Bestandteile des Materials;265
27.1.2;24.1.2 Diffuse;265
27.1.3;24.1.3 Ambient;266
27.1.4;24.1.4 Specular;266
27.1.5;24.1.5 Emissive;266
27.2;24.2 Material initialisieren und aktivieren;266
27.3;24.3 Beispielprogramm für Material;267
28;25 Meshobjekte;270
28.1;25.1 Erstellen eines Mesh–Objektes;271
28.2;25.2 Laden eines Mesh-Objektes;272
28.3;25.3 Darstellen eines Mesh-Objektes;274
29;26 Animation des Mesh-Objektes Frame- Animation;278
29.1;26.1 Prinzip der Frame-Animation;279
29.2;26.2 Timing bei der Frame-Animation;279
29.3;26.3 Mesh-Objekte: Tweening/Keyframe-Animation;282
29.4;26.4 Keyframe-Bestimmung;292
29.5;26.5 Keyframe-Interpolation;293
29.6;26.6 Keyframe rendern;297
30;27 Billboarding;300
30.1;27.1 Was sind Billboards?;300
30.2;27.2 Warum werden Billboards eingesetzt?;301
30.2.1;27.2.1 Schlechtes Billboarding;301
30.2.2;27.2.2 Gutes Billboarding;301
30.3;27.3 Berechnungsmethoden;302
30.4;27.4 Beispielprogramm für Billboarding;303
30.4.1;27.4.1 Textureoberfläche erstellen;304
30.4.2;27.4.2 Hauptspieleschleife erzeugen;305
30.4.3;27.4.3 Rendern;306
31;28 Wasser;310
31.1;28.1 Technik zum Erstellen der Wasseroberfläche;311
31.2;28.2 Aufbau der Wasseroberfläche (Gittergerüst);313
31.3;28.3 Wasseroberfläche erstellen (inkl. Wellen und Textur);314
31.4;28.4 Schwimmende Kisten integrieren;316
31.5;28.5 Rendern Alpha-Blending;317
32;29 Nebel;320
32.1;29.1 Was kann Nebel?;321
32.2;29.2 Berechnungsarten;321
32.2.1;29.2.1 Linear Fog;321
32.2.2;29.2.2 Exponential Fog;322
32.3;29.3 VertexFog oder Pixel-Fog/Table-Fog;323
32.3.1;29.3.1 Prüfung;324
32.4;29.4 Die wahre Tiefe;325
32.5;29.5 Renderstates;326
32.6;29.6 Beispielprogramm für Nebel;327
32.6.1;29.6.1 Erstellen der Straße;328
32.6.2;29.6.2 Einbinden der Meshes (Bäume und Auto);329
32.6.3;29.6.3 Initialisierung des Nebels;330
32.6.4;29.6.4 Rendern;331
33;30 Partikeleffekte;334
33.1;30.1 Partikelstruktur;336
33.2;30.2 Zweidimensional vs. dreidimensional;337
33.3;30.3 Partikelklasse;339
33.4;30.4 Rendern;342
33.5;30.5 GUI;346
34;31 DirectSound: Modell;348
34.1;31.1 DirectSound-DeviceInformation;349
34.2;31.2 DirectSound-Device;349
34.3;31.3 DirectSound-Buffer;350
34.4;31.4 DirectSound-3DBuffer;351
34.4.1;31.4.1 Ausrichtung des 3DBuffers;352
34.5;31.5 DirectSound-3DListener;353
34.5.1;31.5.1 Ausrichtung des 3DListeners;353
34.6;31.6 DirectSound-CaptureBuffer;353
35;32 2DSound-Demo;356
36;33 3DSound-Demo;364
37;34 AudioVideoPlayback;372
37.1;34.1 Ein Wort zu DirectMusic;372
37.2;34.2 AudioVideoPlayback generell;372
37.3;34.3 Audio;373
37.4;34.4 Video;377
38;35 DirectInput;380
38.1;35.1 Objekthierarchie;380
38.2;35.2 Geräteauflistung;381
38.2.1;35.2.1 Beispielprogramm;382
38.2.2;35.2.2 Eingabegeräte ermitteln;382
38.2.3;35.2.3 Objekte ermitteln;384
38.3;35.3 Kooperationsebene;386
38.4;35.4 Datenformat;387
38.5;35.5 Daten empfangen;387
38.6;35.6 Keyboard (Beispielprogramm);388
38.6.1;35.6.1 Sourcecode-Beispiel 1;388
38.6.2;35.6.2 Sourcecode-Beispiel 2;389
38.7;35.7 Maus;393
38.7.1;35.7.1 Kooperationsebene anlegen und das Device erzeugen;394
38.7.2;35.7.2 Daten abfragen;395
38.8;35.8 Joystick;396
38.8.1;35.8.1 Angeschlossene Joysticks ermitteln;398
38.8.2;35.8.2 Akquirieren und Achseneigenschaften festlegen;399
38.8.3;35.8.3 Daten abfragen;399
38.9;35.9 First-Person-Camera;402
38.9.1;35.9.1 Variablen und Strukturen definieren;403
38.9.2;35.9.2 Erzeugen der DirectInput-Devices;404
38.9.3;35.9.3 Maus- und Tastaturdaten empfangen;405
38.9.4;35.9.4 Maus- und Tastaturdaten auswerten;406
39;36 DirectPlay;410
39.1;36.1 Service-Provider;411
39.2;36.2 Wie ist eine Peer-to-Peer Verbindung aufgebaut?;412
39.3;36.3 Erstellen einer GUID;413
39.4;36.4 Host;414
39.5;36.5 Player;414
39.5.1;36.5.1 Host suchen;415
39.5.2;36.5.2 Player erstellen und an der Session anmelden;417
39.6;36.6 Senden von Daten;417
39.7;36.7 Empfangen von Daten;418
39.8;36.8 Beispielprogramm: Simple Chat;419
39.9;36.9 Kommunikationsmodelle;421
39.9.1;36.9.1 Peer-to-Peer-Session;421
39.9.2;36.9.2 Client/Server-Session;421
39.9.3;36.9.3 Sicherheit;421
40;37 Das Spiel: Return From Orion;424
40.1;37.1 Erste Gedanken zum Spiel;425
40.2;37.2 Von der ersten Spielidee zu einem Konzept;425
40.3;37.3 Der Entwicklungsprozess oder die Arbeit vor der Arbeit;427
40.4;37.4 Festlegung des Spielprinzips/Spielablaufs;427
40.5;37.5 Die Storyline – eine Geschichte entsteht;428
40.6;37.6 Festlegen des Designs mit Designstudien;429
40.7;37.7 Das Konzept des Spiels;430
41;38 Das Projekt startet;432
41.1;38.1 Erstellen der ersten Objekte;432
41.2;38.2 Erstellen des Basis-Devices für das Projekt;434
42;39 Eine Welt erschaffen;438
42.1;39.1 Die Theorie des Spielfeldes;438
42.2;39.2 Das Spielfeld in der Praxis;439
42.2.1;39.2.1 Spielfelddaten auslesen;440
42.2.2;39.2.2 Performance-Steigerung im Spielfeld;443
42.2.3;39.2.3 Das Spielfeld erstellen;445
42.2.4;39.2.4 Die Bitmaske;446
42.2.5;39.2.5 Das Spielfeld rendern;447
42.3;39.3 Skydome: Die Begrenzung der Spielwelt;451
43;40 Die Spielfigur;454
43.1;40.1 Die Techniken der Spielfigur;455
43.1.1;40.1.1 Bewegungsablauf – Animation der Spielfigur;455
43.1.2;40.1.2 Bewegung der Spielfigur;459
43.1.3;40.1.3 Relative Bewegungen im Spiel;460
43.1.4;40.1.4 Logik der Bewegung;462
43.1.5;40.1.5 Drehung der Spielfigur;465
43.1.6;40.1.6 Laufen der Spielfigur;467
43.2;40.2 Einfügen der Tastaturabfrage;470
43.3;40.3 Einfügen des Kameramoduls;476
44;41 Gegner: Computergesteuerte Elemente;480
44.1;41.1 Arten von Gegnern;480
44.1.1;41.1.1 Festgelegte Bewegungen und Aktionen;480
44.1.2;41.1.2 Intelligente Bewegungen und Aktionen;481
44.1.3;41.1.3 Intelligente Bewegungen, Aktionen und Kommunikation;482
44.2;41.2 Einfügen der Gegner in „Return From Orion“;483
45;42 Künstliche Intelligenz;490
45.1;42.1 Was ist künstliche Intelligenz?;490
45.1.1;42.1.1 Menschlich handeln;491
45.1.2;42.1.2 Menschlich denken;491
45.1.3;42.1.3 Rational denken;492
45.1.4;42.1.4 Rational handeln;492
45.2;42.2 KI in Computerspielen;492
45.3;42.3 KI in „Return From Orion“;493
45.3.1;42.3.1 Random-Strategie;495
45.3.2;42.3.2 Vertikale Strategie;497
45.3.3;42.3.3 Horizontale Strategie;501
45.3.4;42.3.4 Änderung der KI-Strategie;504
46;43 Kollision;506
46.1;43.1 Kollision in DirectX;506
46.1.1;43.1.1 BoundingBox;506
46.1.2;43.1.2 BoundingSphere;507
46.1.3;43.1.3 Feintuning;508
46.2;43.2 Kollision im Spiel;509
47;44 Soundeffekte;512
48;45 Abschließende Funktionen;516
48.1;45.1 Statusanzeigen erstellen und integrieren;516
48.2;45.2 Splash-Screens;521
48.3;45.3 Kamerafahrt am Anfang jedes Levels;523
48.4;45.4 Framerate begrenzen;525
49;46 Leveleditor;528
49.1;46.1 Zeichnen des Spielfeldes;529
49.2;46.2 Editieren der Spielfelddaten;532
49.3;46.3 Steuerelemente des Leveleditors;537
49.4;46.4 Das Programm-Menü;543
49.4.1;46.4.1 Level neu erstellen;543
49.4.2;46.4.2 Level laden;545
49.4.3;46.4.3 Level speichern;546
49.4.4;46.4.4 Direkt Zugriff auf ein Level;546
49.4.5;46.4.5 Spielfeld umranden;548
49.4.6;46.4.6 Dynamische Objekte einfügen: Random;549
49.5;46.5 Hilfsfunktionen;550
50;47 Fragen und Antworten zu VB.NET;554
51;48 Fragen und Antworten zu DirectX;560
51.1;48.1 Fragen und Antworten zu Texturen;561
52;Glossar;564
53;Anhang;568
53.1;Datentypen;568
54;Index;570

Leseproben

2 Was ist VB.NET? (S. 3-4)

VB.NET ist eine Programmiersprache basierend auf dem Microsoft .NETFramework. Das Framework verbindet verschiedene Programmiersprachen. Programme werden zwar in den jeweiligen Programmierspachen geschrieben, diese werden aber in ein und dieselbe Common Language Runtime kompiliert. Dies ist geradezu ein revolutionäres Konzept, denn bis dato waren wir (die Progrmmierer) unterschiedliche Kompiler mit unterschiedlichen Ergebnissen gewohnt. So konstantierten sich Stärken und Schwächen der einzelnen Programmiersprachen und daraus resultierent schrieb man einer Programmiersprache einem bestimmten Aufgabenbereich zu. Der Aufgabenbereich von Viausl Basic (der Vorgängerversion von VB.NET) war die Datenbankprogrammierung im Officeumfeld. Hier lagen die Stärken dieser Programmierspachen. Mit den neuen Spachen von .NET sind die Grenzen gefallen.

Ein Kompiler für alle Sprachen offenbart die Leistungsfähigkeit aller angeschlossenen Programmierspachen. Nun ist es egal ob der Sourccode in C# oder VB.NET erstellt wird. Das Ergebnis ist ein zum Framework kompatibeles Programm mit identischen Leistungsmerkmalen. Für uns bedeutet dies: wir können mit einer relativ leicht verständlichen Syntax sowie einer übersichtlichen Programmierumgebung arbeiten und leistungsstarke Programme erstellen, welche einem Vergleich zu C# nicht scheuen müssen.


2.1 Unterschiede zu Visual Basic 6

Diese Erläuterungen werden nur für Leser mit VisualBasic6-Erfahrung von Interesse sein. Für Einsteiger werden die aufgelisteten Neuerungen noch keine Aussagekraft haben. Natürlich wird sich das mit wachsender Erfahrung ändern und dann werden Sie sicherlich einige der Neuerungen von VB.NET als selbstverständlich ansehen.

VB.NET ist der Nachfolger von Visual Basic 6. VB.NET ist aber auch Bestandteil von Visual Studio.N ET. Hier haben wir bereits einen Unterschied zu VB 6: Visual Basic 6 war nicht in das Visual Studio-Paket integriert. Zwar wurde VB gemeinsam mit dem Visual Studio-Paket ausgeliefert, aber sie verwendeten unterschiedliche IDEs. Integrated Development Environment (IDE) beschreibt die integrierte Entwicklungsumgebung von Visual Studio.NET.

Mit Visual Studio.NET wird ein C++-, C#- oder VB.NET- Programmierer mit der gleichen Entwicklungsumgebung arbeiten. Dies ist ein bedeutender Vorteil. So rücken Programmierer der unterschiedlichen Programmiersprachen enger zusammen und die Wahl, in welcher Programmiersprache das nächste Projekt verwirklicht wird, ist leichter zu treffen. 2.1.1 Rapid Application Development VB.NET unterstützt die schnelle Anwendungsentwicklung (RAD, Rapid Application Development) mit Projektvorlagen, Designern und anderen Features in der Visual Studio.NET-Entwicklungsumgebung.


2.1.2 Vererbung

Ein weiterer Fortschritt ist die Vererbung. Vererbung ist das Ableiten einer Klasse von einer anderen. Abgeleitete Klassen erben die Eigenschaften, Methoden und Ereignisse der Basisklasse und können diese erweitern. Abgeleitete Klassen können auch vererbte Methoden mit neuen Implementierungen überschreiben.

2.1.3 Ausnahmebehandlung

Außerdem wurde eine verbesserte Fehlerhandhabung (Ausnahmebehandlung) implementiert. Visual Basic verwendet eine erweiterte Version der Try-Catch-Finally-Syntax, die bereits von anderen Sprachen (z.B. von C++) unterstützt wurde. Die strukturierte Ausnahmebehandlung kombiniert eine moderne Kontrollstruktur (vergleichbar mit Select…Case oder While) mit Ausnahmen, geschützten Codeblöcken und Filtern.