Pro VB 2008 and the .NET 3.5 Platform

UNDERSTANDING THE PREVIOUS STATE OF AFFAIRS

Life As a C/Win32 API Programmer

Life As a C++/MFC Programmer

Life As a Visual Basic 6.0 Programmer

Life As a Java/J2EE Programmer

Life As a COM Programmer

' The MyCOMClass type could be written in 
' any COM-aware language, and may be located anywhere 
' on the network (including your local machine). 
Dim myObj As MyCOMClass
Set myObj = New MyCOMClass ' Location resolved using AppID.
myObj.DoSomeWork

Life As a Windows DNA Programmer

THE .NET SOLUTION

• Comprehensive interoperability with existing code: This is (of course) a good thing. ActiveX components can commingle (i.e., interop) with newer .NET applications and vice versa. Also, Platform Invocation Services (PInvoke) allows you to call C-based libraries (including the underlying API of the operating system) from .NET code.
• Integration among .NET programming languages: .NET supports cross-language inheritance, cross-language error handling, and cross-language debugging of code.
• A common runtime engine shared by all .NET-aware languages: One aspect of this engine is a well-defined type system that each .NET-aware language "understands."
• A comprehensive base class library: This library provides shelter from the complexities of raw Windows API calls and offers a consistent object model used by all .NET-aware languages.
• No more COM plumbing: Legacy COM interfaces (such as IUnknown and IDispatch), COM type libraries, and the COM-centric Variant data type have no place in a native .NET binary.
• A truly simplified deployment model: Under .NET, there is no need to register a binary unit into the system registry. Furthermore, .NET allows multiple versions of the same *.dll to exist in harmony on a single machine.

INTRODUCING THE BUILDING BLOCKS OF THE .NET PLATFORM (THE CLR, CTS, AND CLS)

The Role of the Base Class Libraries

WHAT VISUAL BASIC 2008 BRINGS TO THE TABLE

• Full support for classical inheritance and classical polymorphism.
• Strongly typed keywords to define classes, structures, enumerations, delegates, and interfaces. Given these new keywords, VB .NET code is always contained within a *.vb file (in contrast to the VB6-centric *.cls, *.bas, and *.frm files).
• Full support for interface-based programming techniques.
• Full support for attribute-based programming. This brand of development allows you to annotate types and their members to further qualify their behavior (more details in Chapter 16).

• The ability to redefine how intrinsic operators of the language (such as the + symbol) can be interpreted by your custom classes or structures. Formally speaking, this feature is termed operator overloading.
• The introduction of the My namespace. This namespace provides instant access to machine- and project-specific information (which greatly reduces the amount of code you need to author manually).
• The ability to build generic types and generic members. Using generics, you are able to build very efficient and type-safe code that defines numerous "placeholders" specified at the time you interact with the generic item.
• The ability to customize the process of registering, unregistering, or sending events using the Custom keyword.
• Support for signed data types (SByte, ULong, etc.).
• The ability to define a single type across multiple code files using the Partial keyword.

• Support for strongly typed query statements (' la LINQ'Language Integrated Query), which can interact with a variety of data stores (databases, XML documents, collection objects)
• Support for anonymous types, which allow you quickly model the "shape" of a type rather than its behavior
• The ability to extend the functionality of a compiled type using extension methods
• Support for lambda expressions, which greatly simplify how we can work with .NET delegate types
• A new object initialization syntax, which allows you to set property values at the time of object creation

ADDITIONAL .NET-AWARE PROGRAMMING LANGUAGES

http://www.dotnetlanguages.net  

Life in a Multilanguage World

AN OVERVIEW OF .NET ASSEMBLIES

Single-File and Multifile Assemblies

The Role of the Common Intermediate Language

' Calc.vb 
Imports System 

Namespace CalculatorExample 
  ' Defines the program's entry point. 
  Module Program 
    Sub Main() 
    Dim ans As Integer 
    Dim c As New Calc() 
    ans = c.Add(10, 84) 

    Console.WriteLine("10 + 84 is {0}.", ans)
    Console.ReadLine()
  End Sub
End Module
  ' The VB 2008 calculator. 
  Class Calc
    Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer
      Return x + y 
    End Function 
  End Class 
End Namespace 

.method public instance int32 Add(int32 x, int32 y) cil managed
{ 
  // Code size 9 (0x9) 
  .maxstack 2 
  .locals init ([0] int32 Add) 
  IL_0000: nop 
  IL_0001: ldarg.1 
  IL_0002: ldarg.2 
  IL_0003: add.ovf 
  IL_0004: stloc.0 
  IL_0005: br.s IL_0007 
  IL_0007: ldloc.0 
  IL_0008: ret 
} // end of method Calc::Add 

// Calc.cs 
using System; 

namespace CalculatorExample 
{ 
  // Defines the program's entry point. 
  public class Program  
  {

    static void Main()
    {
      Calc c = new Calc();
      int ans = c.Add(10, 84);
      Console.WriteLine("10 + 84 is {0}.", ans);
      Console.ReadLine();
   }
  }
  // The C# calculator. 
  public class Calc 
  { 
    public int Add(int x, int y) 
    { return x + y; } 
  } 
} 

.method public hidebysig instance int32 Add(int32 x, int32 y) cil managed 
{ 
  // Code size 8 (0x8) 
  .maxstack 2 
  .locals init ([0] int32 CS$1$0000) 
  IL_0000: ldarg.1 
  IL_0001: ldarg.2 
  IL_0002: add 
  IL_0003: stloc.0 
  IL_0004: br.s IL_0006 
  IL_0006: ldloc.0 
  IL_0007: ret 
} // end of method Calc::Add 

The Role of .NET Type Metadata

TypeDef #2 (02000003) 
---------------------------------------------------
  TypDefName: CalculatorExample.Calc (02000003) 
  Flags : [Public] [AutoLayout] [Class] 
  [AnsiClass] [BeforeFieldInit] (00100001) 
  Extends : 01000001 [TypeRef] System.Object 
  Method #1 (06000003)
---------------------------------------------------
  MethodName: Add (06000003) 
  Flags : [Public] [HideBySig] [ReuseSlot] (00000086) 
  RVA : 0x00002090 
  ImplFlags : [IL] [Managed] (00000000) 
  CallCnvntn: [DEFAULT] 
  hasThis 
  ReturnType: I4 
    2 Arguments 
    Argument #1: I4 
    Argument #2: I4 
    2 Parameters 
    (1) ParamToken : (08000001) Name : x flags: [none] (00000000)
    (2) ParamToken : (08000002) Name : y flags: [none] (00000000)

The Role of the Assembly Manifest

.assembly extern mscorlib 
{ 
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) 
  .ver 2:0:0:0 
} 
... 
.assembly Calc 
{ 
... 
  .ver 0:0:0:0 
} 
.module Calc.exe 
.imagebase 0x00400000 
.subsystem 0x00000003 
.file alignment 512 
.corflags 0x00000001 

UNDERSTANDING THE COMMON TYPE SYSTEM

CTS Class Types

' A class type. 
Public Class Calc 
  Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer 
    Return x + y 
  End Function 
End Class 

CTS Interface Types

' Classes or structures that implement this interface 
' know how to render themselves. 
Public Interface IDraw 
  Sub Draw() 
End Interface 

CTS Structure Types

' A structure type. 
Public Structure Point 
  Public xPos As Integer 
  Public yPos As Integer 
  
  Public Sub New(ByVal x As Integer, ByVal y As Integer)
    xPos = x
    yPos = y
  End Sub 

  Public Sub Display() 
    Console.WriteLine("({0}, {1}", xPos, yPos) 
  End Sub 
End Structure 

CTS Enumeration Type

' An enumeration type. 
Public Enum CharacterType 
  Wizard = 100 
  Fighter = 200 
  Thief = 300 
End Enum 

CTS Delegate Types

' This delegate type can "point to" any method 
' returning an integer and taking two integers as input. 
Public Delegate Function BinaryOp(ByVal x As Integer, _ 
  ByVal y As Integer) As Integer 

CTS Type Members

Intrinsic CTS Data Types

UNDERSTANDING THE COMMON LANGUAGE SPECIFICATION

' A VB 2008 subroutine. 
Public Sub MyMethod() 
  ' Some interesting code... 
End Sub 

// A C# method with no return value. 
public void MyMethod() 
{ 
  // Some interesting code... 
} 

• Rule 1: CLS rules apply only to those parts of a type that are exposed outside the defining assembly.

Public Class Calc 
  ' Exposed unsigned data is not CLS compliant! 
  Public Function Add(ByVal x As ULong, ByVal y As ULong) As ULong 
    Return x + y 
  End Function 
End Class 

Public Class Calc 
  Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer 
    ' As this ULong variable is only used internally, 
    ' we are still CLS compliant. 
    Dim temp As ULong = 0 
    ... 
	Return x + y 
  End Function 
End Class 

Ensuring CLS Compliance

' Tell the compiler to check for CLS compliance. 
<Assembly: System.CLSCompliant(True)>

UNDERSTANDING THE COMMON LANGUAGE RUNTIME

THE ASSEMBLY/NAMESPACE/TYPE DISTINCTION

' Hello world in VB 2008 
Imports System 

Public Module MyApp 
  Sub Main() 
    Console.WriteLine("Hi from VB 2008") 
  End Sub 
End Module 

// Hello world in C# 
using System; 

public class MyApp 
{ 
  static void Main() 
  { 
    Console.WriteLine("Hi from C#"); 
  } 
} 

// Hello world in C++/CLI 
#include "stdafx.h" 
using namespace System; 

int main(array<System::String ^> ^args) 
{ 
  Console::WriteLine(L"Hi from C++/CLI"); 
  return 0; 
} 

Accessing a Namespace Programmatically

' Here are all the namespaces used to build this application. 
Imports System ' General base class library types. 
Imports System.Drawing ' Graphical rendering types. 
Imports System.Windows.Forms ' GUI widget types. 
Imports System.Data ' General data-centric types. 
Imports System.Data.SqlClient ' MS SQL Server data access types. 

' Explicitly list the namespaces used by this file. 
Imports System 
Imports System.Drawing 

Public Class Program 
  Public Sub DisplayLogo() 
    ' Create a 20 x 20 pixel bitmap. 
    Dim companyLogo As New Bitmap(20, 20) 
    ... 
  End Sub 
End Class 

' Not listing System.Drawing namespace! 
Imports System 

Public Class Program 
  Public Sub DisplayLogo() 
    ' Create a 20 x 20 pixel bitmap. 
    Dim companyLogo As New System.Drawing.Bitmap(20, 20) 
    ... 
  End Sub 
End Class 

Referencing External Assemblies

Using ildasm.exe

Viewing CIL Code

Viewing Type Metadata

Viewing Assembly Metadata (aka the Manifest)

Using Lutz Roeder's Reflector

DEPLOYING THE .NET RUNTIME

THE PLATFORM-INDEPENDENT NATURE OF .NET

• ECMA-334: The C# Language Specification
• ECMA-335: The Common Language Infrastructure (CLI)

SUMMARY