Introducing C#

C#'s Philosophy

C# is a modern, general-purpose, and powerful language which applies two theories:

• Object orientation
• Type safety

C# is an object-oriented language which exploits benefits from classic object-oriented paradigm while eliminating its limitations to shape modern, powerful object orientation model. In particular, C# supports following features:

• Modeling and abstraction
• Encapsulation
• Composition and inheritance
• Polymorphism and generic type

C# allows programmers modeling programming objects from real-life objects by enabling them to create types. Each type contains only state and behaviors that are expected for application business. A type's state and behaviors are known as members of that type. Having type declarations, you could write business logic by initializing type's instances or objects and let them communicate with each other or in some cases you could even let types themselves interact directly.

While creating a type in C# you could specify which members are available outside that type and which members are not. You do so by applying modifiers on members and types. In addition, you also use modifiers to adjust other implementation aspects such as indicating a member is available at type-level or object-level. All this process is known as encapsulation.

Like real-life objects, programming objects usually depend on other objects. There are two relationships between objects in C#. An object can contain another one such as a Customer object can include contact information that is an object of Contact type. This relationship is known as composition. An object also could be derived from another one, for example an Apple object is derived from Fruit object. This relationship is known as inheritance. Both relationships make our programs more meaningful and easier to implement. A note is that unlike real-life objects or older OO programming languages, C# supports only single inheritance and eliminates multiple inheritances. This because multiple inheritances are not meaningful in most cases and using them adds more overheads on type resolving process.

Base on single inheritance, you could write certain code that work on base type and let runtime engine determines what particular derived type you intended to use in current context when the application runs. This feature is called polymorphism and is the most powerful feature of object-oriented programming. The goal to which polymorphism targets, is to help programmers to create generic code that make their programs more compact and effective. In addition, C# adds a further step in creating generic code when it introduces a so-called generic type feature. Generic type or generic for short is a way to create parameterized types so that they can be used to create concrete types for your needs. You will see generic is used very popular in generic collections and in some cases else.

So far, we know that C# is all about types creating and therefore, using types in a right way is an important issue. In earlier OO languages such as C++ you could write code like following but don't get errors until the application executes.

Customer customer = new Customer();
customer.Order();
Product product = customer;
product.Order();

C# eliminates this class of errors by enforcing a mechanism called type safety. In particular, C# requires programmers follow rules when working on types. For example, they must explicitly declare a particular type of a variable or they can not assign between incompatible variables or they can call only a type's members on an object of that type. Since this, C# is also called static typed language or strongly typed language. Not only does C# provide strict rules, but also it executes type checking at compile-time and run-time to ensure no violations happen. With type safety, C# reduces a large of subtle errors, improves programmer's productiveness, and makes program more robustness, reliability and readability.

C# and .NET Framework

C# is not created as a stand-alone language. Instead, it is a language used within the .NET Framework which is a next generation platform for writing modern applications.

By using .NET Framework, you get some important benefits as follows:

• Support object orientation model
• Support cross-language and cross-platform.
• Support runtime services such as automatically memory management, code security, threading, exception handling.
• Support types allowing developers to create any type of applications including Windows applications, Web applications, Web services, Smart device applications, and Cloud applications on Windows Azure.

To provide functionalities listed above, .NET Framework is composed from 3 components:

• A runtime execution engine is called Common Language Runtime (CLR)
• A vast of libraries is called Framework Class Library (FCL)
• A set of tools including Visual Studio, compilers, utilities, etc.

In fact, .NET Framework is a Microsoft's implementation of ECMA 335 standard. This standard specifies a runtime infrastructure (commonly known as Common Language Infrastructure – CLI) required to execute so-called managed code, to allow different libraries and languages to work together seamlessly.

CLI defines an execution engine or virtual machine called Virtual Execution System (VES) as its heart. VES knows nothing but how to manage, load and execute managed code. CLI requires any language want to be used with VES must have a compiler that can compile source code to managed code.

The format of managed code has to comply with the standard CLI defines that is called Common Intermediate Language (CIL). In addition, managed code has to packed in packages called assemblies along with metadata is used to describe information about code and assemblies as well. The CLI also outlines the file format of assemblies to ensure cross-platform compatibility.

To ensure cross-language interoperability, CLI defines a unified types system called Common Type System (CTS). CTS includes common data types that are shared among languages use it. In addition, all common types must derive from a mother type that is, for example, System.Object in .NET Framework

The CTS is a necessary but not enough part to ensure code written by different languages can work together seamlessly. Because different languages have different implementation details, it is possible to have a piece of code that is valid in a language but invalid in another. For example, C# is a case-sensitive language while VB.NET is not. Therefore, if you have a piece of code with two variables have same name but different cases then that code can work in C# but cannot run in VB.NET. The result of that is VB.NET developer cannot use your code in his program.

To absolutely ensure cross-language feature can be used, CLI defines another part called Common Language Specification (CLS). It is a set of rules on which all languages must follow to create types marked CLS-compliant that means all languages will be able to interact with those types. Obviously, one of rules will be "create only types which are compatible with CTS" and another one will be "Do not create two or more variables that its names are different by only cases".

C#'s Evolution

From that time it was born, C# immediately became a preferred choice of many .NET developers due to its power and easiness. However, it is not entirely perfect language at that time and this is still true today. Realizing that and over many years, the C# design team at Microsoft have continually improved it by adding more advanced features.

The following is a briefly description about changes from C# 2.0 to C# 4.

Changes in C# 2.0

Generic	A way to create parameterized types
Iterator	A way to make it easier to support foreach iteration in a class or struct without having to implement the entire IEnumerable interface
Partial class	A way to define a class in multiple files
Nullable type	A way to allow a value type can contain null value. It is useful when working with database's data types
Anonymous method	A way to create inline methods at anywhere a delegate is expected. It eliminates the need to define a new method.
Static class	A safe and convenient way to create a class containing only static members that cannot be instantiated.
Friend assembly	A mechanism to access an internal type or internal member in an assembly

Changes in C# 3.0

Lambda expression	A replacement of anonymous method. It is inspired from functional programming discipline. It is especially useful in LINQ
Extension method	A mechanism allows an existing type to be extended with new methods, without altering the definition of the original type. It is also used to make LINQ available
Implicit typing	A way to declare variables with var keyword. It is used very popular in LINQ
Anonymous type	A way to create inline object to store a set of values. It is used primarily with LINQ
Automatic properties	A way to make properties with no additional logic is required
Object and collection initializer	A way to initialize objects or collections at creation time without having to explicitly invoke a constructor.
Partial method	A way to create a signature and an implementation of a method in a partial class

Changes in C# 4.0

Dynamic type	A way to allow late binding to a type and therefore bypass type checking at compile-time. It is inspired from dynamic typed languages. It is useful in some special cases such as when working with COM API, with IronPython, or with HTML DOM
Named and optional argument	Named arguments enable you to specify an argument by parameter name rather than by the parameter's position in the parameter list. Optional arguments enable you to omit arguments for some parameters.
Covariance and contravariance	A way to enable implicit reference conversion of generic type parameters for interface and delegate types. It helps writing generic code more naturally and allows safe type enforcement