The .Net framework offers a static method in the string class: String.IsNullOrEmpty.

String^ s;

//s = ""; //Uncomment to test 2nd case.

if (String::IsNullOrEmpty(s))
{
  MessageBox::Show("empty string");
}

C++ uses = for it's assignment operator.

int Age;

string FullName; //#include <string>

  
Age = 42;

FullName = "Randy Spitz";

C++ is case sensitive. In C and C++ commands and variable names are case sensitive.

The following first standard C++ snippet works:

printf("hello\n");

Printf("hello\n"); //>>>Does not work!

For C++, Java, JavaScript, and PHP, I prefer to put the first { at the end of the first line of the code block as in the example above because I see more C++ formatted that way.

int Dog::Bark() {
 cout << "My first class method!" << endl;
 return 0;
};

Commenting Code
C++ uses "//" for a single line comment and /* */ for a multiple line comment.

//Single line comment in MS (not ANSI compliant so do NOT use).
  

/* ANSI compliant single line comment. */
  

/*
Multiple line
comment.

*/

/*

* This is another popular

* way to write multi-line

* comments.

*/

General Info: Round Floating Point Numbers

When comparing floating point numbers, make sure you round to an acceptable level of rounding for the type of application you are using.

Languages Focus: Comparison Operators

A comparison operator compares two values either literals as in "Hello" and 3 or variables as in X and Counter. Most languages use the same operators for comparing both numbers and strings. Perl, for example, uses separate sets of comparison operators for numbers and strings.

//C++Builder example (ShowMessage is a VCL method).

//Does C++Builder evaluate the math correctly? No!

If (.1 + .1 + .1 == .3)
  ShowMessage("correct");
else
  ShowMessage("not correct");

In standard C++, you use const and static const to declare constants.

//C++Builder 2009 Example:

const String kName = "Mike";
const int kAge = 35;

ShowMessage("Hi " + kName + ", you are " + kAge + ".");

C++ is a hybrid language and as such offers global functions and class methods. A function must come before it's usage or you can prototype the function.

void sayHello(string pName) {
  cout << "Hello " + pName + "\n";
};

int add(int p1, int p2) {
  int result;

  result = p1 + p2;
  return result;
};

You can use any of the many free and commercially available installation packages.

In Visual Studio.Net, you can create a Setup and Deployment project by using any of the templates available on the New Project dialog (Other Project Types).

C++Builder 2007 and 2009 are bundled with InstallAware Express CodeGear Edition installer.

Languages Focus: Development Tools

Primary development tool(s) used to develop and debug code.

C++ uses a semicolon ";" as an end of statement specifier and you can put multiple statements on a single line of code if you wish as well as split a single statement into two or more code lines.

printf("Hello1");

printf("Hello2");

printf("Hello3"); printf("Hello4");

printf

   ("Hello5");

Important standard C++ file extensions:

• .CPP = C++ Source file. Your startup source file will have a main() routine.
• .C = C source file (sometimes used for C++ source files too).
• .H = Header include file.

Some important Visual C++ file extensions:

• .SLN = Visual Studio.Net solution
• .VCPRJ = The Visual C++ project file. See Project Files and Makefiles for more information.

Same as standard C.

//C++Builder example using the VCL ShowMessage.

int x;

x = 8;

if (x == 10) {
  ShowMessage("x is 10.");
} else if (x < 10) {
  ShowMessage("x is less than 10.");
} else {
  ShowMessage("x must be greater than 10.");
}

Literals are quoted as in "Prestwood". If you need to embed a quote use a slash in front of the quote as in \". 

printf("Hello\n");
printf("Hello \"Mike\".\n"); 

cout << "Hello" << endl;

cout << "Hello \"Mike\".\n";

C++ logical operators:

//Given expressions a, b, c, and d:

if !((a && b) && (c || d)) {

  //Do something.

}

Language Overview: C++ is a hybrid traditional C and OOP language. You code either in a traditional approach using functions, procedures, and global data, or you code using an OOP approach, or a mixture of both.

Target Platforms: C++ is suitable for creating any type of native code applications for many different platforms. The focus of this information is on creating native code Win32 applications that run on Microsoft Windows.

The + operator can be used with any combination of C++ strings, C strings and characters.

string fullname;
 
fullname = "Mike ";
fullname.append("Prestwood");
 
cout << "Hello " + fullname + "." << endl;

An operation with only one operand (a single input) such as ++X and --Y.

Variable names are case sensitive. The fundamental variable types in C++ are char, short int, int, long int, bool, float, double, long double, and wchar_t. The integer data types char, short, long and int can be either signed or unsigned. Signed variables are positive and negative. Unsigned variables are positive only.

C++, Java, and C# all use C-like variable declaration.

int Age;

int Age = 43;

float a, b, c;

string FullName; //#include 

unsigned short int FamilyMemberCount;

Same as standard C++. For C++, Java, JavaScript, and PHP, I prefer to put the first { at the end of the first line of the code block as in the example above because I see more C++ formatted that way.

int Dog::Bark() {
 cout << "My first class method!" << endl;
 return 0;
};

The C++/CLI standard file extensions are the same as standard C++. Important C++ file extensions:

• .CPP = C++ Source file. Your startup source file will have a main() routine.
• .C = C source file (sometimes used for C++ source files too).
• .H = Header include file.

Some important Visual C++ file extensions:

• .SLN = Visual Studio.Net solution
• .VCPRJ = The Visual C++ project file. See Project Files and Makefiles for more information.

Languages Focus: Exception Trapping

A common usage of exception handling is to obtain and use resources in a "try-it" block, deal with any exceptions in an "exceptions" block, and release the resources in some kind of "final" block which executes whether or not any exceptions are trapped.

try {

  //Some code.

}

catch(AnError) {

  //Error code here.

}

Use any report writer you are comfortable with. C++Builder 2009 comes bundled with Rave Reports and Crystal Reports remains popular for Visual C++.

General Info: Associative Array

Languages Focus: Associative Array

Associative arrays are also known as a dictionary or a hash table in other languages.

map<string, int> mymap;

mymap.insert(AValuePair);

Use the inline keyword to tell the compiler to inline a routine.

inline int add(int p1, int p2) {
  int result;

  result = p1 + p2;
  return result;
};

C++ Overloading

• Operator - Yes for C++, no for C. Almost all operators can be overloaded for user-defined types
• Method -

C++ uses both pointers and references. Use the * operator to declare a pointer and use the & operator to declare a reference.

C++/CLI uses = for it's assignment operator.

int Age;

string FullName;

  
Age = 42;

FullName = "Randy Spitz";

Same as standard C++. Both standard C++ and C++/CLI are case sensitive. In C and C++ commands and variable names are case sensitive.

The following first C++/CLI snippet works:

MessageBox::Show("Hello");

messagebox::SHOW("Hello"); //>>>Does not work!

Same as standard C++. For C++, Java, JavaScript, and PHP, I prefer to put the first { at the end of the first line of the code block as in the example above because I see more C++ formatted that way.

class Cyborg {
public: System::Void IntroduceYourself() {
    MessageBox::Show("Hi");
  }
};

Commenting Code
Same as standard C++. C++ uses "//" for a single line comment and /* */ for a multiple line comment.

//Single line comment in MS (not ANSI compliant so do NOT use).
  

/* ANSI compliant single line comment. */
  

/*
Multiple line
comment.

*/

/*

* This is another popular

* way to write multi-line

* comments.

*/

Same as standard C++.

//Does C++/CLI evaluate the math correctly? No!

if (0.1 + 0.1 + 0.1 == 0.3)
  MessageBox::Show("correct");
else
  MessageBox::Show("not correct");

C++/CLI supports the const and static const keywords of standard C++ as well as the new literal keyword. A literal is equivalent to static const in standard C++ and Microsoft's documentation recommends to replace static const with the new literal keyword because a leteral is available in metadata; a static const variable is not available in metadata to other compilers.

You can use static const within the class declaration or locally within a method. However, literal is only valid in the class declaration section and const is only valid within a method.

//some method {

const String^ MyName = "John";
static const Int32 MyAge = 27;

//}

// public class SomeClass : public Object {
public:
  literal double Pi = 3.14159;
  literal String^ MyName = "Mike";
  static const Int32 MyAge = 35;

//...

C++/CLI projects require the .Net framework and any additional dependencies you've added such as Crystal Reports.

In Visual Studio.Net, you can create a Setup and Deployment project by using any of the templates available on the New Project dialog (Other Project Types).

To create a ClickOnce deploy package, search the internet for mage.exe and mageui.exe.

In addition, you can use any of the many free and commercially available installation packages.

The only development tool I know that supports C++/CLI at this time is Visual Studio.Net. C++/CLI was introduced in VS.Net 2005 and continued in VS.Net 2008.

Same as standard C++. C++ uses a semicolon ";" as an end of statement specifier and you can put multiple statements on a single line of code if you wish as well as split a single statement into two or more code lines.

//.Net WinForms example.

//Add, using namespace System::Windows::Forms;

MessageBox::Show("Hello1");

MessageBox::Show("Hello2");

MessageBox::Show("Hello3");

MessageBox::Show("Hello4"); MessageBox::Show("Hello5"); 

MessageBox:: 

  Show 

    ("Hello6");

The C++/CLI standard file extensions are the same as standard C++. Important C++ file extensions:

• .CPP = C++ Source file. Your startup source file will have a main() routine.
• .C = C source file (sometimes used for C++ source files too).
• .H = Header include file.

Some important Visual C++ file extensions:

• .SLN = Visual Studio.Net solution
• .VCPRJ = The Visual C++ project file. See Project Files and Makefiles for more information.

Same as standard C.

int x;

x = 8;

if (x == 10) {
  MessageBox::Show("x is 10");
} else if (x < 10) {
  MessageBox::Show("x is less than 10"); 
} else {
  MessageBox::Show("x must be greater than 10"); 
}

In C++/CLI, inlining is automatically done for you by the JIT compiler for all languages and in general leads to faster code for all programmers whether they are aware of inlining or not.

Same as standard C++. Literals are quoted as in "Prestwood". If you need to embed a quote use a slash in front of the quote as in \". 

MessageBox::Show("Hello");

MessageBox::Show("Hello \"Mike\".");

//Does ASP evaluate this simple

//floating point math correctly? No! 

if ((.1 + .1 + .1) == 0.3) {
  MessageBox::Show("Correct");
} else {
  MessageBox::Show("Not correct");
}

Same as C++ and Java. C# logical operators:

//Given expressions a, b, c, and d:

if !((a && b) && (c || d)) {

  //Do something.

}

Language Overview: A.k.a. C++.Net. Microsoft's C++ language for .Net Framework development.

Language History: C++/CLI was introducted with VS.Net 2005 and replaced Managed C++ (introduced with VS.Net 2002). C++/CLI was standardized by ECMA-372.

Target Platforms: C++/CLI is suitable for creating .Net Framework applications.

C++/CLI performs implicit casting of numbers to strings. To concatenate two strings, a string to an integer, or a string to a floating point number, use the + operator. For example, to convert a floating point number to a string just concatenate an empty string to the number as in "" + 3.2.

//Implicit casting of numbers.

//

//This fails:

//MessageBox::Show(3.3);

//

//This works:

MessageBox::Show("" + 3.3);

AbstractMemberFunction is a pure virtual function makes this class Abstract class indicated by the "=0"and NonAbstractMemberFunction1 is a virtual function.

class AbstractClass {
public:
  virtual void AbstractMemberFunction() = 0;

  virtual void NonAbstractMemberFunction1();

};

Languages Focus: Class..Object

In short, a class is a data type, and an object is an instance of a class type. A class has methods (routines), properties (member variables), and a constructor. The current values of the properties is the current state of the object. The UML is one of the diagraming disciplines that allows you to document the various changing states of a series of objects.

A member function with the same name as the class.

class X {
public:
  X();      // constructor for class X
};

A member function with the same name as the class prefixed with a ~ (tilde). C++ destructors are automatically called when an object goes out of scope, or when you delete a dynamically allocated object. Every class can have only one destructor.

class Cyborg {
public:
  // Constructor for class Cyborg
  Cyborg();

  
  // Destructor for class Cyborg
  ~Cyborg();
};

In C++ you use the class keyword to signify a class and a colon followed by the parent class name for inheritance.

In the following example, a terminator T-600 is-an android. 

class Android {

};

class T-600: Public Android {

};

C++ supports both multiple implementation inheritance and multiple interface inheritance.

You can mimic an interface by using a class that has only pure-virtual functions and no member variables.

C++ implements class and member visibility specifiers traditionally. Note the colon at the end of each visibility specifier and the semi-colon at the end of the class (the end of the statement).

class Cyborg: Public AParentClass {
public:
 

protected:

private:

};

Make the constructor a private member of the class.

C++ supports static methods and static member fields using the static keyword.

class MyUtils {
public:
  static void MyStaticMethod();
};

In C++/CLI, the Object keyword is an alias for the base System::Object class and is the single base class all classes ultimately inherit from.

In C++/CLI, the Object keyword is an alias for the base System::Object class and is the single base class all classes ultimately inherit from.

Unlike standard C++, C++/CLI uses the .Net garbage collector to free managed object instances. Prism does not have nor need a true destructor.

In .Net, a finalizer is used to free non-managed objects such as a file or network resource. Because you don't know when the garbage collector will call your finalizer, Microsoft recommends you implement the IDisposable interface for non-managed resources and call it's Dispose() method at the appropriate time.

Use any report writer you are comfortable with but Crystal Reports remains popular for Visual C++ and C++/CLI.

Delphi supports both static and dynamic arrays.

var
  MyArray: array[0..3] of string;
  i: Integer;
begin
  MyArray[0] := 'Mike';
  MyArray[1] := 'Lisa';
  MyArray[2] := 'Felicia';
  MyArray[3] := 'Nathan';

  for i := 0 to High(MyArray) do
    ShowMessage(MyArray[i]);
end;

Length() or SizeOf() will correctly identify an unassigned string variable or an empty string.

if length(s) = 0 then
  ShowMessage('empty string');

Many objects in Delphi have events you can use to trigger code. For example, when you add a form to your project you have access to the form events such as onCreate, onShow, onHide, onDockDrop, etc. In addition, Delphi offers module level events initialization and finalization sections.

Delphi also offers a try...finally where code will execute in the finally section no matter what. It's common to put a try...except inside a try...finally:

var
  y : Double;
begin
  try
    y := 0;
    y := (1/y);
    ShowMessage(FloatToStr(y));
  except
    ShowMessage('You cannot divide by zero.');
  end;
end;

In Delphi, you can inline assembler code using the asm keyword.

In Delphi, member events are essentially properties of the type method pointer.

Delphi create native code Windows applications so you can create an EXE with no dependencies that will run on any Windows computer. If you add dependencies (reports, database libraries, DLLs, etc.) use a Windows installer to build an installation program.

D2007 and D2009 are bundled with InstallAware Express CodeGear Edition installer.

Delphi uses := for it's assignment operator.

var

  FullName: String;

  Age: Integer;

begin

  FullName := "Randy Spitz";
  Age := 38;

end

Object Pascal is generally not case sensitive.

Variables and commands are not case sensitive.

var
 FullName: String;
begin
 fullname := 'Mike Prestwood';
 ShowMessage(fullNAME);
 SHOWMESSAGE(FULLNAME);
 showmessage(fullname);

end;

Object Pascal requires the semi-colon after the "declaration" part.

function DoSomething : integer;

var

  a, b : integer

begin

  a := 1;

  b := 2;

  result := a + b;

end;

Delphi uses // for a single line comment and both {} and (**) for multiple line comments. Although you can nest different types of multiple line comments, it is recommended that you don't. A special comment. Delphi compiler directives are in the form of {$DIRECTIVE}. Of interest for comments is using the $IFDEF compiler directive to remark out code.

//This is a single line comment.

 
{

Multiple line

comment.

}

 
(*
This too is a
multiple line comment.
*)

 
{$IFDEF TEMPOUT}
  //...code here
{$ENDIF}

In Delphi, you define constants similar to how you define variables but use the Const keyword instead of the Var keyword. Declare global constants in a unit's interface section and unit constants (scope limited to unit) in the implementation section. Declare local constants above the begin..end block.

Const 

  kFeetToMeter: Double = 3.2808;

  kMeterToFeet: Double = .3048;

  kName: String = "Mike";

//Local constants:

procedure SomeProcedure;

const

  kPI: Double=3.1459;

begin

end;

Languages Focus: Development Tools

Primary development tool(s) used to develop and debug code.

Languages Focus: End of Statement

In coding languages, common End of statement specifiers include a semicolon and return (others exist too). Also of concern when studying a language is can you put two statements on a single code line and can you break a single statement into two or more code lines.

WriteLn('Hello1');
WriteLn('Hello2');
WriteLn('Hello3');
 
//Same line works too:
WriteLn('Hello4');  WriteLn('Hello5');
 
//Two or more lines works too:
WriteLn
  ('Hello6');

Common source code file extensions include:

• .BDSPROJ - Project, Borland Developer Studio project file holds compiler options, etc. This is the file you open.
• .DCU - Delphi Compiled Unit file.
• .DFM - Delphi Win32 form file (a text resource file).
• .DPR - Delphi project file. Primary project "source" file.
• .PAS - Delphi unit source file.

Notice in the more complete example that the semicolon for the begin..end block after end is not included. That tells the compiler something else is coming (the statement is not finished). Also note the semicolon is missing right before the final "else" statement.

Note: The following example uses floating point literals. In Delphi, to specify a fractional floating point literal between 1 and -1, you preceed the decimal with a 0; otherwise, you will get a compiler error (i.e. .1 + .1 does not work).

if (0.1 + 0.1 + 0.1) = 0.3 then
  ShowMessage('Correct')
else
  ShowMessage('Not correct');

//Complete example:
if x = true then
begin 

  ShowMessage('x is true');

end

Else If y = 'Mike' Then 

  ShowMessage('hello mike')

Else 

  ShowMessage('last option');

Literals are single quoted (the apostrophe) as in 'Prestwood'. If you need to embed an apostrophe use two apostrophies in a row.

ShowMessage('Hello');
ShowMessage('Hello Mike''s website.');

Delphi logical operators:

//Given expressions a, b, c, and d:

if Not (a and b) and (c or d) then

  //Do something.

Language Overview: Delphi programming language is a type-safe language consisting of hybrid traditional Pascal and OOP features. You code either in a traditional approach using functions, procedures, and global data, or you code using an OOP approach, or a mixture of both.

Target Platforms: Delphi for Win32 is most suitable for creating native code Win32 applications that run on Microsoft Windows.

Object Pascal allows parameters of the same type to be listed together, separated by commas, and followed with a single data type (more params of different data types can follow, after a semi-colon). The default for parameters is by value. For by reference, add var in front of the parameter. Object Pascal also offers constant parameters where you add const in front of the parameter. A constant parameter is like a local constant or read-only parameter the compiler can optimize. You cannot assign a value to a constant parameter, nor can you pass one as a var parameter to another routine.

function Add(a, b: integer) : integer; 
begin
  Result := a + b;
end;
  
procedure ReplaceTime(var pDT: TDateTime; const pNewDT: TDateTime);
begin
end;

Use the + operator to concatenate two strings. Use IntToStr to convert an integer to a string and FloatToStr to convert a floating point number to a string.

var 

  FirstName : String; 

  LastName : String;

begin 

  FirstName := 'Mike'; 

  LastName := 'Prestwood';

  ShowMessage('Full name: ' + FirstName + ' ' + LastName);

  ShowMessage(FloatToStr(3.2));

end;

An operation with only one operand (a single input). In Object Pascal, a unary operator always precedes its operand (for example, -B), except for ^, which follows its operand (for example, P^). The Delphi unary operators are +, -, and ^ (pointer).

The TYPE operator is also a unary operator and is�evaluated at compile time. The TYPE operator returns the size in bytes of the operand,

Declare global variables in the interface section of a unit, variables declared within the implementation section (but not within a method) have a scope limited to the unit. You declare local variables in a var block outside (above) your begin..end code block. You cannot declare variables in-line (inside begin..end). You can initialize global and unit variables but you cannot initialize local variables. Delphi offers many variable types. Some common variable types include String, WideString, PChar, Integer, Boolean, Single, Double, Pointer, and Variant.

procedure SomeProcedure;

var
  Fullname: String;
  Age: Integer;

  X, Y, Z: Double;

  MyArray: array [1..100] of Char;

begin

end;

//You can initialize global variables.

var

  ClickCounter: Integer = 0;

TStringList Example
Object Pascal doesn't have a native associative array, but you can use a TStringList the same way. (Alternatively, search the Internet for TStringHash and THashedStringList classes for implementations of a true associative array).

var
  StateList : TStringList;
begin
   StateList := TStringList.Create;	//Create list.

  //Add values comma separated.
  StateList.CommaText := 'CA=California, AR=Arizona';
  StateList.CommaText := StateList.CommaText + ', FL=Florida';

  //Also, can add individually.
  StateList.Add('NV=Nevada');

  //Use it.
  ShowMessage('FL is ' + StateList.Values['FL']);
end;

Object Pascal doesn't have a native associative array, but you can use a TStringList the same way. (Alternatively, search the Internet for TStringHash and THashedStringList classes for implementations of a true associative array).

var
  StateList : TStringList;
begin
  StateList := TStringList.Create; 

  StateList.CommaText := 'CA=California, FL=Florida';

  ShowMessage('FL is ' + StateList.Values['FL']);
end;

Common comparison operators:

//Does Delphi evaluate the math correctly? Yes!

//Refer to math.pas MaxSingle for more info.

if (0.1 + 0.1 + 0.1 = 0.3) then
  ShowMessage('correct')
else
  ShowMessage('not correct')

Delphi is a hybrid language so you can create either class methods (functions and procedures) or you can create global functions and procedures. When a function or procedure is part of a class, it is a class method.

[function/procedure] RoutineName : ReturnType;

As with C++, your custom routine must come before it's first usage or you have to prototype it in the Interface section.

Note: Contrast Delphi with Delphi Prism which is an OOP language (everything is within a class). Both Delphi and Delphi Prism are based on Object Pascal but implement OOP features differently and have some syntax differences too.

procedure SayHello(pName: String);
begin
  ShowMessage('Hello ' + pName);
end;

function Add(p1, p2 : Double): Double;
begin
  Result := p1 + p2;
end;

Delphi introduced developer defined function and procedure inlining with Delphi 2005. Use the inline keyword to tell the compiler to inline a routine. Since Delphi will always inline the routine, make sure you test for speed because inlining a routine can lead to slower code under some circumstances.

function Add(a, b: Integer): Integer; inline;

begin

end;

Delphi LeftStr

Uses StrUtils;

ShowMessage(LeftStr('Prestwood', 3));

Object Pascal

• Operator - Yes. But not Pascal.
• Method - Yes.  

function Add(a, b: integer): Integer;  overload;
begin
  Result := a+b;
end;

function Add(const msg: String; a, b: integer): String; overload;
begin
  Result := msg + IntToStr(a+b);
end;

Although pointer data types in Delphi coding are less important and not required for most general coding, Delphi fully supports developer defined pointers. Use a carrot (^) to declare a pointer data type. Use the @ operator or Addr function to return the current address of a variable.

//Declare a pointer of type integer.

PCounter : ^Integer;

//Assign a value to the location of a pointer.

//Also known as dereferencing.

PCounter^ := 8;

//Assign address of A to B.

PointerB := @PointerA;  //or...PointerB := Addr(PointerA);

Within the implementation of a method, the identifier Self references the object in which the method is called. The Self variable is an implicit parameter for each object method.
A method can use this variable to refer to its owning class.

ShowMessage('Self=' + Self.ClassName);

Simple example of using sets in Delphi. Sets are similar to arrays and are convenient to use with 'in'.

procedure TForm1.Button7Click(Sender: TObject);

var
  ValidStrings: Set of Char;
begin
  ValidStrings := ['Y', 'N', 'X']; 
 

  If 'Y' in ValidStrings then
    ShowMessage('Yes, Y is valid');
end;

Delphi for Win32 supports abstract class members using the abstract keyword. You can even instantiate instances of a class that contains abstract members. Then you override each abstract member in a descendant class with Override. Delphi does not support setting an entire class as abstract. You can create an abstract class (a class with one or more abstract methods), but there is no way to tell the compiler to not allow the instantiation of the abstract class. Delphi does not support abstract member properties directly. To implement an abstract properity, make use of abstract methods. That is, you can read a GetPropertyX abstract function and write to a SetPropertyX abstract procedure. In effect, creating  an abstract property.

TCyborg = class(TObject)
public
  procedure Speak(pMessage: String); virtual; abstract;
  procedure Walk; virtual; abstract;
end;

TSeries600 = class(TCyborg)
public
  procedure Speak(pMessage: String); override;
  procedure Walk; override;
end;

In Delphi programming language (Object Pascal), all classes ultimately inherit from the base class TObject.

//Specify both namespace and class:

TCyborg = class(System.TObject)
end;

//Use shortcut alias:

TCyborg = class(TObject)
end;

//None, default is System.TObject

TCyborg = class
end;

Delphi allows you to extend an existing class without using inheritance. Buggy in 2005 and not officially supported but stable and usable in 2006 and above. You declare a class helper similiar to how you declare a class but use the keywords class helper for.

• You can name a helper anything.
• Helpers have access only to public members of the class.
• You cannot create an object instance directly from a class helper.
• self refers to the class being helped.

TCyborg = class(TObject)
public
  FCyborgName: String;
end;

TCyborgHelper = class helper for TCyborg
  procedure ShowClassName;
end;

Object Pascal supports static methods, but not static member fields. For static member fields, use traditional Pascal-like global variables. Since Object Pascal is a hybrid language, you can use global functions and data so the need for class methods is diminished but still useful. Delphi 1-7: All classes in a unit are friendly (see eachother's private members), some developers like to put each class in it's own unit and reserve putting multiple classes in the same unit until they wish to implement friendly classes. Delphi 2005+: New strict keyword allows you to indicate friendly.

type
TMyUtils = class(TObject)
public
  class function MyStaticMethod: Integer;
end;

In implimentation:

class function TMyUtils.MyStaticMethod: Integer;

Declare your class in the Interface section. Then implement the class in the Implementation section.

//Interface section:

TCyborg = class(TObject)
public
 procedure IntroduceYourself;
end;

//Implementation section;

procedure TCyborg.IntroduceYourself;
begin
 ShowMessage('Hi, I do not have a name yet.');
end;

//Some event like a button click:

var
  T1: TCyborg;
begin
  T1 := T1.Create;
  T1.IntroduceYourself;

  FreeAndNil(T1);      //Be sure to clean up!
end;

In Delphi, use the constructor keyword to signify which method or methods are constructors for a class. It is traditional but not required to use a procedure called Create.

In addition to having multiple named constructors, you can overload constructors.

//Interface section.

TCyborg = class(TObject)
public
  constructor Create;
end; 

Then implement the class constructor in the Implementation section.

constructor TCyborg.Create;
begin
  inherited;  //Call the parent Create method

end;

Object Pascal uses a standard virtual destructor named Destroy which is called by the standard Free method. All objects are dynamic, so you need to call MyObject.Free method or the FreeAndNil(MyObject) routine for each object you create.

var
  MyObject: TObject;
begin
  MyObject := TObject.Create;

  //Use it...

  MyObject.Free

  //Or use...FreeAndNil(MyObject);
end;

In Delphi, you use the class keyword followed by the parent class in parens. If you leave out the parent class, your class inherits from TObject.

In the following example, a terminator T-600 is-an android. 

TAndroid = class

end;

T-600 = class(TAndroid)

end;

Delphi does not support multiple implementation inheritance. Each class can have only one parent class (a single inheritance path). In Delphi, you can use multiple interface usage to design in a multiple class way horizontally in a class hierarchy.

You specify an interface in the type block just like you do for a class but you use the interface keywoard instead of the class keyword and in the interfaces section only. Since interfaces, by definition, do not have any implementation details, all you do is specifiy it in the type block.

//Language interface:

//Interface section of unit.

IHuman = Interface(IInterface)
  //Specify interface methods and properties here.

end;

TCyborg = class(TInterfacedObject)

end;

TCyborgHuman = class(TCyborg, IHuman)
  //Specify each here and implement in
  //implementation section.
end;

In Delphi, it is common to start all member fields with "F" as in FName and FAge. You can initialize the value of member fields. Delphi member fields do not support static data. The workaround is to use the hybrid nature of Delphi and use a unit variable (a variable declared in the implementation section of a unit).

TCyborg = class(TObject)
private
  FSerialNumber: String='A100';
public
  FCyborgName: String;
  FCyborgAge: Integer=0;
  FSeriesID: Integer=100;
end;

Delphi uses the keywords procedure and function. A procedure does not return a value and a function does.

//Interface section:

TCyborg = class(TObject)
public
  procedure IntroduceYourself;
end;

//Implementation section;

procedure TCyborg.IntroduceYourself;
begin
  ShowMessage('Hi, I do not have a name yet.');
end;

//Some event like a button click:

var
  T1: TCyborg;
begin
  T1 := T1.Create;
  T1.IntroduceYourself;
end;

Specify Delphi member modifiers as follows:

reintroduce; overload; [binding modifier]; [calling convention]; abstract; [warning]

The binding modifiers are virtual, dynamic, or override. The calling conventions are register, pascal, cdecl, stdcall, or safecall. The warnings are platform, deprecated, or library. Additional directives include reintroduce, abstract, class, static, overload, and message.

TCyborg = class(TObject)

public

  procedure Speak(pMessage: String); virtual;

end;

 
TSeries888 = class(TCyborg)

public

  procedure Speak(pMessage: String); override;

end;

Delphi uses a special property keyword to both get and set the values of properties. The read and write keywords are used to get and set the value of the property directly or through an accessor method. For a read-only property, leave out the write portion of the declaration.

You can give properties any visibility you wish (private, protected, etc). It is common in Delphi to start member fields with "F" ("FName" in our example) and drop the "F" with properties that manage member fields ("Name" in our example).

TCyborg = class(TObject)
private
  FCName: String;
public
  property CyborgName: String read FCName write FCName;
end;

Up until D2005, private and protected were not implemented strictly. Starting with D2005, a traditional strict versions of OOP are supported using the strict keyword. OO purist will want you to use strict private over private and strict protected over protected. I suggest you follow that advice until you both fully understand the differences and have a specific need. Delphi offers a special published specifier which is the same as public members but runtime type information (RTTI) is generated.

TCyborg = class(System.Object)
private
  //Don't use accept when you really want private friendly members.
strict private
  //Use as your default private members.

  FName: String;
protected
  //Don't use accept when you really want protected friendly members.

strict protected
  //Use as your default protected members.

public

  

published

  //RTTI Info

end;

In Delphi, you specify a virtual method with the virtual keyword in a parent class and replace it in a descendant class using the override keyword. Call Inherited in the descendant method to execute the code in the parent method.

TRobot = class(TObject)
public
  procedure Speak; virtual;
end;

TCyborg = class(TRobot)
  procedure Speak; Override;
end;

Delphi supports the following types of polymorphism:

• Parametric Polymorphism (Method Overloading)
• Inheritance-Based Polymorphism
• Interface-Based Polymorphism (Interfaces)
• Ad-Hoc Polymorphism (Operator Overloading)

With Delphi, use the sealed keyword to prevent a class from being inherited from and use the final keyword to prevent a method from being overridden.

type

  Robot = class sealed(TObject)
  public
    procedure Speak(pSentence: String); virtual; final;
  end;

I always found the sleep command in ObjectPAL very useful. The following code does about the same thing in Delphi. It makes use of GetTickCount which is a Win32 API call that retrieves the number of milliseconds that have elapsed since the system was started, up to 49.7 days.

procedure TUtils.Delay(MillisecondsDelay: Integer);
var
   FirstTickCount: LongInt;
begin
   FirstTickCount := GetTickCount;
   repeat 
       Application.ProcessMessages;
   until ((GetTickCount-FirstTickCount) >= Longint(MillisecondsDelay));
end;

The .Net framework offers a static method in the string class: String.IsNullOrEmpty.

String s;

s = "";
//s = null;  //Uncomment to test 2nd case.

if (String.IsNullOrEmpty(s))
{
  MessageBox.Show("empty string");
}

Languages Focus: Assignment

Common assignment operators for languages include =, ==, and :=. An assignment operator allows you to assign a value to a variable. The value can be a literal value like "Mike" or 42 or the value stored in another variable or returned by a function.

int Age;

string FullName;

  
Age = 42;

FullName = "Randy Spitz";

C# is case sensitive. The following does NOT:

messagebox.Show("hello");  //Does not work!

The first time you type any other case for commands or variables, VS.Net will change it to the accepted or defined case. For example, if you type messagebox.show it is converted to MessageBox.Show. Once corrected, you can break it again by editing MessageBox to messagebox and the compiler will give you an error.

The following code works:

MessageBox.Show("hello");

General Info: Round Floating Point Numbers

When comparing floating point numbers, make sure you round to an acceptable level of rounding for the type of application you are using.

Languages Focus: Comparison Operators

A comparison operator compares two values either literals as in "Hello" and 3 or variables as in X and Counter. Most languages use the same operators for comparing both numbers and strings. Perl, for example, uses separate sets of comparison operators for numbers and strings.

//Does C# evaluate the math correctly? No!

if (.1 + .1 + .1 == .3)
  MessageBox.Show("correct");
else
  MessageBox.Show("not correct");

In C#, you define constants with the const keyword.

All constants are part of a class (no global constants) but you can make a constant public and have access to it so long as you have added the class to the project (even without creating the class as if they were static, but you cannot use the static keyword).

Constants must be of an integral type (sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, or string), an enumeration, or a reference to null.

public class Convert : Object
{
  public const string kName = "Mike";
  

  //You can declare multiple of the same type too:

  const Double kFeetToMeter = 3.2808, kMeterToFeet = .3048;
}

C# projects require the .Net framework and any additional dependencies you've added such as Crystal Reports.

In Visual Studio.Net, you can create a Setup and Deployment project by using any of the templates available on the New Project dialog (Other Project Types).

In addition, C# projects also support ClickOnce which brings the ease of Web deployment to Windows Forms and console applications. To get started, right click on your solution in the Solution Explorer, click Properties then select the Security tab. 

In addition, you can use any of the many free and commercially available installation packages.

Common source code file extensions include:

• .SLN - Solution File. Contains solution specific information such as links to the projects within this solution.
• .CSPROJ - C# Project File. Contains project specific information.
• .CS - C# source file.
• .Designer.CS - C# form file (a text resource file).

//Sample code snippet from the .csproj project file:

<ItemGroup>
  <Compile Include="Cyborg.cs" />
  <Compile Include="Cyborg600.cs" />
  <Compile Include="Form1.cs">
    <SubType>Form</SubType>
  </Compile>

  //...

Commenting Code
C# uses "//" for a single line comment and /* */ for a multiple line comment.

//Single line comment.

/*
Multiple line
comment.

*/

Language Overview: C# is an OOP language (no global functions or variables) and is type-safe. You code using a fully OOP approach (everything is in a class).

Target Platforms: C# is most suitable for creating any type of application that runs on the .Net platform. This includes desktop business applications using WinForms and websites using WebForms.

For WebForm applications the client target is the browser (a document interfaced GUI), a common solution is to simply output an HTML formatted page with black text and a white background (not much control but it does work for some situations). For WinForm applications, Crystal Reports is still a popular choice with C# developers because it has been bundled with many Microsoft products, it's overall popularity, and compatibility with many different development tools.

C# String Concatenation

C# performs implicit casting of numbers to strings. To concatenate two strings, a string to an integer, or a string to a floating point number, use the + operator. For example, to convert a floating point number to a string just concatenate an empty string to the number as in "" + 3.2.

Alternatively, you can use the System.Text.StringBuilder class which frequently but not always provides faster code.

String FirstName;

String LastName;

Int16 Age;

FirstName = "Mike";

LastName = "Prestwood";

Age = 43;

Console.WriteLine(FirstName + " " + LastName + " is " + Age + ".");

//Implicit casting of numbers.

//

//This fails:

//MessageBox.Show(3.3);

//

//This works:

MessageBox.Show("" + 3.3); 

C++, Java, and C# all use C-like variable declaration.

C# has C-like variable declaration and although variables are case sensitive, VS.Net will auto-fix your variable names to the defined case.

C# offers many variable types. Some common types used include short, int, long, float, double, decimal, Int16, UInt16, Int32, Int64, string, and bool.

You can also specify the value when you declare a variable as in:

String FirstName = "Mike";

String LastName = "Prestwood";

Int16 Age = 42;

string FullName;

int16 Age;

double Weight;

FullName = "Mike Prestwood";

Age = 32;

Weight = 154.4;

For C#, I prefer to put the opening { and the closing } on their own line (as opposed to C++, Java, and JavaScript where I put the opening bracket at the end of the first line.

int DoSomething()

{

 int a = 1;

 int b = 2;

 return a + b;

}

ReturnType RoutineName()

Note: C# requires () in both the function declaration, and when it's invoked.

void SayHello(String pName)
{
  MessageBox.Show("Hello " + pName);
}
 

int Add(int a, int b) 
{
  return a + b;
}

Languages Focus: Development Tools

Primary development tool(s) used to develop and debug code.

C# uses a semicolon ";" as an end of statement specifier and you can put multiple statements on a single line of code if you wish as well as split a single statement into two or more code lines.

Console.WriteLine("Hello1");
Console.WriteLine("Hello2");  
Console.WriteLine("Hello3");
 
//Same line works too:
Console.WriteLine("Hello4");  Console.WriteLine("Hello5");

//Two or more lines works too: 
Console.

  WriteLine
    ("Hello6");

C# uses a try...catch...finally statement to trap for errors.

try {}

catch {}

finally {}

try
{
  int y = 0;
  y = 1 / y;
}
catch
{
  MessageBox.Show("you cannot divide by zero");
}

Use () around evaluation with no "then".

Boolean x = true;

if (x)
{
  MessageBox.Show("hello");
}
else if (x==false)
{
  MessageBox.Show("goodbye");
}

else

{

  MessageBox.Show("what?");
}

Simple syntax example of class inheritance.

In the following example, a terminator T-600 is-an android. 

public class Android

{

}

public class T-600 : Android

{

}

Literals are quoted as in "Prestwood". If you need to embed a quote use a slash in front of the quote as in \". 

Console.WriteLine("Hello");
Console.WriteLine("Hello \"Mike\".");

//Does C# evaluate this simple

//floating point math correctly? No! 

if ((0.1 + 0.1 + 0.1) == 0.3)
{
  MessageBox.Show("Correct");
}
else
{
  MessageBox.Show("Not correct");
}

Same as C++ and Java. C# logical operators:

//Given expressions a, b, c, and d:

if !((a && b) && (c || d)) 

{

  //Do something.

}

C# Overloading

• Operator - Yes.
• Method - Yes.

Defining
In C# the data type of each parameter must be specified, even if adjacent parameters are of the same type.

integer Add(int a, int b)

C# Substring

Above returns "abcd" on a string literal. You can, of course, use VarName.Substring(0, 4).

Console.WriteLine("abcdefgh".Substring(0, 4));

An operation with only one operand (a single input). The following are the C# unary operators: +, -, !, ~, ++, --, true, or false.

General Info: Associative Array

Languages Focus: Associative Array

Associative arrays are also known as a dictionary or a hash table in other languages.

//using System.Collections.Generic;

Dictionary <String, String> airports = new Dictionary <String, String>();
 

airports.Add("LAX", "Los Angeles"); 
airports.Add("SFO", "San Francisco"); 
airports.Add("SAN", "San Diego");
 

MessageBox.Show(airports["LAX"]);

In C#, inlining is automatically done for you by the JIT compiler for all languages and in general leads to faster code for all programmers whether they are aware of inlining or not.

Although pointer data types in C# coding are less important than in other languages such as C++, C# does support developer defined pointers. Use the * operator to declare a pointer data type. Use the & operator to return the current address of a variable.

In .Net managed coding the use of pointers is not safe because the garbage collector may move memory around. To safely use pointers, use the unsafe keyword.

C++/CLI has more extensive support for pointers than C#. If you have needs that go beyond what C# offers, you can code in C++/CLI and add it to your project.

//Declare a pointer of type integer.

Integer *PCounter;

C# supports abstract class members and abstract classes using the abstract modifier. An abstract class is a class with one or more abstract members and you cannot instantiate an abstract class. However, you can have additional implemented methods and properties. An abstract member is either a method (implicitly virtual), property, indexer, or event in an abstract class. You can add abstract members ONLY to abstract classes using the abstract keyword.

abstract public class Cyborg : System.Object

{

  abstract public void Speak(string pMessage);

}

public class Series600 : Cyborg

{

  public override void Speak(string pMessage)  

  {

    MessageBox.Show(pMessage);  

  }

}

In C#, you specify each class and each class member's visibility with an access modifier. The C# access modifiers are the traditional public, protected, and private plus the two additional .Net modifiers internal and protected internal.

Internal indicates members are accessible from types in the same assembly. Protected internal indicates members are accessible from types in the same assembly as well as descendant classes. OO purist might object to internal and protected internal and I suggest you choose private, protected, or public over them until you both fully understand them and have a need that is best suited by them.

The default for class and class members is Internal (members are accessible from types in the same assembly). This is different than with interfaces where the default for an interface is Internal but an interface's members are always public -- which makes sense but is noteworthy.

With both classes and interfaces, if you make a class public, the members are public. This applies to the other access modifiers too. For example, if you make a class protected, the members default access modifiers are protected.

public class Cyborg

{

private String FName;

}

In C#, the Object keyword is an alias for the base System.Object class and is the single base class all classes ultimately inherit from.

//Specify both namespace and class:

public class Cyborg : System.Object 

{ }

//Use shortcut alias:

public class Cyborg : Object 

{ }

//None, default is System.Object

public class Cyborg

{ }

In C#, you use the class keyword to specify a class and you signify its parent with a colon and the name of the parent class. When you instantiate an object from a class, you use the new keyword.

Define class:

public class Cyborg : System.Object
{
  public virtual void IntroduceYourself()
  {
    MessageBox.Show("Hi, I do not have a name yet.");  
  }
}

Create object from class:

Cyborg T1 = new Cyborg();
T1.IntroduceYourself();

//No need to clean up with managed classes.

//The garbage collector will take care of it.

In C#, a constructor is called whenever a class or struct is created. A constructor is a method with the same name as the class with no return value and you can overload the constructor. If you do not create a constructor, C# will create an implicit constructor that initializes all member fields to their default values.

Constructors can execute at two different times. Static constructors are executed by the CLR before any objects are instantiated. Regular constructors are executed when you create an object.

public class Cyborg
{
  public string CyborgName;

  //Constructor.

  public Cyborg(string pName)
  {
    CyborgName = pName;
  }
}

Use a destructor to free unmanaged resources. A destructor is a method with the same name as the class but preceded with a tilde (as in ~ClassName). The destructor implicity creates an Object.Finalize method (you cannot directly call nor override the Object.Finalize method).

In C# you cannot explicitly destroy an object. Instead, the .Net Frameworks garbage collector (GC) takes care of destroying all objects. The GC destroys the objects only when necessary. Some situations of necessity are when memory is exhausted or you explicitly call the System.GC.Collect method. In general, you never need to call  System.GC.Collect.

class Cyborg {
public:
  //Destructor for class Cyborg.
  ~Cyborg();

  {

  //Free non-managed resources here.

  }
};

C# does not support multiple implementation inheritance. Each class can have only one parent class (a single inheritance path). In C#, you can use multiple interface usage to design in a multiple class way horizontally in a class hierarchy.

Classes and structs can inherit from interfaces in a manner similar to how classes can inherit a base class or struct, but a class or struct can inherit more than one interface and it inherits only the method names and signatures, because the interface itself contains no implementations.

class MyClass: IMyInterface

{  

  public object Clone()
  {
  return null; 
  }  

// IMyInterface implemented here...
} 

interface IMyInterface

{

  bool IsValid();

}

In C# you can set the visibility of a member field to any visibility: private, protected, public, internal or protected internal.

You can intialize a member field with a default when declared. If you set the member field value in your constructor, it will override the default value.

Finally, you can use the static modifier (no instance required) and readonly modifier (similar to a constant).

public class Cyborg : System.Object
{

  private string serialNumber = "A100";

  public string cyborgName; 
  public int cyborgAge = 0;
  public static readonly int seriesID = 100;
}

In C# you can set the visibility of a member field to any visibility: private, protected, public, internal or protected internal. You can intialize a member field with a default when declared. If you set the member field value in your constructor, it will override the default value. Finally, you can use the static modifier (no instance required) and readonly modifier (similar to a constant).

Define class:

public class Cyborg : System.Object
{
  public virtual void IntroduceYourself()
  {
    MessageBox.Show("Hi, I do not have a name yet.");  
  }
}

Create object from class:

Cyborg T1 = new Cyborg();
T1.IntroduceYourself();

The method modifiers are abstract, extern, new, partial, sealed, virtual, and override. Specify C# member modifiers as follows:

abstract SomeMethod() {..}

The field modifiers are const, readonly, static, volatile. Specify field modifiers as follows:

readonly int MyAge;

In C#, parens indicate a method and the lack of parens indicate a property. You use special get and set methods to both get and set the values of properties. For a read-only property, leave out the set method. The value keyword is used to refer to the member field. Properties can make use of any of the access modifiers (private, protected, etc). It is common to use a lowercase member names for member fields ("name" in our example) and uppercase properties to manage member fields ("Name" in our example).

public class Cyborg : System.Object
{
  private string cyborgName;

 
  public string CyborgName
  {
    get {return cyborgName;}
    set {cyborgName = value;}
  }
}

Method overriding allows you to define or implement a virtual method in a parent class and then replace it in a descendant class. In C#, you specify a virtual method with the virtual keyword in a parent class and replace it in a descendant class using the override keyword.

class Robot

{

  public virtual void Speak()

  {

  }
}
 

class Cyborg:Robot

{

  public override void Speak()

  {

  }
}

C# uses the keyword partial to specify a partial class. All parts must be in the same namespace.

A partial class, or partial type, is a class that can be split into two or more source code files and/or two or more locations within the same source file. Each partial class is known as a class part or just a part. Logically, partial classes do not make any difference to the compiler. The compiler puts the class together at compile time and treats the final class or type as a single entity exactly the same as if all the source code was in a single location.

You can use them for many things including to separate code generator code, organize large classes, divice a class up so you can split ownwership among multiple developers, have different versions of the same class, and to utilize multiple languages with a single class.

class partial Cyborg: System.Object

{

}

C# supports the following types of polymorphism:

• Parametric Polymorphism (Overloading)
• Inheritance-Based Polymorphism
• Interface-Based Polymorphism
• Ad-Hoc Polymorphism
  

With C#, use the sealed keyword to prevent a class from being inherited from and to prevent a method from being overridden.

A method marked sealed must override an ancestor method. If you mark a class sealed, all members are implicitly not overridable so the sealed keyword on members is not legal.

public class Machine : System.Object
{
  public virtual void Speak(String pSentence)
  {
    MessageBox.Show(pSentence);
  }
}
    
public class Robot : Machine
{
  public sealed override void Speak(String pSentence)
  {
    MessageBox.Show(pSentence);
  }
}

public sealed class Cyborg : Robot
{ 
}

To refer to the current instance of a class, use the this keyword. The this keyword provides a way to refer to the specific instance in which the code is currently executing. It is particularly useful for passing information about the currently executing instance.

The this keyword is also used as a modifier of the first parameter of an extension method.

You cannot use this with static method functions because static methods do not belong to an object instance. If you try, you'll get an error.

C# supports both static members and static classes using the static keyword. You can add a static method, field, property, or event to an existing class. Also, you can designate a class as static and the compiler will ensure all members in that class are static. You can add a constructor to a static class to initialize values.

The CLR automatically loads static classes with the program or namespace.

//Static Class Example
public static class MyStaticClass
{

  //Static Method Example

  public static void MyStaticMethod()
  {
  // static method code
  }

}

VB Classic supports a form of single level inheritance where you, in essence, create an abstract class and then implement it in one or more classes that inherit from the abstract class. However, you cannot have any further descendant classes so "prevent derivation" is implemented by design of this simple inheritance model.

VB.Net is not case sensitive. If you type any other case for commands or variables, VB.Net will change it to the accepted or defined case. For example, if you type messagebox.show it is converted to MessageBox.Show.

The following code works:

MessageBox.Show("hello")

VB.Net, like VBClassiccode blocks, are surrounded by statement ending keywords that all use End such as End Class, End Sub, End Function, End If, and End If.

Public Class Dog

End Class

Protected Sub MySub

End Sub

Public Shared Function MySharedFunction() As Integer
 MySharedFunction = 12345
End Function 

If x Then

End If

The .Net framework offers a static method in the string class: String.IsNullOrEmpty.

Dim s As String 

's = "" 'Uncomment to test 2nd case.

If String.IsNullOrEmpty(s) Then
  MessageBox.Show("hello")
End If

Common source code file extensions include:

• .SLN - Solution File. Contains solution specific information such as links to the projects within this solution.
• .VBPROJ - VB.Net Project File. Contains project specific information.
• .VB -VB.Net source file.
• .Designer.VB -VB.Net form file (a text resource file).

//Sample code snippet from the .vbproj project file:

<ItemGroup>
  <Compile Include="Cyborg.vb" />
  <Compile Include="Form1.vb">
    <SubType>Form</SubType>
  </Compile>

  //...

Same as VB classic.

If x Then
  MessageBox.Show("hello")
ElseIf Not x Then
  MessageBox.Show("goodbye")
Else
  MessageBox.Show("what?")
End If

The above usage of Left and Substring are equivalent.

Left is a traditional VB approach popular with developers moving from VB Classic to VB.Net. Substring is considered the .Net way of doing string manipulation.

Dim FullName

FullName = "Prestwood"
Console.WriteLine("Hello " + Left(FullName, 4))
Console.WriteLine("Hello " + FullName.Substring(0, 4))

By Reference or Value
For parameters, you can optionally specify ByVal or ByRef. ByVal is the default if you don't specify which is changed from VB Classic (in VB Classic, ByRef was the default).

Private Function Add(ByRef a As Integer, _
  ByRef b As Integer) As Integer
  Add = a + b
End Function

Languages Focus: Assignment

Common assignment operators for languages include =, ==, and :=. An assignment operator allows you to assign a value to a variable. The value can be a literal value like "Mike" or 42 or the value stored in another variable or returned by a function.

Dim Age As Integer

Dim FullName As String

FullName = "Randy Spitz"
Age = 38

Languages Focus: Comments

Commenting code generally has three purposes: to document your code, for psuedo coding prior to coding, and to embed compiler directives. Most languages support both a single line comment and a multiple line comment. Some languages also use comments to give instructions to the compiler or interpreter.

'Single line comment.
 

REM Old school single line comment.

In VB.Net, you define constants with the Const keyword.

All constants are part of a class (no global constants) but you can make a constant public and have access to it using ClassName.ConstantName so long as you have added the class to the project. This works even without creating the class as if the public constants were static, but you cannot use the Shared keyword.

Constants must be of an integral type (sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, or string), an enumeration, or a reference to null.

Public Class Convert
  Inherits System.Object

  Public Const kName As String = "Mike"

  Private Const kPI Double = 3.1459

  //Declare two or more on same line too:
  Const kFeetToMeter = 3.2808, kMeterToFeet = 0.3048
End Class

VB.Net projects require the .Net framework and any additional dependencies you've added such as Crystal Reports.

In Visual Studio.Net, you can create a Setup and Deployment project by using any of the templates available on the New Project dialog (Other Project Types).

In addition, VB.Net projects also support ClickOnce which brings the ease of Web deployment to Windows Forms and console applications. To get started, right click on your solution in the Solution Explorer, click Properties then select the Security tab. 

In addition, you can use any of the many free and commercially available installation packages.

Languages Focus: Development Tools

Primary development tool(s) used to develop and debug code.

Languages Focus: End of Statement

In coding languages, common End of statement specifiers include a semicolon and return (others exist too). Also of concern when studying a language is can you put two statements on a single code line and can you break a single statement into two or more code lines.

Console.WriteLine("Hello1")
Console.WriteLine("Hello2")
Console.WriteLine("Hello3")
 
'The following commented code 
'on a single line does not work...
'Console.WriteLine("Hello4")  Console.WriteLine("Hello5")
 
'Two or more lines works too with a space+underscore:
Console.WriteLine _
 "Hello6";

General Info: Programming Literals

A value directly written into the source code of a computer program (as opposed to an identifier like a variable or constant). Literals cannot be changed. Common types of literals include string literals, floating point literals, integer literals, and hexidemal literals. Literal strings are usually either quoted (") or use an apostrophe (') which is often referred to as a single quote. Sometimes quotes are inaccurately referred to as double quotes.

Languages Focus: Literals

In addition to understanding whether to use a quote or apostrophe for string literals, you also want to know how to specify and work with other types of literals including floating point literals. Some compilers allow leading and trailing decimals (.1 + .1), while some require a leading or trailing 0 as in (0.1 + 0.1). Also, because floating point literals are difficult for compilers to represent accurately, you need to understand how the compiler handles them and how to use rounding and trimming commands correctly for the nature of the project your are coding.

Console.WriteLine("Hello")
Console.WriteLine("Hello ""Mike"".")

'Does VB.Net evaluate this simple

'floating point math correctly? No! 

If (.1 + .1 + .1) = 0.3 Then
  MsgBox "Correct"
Else
  MsgBox "Not correct"
End If

Language Overview: VB.Net is an OOP language (no global functions or variables). You code using a fully OOP approach (everything is in a class).

Target Platforms: VB.Net is most suitable for creating any type of application that runs on the .Net platform. This includes desktop business applications using WinForms and websites using WebForms.

Microsoft includes ReportViewer Starting with Visual Studio 2005. You can even surface this .Net solution in your VB Classic application if you wish. For WebForm applications the client target is the browser (a document interfaced GUI), a common solution is to simply output an HTML formatted page with black text and a white background (not much control but it does work for some situations). For WinForm applications, Crystal Reports is still very popular with VB.Net developers because it has been bundled with Visual Basic since VB 3, it's overall popularity, and compatibility with many different development tools.

Most (many?) developers recommend using "+" because that's what C# uses but "&" is also available and many VB Classic and VBA/ASP developers prefer it. My preference is to use the & because it offers implicit type casting.

Dim FullName

Dim Age

//You can use + for strings.

FullName = "Prestwood"
Console.WriteLine("Hello " + FullName)

//For implicit casting, use &

Age = 35

Console.WriteLine(FullName & " is " & Age & " years old.")

'Implicit casting of numbers.

'

'This works:
MessageBox.Show(3.3)

'This fails:

'MessageBox.Show("" + 3.3)

'This works:
MessageBox.Show("" + CStr(3.3))

'Implicit casting &. This also works:

MessageBox.Show("" & 3.3)

Variables are case sensitive but VS.Net will auto-fix your variable names to the defined case. You can declare variables in-line wherever you need them and declarative variable assignment is supported.

Dim FullName As String
Dim Age As Integer
Dim Weight As Double
FullName = "Mike Prestwood"
Age = 32
Weight = 154.4
'Declaritive variable assignment: 
Dim Married As String = "Y"
MsgBox(Married)