Cross Ref > Language Basics

In C# commands and variable names are case sensitive. The following does NOT:

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

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.

MessageBox.Show("hello");

 C# Case Sensitivity (Yes)  

Object Pascal is generally not case sensitive.

Syntax Example:   Variables and commands are not case sensitive. var FullName: String; begin fullname := 'Mike Prestwood'; ShowMessage(fullNAME); SHOWMESSAGE(FULLNAME); showmessage(fullname); end;

 Camel versus Pascal Casing

C# uses braces {} to indicate a code block of more than one line. For one line of code, the braces are optional.

I prefer to put the opening { and the closing } on their own line only because most of the examples I see do this. As opposed to C++, Java, and JavaScript where I put the opening bracket at the end of the first line (which I actually prefer).

int DoSomething()

{

 int a = 1;

 int b = 2;

 return a + b;

}

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;

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

//Single line comment.

/*
Multiple line
comment.

*/

Commenting Code
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.

Compiler Directives - $
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}

 Delphi Comments (// or { ... } or (* ... *))  

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 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 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.

Syntax Example:   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; }

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;

 Delphi Constants (Const kPI: Double=3.1459;)  

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.

Syntax Example:   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");

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

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

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

To specify a floating point literal between 1 and -1, you can preceed the decimal with a 0 or not (both work). In other words, preceding decimals are allowed (both .1 and 0.1). Trailing decimals are not allowed.

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");
}

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

Floating point literals must start with an integer. For example, 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.

//x := .1 + .1;   //Does not work.

x := 0.1 + 0.1;   //Does work.

Syntax Example:   ShowMessage('Hello'); ShowMessage('Hello Mike''s website.');

 Ref: https://forums.codegear.com/thread.jspa?threadID=8909&tstart=60

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;

The Delphi language is a strongly typed language so you have to specifically declare variables and frequently use commands such as IntToStr and StrToInt.

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.

Note: D2009 introduced a new UnicodeString type.

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;

 Delphi Variables (var x: Integer = 0;)