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)