This sheet lists several programming-specific and C#-specific terms used in the literature. Many terms are from the C# Language Specification. This terms are useful for writing about the C# language and describing it more clearly. Keep it alphabetized as well as possible. This was last updated 4/28/2009.
=== Alphabetical list of terms (dotnetperls.com) ===
Access routines:
Used to meter access to globals (Code Complete)
Accessibility domain (C#):
Where use of variable is permitted. [From spec.]
Accessible (C#):
Whether the variable can be 'reached' from somewhere.
[See inaccessible]
Air castles:
"Programming is building air castles" -- Code Complete,
Air castles are intellectual not physical
Aliased types (C#):
See Aliases.
Aliases (C#):
Keywords are equivalent to types in System namespace.
int aliases "System.Int32"
enum aliases "System.Enum"
string aliases "System.String"
object aliases "System.Object"
array (such as 'int[]') aliases "System.Array"
AppDomain (C#):
? <-- read more
Arcs:
Can "transfer control" [C# spec.] <-- Read more
Arguments (C#):
The variables passed to method in method call (call site)
(see Parameters)
Array offsets:
More correct term for array indexes, but less used
Backus-Naur grammar:
? <-- describes language specification
Barricaded:
? <-- (Code Complete)
Binary operator:
Has two operands (such as A + B)
Doesn't refer to bits or 'binary 0s and 1s', refers to 2 parts.
[See Operand, Operator]
Capped:
Unofficial term describing 'limits' to usage of variable accessibility.
"Accessibility is 'capped'" [Annotated C# spec.]
Centralized control:
Benefit of OOP
Character literal:
Char embedded in code
Class body:
All contents of class type. [Precise term, C# spec.]
Comparator:
Programs such as DIFF that produce list of changes in lines
Constant declarator:
Does not include type [such as int]
Just 'name = 1'
[See MSDN.]
Constant expression value (C#):
Assignment in enumerated type (right hand side).
Constructed type (C#):
Generic types are constructed types (have type parameters) [C# spec.]
Contextual keywords (C#):
yield, select
Data members (C#):
All members not containing executable code [fields, constants]
[Opposite is Function members]
Decimal-integer literal:
Used for more complex numbers (0.1d)
Decomposition:
(Function decomposition <-- figure this out)
Definite assignment analysis (C#):
The compiler ensures that all local variables are assigned before use
Also called "definitely assigned"
Delegate (C#):
Reference type with specific parameter list and return type
Delimited comment:
Example: /* */
Destructors (C#):
Methods with ~ symbol; this is the official term
Enclosing block:
Scope (block) that contains this scope. [C# spec.]
[See Nested block]
Enclosing classes (C#):
Similar to enclosing block (for class declaration) [See Enclosing block]
False expression:
Evaluates to false [term for static flow analysis]
Fully qualified name (C#):
Name that uses full hierarchal path in type.
[See hierarchal path]
Function members (C#):
Function refers to all members with executable code, not just methods.
Includes: constructors, properties, indexers, events, operators, destructors
[Opposite is Data members]
Handle-recycling exploits:
? <-- read more
Hierarchal path (C#):
Term for uniquely identified name for declaration. [C# spec.]
Identifiers:
Variable names (user defined)
Identity conversion (C#):
Means you can convert one type to the same type. [WOW] [C# spec.]
Implicitly sealed (C#):
Describes 'struct' type. Cannot inherit from struct.
Inaccessible (C#):
Whether a variable can be reached (it can't)
[See accessible]
Inheritance hierarchy:
Describes the structure of how classes inherit from each other
Initially assigned:
Term for when variables are assigned at declaration [C# spec.]
Instance constructor:
Term for non-static constructors.
For example: "public parameterless instance constructor" [C# Ill. 2008]
Instance variable:
Class-level variable [Not 'local' variable] [C# spec.]
Integer literal:
Number embedded in code
Integral types:
Technical term for int, etc <-- need more
Interoperating:
gerund of Interop, interoperability
Invocation list (C#):
Internal list of methods called by delegate types (instance, static ok)
Iteration statements:
while/do/for/foreach
Iteration variable (C#):
Loop variable such as in for (i)
Jump statements:
break, continue, etc.
Kleene syntax:
? <-- describes language specification (not in C# spec)
Lexical analysis:
Translates program to series of tokens (keywords etc)
Local variable declaration space (C#)
Where variables are declared and reachable.
Memory regions:
Two--stack and heap
Method signature (C#);
How the compiler distinquishes methods.
Includes parameter overloads.
Mutator methods:
Changes contents of referrer object (such as one passed by ref or a reference type)
Mutual exclusion:
Provided by lock (Mutex)
Name hiding:
Term used when declaration in nested block conflicts with enclosing block.
[C# spec.]
Named constant (C#):
Refers to identifiers inside enums. [C# spec.]
Nested block:
Scope that is nested in another scope (as with "{ }") [C# spec.]
[See Enclosing block]
Non-virtual method (C#):
Determined at compile-time
Null (C#):
Special value for all reference types.
Specifies ABSCENCE of object data.
Null literal:
Null embedded in code
Object (C#):
This is the data, NOT the reference or variable.
Data pointed to by references. [C# spec.]
Also, instance of a type
Operand:
Between operators. [C# spec,; See Operator]
Use for labeling part of expression.
Operator:
Such as + and +=
[See Binary Operator]
Overflow checking (C#):
Provided by checked/unchecked
Overload resolution (C#):
How the compiler determines which method you are calling by its arguments
Parameters (C#):
The variables received at the method itself (see Arguments)
Parameter array (C#):
params object[]
Preprocessing directive:
#define #undef
Program text (C#):
Term for all source files in complete program. [From spec.]
Property (C#):
May be read-write, read-only, or write-only
Psychological set:
Programmers overlook things they are expecting but don't actually see (exactly)
(Code Complete)
Punctuator:
? <-- read more
Reference parameter:
'ref' keyword; passes reference to variable [not reference to instance]
ALSO: Parameter does not contain storage location inline
Reference variable (C#):
Such as string, StreamReader, StringBuilder
Referential identity (C#):
Type of objects being pointed to is preserved.
You can change type of reference, but not type of object pointed to. [C# spec.]
Scope (C#):
Where variable can be referred to without qualification. [C# spec.]
Selection statements:
if/switch <-- read more
Single-line comment:
Example: //
Static flow analysis (C#):
Used by C# compiler for proving definite assignment.
[See Definite assignment]
Substitution markers (C#):
The {0} {1} {2} in string.Format calls
Superset:
Describes behavior or data that contains set.
Contains more than that 'set'. [C# Spec.]
Symbolic information (C#):
Contained in metadata, assemblies
Syntactic analysis:
Translates stream of program tokens (keywords etc) to executable code (IL)
Textual order (C#):
Includes the position of expression in the program text.
Matters for local variables, not for instance variables.
Transformation (C# compilation step 1):
Converts program to Unicode
True expression:
Evaluates to true [term for static flow analysis]
Type parameters:
Used in generics (List<int>)
Unwrapping (C#):
Accessing value inside Nullable type [Getting T from T?]
[See Wrapping]
Value parameter (C#):
Parameter to method that contains storage location.
Passed by value. [C# spec.]
[See Reference parameter]
Verbatim string literal:
@"Cat", uses quote escape literal
Virtual method (C#):
Determined at runtime
Wrapping (C#):
Putting value in Nullable type [Such as value in T? that is T]
[See Unwrapping]