C# and JavaScript Cross Reference Guide

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.

 C# Deployment Overview

Microsoft Visual C# and the full version of Microsoft Visual Studio.Net are the current primary tools. CodeGear does have C#Builder but it's not a primary tool currently and development on the tool has slowed in recent years.

Many developers just use a text editor. There are JavaScript editors available including 1st JavaScript Editor, Antechinus JavaScript Editor Professional, and SplineTech JavaScript Debugger PRO.

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. When you add a file containing one or more classes, it is added to this file.
• .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>

  //...

.js is the common standard for browser-side JavaScript and .jsp is the common standard for server-side JavaScript.

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 .Net Framework applications. This includes desktop business application using WinForms and websites using WebForms.

Language Overview: Class-like language with limited but usable class-like and object-like functionality but no formal inheritance nor visibility control, etc.

Many developers are hoping the next version of JavaScript will be a fully OOP language. If you're a working OO developer and need to use JavaScript in an OO manor now, there are many books that help you simulate OOP. One such book we recommend is Pro JavaScript Design Patterns.

Target Platforms: JavaScript is most commonly used to extend HTML by executing code on the browser side when visiting a website. It does have other uses including server side scripting and AJAX.

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# Report Tools Overview

No built-in report writer but because JavaScript most frequently targets website development (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).

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)  

JavaScript is case sensitive. Change the case, and it no longer works! Notice the "W" in "Write" is capitalized.

<script language=JavaScript> 
<!--
document.Write("Hello"); //Does not work! 
//--> 
</script>

Variable names are case sensitive.

<script language=JavaScript> 
<!--
document.write("Hello"); 
//--> 
</script>

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;

}

In html pages, you embed JavaScript code between <script> and </script> (see example). Also it's tradtional to put an HTML comment around your code too so that really old browsers don't crash (probably not all that important these days).

For JavaScript, Java, PHP, and C++, 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 moreJavaScript codeformatted that way.

<script language="JavaScript" type="text/javascript">

<!--

function DisplayDialogLg(StrURL) {
}

if (x == -1) {

}

-->

</script>

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

//Single line comment.

/*
Multiple line
comment.

*/

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

//This is a single line comment.
 
/*
Multiple line
comment.

*/

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

Although JavaScript has variables, it does not have constants.

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

In JavaScript, using a semicolon at the end of statements is optional. You might think a semicolon then is just another comment specifier but it is not. The semicolon is an optional end of statement specifier. To put two statements on a single code line, you must use a semicolon. However, the semicolon is optional, but probably confusing, when you break a single statement into multiple code lines.

document.write("Hello1");
document.write("Hello2");
 
//Semicolons are optional:
document.write("Hello3")
document.write("Hello4")
 
//This works too but only if you use a semicolon:
document.write("Hello5");  document.write("Hello6");
 
//Two lines also works:
document.write
  ("Hello7")

 JavaScript End of Statement (; is optional)

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 use either an apostrophe (also known as a single quote) as in 'Prestwood' or quoted as in "Prestwood". If you need to embed an apostrophe in an apostrophe-literal or a quote in a quoted-literal, precede it with a slash as in \' and \".

Alert("Hello");

Alert("Hello \"Mike\".")

Alert('Hello');

Alert('Hello Mike\'s website.')

//Does JavaScript evaluate this simple

//floating point math correctly? No! 

if ((.1 + .1 + .1) == .3) {
 document.write("Correct")
} else {
 document.write("Not correct")
}

 JavaScript Literals (quote or apostrophe)

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;

JavaScript is a loosely typed language. Each variable is cast in usage as string, number, boolean, function, or object.

Variable names are case sensitive.

Alternatively, you can specify the value when you declare a variable:

var FirstName = "Mike";

var LastName = "Prestwood";

var Age = 42;

var FirstName;

var LastName;

var Age;

C# requires () in both the function declaration, and when it's invoked. Leave off the parens to signify a property.

ReturnType RoutineName()

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

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

JavaScript uses functions and loosely typed parameters. Function definitions must come before their usage so the usual preference when adding JavaScript to HTML pages is to include them between the head tags.

function SayHello(pName) {
 document.write("Hello " + pName + "<br>");
}

function add(p1, p2) {
 var result;
 
 result = p1 + p2;
 return result;

}

 JavaScript Custom Routines (function)

The JavaScript event handler contains events centered around the Document Object Model (DOM). Common events include onMouseOver and onMouseOut, onFocus and onBlur, onClick and onDblClick, onChange and onSelect, onLoad and onUnload.

For example, onMouseOver and onMouseOut are frequently used with websites to change an image when your mouse moves over it. The onClick event is used to trigger code upon a mouse click.

<img id="Image1" src="i_search.gif"

 onmouseover="document.images['Image1'].src='i_coat.gif';"

 onmouseout="document.images['Image1'].src='i_search.gif';">

 JavaScript Event Model

Since all the .Net languages compile into intermediate language (IL), and not to a specific CPU, they do not provide support for inline assembler code.

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.

C# supports both method and operator overloading.

For methods, C# supports implicit overloading (no need for an overload keyword).

 C# Overloading (implicit)

JavaScript Overloading

• Operator - No.
• Method -

 JavaScript Overloading

In C# the data type of each parameter must be specified, even if adjacent parameters are of the same type. To pass a parameter by reference, use the ref or out keyword.

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.

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. However, avoid unsafe code if possible.

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;

JavaScript does not offer developer defined pointers. However, you can use the eval function to simulate pointers.

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

 C# Exception Trapping (try...catch...finally)

See "throw" to raise (throw) an error.

try {

  //Do something.

}

catch(e) {        //one or more.

  //Do something.

}

finally {         //0 or one.

  //Do something.

}

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

Same as C/C++ but, as usual, the semicolons are optional.

var x = 8;

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

C# uses = for it's assignment operator.

int Age;

string FullName;

  
Age = 42;

FullName = "Randy Spitz";

JavaScript uses = for it's assignment operator.

//Regular assignment.

LastName = 'Spitz';

//Variable declaration with assignment.

var FullName = 'Randy Spitz';

var Age = 38;

 JavaScript Operators

Common comparison operators:

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

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

Common comparison operators:

//Does JavaScript evaluate the math correctly? No!

if (.1 + .1 + .1 == .3) {
  document.write("correct");
}
else {
  document.write("not correct");
}

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

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

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

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

{

  //Do something.

}

JavaScript logical operators:

JavaScript always short circuits. Given the expression this || that, if this evaluates to true, then that is never executed.

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

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

  //Do something.

}

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

To concatenate two strings, a string to an integer, or a string to a floating point number, use the + operator. JavaScript performs implicit casting when concatenating a string and a number. For example, to convert a floating point number to a string just concatenate an empty string to the number as in "" + 3.2.

 

// -->

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

 C# Unary Operators

An operation with only one operand (a single input). JavaScript unary operators include ++ and --. They can be used either before or after a variable as in: a++, b--, and ++a, and --b.

Examples:

iCounter++;

iCounter--;

++iCounter;

--iCounter;

var iCounter=0;

for (iCounter=0;iCounter<=5;iCounter++)
{
  document.write("Count is " + iCounter + "<br>");
}

 JavaScript Unary Operators

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

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

Above returns "Mike P".

SubStr(StartIndex, NumberOfCharacters)

Notice JavaScript is 0 based (the first character is character 0).�0 is start character, 6 is number�of characters).�

You can also use substring where both numbers are indexes:

SubString(StartIndex, EndIndex)

The following returns "re".

var sName;
sName = "Mike Prestwood";
sName = sName.substring(6, 8);
document.write(sName); 

var sName;
sName = "Mike Prestwood";
sName = sName.substr(0, 6);
document.write("Hello " + sName);

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.

Syntax Example:   //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.

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

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

//No need to clean up with managed classes.

//The garbage collector will take care of it.

 C# Class..Object (class...new)  

Creating classes in JavaScript is not really OOP, but rather a super type. That is, a type that has some class-like features but is missing the necessary OOP requirements.

There is nothing in Javascript to stop you from accessing the functions within your class outside of the class so this is not fully OOP but is usable.

//Class definition.

function Person() {
this.name = 'unknown';
this.age = 0;
}

//Use object created from class.

var Lisa = new Person();

Lisa.name='Lisa';

Lisa.age=28;

In C#, you use the class keyword followed by the parent class after a colon. If you leave out the parent class, your class inherits from System.Object.

public class Android

{

}

public class T-600 : Android

{

}

 C# Inheritance (: ParentClass)

JavaScript does not offer a formal inheritance machanism. There are some tricks some developers are fond of.

 JavaScript Inheritance (No, but sort of.)

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

 C# Member Field  

In C#, you indicate a method with parens, no parens indicates a member property. Use the void return type for methods that do not return a value.

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

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

 C# Member Method

Not fully OOP as you can call the method outside of the class.

function Dog() {

  //Class variables here.

  this.prototype.bark = function() {
  //Class method code here.
  }
} 

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.

C# 3.0 introduced auto-implemented properties for use when no additional logic is required.

pulic int VendorID {get; set;}

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

 C# Member Property (no (), get, set)  

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.

public class Cyborg

{

private String FName;

}

 C# Access Modifiers  

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. Then you override it in a descendant class with Override.

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

  }

}

 C# Abstraction (abstract, override)  

However, developers sometimes use the term "class helper" to refer to code that helps out a class. Not truly the meaning we are using here, but you should be aware of the term's general usage.

Although not currently supported, there are plans for the next version of VS.Net and .Net using Requires and Ensures keywords. Look for code contracts in VS.Net 2010 and .Net 4.

• Read About It: Introduction to Code Contracts

If you code with VS.Net 2008 Pro or above and wish to implement contracts now, checkout the following download:

• Managed Contract Tools

//Future syntax may look something like:

string SetAge(int pAge) { 
  Contract.Requires(pAge>0);
}

string GetAge() { 
  Contract.Ensures(Contract.Result() != null);

}

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

 C# Constructors (Use class name)  

In C# you cannot explicitly destroy a managed object. Instead, the .Net Framework's 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().

In .Net, a finalizer is used to free non-managed objects such as a file or network resource. In C#, a finalizer is a method with the same name as the class but preceded with a tilde (as in ~ClassName). The finalizer method implicity creates an Object.Finalize method (you cannot directly call nor override the Object.Finalize method). 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.

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

  {

  //Free non-managed resources here.

  }
};

 C# Finalizer (~ClassName)  

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.

There is a trick to fake one descendant class multiple inheritance. Not really worth exploring though but...inside a constructor, call another constructor function. The new object instance will inherit any properties and methods defined in that constructor. However, the new object will not inherit methods defined in the second constructor's prototype chain.

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();

}

 C# Interfaces (interface)

In C#, you specify a virtual method with the virtual keyword in a parent class and extend (or replace) it in a descendant class using the override keyword.

Use the base keyword in the descendant method to execute the code in the parent method, i.e. base.SomeMethod().

class Robot

{

  public virtual void Speak()

  {

  }
}
 

class Cyborg:Robot

{

  public override void Speak()

  {

  }
}

 C# Overriding (virtual, override)

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

class partial Cyborg: System.Object

{

}

 C# Partial Classes (partial)  

C# supports the following types of polymorphism:

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

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
{ 
}

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
  }

}

 C# Static Members (static)