1.
Different Kinds of Type Members
A
type can define zero or more of the following kinds of members:
Constants
A constant is a symbol that
identifies a never-changing data value
Fields
A field represents a read-only or
read/write data value
Instance constructors
An instance constructor is a special method
used to initialize a new object’s instance fields to a good initial
state
Type constructors
A type constructor is a special method used to
initialize a type’s static fields to a good initial state
Methods
A method is a function that performs operations
that change or query the state of a type (static method) or an object
(instance method)
Operator overloads
An operator overload is a method that defines
how an object should be manipulated when certain operators are applied to
the object
Conversion operators
A conversion operator is a method that defines
how to implicitly or explicitly cast or convert an object from one type to
another type
Properties
A property is a mechanism that allows a simple,
field-like syntax for setting or querying part of the logical state of a
type (static property) or object (instance property) while ensuring that
the state doesn’t become corrupt. Properties can be parameterless
(very common) or parameterful (fairly uncommon but used frequently with
collection classes)
Events
A static event is a mechanism that allows a
type to send a notification to one or more static or instance methods
Types
A type can define other types nested
within it
2.
Type Visiblity
You can specify the type’s visibility as being
either public or internal
A public type
is visible to all
code within the defining
assembly as well as all
code written in other assemblies.
An internal type
is visible to all
code within the defining assembly, and the
type is not visible to code written in other assemblies.
If
you do not explicitly specify either of these when you define a type, the
C# compiler sets the type’s visibility
to internal (the more
restrictive of the two).
e.g
using System;
// The type below has public visibility and can be accessed by
code
// in this assembly as well as code written in other
assemblies.
public class ThisIsAPublicType { ... }
// The type below has internal visibility and can be accessed by
code
// in this assembly only.
internal class ThisIsAnInternalType { ... }
// The type below is internal because public/internal
// was not explicitly stated
class ThisIsAlsoAnInternalType { ... }
3.
Friend Assemlbies
When an assembly is built, it can indicate other assemblies it
considers “friends” by
using the InternalsVisibleTo attribute defined
in
the System.Runtime.CompilerServices namespace.
The attribute has a string parameter that identifies the friend assembly’s
name and public key (the string you pass to the attribute must not include
a version, culture, or processor architecture).
Note
that friend assemblies
can access all of an
assembly’s internal types as well as
these type’s internal members.
4.
Member Accessiblity
5.
Static classes
The compiler enforces many restrictions on a static class:
.. The class must
be derived directly from
System.Object because deriving from any other
base class makes no sense since inheritance applies only to objects, and
you cannot create an instance of a static class.
.. The class must not implement any
interfaces since interface methods are callable
only when using an instance of a class.
..
The class must define only static
members (fields, methods, properties, and
events). Any instance members cause the compiler to generate an
error.
.. The class cannot be used as a field,
method parameter, or local variable because all
of these would indicate a variable that refers to an instance, and this is
not allowed. If the compiler detects any of these uses, the compiler issues
an error.
6.
Partial Classes, Structures, and Interfaces
The partial keyword
tells the C# compiler that the source code for
a single class, structure, or
interface definition
may span one or more source code files. There
are three main reasons why you might want to split the source code for a
type across multiple files:
.. Source control
.. Splitting a class or structure into distinct logical units
within a single file
.. Code spitters
The partial keyword
is applied to the types in all files. When the files are compiled
together, the compiler combines the code to produce one type that is in the
resulting .exe or .dll assembly file (or .netmodule module file).
7. Components,
Polymorphism, and Versioning
Component Software Programming (CSP)
