CLR via C# 3rd - 06 - Type and Member Basics

 

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)