Abstract class

Accessibility options in C#

Accessors

Access reordering and volatility

    singletons

Addition operators

    numeric

    string concatenation

Add() method

Ad hoc sorting order

Aggregate() method

Aliases

    external assembly

    type

All() conditional method

Anonymous methods

Anonymous type class

Any() conditional method

Arithmetic operators

    addition operators

    bitwise complement

    increment and decrement operators

    left and right shift operators

    multiplication operator

    numeric

        string concatenation

    remainder operator

    subtraction operator

    unary minus

    unary plus

Array of engineers

Arrays

    conversions

    definite assignment

    intitialization

    jagged arrays

    multidimensional arrays

    reference element type

    of reference types

    syntax

    System.Array, sorting and searching support

    System.Array type

        BinarySearch() function

        IndexOf() function

        LastIndexOf() function

        Reverse() function

        Sort() function

    value element type

As operator

Assembly loading

Assert behavior change

Asserts

Assignment operators

    compound assignment

    simple assignment

Asynchronous programming. See Parallel programming

Async keyword

Attributes

    conditional attribute

    description

    design

        parameter types

        target values

    identifiers

    multiuse attribute

    predefined attribute

    reflection

    return type

    usage

    value fetch

Automatic properties

Average() aggregate method

Await keyword

Base class and inheritance

    abstract class

        CalculateCharge()

        TypeName()

    array of engineers

    engineer class

    sealed classes and methods

    simple inheritance

    virtual functions

Base class constraints

Base Class Library (BCL)

    custom format

    custom object formatting

    date and time formatting

    environment setting access

    I/O functions

    BinaryReader and BinaryWriter classes

        directory traversal

        File and StreamReader classes

        File and StreamWriter classes

        Process class

        TextReader and TextWriter classes

        XML

    namespaces

    .NET Framework

    numeric parsing

    numeric type formatting (see Numeric type formatting)

    programs and support

    serialization

        custom

        XML

    special libraries for application/service creation

    TryParse()

    web page reading

Binary operators

BinaryReader class

BinarySearch() function

BinaryWriter class

Bit flag enums

Bitwise complement operator

Boolean literals

BooleanSwitch

Boxing

Break statement

Button class

C#

    allocation

        finalization

        GC behavior control

        generations 0 and 1

        Mark and Compact algorithm

    base class and inheritance (see Base class and inheritance)

    behavior vs. database behavior

    classes (see Classes)

    class naming guidelines

    code optimization

    compiler

    compiler as a service

    development

        decompilers

        ILDASM

        NGEN

        obfuscators

        Tools of Note

    fundamentals

        attributes

        class

        delegates and events

        enumerations

        implementation

        interfaces

        statements

        structs

    garbage collection

    generics vs. C++ templates

    naming conventions style

    reflection

        function invoking

        generics

        type members listing

        types listing in assembly

    rule

    unsafe code

    XML documentation

        compiler support tags

        files

        real documentation generation

        tags

Callback functions

Calling function

    Caller Beware

    Caller Confuse

    Caller Inform

Case-insensitive collections

Cast() method

Catch block selection

Catch statement

Character escape sequences

Character literals

Character marshaling

Checked conversions

Checked expressions

Checked statement

Classes

    accessibility

    anonymous types

    constants

    constructors

        private

    destructors

    Dispose()

    extension methods

        usage guidelines

    generation

    initialization

    member function

    members, definite assignment

    naming

    nested

    object initializer

    other nestings

    nonmemory resource management

    overloading

    parameters

        getpoint parameter

        out parameter

        ref parameter

    partial classes and methods

    read-only fields

    simple class

        container

        field

        field naming conventions

        instance

        Main() function

        Point class

    static classes

    static constructors

    static fields

    static member functions

    and struct constraints

    Using statement

CLR. See .NET Common Language Runtime (CLR)

Code generation

    assembly loading

    C# compiler as a service

    dynamic

    runtime

        algorithm in code

        code calling

        code translation and loading

        design guidelines

Code optimization

Code tracing

Collection classes

    case-insensitive collections

    concurrent collections

    design guidelines, interface and virtual methods

    generic collections

    ObjectModel collections

    synchronized collections

Command-line parameters

Comments

Common Language Runtime

COM objects

Compiler support tags

Completion port approach

Complex number class

Compound assignment operator

Concat() whole sequence method

Concurrent collections

Conditional attribute

Conditional methods

Conditional operator

Constants

Constraints

    base class constraints

    class and struct constraints

    interface constraints

    multiple constraints

Constructors

    and structs

Contains() conditional method

Contextual keywords

Continue statement

Contravariance

Conversion lookup

Conversions. See also User-defined conversions

    arrays

    of classes/reference types

        base class

        interface implementation

        interface reference conversion

        object to interface reference conversion

    explicit

    implicit

    numeric types

        checked conversions

        explicit conversions

        member lookup

    of structs/value types

Count() aggregate method

Covariance and contravariance

C++ templates vs. C# generics

Currency format string

Custom date format

Custom format strings

    decimal point

    digit or space placeholder

    digit or zero placeholder

    escapes and literals

    exponential notation

    group separator

    number prescaler

    percent notation

    section separator

Custom object formatting

Database behavior vs. C# behavior

Data filtering

Data parallelism

Data protection and synchronization

    example

    exclusion primitives

    immutable objects

    interlocked operations

    lock statement

    mutexes

    non-sharing of data

Data transformation

Data types

    reference

    value

Date and time formatting

    custom format

DebuggerDisplay attribute

Debugger experience improvement

    DebuggerDisplay attribute

    debugger visualizers

    detail display customization

    type detail display change

    type display change

Debugger visualizers

Debugging techniques

    assert behavior change

    asserts

    code tracing

    conditional methods

    debugger experience improvement

        DebuggerDisplay attribute

        debugger visualizers

        detail display customization

        type detail display change

        type display change

    debug/trace output messages

    debug/trace switch control,

        BooleanSwitch

        process metadata capture

        TraceSwitch

        user-defined switch

    in .NET framework

Debug/trace switch control

    BooleanSwitch

    process metadata capture

    TraceSwitch

    user-defined switch

Decimal format string

Decimal point separator

Decompilers

Decrement operator

DefaultIfEmpty() method

Definite assignment

    and arrays

    and class members

Delegate.Combine() function

Delegates

    anonymous methods

    description

    to instance members

    lambda implementation

    lambda guidelines

        construct selection

        parameter naming

    multicasting

    as static members

    usage

    variable capturing

Design guidelines

    adding conversions

    alternate versions of conversions

    complex type conversions

    conversion lookup

    DLL function calling

        C# or C++

        data marshaling

    exceptions

        catching

        exceptional conditions

        exception wrapping

        rethrowing

        retry logic

        specific type

    implicit conversions

    interface and virtual methods

    parallel programming

    reference type guidelines

    runtime code generation

    single conversion to/from hierarchy

    value type guidelines

Destructors

Digit or space placeholder

Digit or zero placeholder

Directives, preprocessing

    inline warning control

    preprocessor expressions

Directory traversal

Disassemblers

Dispose()

Distinct() subset method

DLL function calling

    design guidelines

        C# or C++

        data marshaling

    fixed-size buffers

    Marshall class

    pointers and declarative pinning

    structure layout

    with structure parameter

    Windows callback

Do statement

Dynamic code generation

Dynamic failure

Dynamic keyword

Dynamic runtime

Dynamic typing

    dynamic failure

    dynamic keyword

    generic arithmetic

    usage guidelines

ElementAt() method

ElementAtOrDefault() method

Empty() generator method

#Endregion function

Engineer class

Enumerations. See also Object enumeration

    base types

    bit flag enums

    chaining

    initialization

    line-style enumeration

    System.Enum type

    type conversions

    values

Enumerators. See Object enumeration

Environment setting access

Equality

Equality and nullable types

#Error function

Escapes and literals

EventArgS<T>

EventHandler<T>

Events

    add() method

    vs. delegates

    EventArgS<T>

    EventHandler<T>

    example using delegates

    function addition/removal

    remove() method

    safe event invocation

Exception handling

    calling function

        Caller Beware

        Caller Confuse

        Caller Inform

    catch block selection

    design guidelines

        catching

        exceptional conditions

        exception wrapping

        rethrowing

        retry logic

        specific type

    efficiency and overhead

    final cleanup

    return codes

    top-level exception handlers

    try and catch block

    user-defined exception classes

Except() whole sequence method

Exclusion primitives

Execution flow control. See Iteration statements

Explicit interface

Explicit numeric conversions

Exponential notation

Expressions

    checked

    operator precedence order

    type inference

        var usage

    unchecked

Extension methods

    usage guidelines

External assembly aliases

Extraction methods

    DefaultIfEmpty() method

    ElementAt() method

    ElementAtOrDefault() method

    empty sequence

    First() method

    Last() method

    LastOrDefault() method

    list filtering

    Single() method

    SingleOrDefault() method

Fields vs. properties

Filtering of data

Finalization

Finally statement

First() extraction method

FirstOrDefault() extraction method

Fixed-point format string

Fixed-size buffers

Foreach statement

Formatting of properties

For statement

Function invoking

Garbage collection

    allocation

    finalization

    GC behavior control

        collection forcing

        finalization suppression

    generations 0 and 1

    Mark and Compact algorithm

General format string

Generator methods

Generic arithmetic

Generic collections

Generic delegates

Generic methods

Generic naming guidelines

Generic types

    in C# 1.0

    constraints

        base class constraints

        class and struct constraints

        interface constraints

        multiple constraints

    contravariance

    covariance and contravariance

    C++ templates vs. C# generics

    default type value

    generic delegates

    generic methods

    interfaces and inheritance

    and iterators

    list of integer values

    naming guidelines

    and runtime efficiency

GetHashCode() function

Goto statement

GroupBy() method

Group separator

Guidelines. See Design guidelines

Hash code use

Hexadecimal format string

Identifiers

IDEs

    disassemblers and decompilers

    obfuscators

    productivity

    profilers

    regular expressions

    software package usage

    unit testing and TDD

        test utilities/runners

IEnumerable

If statement

ILDASM0. See Intermediate Language [IL] Disassembler (ILDASM)

Immutable classes

Immutable objects

Impedance mismatch

Increment operator

Indexing

    design guidelines

    integer index

    string index

    with multiple parameters

IndexOf() function

Inheritance

    hierarchy

    and properties

Initialization of classes

Inline warning control

Integer index

Integer literals

Interface constraints

Interfaces

    based on interfaces

    constraints

    design guidelines

    DiagramObject class

    inheritance hierarchy

    multiple implementation

        explicit interface

        implementation hiding

    object casting

    as operator

    and structs

Interlocked operations

Intermediate Language [IL] Disassembler (ILDASM)

Interop

    COM objects

    native DLL function calling

        design guidelines

        fixed-size buffers

        Marshall class

        pointers and declarative pinning

        structure layout

        Windows callback

        with structure parameter

Intersect() whole sequence method

Intitialization of arrays

I/O functions

    BinaryReader and BinaryWriter classes

    directory traversal

    File and StreamReader classes

    File and StreamWriter classes

    Process class

        output redirection

        process completion detection

    TextReader and TextWriter classes

    XML, serial ports

Is operator

Iteration statements

    do statement

    foreach statement

    for statement

    while statement

Iterators

    and generic types

    named iterators

    and resource management

Jagged arrays

Joining

Join() method

Jump statements

    break statement

    continue statement

    goto statement

    return statement

Keywords

Lambda implementation

Lambda guidelines

    construct selection

    implementation

    parameter naming

LastIndexOf() function

Last() method

LastOrDefault() method

Lexical details

    comments

    contextual keywords

    identifiers

    keywords

    literals

        boolean

        character

        integer

        real

        string

        Verbatim strings

#Line function

Line-style enumeration

Linq

    advantages

    query

    sequence method

        aggregate method

        conditional methods

        extraction methods (see Extraction methods)

        generator methods

        GroupBy() method

        Join() method

        ordering methods

        subset methods

        transformational methods (see Transformational methods)

        whole sequence methods

    to entities

    to objects

        advantages of enumerator chaining

        C# rule

        data filtering

        data transformation

        IEnumerable

        vs. Linq to SQL

        query expressions

        sequence stringing

    to SQL

    to XML

Linq to SQL

    database access

    data modification

    equals

    impedance mismatch

    Linq query

    Linq to Entities

    vs. Linq to objects

    query and class generation

    stored procedures

    table join

    working principle

Linq to XML

    Namespaces

        comments

        design decision

        prefixes

        XDocument

        XText instance

    XML creation

    XML parsing

        element value access

        Namespaces and parsing

        node expressions

        tree node traversal

        XElement method naming

        XElement representation

        XML loading

        XPath expression

Literals

    boolean

    character

    integer

    real

    string

    Verbatim strings

Lock statement

Logging techniques. See Debugging techniques

Logical negation operator

Looping statements. See Iteration statements

Main() function

    command-line parameters

    Int status

    static test function

Managed vs. unmanaged code

Mark and Compact algorithm

Marshall class

Max() aggregate method

Member accessibility

    and class accessibility

    default arguments

        vs. method overloading

    internal modifier

        internal-level access

    internal protected modifier

    levels

    method overloading

        vs. default arguments

        implicit conversions

        method hiding

    named arguments

    variable-length parameter lists

Method overloading

    vs. default arguments

    implicit conversions

    method hiding

Min() aggregate method

Multicasting

Multidimensional arrays

Multiple constraints

Multiple interfaces

    explicit interface

    implementation hiding

Multiple sort order

Multiplication operator

Mutable structs

Mutexes

Named iterators

Namespacess

    assembly

    comments

    design decision

    and parsing

    prefixes

    statement

    XDocument

    XText instance

Naming conventions, C#

Native image generator (NGEN)

Nested classes

.NET Base Class Library. See Base Class Library (BCL)

.NET Common Language Runtime (CLR)

.NET framework

    design guidelines

        reference type guidelines

        value type guidelines

    GetHashCode() function

    object equality

    ToString() function

NGEN. See Native image generator(NGEN)

Nullable types

    C# behavior vs. database behavior

    customer tracking system example

    definition

    and equality

    null coalescing

    use of

Null coalescing

Null coalescing operator

NumberFormatInfo format string

Number format string

Number prescaler

Numeric addition operator

Numeric parsing

    TryParse()

Numeric promotions

Numeric type formatting

    custom format strings

        decimal point

        digit or space placeholder

        digit or zero placeholder

        escapes and literals

        exponential notation

        group separator

        number prescaler

        percent notation

        section separator

    standard format strings

        currency

        decimal

        fixed-point

        general

        hexadecimal

        number

        NumberFormatInfo

        Round-Trip

        scientific (exponential)

Numeric types

    checked conversions

    conversions and member lookup

    explicit conversions

Obfuscators

Object casting

Object enumeration

    enable

    enumerators and foreach

    history

    iterators

        and generic types

        named iterators

        and resource management

Object equality

Object initializer

ObjectModel collections

OfType() subset method

OnKey method

Operator overloading

    binary operators

    complex number class

    definition

    example

    guidelines

    restrictions

    unary operators

Operators

    arithmetic operators

        addition operators

        bitwise complement

        division operator

        increment and decrement operators

        left and right shift operators

        multiplication operator

        remainder operator

        subtraction operator

        unary minus

        unary plus

    assignment operators

        compound assignment

        simple assignment

    conditional operator

    logical negation operator

    null coalescing operator

    numeric promotions

    precedence order

    relational operators

    type operators

        as operator

        is operator

        typeof

    user-defined operators

OrderByDescending() ordering method

OrderBy() ordering method

Ordering methods

Overloading of operators. See Operator overloading

Parallel programming

    async, await and parallel operations

    async keyword

    await keyword

    data parallelism

    design guidelines

    disadvantages

    history

    .NET framework support

    PLinq

    Task Parallel Library, return values

    tasks and completion port approach

    tasks and parallel operations

    thread number

    thread pools

Parameter naming

Partial classes and methods

Percent notation

Platform invoke (p/invoke)

PLinq

Pointers and declarative pinning

Point struct

Precedence order, operators

Preprocessing

    directives

        inline warning control

        preprocessor expressions

    preprocessor functions

        #line function

        #region and #endregion functions

        region-itis

        #warning and #error functions

Preprocessor expressions

Preprocessor functions

    #line function

    #region and #endregion functions

    region-itis

    #warning and #error functions

Private constructors

Process class

    output redirection

    process completion detection

Process metadata capture

Profilers

Properties

    accessibility of

    accessors

    automatic properties

    definition

    efficiency of

    vs. fields

    formatting

    and inheritance

    methods

    mixed accessibility evolution

    read-only property

    static properties

    using properties

    value setting, side effects

    virtual properties

    write-only property

Query expressions

Query generation

Range() generator method

Read-only fields

Read-only property

Real literals

Reference type guidelines

Reflection

    function invoking

    generics

    process

    type members listing

    types listing in assembly

#Region function

Region-itis

Regular expressions

Relational operator overloading

Relational operators

Remainder operator

Remove() method

Repeat() generator method

Resource management, and iterators

Return codes

Return statement

Reverse() function

Reverse() ordering method

Round-Trip format string

Runtime code generation

    algorithm in code

    code calling

    code translation and loading

    design guidelines

Safe event invocation

Safe function pointers

Scientific (exponential) format string

Sealed class

Section separator

Selection statements

    if statement

    switch statement

SelectMany() method

Select() method

SequenceEqual() conditional method

Sequence method

    aggregate method

    conditional methods

    extraction methods (see Extraction methods)

    generator methods

    GroupBy() method

    Join() method

    ordering methods

    subset methods

    transformational methods (see Transformational methods)

    whole sequence methods

Serialization

    custom

    XML

        XmlSerializer or XElement

Serial ports

Shift operators

Simple assignment operator

Single() method

SingleOrDefault() method

Singletons

Skip() subset method

SkipWhile() subset method

Sort() function

Sorting and searching functionality

    ad hoc sorting order

    hash code use

    multiple sort order

    relational operator overloading

    sort order specification

SQL

    database access

    data modification

    equals

    impedance mismatch

    Linq query

    Linq to entities

    query and class generation

    stored procedures

    table join

    working principle

Standard format strings

    currency

    decimal

    fixed-point

    general

    hexadecimal

    number

    NumberFormatInfo

    Round-Trip

    scientific (exponential)

Statements

    catch statement

    checked statement

    finally statement

    iteration statements

        do statement

        foreach statement

        for statement

        while statement

    jump statements

        break statement

        continue statement

        goto statement

        return statement

    lock statement

    selection statements

        if statement

        switch statement

    try statement

    unchecked statement

    using statement

    yield statement

Static classes

Static constructors

Static fields

Static member functions

Static members

Static properties

Static test function

Stored procedures

StreamReader classes

StreamWriter class

StringBuilder

    methods

    properties

    string creation

String concatenation operator

String index

String interning

String literals

Strings

    comparison and search methods

    encodings and conversions

    literals

    modification methods

    object to string conversion

    regular expressions

        complex parsing

        options

    split function

    StringBuilder

        methods

        properties

        string creation

Structs

    and constructors

    boxing

    design guidelines

    immutable classes

    and interfaces

    mutable structs

    point struct

    unboxing

Subtraction operator

Sum() aggregate method

Switch statement

Synchronization. See Data protection and synchronization

Synchronized collections

System.Array

    sorting and searching support

        ad hoc sorting order

        hash code use

        multiple sort order

        relational operator overloading

        sort order specification

System.Array type

    BinarySearch() function

    IndexOf() function

    LastIndexOf() function

    Reverse() function

    Sort() function

System.Enum type

Table join

Take() subset method

TakeWhile() subset method

Task approach

Task Parallel Library

    return values

Test utilities/runners

TextReader class

TextWriter class

ThenByDescending() ordering method

ThenBy() ordering method

Threading. See also Multi-threading