1.4 The C# Language
The
C#
language is disarmingly simple, with only about 80 keywords and a
dozen built-in datatypes, but C# is highly expressive when it comes
to implementing modern programming concepts. C# includes all the
support for structured, component-based, object-oriented programming
that one expects of a modern language built on the shoulders of C++
and Java.
The C# language was developed by a small team led by two
distinguished Microsoft engineers, Anders Hejlsberg and Scott Wiltamuth.
Hejlsberg is also known for creating Turbo Pascal, a popular language
for PC programming, and for leading the team that designed Borland
Delphi, one of the first successful integrated development
environments for client/server programming.
At the heart of any object-oriented language is its support for
defining and working with classes. Classes define new types, allowing
you to extend the language to better model the problem you are trying
to solve. C# contains keywords for declaring new classes and their
methods and properties, and for implementing encapsulation,
inheritance, and polymorphism, the three pillars of object-oriented
programming.
In C#, everything pertaining to a class declaration is found in the
declaration itself. C# class definitions do not
require separate header files or Interface Definition
Language (IDL) files. Moreover, C# supports a new XML style of inline
documentation that simplifies the creation of online and print
reference documentation for an application.
C# also supports
interfaces,
a means of making a contract with a class for services that the
interface stipulates. In C#, a class can
inherit from only a single parent, but a
class can implement multiple interfaces. When it implements an
interface, a C# class in effect promises to provide the functionality
the interface specifies.
C# also provides support for
structs,
a concept whose meaning has changed significantly from C++. In C#, a
struct is a restricted, lightweight type that, when instantiated,
makes fewer demands on the operating system and on memory than a
conventional class does. A struct can't inherit from
a class or be inherited from, but a struct can implement an
interface.
C# provides component-oriented features, such as properties, events,
and declarative constructs (called
attributes).
Component-oriented programming is supported by the
CLR's support for storing
metadata with the
code for the class. The metadata describes the class, including its
methods and properties, as well as its security needs and other
attributes, such as whether it can be serialized; the code contains
the logic necessary to carry out its functions. A compiled class is
thus a self-contained unit. Therefore, a hosting environment that
knows how to read a class' metadata and code needs
no other information to make use of it. Using C# and the CLR, it is
possible to add custom metadata to a class by creating custom
attributes. Likewise, it is possible to read class metadata using CLR
types that support reflection.
An
assembly
is a collection of files that appear to the programmer to be a single
dynamic link library (DLL) or executable (EXE). In .NET, an assembly
is the basic unit of reuse, versioning, security, and deployment. The
CLR provides a number of classes for manipulating assemblies.
A final note about C# is that it also provides support for directly
accessing memory using C++ style pointers and keywords for bracketing
such operations as unsafe, and for warning the CLR garbage collector
not to collect objects referenced by pointers until they are
released.
|