C# - The Beautiful “Chord” of Computing
Seth Waldrop
CSC 415 – Programming Languages
Dr. Bill Lyle
November 8, 2011
C# - The Beautiful “Chord” of Computing
History of C#
Introduction
In the late 1990s, Microsoft introduced the .NET Framework initiative. This initiative
was designed to fulfill the following objectives:






To provide a consistent object-oriented programming environment whether object code is
stored and executed locally, executed locally but Internet-distributed, or executed
remotely.
To provide a code-execution environment that minimizes software deployment and
versioning conflicts.
To provide a code-execution environment that promotes safe execution of code, including
code created by an unknown or semi-trusted third party.
To provide a code-execution environment that eliminates the performance problems of
scripted or interpreted environments.
To make the developer experience consistent across widely varying types of applications,
such as Windows-based applications and Web-based applications.
To build all communication on industry standards to ensure that code based on the .NET
Framework can integrate with any other code. (Microsoft, Inc., 2011)
In February 2002, Microsoft released version 1.0 of the .NET framework. As years
progressed, Microsoft has released various updates and newer versions (See Appendix A),
culminating with the current version, .NET-4.0.
Object-oriented programming, or OOP, wasn’t a new trend, as the idea had been around
as early as the 1950s (McCarthy, 2011). However, with the advent of Microsoft’s .NET
Framework came an influx of newer object-oriented languages. Thus, C# emerged.
C# was developed by Microsoft Corporation as part of their .NET initiative. And it was
actually developed “in response to the success of Sun Microsystems' Java programming
language,” (C# Online.Net, 2011). C# has been derived from C, C++, and Java, and some
concepts of Microsoft’s Visual Basic also went into the making of this language. (C# Online.Net,
2011).
C# - The Beautiful “Chord” of Computing
The “primary architects of C# were Peter Golde, Eric Gunnerson, Anders Hejlsberg,
Peter Sollichy, and Scott Wiltamuth.” Of these, Anders Hejlsberg was the principal designer and
lead architect. Hejlsberg’s “pedigree” is rather prominent, including experience in designing the
framework of J++ (Microsoft’s old version of Java), as well as Delphi and Turbo Pascal (C#
Online.Net, 2011).
It is also interesting to note that, “both C# and the Common Language Infrastructure
(CLI) have been submitted to international standards organizations European Computer
Manufacturers Association (ECMA) and International Organization for Standardization (ISO) /
International Electrotechnical Commission (IEC),” (C# Online.Net, 2011).
Design Goals
C#’s developers had a number of design goals in mind for the language, including:
 C# is intended to be a simple, modern, general-purpose, object-oriented programming
language.
 The language, and implementations thereof, should provide support for software
engineering principles such as strong type checking, array bounds checking, detection
of attempts to use uninitialized variables, and automatic garbage collection. Software
robustness, durability, and programmer productivity are important.
 The language is intended for use in developing software components suitable for
deployment in distributed environments.
 Source code portability is very important, as is programmer portability, especially for
those programmers already familiar with C and C++.
 Support for internationalization is very important.
 C# is intended to be suitable for writing applications for both hosted and embedded
systems, ranging from the very large that use sophisticated operating systems, down
to the very small having dedicated functions.
 Although C# applications are intended to be economical with regard to memory and
processing power requirements, the language was not intended to compete directly on
performance and size with C or assembly language.
(C# Online.Net, 2011)
C# - The Beautiful “Chord” of Computing
Versions
C# has, of course, come a long way from its initial release in 2000 (C# Online.Net,
2011). Much like the .NET Framework, C# has released various versions. In fact, the release
dates for each version of C# is almost identical to that of each subsequent version of the .NET
Framework (Compare Appendices A and B). With each version release came, as one would
expect, more functionality not offered before, as well as improved functionality on what was
already offered. The current version—C#-4.0—will be used as the scope of this evaluation.
However, it is imperative, in evaluating the current state of a language, to see not only where the
language is now, but also where it has been. Thus, in Appendix C there is a comparative list of
the “highlights” each of versions 2.0 and 3.0, respectively, brought to the table.
Overview of C# Language Design, Syntax, and Semantics
Names, Bindings and Scopes
As the program is built, it is always best to have consistency in the naming of variables,
methods, etc. Having a consistent naming convention does absolute miracles for the readability
of one’s code, regardless of what language he/she is typing in. Typically a coding convention is
decided upon by a particular company or team; however, it is becoming more and more common
to see a more standardized naming convention in the software development arena. Following is
the common standard among C# programmers today.
Private variables should be prefixed with an underscore (_) character and the words
should follow a “camel-case” format. An example of this is: “_privateVariable”. (Zahn, 2003)
Local variables should follow the camel-case format, as well. Essentially, they will look
the same as the private variables, except without the underscore: “localVariable”. (Zahn, 2003)
C# - The Beautiful “Chord” of Computing
Namespaces will follow the pascal-case format, and one should develop distinguishable
names in attempt to prevent (or lessen) the possibility of having “two published namespaces with
the same name.” (Zahn, 2003) An example is: “System.Windows.Data”.
Classes should be named also using the pascal-case format. Classes should also be
named using a noun or noun phrase: “SampleClassName”. (Zahn, 2003)
Interfaces should be prefixed with an “I” and should also use pascal-casing. Neither
interfaces nor classes should use an underscore character. An example of an interface name is:
“IExampleInterface”. (Zahn, 2003)
Method names should be verbs or verb phrases and should use the pascal-casing format,
such as: “SampleMethod();”. (Zahn, 2003)
Properties should also be in pascal-case format: “SampleProperty”. (Zahn, 2003)
Event handlers should be in pascal-case, and have the EventHandler suffix attached to it;
the EventArgs suffix should also be tied to the end of the second parameter in the event handler
method (discussed later under “Exception Handling and Event Handling”. A sample event
handler is: “SampleEventHandler( object sender, SampleEventArgs e)”. (Zahn, 2003)
An exception object (also discussed under “Exception Handling and Event Handling”) is
typically given the name “ex”. (Zahn, 2003)
As far as variables go, the naming of them used to vary based on what type they were (for
instance a variable of "int" type would be prefixed with an “i”). However, in my own
experience, Microsoft has most recently begun using the type as the suffix in the name. For
example: “int newSampleInt;” or possibly: “string newSampleString;”. (Zahn, 2003)
C# - The Beautiful “Chord” of Computing
Scopes in C# are determined on a run-time basis. So as long as whatever is being called
is in scope when it is called, the program will run smoothly. For instance, the example shown
below has two scoping issues.
public void Method1()
{
int a;
while (...)
{
double a, b;
}
int sum = a + Convert.ToInt32(b);
}
The variable “a” is declared inside of Method1. Then, “a” is also attempting to be declared
inside the while loop. The compiler complains about this because “’a’ is already declared in this
scope, and this new ‘a’ would change the meaning of the ‘a’ already declared in scope. So even
though the ‘a’ inside the while loop is declared as type double, the compiler still won’t allow it
because the variable ‘a’ is already declared in the “current scope.” The second issue the
compiler complains about is using the ‘b’ outside of the while loop. Because ‘b’ is a variable
local to the while loop, anything outside of the while loop cannot access it. However, anything
inside of the while loop (including another nested loop) can access it. To make a workable
solution (at least scope-wise), we would need to change the above code to the following:
public void Method1()
{
int a;
while (...)
{
double b;
int sum = a + Convert.ToInt32(b);
}
}
C# - The Beautiful “Chord” of Computing
Data Types
C# distinguishes between two categories of data types: value types, and reference types.
(Wrox, 2010, p. 31) It is interesting to note that “some C# types have the same names as C++
and Java types but have different definitions,” (Wrox, 2010, p. 31). An example of this is
looking at the “int” type. In C#, “int” is always a 32-bit signed integer. However, in C++, “int”
is a signed integer, “but the number of bits is platform-dependent,” (Wrox, 2010, p. 31). In
looking to the future possibilities of porting C# and .NET to other platforms, all data types in C#
have been designed to be “platform-independent,” (Wrox, 2010, p. 31).
C# supports the use of eight different predefined integer types (Wrox, 2010, p. 31).
These are listed in Appendix D, under “Integer types.”
Two floating-point types are also supported in C#: float (32-bit single-precision floating
point) and double (64-bit double-precision floating point). (Wrox, 2010, p. 32)
Decimal, Boolean, and character types are also supported. These types and their values
can also be found in Appendix D, under their respective labels. (Wrox, 2010, pp. 32-33)
Two categories of predefined reference types are supported in C#: object and string.
(Wrox, 2010, p. 33) The object type, in C#, is the “ultimate parent type from which all other
intrinsic and user-defined types are derived,” (Wrox, 2010, p. 36).
The string type, at a glance, appears to be a value type:
string sampleString = "Hello";
However, what is going on “behind the scenes” is the string object is placed on the heap, not the
stack. (Wrox, 2010, p. 36) So “when you assign one string variable to another string, you get
two references to the same string in memory,” (Wrox, 2010, p. 36). Interestingly, though, strings
are “immutable,” meaning that if you have the following code:
string sampleString = "Hello";
string newString = sampleString;
C# - The Beautiful “Chord” of Computing
sampleString = "World";
The result would produce sampleString as “World” and newString as “Hello.” Since newString
was assigned “sampleString,” you would expect (since string is a reference type) that when we
change sampleString’s value, the value of newString would also change. However, this is not
the case, as newString is still assigned the same string as originally assigned.
Expressions and Assignment Statements
There are various operators available in C#. Unary operators include plus (+), minus (-),
increment (++), decrement (--), logical negation (!), and bitwise complement (~). (CSharpHelp,
2006) The plus, minus, increment and decrement operators operate as one would typically think.
The logical negation operator is used to invert a Boolean result. For instance if you wanted to
run a loop while a bool variable “x” was not true, you would write “!x”. The bitwise
complement operator simply inverts the binary representation of an expression (switching the 1’s
to 0’s, and vice versa), (CSharpHelp, 2006).
Binary operators supported in C# include multiplication (*), division (/), remainder (%),
addition (+), subtraction (-), left shift (<<), and right shift (>>), (CSharpHelp, 2006). These
operators, likewise, do their respective operations as you would expect. As a note, the left and
right shift perform a shift in the binary representation of a specified object either left or right
(respectively) a specified number of positions.
Relational operators include the standard equal (==), not equal (!=), less than (<), greater
than (>), less than or equal to (<=), and greater than or equal to (>=), (CSharpHelp, 2006). The
equal and not equal operators tend to be difficult initially to programmers new to the language—
a common mistake is to only put one “=” sign when two are necessary. Also, with the not equal
operator comes more trouble with new-to-the-language programmers: a lot of languages use the
C# - The Beautiful “Chord” of Computing
“/=” to represent not equal, thus a reconditioning process must ensue, just as in learning any
other new language.
Assignment statements in C# are very straightforward. A simple “=” is used. (Microsoft,
Inc., 2011) This can be compared to the assignment operator in Ada: “:=”. Examples of
assignment statements have been used throughout this evaluation (see above for examples).
Operators coupled with the equal sign (such as +=, *=, %=, etc.) provide a shorthand for
the programmer to write assignment statements based on the respective operator used. For
instance, instead of writing “x = x + y” the programmer could instead choose to write “x += y”
and get the same result. Likewise, for finding something such as the remainder of integer
division (%), one can write “x %= y” instead of “x = x % y.” (Microsoft, Inc., 2011)
Statement-Level Control Structures
Flow control in C# is supported through three major categories: conditional statements,
loops, and jump statements.
The “if” statement is very intuitive and simple. First, you are not required to have a
“then”, “else”, or “end if”, or any other key words within the statement as some languages
require. If the statement can be included in one line, it doesn’t even need curly braces ({ }) to
enclose it. However, a common practice, for consistency and readability, is to include the curly
braces anyway. C# does not have a designated key word for a condition “elsif” as in other
languages. However, it does support the same idea by starting another “if” statement. An
example is shown below:
int x = 4;
if (x > 5)
{
...
}
else if (x < 5)
{
C# - The Beautiful “Chord” of Computing
...
}
else
{
...
}
(Wrox, 2010, pp. 37-38)
Another way to go about coding a conditional statement in C# is using the “switch-case”
combination. The switch statement evaluates the state of a specified parameter and tests to see if
the value of the parameter is equal to any of the “cases” that are within the switch block. If a
case is satisfied, the code directly following the case will execute. Otherwise, if none of the
cases are satisfied, the “default” case will execute. Below is an example:
int x = 3;
switch (x)
{
case 1:
...
break;
case 3:
...
break;
default:
...
break;
}
Notice the “break” key word. Some may think this is a hassle, but it prevents the classic case of
“fall-through” errors within the program. The only exception where “fall-through” is still
possible is if the case is empty. (Wrox, 2010, p. 39)
Looping in C# is also very powerful. The “for” loop provides the opportunity to iterate
through a loop where a condition is tested before each iteration. The following is the equivalent
of “for i = 0 to 99” in VB:
for (int i = 0; i < 100; i++)
{
}
(Wrox, 2010, p. 41)
The “while” loop in C# is a pretest loop that takes only one expression argument:
C# - The Beautiful “Chord” of Computing
while (condition)
{
}
(Wrox, 2010, p. 42)
The “do…while” loop is very similar to the aforementioned “while” loop, except it is the
post-test counterpart:
do
{
} while (condition)
(Wrox, 2010, p. 42)
Lastly, C# offers the “foreach” loop, which loops through each item in a specified
collection:
foreach (int i in integerArray)
{
}
(Wrox, 2010, p. 43)
We have already seen one of the “jump” statements (break). However, there are also
three others: goto, continue, and return. The “goto” statement allows the user to “jump” directly
to the specified line within the program, (Wrox, 2010, p. 43). The “continue” statement works
similarly to the “break” statement. However, it only “jumps” out of the current iteration, instead
of “jumping” out of the loop altogether, as “break” does, (Wrox, 2010, p. 44). The “return”
statement is “used to exit a method of a class, returning control to the caller of the method,”
(Wrox, 2010, p. 44). If the specified method has a return value, the value would be placed here
in code as well in the format “return value;” (Wrox, 2010, p. 44).
Subprograms
C# supports the use of subroutines via methods. Methods in C# are declared in either a
class or a struct, (Microsoft, Inc., 2011). The parameters of a method are located in parentheses
following the method name, (Microsoft, Inc., 2011). When a value type is passed as an
C# - The Beautiful “Chord” of Computing
argument, by default a copy of that value type is what is actually passed. This way, the original
copy isn’t affected by the changes to the argument. Reference types are passed into methods by
reference, naturally. This reference points directly to the original, so changes to the argument
does directly affect the original, (Microsoft, Inc., 2011).
The return type of a method is specified directly before the method name. Methods may
return types as mentioned in the “Types” section above, or they may also return “void.” If they
do not return “void, the method can return the value by using the return keyword,” within the
method, (Microsoft, Inc., 2011). An example method is shown below:
public int AddTwoNumbers(int number1, int number2)
{
return number1 + number2;
}
(Microsoft, Inc., 2011)
Abstract Data Types and Encapsulation Constructs
C# supports the use of abstract data types through its “var” type. “Var” is an “implicitly
typed local variable,” where the type is determined by the compiler, (Microsoft, Inc., 2011). The
compiler determines the type of the “var” variable by looking at what is assigned to it, and how it
operates. Essentially, the “looks-like-a-duck” principle applies here.
Access modifiers are supported in C# through four ways: public, protected, internal, and
private. Public access is the most permissive level of access, (Microsoft, Inc., 2011). In other
words, public members enforce no restrictions on access to its parts.
Protected access is next highest, in terms of restrictions on access to its members. It is,
“accessible within its class and by derived class instances,” (Microsoft, Inc., 2011).
Next up the ladder is internal access. Internal types or assemblies are accessible, “only
within files in the same assembly,” (Microsoft, Inc., 2011).
C# - The Beautiful “Chord” of Computing
Finally, there is private access, the most restricted access of them all. Private members
are accessible, “only within the body of the class or the struct in which they are declared,”
(Microsoft, Inc., 2011).
Support for Object-Oriented Programming
As stated in the design goals above, C# was designed to be a “simple, modern, general
purpose, object-oriented language.” So, naturally, it supports the object-oriented paradigm. C#
makes use of classes and structs to lay the “blueprint” of each respective type, (Microsoft, Inc.,
2011). Objects, then, are essentially “just a block of memory that has been allocated and
configured according to the blueprint,” (Microsoft, Inc., 2011). These structs and classes look
essentially identical to those in C++, for those familiar with C++, containing similarly coded data
members, constructors, etc.
Concurrency
Concurrency in C# is supported via the multi-threading capabilities. Concurrency is not a
new concept; however, with each release of the .NET framework, concurrency becomes less
work for the programmer as the framework takes on more and more of the “dirty work.” For
instance, in the .NET-4.0 framework, there is a “new namespace with collections that make it
easier to write multi-threaded programs that share data between threads,” (Wagner, 2011). This
new collection essentially does the majority of the work needed to “implement a
producer/consumer idiom,” in the applications you produce (Wagner, 2011).
C# - The Beautiful “Chord” of Computing
Exception Handling and Event Handling
The exception handling functionality of C# is incredible. C# makes use of its “try-catchfinally” block as a means for handling any “unexpected exceptions” that may arise in the
application, (Microsoft, Inc., 2011). This block of code essentially looks like this:
try
{
...
}
catch (Exception ex)
{
...
}
finally
{
...
}
The “try” portion is where you would put the code you want to attempt to execute. “Catch” is
triggered if any exceptions are thrown while attempting to run code in the “try” block. “Finally”
is used to basically clean up any resources used during the “try” block, (Microsoft, Inc., 2011).
Event handlers in C# look very similar to the layout of the methods, mentioned earlier.
Shown below is a sample event handler—auto-generated by Visual Studio—to handle a “mouse
click” event on a button:
private void AddButton_Click(object sender, RoutedEventArgs e)
{
...
}
The first parameter (sender) is what triggered the event to happen. The second parameter (e) is
used to hold data to be used in the event handler, (Dutta, 2002).
Evaluation of C#
Using Sebesta’s four criteria for evaluation (readability, writability, reliability, and cost),
we will now evaluate C#.
C# - The Beautiful “Chord” of Computing
Readability
C# is relatively easy to read. As with any new programming language, there will be time
needed to get used to the overall format. However, due to its similarity to C++ and Java, it is
very easy and manageable for one to move rather smoothly from these languages into C#.
Loops are simple and straightforward, contributing to the readability of C# code. Having
the iteration definitions conveniently located in one place at the beginning (or end, for the
“do…while” loop) contributes to this simple layout.
Exception handling is also fantastic to navigate through thanks to the “try-catch” block.
Event handling and methods are also easy to read with the use of a similar layouts for each.
Some would say the curly braces are not the easiest to read. However, I say they are a
plus. This is because the only time a curly brace is used is to open or close a block of code.
When you have a phenomenal IDE such as Visual Studio to assist in tabbing, and highlighting
correlating brackets and key words, you have an easy-to-read, and therefore easy-to-debug,
program.
Writability
Writability is arguably C#’s biggest strong point. Some concessions must be made in
that C# is case-sensitive, which may cause some writability issues, especially with programmers
coming from non-case-sensitive programming backgrounds. However, this is a minor sacrifice
that can be adjusted to rather quickly.
Being able to outline all iteration definitions for loops in one convenient parenthesized
statement makes defining the loop parameters a snap.
C# - The Beautiful “Chord” of Computing
Again, having a solid IDE such as Visual Studio really helps with the writability. Visual
Studio’s intellisense assists you with giving you options of what pieces of code are able to be
placed in the current location. In fact, from easily navigated file structures, to drag-and-drop
functionality, Visual Studio puts so much ease on the programmer. With other downloadable
add-ons and extensions that include features that check for spelling errors to even autogenerating code, Visual Studio makes programming (especially programming in C#) such a fun
experience.
Reliability
C# is a highly reliable language as well. As mentioned above, C# was designed with the
future in mind. It was designed with the capability to be ported across multiple platforms in the
future.
One of the best parts about C# is the fact that it is such a widely-used language—and
growing in users every day. This makes for a bountiful support group when you get stuck on
solving a problem or need to understand a particular part of the language. Namely, Microsoft’s
MSDN library of documentation is very thorough and includes exhaustive help guides and
sample code for nearly any and every part of the C# programming experience.
Cost
Cost is C#’s weakest point. Not so much the cost of learning. Learning the language is
relatively simple, especially if you’re coming from a background of C++ or Java. With all the
tutorials and help-guides on the Web today, learning the language is relatively easy.
The real cost comes into play with purchasing Visual Studio licenses. Visual Studio
2010 Professional costs $549 per license, (Microsoft, Inc., 2011). VS2010 Premium jumps up to
C# - The Beautiful “Chord” of Computing
$2299 per license, and Ultimate edition is priced at $3799 per license, (Microsoft, Inc., 2011).
One might say, “Why don’t you just get a different IDE for developing C# programs?” The
reality is it would be ill-advised to get an IDE other than Visual Studio for any .NET
development. And even though the cost is high, and it was even mentioned as the biggest
weakness of developing in C#, but it is well-worth the cost—especially with the functionality
Visual Studio comes with and how much more productive it allows you to be.
Conclusion
C# is a wonderful language. Of course, it’s not perfect—no programming language is
perfect. Although it has its downsides, there are a lot more positive notes about C# that
outweigh the negative. From the simplicity, to the exhaustive documentation, to the brilliant
IDE that is Visual Studio, there are many positive “notes” that make C# the beautiful “chord” of
computing.
C# - The Beautiful “Chord” of Computing
Appendices
Appendix A
Version
Version
Number
Release Date
Visual Studio
Default in Windows
Windows XP Tablet and Media Center
Editions[4]
1.0
1.0.3705.0
2002-02-13
Visual Studio .NET
1.1
1.1.4322.573
2003-04-24
Visual Studio .NET
Windows Server 2003
2003
2.0
2.0.50727.42
2005-11-07
Visual Studio 2005 Windows Server 2003 R2
3.0
3.0.4506.30
2006-11-06
Windows Vista, Windows Server 2008
3.5
3.5.21022.8
2007-11-19
Visual Studio 2008 Windows 7, Windows Server 2008 R2
4.0
4.0.30319.1
2010-04-12
Visual Studio 2010
4.5
4.5.40805
2011-09-13 (Developer
Preview)
Visual Studio '11'
Windows 8, Windows Server 8
(Wikipedia, 2011)
Appendix B
Version
C# 1.0
C# 1.2
C# 2.0
Language specification
ECMA
ISO/IEC
December
2002
April 2003
June 2006
September
2006
C# 3.0
Date
.NET Framework
Visual Studio
January 2002
January
2002
.NET Framework 1.0
Visual Studio
.NET 2002
October 2003
April 2003
.NET Framework 1.1
Visual Studio
.NET 2003
September
2005[note 1]
November
2005
.NET Framework 2.0
Visual Studio
2005
August 2007
November
2007
.NET Framework 2.0 (Except
LINQ/Query Extensions) [1]
.NET Framework 3.0 (Except
LINQ/Query Extensions) [2]
.NET Framework 3.5
Visual Studio
2008
Visual Studio
2010
April 2010
April 2010
.NET Framework 4
Visual Studio
2010
Microsoft
None[note 2]
C# 4.0
(Wikipedia, 2011)
1. The Microsoft C# 2.0 specification document only contains the new 2.0 features. For older
features use the 1.2 specification above.
2. As of December 2010, no ECMA and ISO/IEC specifications exist for C# 3.0 and 4.0.
C# - The Beautiful “Chord” of Computing
Appendix C
C#-2.0



A new form of iterator that makes use of co-routines by way of the “yield” key word,
similar to that found in Python.
Generics or parameterized types support some features not supported by C++ templates
such as type constraints on generic parameters.
Nullable value types facilitate interaction with SQL databases. Such as:
int? variableName = null;

Partial types allow the separation of a class implementation into more than one source
file.
(C# Online.Net, 2011)
C#-3.0



Anonymous types: tuple types automatically inferred and created from object initializers.
Object initializers ease construction and initialization of objects.
Implicitly typed local variables permit the type of local variables to be inferred from the
expressions used to initialize them.
 Implicitly typed arrays: a form of array creation and initialization that infers the element
type of the array from an array initializer.
 Extension methods make it possible to extend existing types and constructed types with
additional methods.
 Lambda expressions: an evolution of anonymous methods providing improved type
inference and conversions to both delegate types and expression trees.
 Expression trees permit lambda expressions to be represented as data (expression trees)
instead of as code (delegates).
 Query expressions provide a language integrated syntax for queries that is similar to
relational and hierarchical query languages such as SQL and XQuery.
(C# Online.Net, 2011)
Appendix D
Integer types:







sbyte – 8-bit signed integer
short – 16-bit signed integer
int – 32-bit signed integer
long – 64-bit signed integer
byte – 8-bit unsigned integer
ushort – 16-bit unsigned integer
uint – 32-bit unsigned integer
C# - The Beautiful “Chord” of Computing
 ulong – 64-bit unsigned integer
(Wrox, 2010, p. 31)
Floating-point types:
 float – 32-bit single-precision floating point
 double – 64-bit double-precision floating point
(Wrox, 2010, p. 32)
Decimal type:
 decimal – 128-bit high-precision decimal notation
(Wrox, 2010, p. 32)
Boolean type:
 bool – represents true or false
(Wrox, 2010, p. 33)
Character type:
 char – represents a single 16-bit (Unicode) character
(Wrox, 2010, p. 33)
C# - The Beautiful “Chord” of Computing
References
C# Online.Net. (2011). C# Overview. Retrieved 9 11, 2011, from csharp-online.net: http://en.csharponline.net/CSharp_Overview
CSharpHelp. (2006, 4 30). Writing Expressions in C#. Retrieved 10 24, 2011, from CSharpOnline.com:
http://www.csharphelp.com/2006/04/writing-c-expressions/
Dutta, D. (2002, 3 13). Event Handling in .NET using C#. Retrieved 10 19, 2011, from csharpcorner.com: http://www.csharpcorner.com/UploadFile/ddutta/EventHandlingInNetUsingCS11092005052726AM/EventHa
ndlingInNetUsingCS.aspx
Microsoft, Inc. (2011). .NET Framework Conceptual Overview. Retrieved 10 5, 2011, from MSDN:
http://msdn.microsoft.com/library/zw4w595w(VS.100).aspx
Microsoft, Inc. (2011). Assignment Statements. Retrieved 10 20, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/z2wkh0tk(v=VS.90)
Microsoft, Inc. (2011). Exceptions and Exception Handling (C# Programming Guide). Retrieved 10 21,
2011, from MSDN: http://msdn.microsoft.com/en-us/library/ms173160(v=VS.100).aspx
Microsoft, Inc. (2011). internal (C# Reference). Retrieved 10 20, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/7c5ka91b.aspx
Microsoft, Inc. (2011). Methods (C# Programming Guide). Retrieved 10 23, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/ms173114(v=VS.100).aspx
Microsoft, Inc. (2011). private (C# Reference). Retrieved 10 20, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/st6sy9xe.aspx
Microsoft, Inc. (2011). protected (C# Reference). Retrieved 10 20, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/bcd5672a.aspx
Microsoft, Inc. (2011). public (C# Reference). Retrieved 10 20, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/yzh058ae.aspx
Microsoft, Inc. (2011). try-finally (C# Reference). Retrieved 10 21, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/zwc8s4fz.aspx
C# - The Beautiful “Chord” of Computing
Microsoft, Inc. (2011). var (C# Reference). Retrieved 10 22, 2011, from MSDN:
http://msdn.microsoft.com/en-us/library/bb383973.aspx
Microsoft, Inc. (2011). Visual Studio 2010. Retrieved 10 25, 2011, from Microsoft.com:
http://www.microsoftstore.com/store/msstore/list/categoryID.50804700?WT.mc_id=pointitsem_
US_Bing_5VisualStudio_buy&wt.term=visual%20studio%202010%20prices&wt.campaign=5++Visual+Studio&wt.content=w8PBPH7A&wt.source=bing&wt.medium=cpc&WT.srch=1
Wikipedia. (2011, 10 17). .NET Framework. Retrieved 10 20, 2011, from Wikipedia:
http://en.wikipedia.org/wiki/.NET_Framework
Wikipedia. (2011, 10 15). C Sharp (programming language). Retrieved 10 20, 2011, from
Wikipedia.com: http://en.wikipedia.org/wiki/C_Sharp_(programming_language)
Wrox. (2010). Professional C# and .NET 4. Indianapolis: Wiley Publishing, Inc.
Zahn, M. (2003, 3 20). Naming Conventions for .NET / C# Projects . Retrieved 10 20, 2011, from
Akadia.com: http://www.akadia.com/services/naming_conventions.html
McCarthy, J.; Brayton, R.; Edwards, D.; Fox, P.; Hodes, L.; Luckham, D.; Maling, K.; Park, D. et al.
(March 1960). LISP I Programmers Manual. Boston, Massachusetts: Artificial Intelligence
Group, M.I.T. Computation Center and Research Laboratory. p. 88f.
http://history.siam.org/sup/Fox_1960_LISP.pdf. "In the local M.I.T. patois, association lists [of
atomic symbols] are also referred to as "property lists", and atomic symbols are sometimes called
"objects"."