To modify a class, method, property, or field

abstract    const     extern      internal    new        override    private    protected    public  readonly    sealed     static        virtual       volatile    void  

To deal with object type and type conversions

 as    explicit     implicit    is    operator     sizeof     typeof  

are aliases to built in types, are specific types, or have to do with enumerations

 bool    byte     char     class     decimal     double     enum    float     int     interface
 long     object     sbyte     short     string     struct     uint     ulong     ushort

To control program flow

 break     case     continue     default     do     else     for     foreach, in     goto     if
 return     switch     while

To use in exception handling

 catch     checked     finally     throw     try     unchecked

like C++ function pointers and related subjects

 delegate     event

To affect garbage collection

 fixed

to help with critical sections of code

lock

 To declare scope

 namespace

 To control object allocation/destruction

 new     stackalloc

 To affect method parameter passing

 out     params     ref

 are literals or refer to the current instance of an object

 null    false     true     this     value

 To deal with unmanaged code

 unsafe

Miscellaneous

base     void

The abstract modifier indicates that the thing being modified has a missing or incomplete implementation. The abstract modifier can be used with classes, methods, properties, indexers, and events. Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes. Members marked as abstract, or included in an abstract class, must be implemented by classes that derive from the abstract class.

as

The as operator is like a cast operation. However, if the conversion is not possible, as returns null instead of raising an exception.

base

The base keyword is used to access members of the base class from within a derived class: 1) Call a method on the base class that has been overridden by another method. 2) Specify which base-class constructor should be called when creating instances of the derived class. A base class access is permitted only in a constructor, an instance method, or an instance property accessor. It is an error to use the base keyword from within a static method.

bool

The bool keyword is an alias of System..::.Boolean. It is used to declare variables to store the Boolean values, true and false. If you require a Boolean variable that can also have a value of null, use bool?. The default value of a bool or bool? variable is false.

break

The break statement terminates the closest enclosing loop or switch statement in which it appears. Control is passed to the statement that follows the terminated statement, if any.

byte

The byte keyword denotes an integral type that stores values. System.byte. Range is 0 to 255

case

 Control is transferred to the case statement which matches the value of the switch. The switch statement can include any number of case instances, but no two case statements can have the same value. Execution of the statement body begins at the selected statement and proceeds until the break statement transfers control out of the case body. A jump statement such as a break is required after each case block, including the last block whether it is a case statement or a default statement. With one exception, (unlike the C++ switch statement), C# does not support an implicit fall through from one case label to another. The one exception is if a case statement has no code.

If no case expression matches the switch value, then control is transferred to the statement(s) that follow the optional default label. If there is no default label, control is transferred outside the switch.

catch

 The try-catch statement consists of a try block followed by one or more catch clauses, which specify handlers for different exceptions. When an exception is thrown, the common language runtime (CLR) looks for the catch statement that handles this exception. If the currently executing method does not contain such a catch block, the CLR looks at the method that called the current method, and so on up the call stack. If no catch block is found, then the CLR displays an unhandled exception message to the user and stops execution of the program.

The try block contains the guarded code that may cause the exception. The block is executed until an exception is thrown or it is completed successfully. For example, the following attempt to cast a null object raises the NullReferenceException. It is possible to use more than one specific catch clause in the same try-catch statement. In this case, the order of the catch clauses is important because the catch clauses are examined in order. Catch the more specific exceptions before the less specific ones. The compiler will produce an error if you order your catch blocks so that a later block will never be reached. A throw statement can be used in the catch block to re-throw the exception, which has been caught by the catch statement.

char

The char keyword is used to declare a Unicode character. It is 16 bit. Range is U+0000 to U+ffff.

checked

The checked keyword is used to explicitly enable overflow-checking for integral-type arithmetic operations and conversions.

class

Classes are declared using the keyword class. only single inheritance is allowed in C#. a class can inherit implementation from one base class only. However, a class can implement more than one interface. The access levels protected and private are only allowed on nested classes. You can also declare generic classes that have type parameters; see Generic Classes for more information. A class can contain declarations of   Constructors, Destructors, Constants, Fields, Methods, Properties, Indexers, Operators, Events, Delegates,
Classes, Interfaces, Structs.

const

The const keyword is used to modify a declaration of a field or local variable. It specifies that the value of the field or the local variable is constant, which means it cannot be modified. The type of a constant declaration specifies the type of the members introduced by the declaration. A constant expression must yield a value of the target type, or of a type that can be implicitly converted to the target type. A constant expression is an expression that can be fully evaluated at compile time. Therefore, the only possible values for constants of reference types are string and null.

The constant declaration can declare multiple constants. The static modifier is not allowed in a constant declaration.  The readonly keyword differs from the const keyword. A const field can only be initialized at the declaration of the field. A readonly field can be initialized either at the declaration or in a constructor. Therefore, readonly fields can have different values depending on the constructor used. Also, although a const field is a compile-time constant, the readonly field can be used for run-time constants.

continue

The continue statement passes control to the next iteration of the enclosing iteration statement in which it appears.

decimal

The decimal keyword indicates a 128-bit data type. Compared to floating-point types, the decimal type has more precision and a smaller range, which makes it appropriate for financial and monetary calculations. precision is 28-29 significant digits.

default

 The default keyword can be used in the switch statement to Specifies the default label or in generic code to

specify the default value of the type parameter. This will be null for reference types and zero for value types.

delegate

A delegate declaration defines a reference type that can be used to encapsulate a method with a specific signature. A delegate instance encapsulates a static or an instance method. Delegates are roughly similar to function pointers in C++; however, delegates are type-safe and secure. A delegate lets you pass a function as a parameter. The type safety of delegates requires the function you pass as a delegate to have the same signature as the delegate declaration.  Delegates are the basis for events.A delegate that contains an out parameter cannot be composed.

do

The do statement executes a statement or a block of statements repeatedly until a specified expression evaluates to false.Unlike the while statement, the body loop of the do statement is executed at least once regardless of the value of the expression.

double

The double keyword denotes a simple type that stores 64-bit floating-point values. By default, a real numeric literal on the right-hand side of the assignment operator is treated as double. However, if you want an integer number to be treated as double, use the suffix d or D.

else

The if statement selects a statement for execution based on the value of a Boolean expression.

enum

The enum keyword is used to declare an enumeration, a distinct type consisting of a set of named constants called the enumerator list. Every enumeration type has an underlying type, which can be any integral type except char. The default underlying type of the enumeration elements is int. By default, the first enumerator has the value 0, and the value of each successive enumerator is increased by 1. 

Specifies an event. The event keyword lets you specify a delegate that will be called upon the occurrence of some "event" in your code. The delegate can have one or more associated methods that will be called when your code indicates that the event has occurred. An event in one program can be made available to other programs that target the .NET Framework common language runtime.

explicit

The explicit keyword is used to declare an explicit user-defined type conversion operator. Unlike implicit conversion, explicit conversion operators must be invoked via a cast. If a conversion operation can cause exceptions or lose information, you should mark it explicit. This prevents the compiler from silently invoking the conversion operation with possibly unforeseen consequences.

extern

Use the extern modifier in a method declaration to indicate that the method is implemented externally. A common use of the extern modifier is with the DllImport attribute. It is an error to use the abstract and extern modifiers together to modify the same member. Using the extern modifier means that the method is implemented outside the C# code, while using the abstract modifier means that the method implementation is not provided in the class. Because an external method declaration provides no actual implementation, there is no method body; the method declaration simply ends with a semicolon and there are no curly braces following the signature

false

In C#, the false keyword can be used as an overloaded operator or as a literal.false Operator :- User-defined types can define a false operator that returns the bool value true to indicate false and returns false otherwise. This is useful for types that represent true, false, and null (neither true nor false), as used in databases. Such types can be used for the controlling expression in if, do, while, and for statements and in conditional expressions. If a type defines operator false, it must also define operator true. A type cannot directly overload the conditional logical operators, but an equivalent effect can be achieved by overloading the regular logical operators and operators true and false. false Literal :- The false keyword is a literal of type bool representing the boolean value false.

finally

The finally block is useful for cleaning up any resources allocated in the try block. Control is always passed to the finally block regardless of how the try block exits.

fixed

Prevents relocation of a variable by the garbage collector. The fixed statement is only permitted in an unsafe context. The fixed statement sets a pointer to a managed variable and "pins" that variable during the execution of statement. Without fixed, pointers to managed variables would be of little use since garbage collection could relocate the variables unpredictably.

float

The float keyword denotes a simple type that stores 32-bit floating-point values. By default, a real numeric literal on the right-hand side of the assignment operator is treated as double. Therefore, to initialize a float variable use the suffix f or F. If you don't use the suffix in the previous declaration, you will get a compilation error because you are attempting to store a double value into a float variable.

for

The for loop executes a statement or a block of statements repeatedly until a specified expression evaluates to false. Because the test of expression takes place before the execution of the loop, a for statement executes zero or more times.

foreach

The foreach statement repeats a group of embedded statements for each element in an array or an object collection. The foreach statement is used to iterate through the collection to get the desired information, but should not be used to change the contents of the collection to avoid unpredictable side effects.

goto

The goto statement transfers the program control directly to a labeled statement. In the first form, the identifier indicates a label located in the current body, the same lexical scope, or an enclosing scope of the goto statement. A common use of goto is to transfer control to a specific switch-case label or the default label in a switch statement. The goto statement is also useful to get out of deeply nested loops.

if

The if statement selects a statement for execution based on the value of a Boolean expression.

implicit

The implicit keyword is used to declare an implicit user-defined type conversion operator. By eliminating unnecessary casts, implicit conversions can improve source code readability. However, because implicit conversions can occur without the programmer's specifying them, care must be taken to prevent unpleasant surprises. In general, implicit conversion operators should never throw exceptions and never lose information so that they can be used safely without the programmer's awareness. If a conversion operator cannot meet those criteria, it should be marked explicit.

in

The foreach statement repeats a group of embedded statements for each element in an array or an object collection.

 is

 The is operator is used to check whether the run-time type of an object is compatible with a given type. The is operator cannot be overloaded.

Note that the is operator only considers reference conversions, boxing conversions, and unboxing conversions. Other conversions, such as user-defined conversions, are not considered by the is operator.

 lock

 The lock keyword marks a statement block as a critical section by obtaining the mutual-exclusion lock for a given object, executing a statement, and then releasing the lock. lock ensures that one thread does not enter a critical section while another thread is in the critical section of code. If another thread attempts to enter a locked code, it will wait (block) until the object is released.

 long

 The long keyword denotes an integral type that stores values  to the size Signed 64-bit integer and range –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. System.Int64

 namespace

 The namespace keyword is used to declare a scope. This namespace scope lets you organize code and gives you a way to create globally-unique types. Even if you do not explicitly declare one, a default namespace is created. This unnamed namespace, sometimes called the global namespace, is present in every file. Any identifier in the global namespace is available for use in a named namespace. Namespaces implicitly have public access and this is not modifiable.

 new

 The new keyword can be used as an operator or as a modifier.  The new operator is used to create objects and invoke constructors. It is also used to invoke the default constructor for value types. Remember that it is an error to declare a default constructor for a struct, because every value type implicitly has a public default constructor. It is possible though to declare parameterized constructors on a struct type. The new operator cannot be overloaded. Value-type objects such as structs are created on the stack, while reference-type objects such as classes are created on the heap. The new operator cannot be overloaded. If the new operator fails to allocate memory, it throws the exception OutOfMemoryException. new can as well be used as modifier. Use the new modifier to explicitly hide a member inherited from a base class. To hide an inherited member, declare it in the derived class using the same name, and modify it with the new modifier. It is an error to use both new and override on the same member. Using the new modifier in a declaration that does not hide an inherited member generates a warning.

It is a compile-time error to reference a private member outside the class or the struct in which it is declared.

 The ref method parameter keyword on a method parameter causes a method to refer to the same variable that was passed into the method. Any changes made to the parameter in the method will be reflected in that variable when control passes back to the calling method. To use a ref parameter, the argument must explicitly be passed to the method as a ref argument. The value of a ref argument will be passed to the ref parameter. An argument passed to a ref parameter must first be initialized. Compare this to an out parameter, whose argument does not have to be explicitly initialized before being passed to an out parameter. A property is not a variable and cannot be passed as a ref parameter. An overload will occur if declarations of two methods differ only in their use of ref. However, it is not possible to define an overload that only differs by ref and out.

A sealed class cannot be inherited. It is an error to use a sealed class as a base class. Use the sealed modifier in a class declaration to prevent inheritance of the class. It is not permitted to use the abstract modifier with a sealed class. Structs are implicitly sealed; therefore, they cannot be inherited.

 Allocates a block of memory on the stack. A block of memory of sufficient size to contain  elements of specified type is allocated on the stack, not the heap. the address of the block is stored in the specified pointer. This memory is not subject to garbage collection and therefore does not have to be pinned (via fixed). The lifetime of the memory block is limited to the lifetime of the method in which it is defined. stackalloc is only valid in local variable initializers. Because Pointer types are involved, stackalloc requires unsafe context.

 A struct type is a value type that can contain constructors, constants, fields, methods, properties, indexers, operators, events, and nested types. The struct type is suitable for representing lightweight objects such as Point, Rectangle, and Color. Although it is possible to represent a point as a class, a struct is more efficient in some scenarios. For example, if you declare an array of 1000 Point objects, you will allocate additional memory for referencing each object. In this case, the struct is less expensive. It is an error to declare a default (parameterless) constructor for a struct. A default constructor is always provided to initialize the struct members to their default values. It is an error to initialize an instance field in a struct. When you create a struct object using the new operator, it gets created and the appropriate constructor is called. Unlike classes, structs can be instantiated without using the new operator. If you do not use new, the fields will remain unassigned and the object cannot be used until all of the fields are initialized. There is no inheritance for structs as there is for classes. A struct cannot inherit from another struct or class, and it cannot be the base of a class. Structs, however, inherit from the base class Object. A struct can implement interfaces, and it does that exactly as classes do. Unless you need reference type semantics, a class that is smaller than 16 bytes may be more efficiently handled by the system as a struct.

The unchecked keyword is used to control the overflow-checking context for integral-type arithmetic operations and conversions. It can be used as an operator or a statement. In an unchecked context, if an expression produces a value that is outside the range of the destination type, the result is truncated. If neither checked nor unchecked is used, a constant expression uses the default overflow checking at compile time, which is checked. Otherwise, if the expression is non-constant, the run-time overflow checking depends on other factors such as compiler options and environment configuration.

 The virtual keyword is used to modify a method or property declaration, in which case the method or the property is called a virtual member. The implementation of a virtual member can be changed by an overriding member in a derived class. When a virtual method is invoked, the run-time type of the object is checked for an overriding member. The overriding member in the most derived class is called, which might be the original member, if no derived class has overridden the member. By default, methods are non-virtual. You cannot override a non-virtual method. You cannot use the virtual modifier with the static, abstract and override modifiers. Virtual properties behave like abstract methods, except for the differences in declaration and invocation syntax. It is an error to use the virtual modifier on a static property. A virtual inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

When used as the return type for a method, void specifies that the method does not return a value. void is not allowed in a method's parameter list. void is also used in an unsafe context to declare a pointer to an unknown type.