MCSD Study Guide - Key Terms Flashcards
(209 cards)
1
Q
assignment
A
Providing a value for a variable
2
Q
Boolean
A
A value that is represented as either true or false
3
Q
branching
A
Refers to changing code execution to a different path
4
Q
condition
A
An evaluation of operands using logical operators
5
Q
conditional instructions
A
Instructions that evaluate Boolean expressions and take action based on the outcome of the evaluation
6
Q
comment
A
A code line that starts with the // characters and is a way of helping to document the code so that programmers can understand what the different code segments are intended to do
7
Q
complex statement
A
A statement that can enclose one or more simple statements into a code block surrounded by curly braces { }. Typical complex statements are those used for repetition and decision structures such as foreach { }, if { }, switch, do { }, and so on.
8
Q
constant
A
A named value that is assigned at time of declaration and cannot be changed in code later
9
Q
declaration
A
Used to create a variable in code
10
Q
decrement
A
To decrease by a certain value
11
Q
expression
A
An activity or code statement that returns a result
12
Q
IEnumerable
A
A code component in C# that supports iteration
13
Q
increment
A
To increase by a certain value
14
Q
initialize
A
To set a starting value
15
Q
iterator
A
A portion of loop that changes a value
16
Q
literal
A
A notation used to indicate fixed values in code. Not the same as a constant. You cannot assign a value to a literal.
17
Q
loop
A
A repetition structure that repeats instructions
18
Q
modulus
A
Returns the REMAINDER of integer division
19
Q
operator
A
Performs an operation on values
20
Q
program flow
A
The logical execution of code
21
Q
sentinel
A
A value used to signal the end for execution on a loop
22
Q
simple statement
A
A statement that ends with a semicolon and is typically used for program actions such as declaring variables, assigning values to variables, method calls, and code branching.
23
Q
spaghetti code
A
A term used to describe code that is complicated to follow and understand due to branching
24
Q
statement
A
The code construct of the C# programming language that causes the application to perform an action
25
ternary operator
An operator that takes three arguments, a condition, a value for true, and a value for false
26
variables
Named values that can be changed in code
27
abstract method
Indicates that the thing 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 to be only a base class of other classes.
28
accessor methods
Methods used to access hidden member variables
29
class files
File that contain a C# class. Classes encapsulate data and functionality into one unit of code
30
classes
Coding components that enable you to create custom types that group together characteristics, methods, and events.
31
constructors
Class methods executed when an object of a given type is created
32
data structures
Components in code that are used to store data within the program
33
encapsulation
The hiding of details around the implementation of an object so there are no external dependencies on the particular implementation
34
enumerations
A distinct type consisting of a set of named constants
35
event publisher
The object in code that will raise the event for the listener or subscriber
36
event subscriber
The object that listens for an event to be raised
37
fields
Variables that store characteristic data for a class
38
heap
An area of memory used by the .NET compiler to store reference type variables
39
instance fields
The same as fields but are known as instance fields because they relate to an instance of an object. In other words, their values are not shared among objects of the same class
40
memory address
An addressable location in computer memory that is used to store and retrieve values stored there
41
methods
Provide the functionality for a class
42
modifiers
Modify declarations of types and type members
43
overloaded methods
Methods with identical names for procedures that operate on different data types
44
override
To extend or modify the abstract or virtual implementation of an inherited method, property, indexer, or event.
45
properties
Members that provide a flexible mechanism to read, write, or compute the values of private fields
46
reference types
Class files or other objects represented as references to the actual data (memory addresses)
47
signature
In this case, a method signature. It is the unique identifying components of the method such as return type, name, and parameters.
48
stack
An area of memory used by the .NET compiler to store value types during program execution
49
boxing
Boxing is the process of converting a value type such as int or bool into an object or an interface supported by the value's type. This enables a program to treat a simple value as if it were an object.
50
CLR
Common Language Runtime
Avirtual machine that manages execution of C# (and other .NET) programs
51
composite format
A format item used by String.Format to indicate how an argument should be formatted. The basic syntax is {index[, length] [:formatString]}
52
custom formatting string
Enable you to build formats that are not provided by the standard formatting strings
53
explicit conversion
In an explicit conversion, the code uses an operator (such as cast) or method (such as int.Parse) to explicity tell the program how to convert a value from one type to another
54
Immutable
A data type is immutable if its value cannot be changed after it has been created. The String class is immutable. String methods that seem to modify a String, such as Replace and ToUpper, actually replace the String with a new value containg the modified contents.
55
Implicit Conversion
In an implicit conversion, the program automatically converts a value from one data type to another without any extra statements to tell it to make the conversion
56
intern pool
The CLR maintains a table called "intern pool" that contains a single reference to every unique string used by the program
57
interoperability
Interoperability enables managed code (such as C# program) to use classes provided by unmanaged code that was not written under the control of the CLR
58
narrowing conversion
A narrowing conversion is a data type conversion where the destination type
cannot hold every possible value provided by the source data type. Converting from a long to an int
is a narrowing conversion because a long can hold values such as 4,000,000,000 that cannot fit in an
int. Narrowing conversions must be explicit.
59
standard formatting string
Enables you to determine how you want a value displayed at a high level.
60
unboxing
Unboxing is the processing of converting a boxed value back into its original value type value.
61
Unicode
Unicode is a standard for encoding characters used by scripts in various locales around the
world. It enables a program to display English, Chinese, Kanji, Arabic, Cyrillic, and other character
sets. The .NET Framework uses the UTF-16 encoding, which uses 16 bits to represent each character.
62
widening conversion
A widening conversion is a data type conversion where the destination type can hold any value provided by the source data type; although, some loss of precision may occur. For example, converting from an int to a long is a widening conversion.
63
ancestor class
A class's parent, the parent's parent, and so on
64
base class
A class from which another class is derived through inheritance. Also known as a parent class or superclass
65
child class
A class derived from a parent class
66
Common Language Runtime
CLR
A virtual machine that manages execution of C# (and other .NET) programs
67
deep clone
A copy of an object where reference fields refer to new instances of objects, not to the same objects referred to by the original object's fields
68
derive
To create one class based on another through inheritance
69
derived class
A child class derived from a parent class through inheritance
70
descendant class
A class's child classes, their child classes, and so on
71
destructor
A method with no return type and a name that includes the class's name prefixed by -. The destructor is converted into a Finalize method that the GC executes before permanently destroying the object.
72
finalization
The process of the GC calling an object's Finalize method
73
finalization queue
A queue through which objects with finalizers must pass before being destroyed. This takes some time, so you should not give a class a finalizer (destructor) unless it needs one.
74
garbage collection
The process of running the GC to reclaim memory that is no longer accessible to the program
75
GC
garbage collector
A process that executes periodically to reclaim memory that is no longer accessible to the program
76
inherit
A derived class inherits the properties, methods, events, and other code of its base class
77
Interface Inheritance
Using an interface to require a class to provide certain features much as inheritance does (except the interface doesn't provide an implementation).
78
managed resources
Resources that are under the control of the CLR
79
multiple inheritance
Allowing a child class to have more than one parent class. C# does not allow multiple inheritance
80
nondeterministic finalization
Because you can't tell when the GC will call an object's Finalize method, the process is called "nondeterministic finalization"
81
parent class
A bare class. Also known as a superclass
82
reachable
During garbage collection, an object is reachable if the program has a path of references that let it access the object
83
shallow clone
A copy of an object where reference fields refer to the same objects as the original object's fields
84
sibling classes
Classes that have the same parent class
85
subclass
A derived class
86
subclassing
The process of deriving a subclass from a base class through inheritance
87
superclass
A base class. Also known as a parent class
88
unmanaged resources
Resources that are not under the control of the CLR
89
unreachable
During garbage collection, an object is unreachable if the program has no path of references that let is access the object
90
checked
By default, a program doesn’t throw OverflowExceptions when an arithmetic operation
causes an overflow. A program can use a checked block to make arithmetic expressions throw those
exceptions.
91
contravariance
```
A feature of C# that enables a method to take parameters that are from a superclass of
the type expected by a delegate. For example, suppose the Employee class is derived from the Person
class and the EmployeeParameterDelegate type represents methods that take an Employee object as a
parameter. Then you could set an EmployeeParameterDelegate variable equal to a method that takes
a Person as a parameter because Person is a superclass of Employee. When you invoke the delegate
variable’s method, you will pass it an Employee (because the delegate requires that the method take an
Employee parameter) and an Employee is a kind of Person, so the method can handle it.
```
92
contravariant
A variable is contravariant if it enables contravariance.
93
covariance
```
A feature of C# that enables a method to return a value from a subclass of the result
expected by a delegate. For example, suppose the Employee class is derived from the Person class
and the CreatePersonDelegate type indicates a method that returns a Person object. Then you
could set a CreatePersonDelegate variable equal to a method that returns an Employee because
an Employee is a kind of Person.
```
94
delegate
A data type that defines a method with given parameters and return value.
95
error checking
The process to anticipate errors, check to see if they occur, and work around them,
for example, validating an integer entered by the user in a TextBox instead of simply trying to parse
it and failing if the value is not an integer. See also exception handling.
96
exception handling
The process to protect the application when an unexpected error occurs, for example,
protecting the code in case a file downloads fails when it is halfway done. See also error checking.
97
expression lambda
A lambda expression that has a single expression on the right side.
98
lambda expression
A concise syntax for defining anonymous methods.
99
publisher
An object that raises an event.
100
statement lambda
Similar to an expression lambda except it encloses its code in braces and it can
execute more than one statement. If it should return a value, it must use a return statement.
101
subscriber
An object that receives an event.
102
try-catch-finally block
The program structure used to catch exceptions. The try section contains the
code that might throw an exception, catch sections catch different exception types, and the finally
section contains code to be executed when the try and catch sections finish executing.
103
unhandled exception
Occurs when an exception is thrown and the program is not protected by a
try-catch-finally block, either because the code isn’t inside a try section or because there is no
catch section that matches the exception.
104
asynchrony
Operations that are run in a nonblocking fashion. When a method needs to call another
method that potentially can block, instead of calling that method directly you can apply different
techniques to avoid the blocking of the calling method.
105
Asynchronous Pattern Model (APM)
When using this pattern, a method is split in two parts, a
Begin and an End part. The begin part is responsible to prepare the call and to return the caller
right away, and the end part is the one called to get back the result. The method was run in a
thread from the thread pool. It is not recommended to use this approach for new development;
instead use the new TAP.
106
atomic operation
An operation that will be run at once without being interrupted by the scheduler.
107
deadlock
Occurs when two or more threads try to acquire a lock on a resource that one of the other
threads has locked already; neither of them can make more progress. There are four conditions that
need to be fulfilled and that lead to a deadlock: mutual exclusion, hold and wait, no preemption, and
circular wait.
108
Event-based Asynchronous Pattern (EAP)
This pattern requires a method to be suffixed with Async
and provide events and delegates to signal when the method finished or failed. It is not recommended
for new development to use this approach; instead use the new TAP.
109
fork-join pattern
The process of spawning another thread from the current thread (fork) to do
something else while the current threads continue their work and then to wait for the spawned
thread to finish its execution (join).
110
multithreading
The capability of an operating system, or a hardware platform to have several threads
of execution at the same time.
111
mutual exclusion
Mutual exclusion is the problem, first solved by Edsger W. Dijkstra, of ensuring
that two threads can’t be in the same critical section at the same time.
112
race condition
Occurs when two or more threads access shared data, writing at the same time. If
the access to data is for read purposes only, there is no problem. But when several threads try to
write, one thread might overwrite the data written by another thread, not taking in consideration
the change.
113
scheduler
A component of the operating system that ensures that threads are given access to the
CPU in a fair manner, avoiding situations when a thread monopolizes the CPU.
114
task
A unit of work. It normally represents an asynchronous operation that is part of a bigger problem.
115
Task Parallel Library (TPL)
A .NET library created by Microsoft that tries to abstract away and
simplify the code that deals with threads.
116
Task-based Asynchronous Pattern (TAP)
A pattern based on a single method that returns Task or
Task objects that represent the asynchronous work in progress. This is the recommended
pattern for the new development.
117
thread
The smallest unit of execution that can be independently scheduled by the operating system.
118
thread pool
The thread pool represents a pool of precreated threads that can be used by the tasks, or
to queue work items, or to run asynchronous I/O operations.
119
anonymous method
Enables you to associate a block of code with a delegate without declaring the
method signature.
120
assembly
A compiled piece of code in a DLL or EXE file.
121
attribute
Enables you to associate metadata with assemblies, types, methods, properties, and so on.
122
Code Document Object Model (CodeDOM
Enables the developer to generate code in multiple languages
| at run time based on a single code set.
123
context
When loading an assembly using reflection, the context is where reflection searches for
the assembly.
124
contravariance
Permits parameter types that are less derived than the delegate’s parameter types.
125
covariance
Enables you to have a method with a more derived return type than the delegate’s
return type.
126
delegate
A type that references a method.
127
expression lambda
A lambda expression that contains only one statement for the body.
128
Expression Tree
Code in a tree-like structure where each node is an expression.
129
field
A variable defined in a class or struct.
130
lambda expression
Shorthand syntax for an anonymous method that can be associated with a
delegate or expressions tree.
131
load context
When loading an assembly using reflection, this context contains the assemblies found
by probing.
132
load-from context
When loading an assembly using reflection, this context contains the assemblies
located in the pat passed into the LoadFrom method.
133
module
A file that composes an assembly. Typically this is the DLL or EXE file.
134
probing
The process of looking in the GAC, the host assembly store, the folder of the executing
assembly, or the private bin folder of the executing assembly to find an assembly.
135
reflection
Provides classes that can be used to read metadata or dynamically invoke behavior from
a type.
136
reflection-only context
When loading an assembly using reflection, this is the context that contains
the assemblies loaded with the ReflectionOnlyLoad and ReflectionOnlyLoadFrom methods.
137
statement lambda
A lambda expression with more than one statement in the body of the expression.
138
target
The class, property, or method that contain metadata defined by an attribute.
139
type
Any class, interface, array, value type, enumeration, parameter, generic type definition, and
open or closed constructed generic type.
140
ADO.NET Entity Framework
An object relational mapping tool that provides a graphical user interface
that generates to code to perform operations against a database using ADO.NET
141
array
The most basic type used to store a set of data.
142
async
Indicates that the method, lambda expression, or anonymous method is asynchronous.
143
await
Suspends the execution of a method until the awaited task completes.
144
boxing/unboxing
Boxing is the process of converting a value type to a reference type. Unboxing is
the process of converting a reference type to a value type.
145
collection
A generic term that encompasses lists, dictionaries, queues, stacks, hash tables, and other
objects that can contain sets of data.
146
connection object
An object in ADO.NET that allows you to open and execute commands against
a database.
147
IComparable interface
```
A class that implements the IComparable interface can be sorted when used
in a collection or array.
```
148
indexer
A method that is used when referencing an element in an array or collection by using square
brackets, [], and its index.
149
JSON
JavaScript Object Notation is a lightweight data-interchange format.
150
Object Relational Mapping (ORM)
A computer software term for tools that convert data between
| type systems using an object oriented programming language.
151
OData ATOM
The XML representation of data returned from an OData query.
152
Open Data Protocol (OData)
A web protocol for querying and updating data through the Internet
or intranet.
153
shallow copy
Creating a new copy of an object that copies all value types and copies object references
for reference types.
154
serialization
The process of converting an object into a stream of bytes that can be stored
or transmitted.
155
stream
An abstract class that provides a generic view of a sequence of bytes.
156
Text Transformation Template Toolkit (T4 Template)
A file that contains text blocks and control
| statements that enable to you to generate a code file.
157
WCF Data Services
Enables you to use OData to expose and consume data over the web or
an intranet.
158
anonymous type
A type created with read-only properties without having to write the code to
declare the class.
159
composite keys
Contains multiple properties that you need for the purpose of a join.
160
deferred execution
Execution of a LINQ query is deferred until the result is enumerated or by
calling a function on the result.
161
Goes To operator
The Goes To operator is the => signs in a lambda expression.
162
implicitly typed variable
A variable that has its type determined by the expression on the right side
of the initialization statement. Use the keyword var to declare an implicitly typed variable.
163
inner sequence
When using the method-based Join function, this refers to the sequence passed into
the Join method as a parameter.
164
Language Integrated Query (LINQ)
A set of features that extends powerful query capabilities to C#.
165
method-based query
A feature of LINQ that uses extension methods on types that implement the
IEnumerable or IQuerable interface to query the data.
166
outer join
Selects all elements from one sequence when joined to another sequence even if there is
not a match on the joined property.
167
outer sequence
When using the method-based Join function, this refers to the sequence calling the
Join method.
168
ParamArray
A parameter to a method that enables you to pass an unknown number of parameter to
the method.
169
predicate
The code executed in a where clause for a query expression.
170
projection
Selecting a subset of properties from a type that creates a new anonymous type.
171
query expression
A feature of LINQ that enables you to query any type that implements the
IEnumerable or IQueryable interface by using syntax that is easy to comprehend.
172
assertion
A piece of code that makes a particular claim about the data and that throws an exception
if that claim is false. In C# you can use the System.Diagnostics.Debug.Assert method to
make assertions.
173
character class
A regular expression construction that represents a set of characters to match.
174
conditional compilation constant
A predefined symbol created by Visual Studio that you can use with
the #if, #elif, #else, and #endif directives to determine what code is included in the program. These
include DEBUG and TRACE, which are normally defined in debug and release builds, respectively.
175
data validation
Program code that verifies that a data value such as a string entered by the user
makes sense. For example, the program might require that a value be nonblank, that a monetary
value be a valid value such as $12.34 not “ten,” or that an e‑mail address contain the @ symbol.
176
escape sequence
A sequence of characters that have special meaning, for example, in a regular
expression.
177
inline options
Options set in a regular expression by using the syntax (?imnsx).
178
instrumenting
Adding features to a program to study the program itself.
179
logging
The process of instrumenting a program, so it records key events.
180
pattern
A regular expression used for matching parts of a string.
181
performance counter
A system-wide counter used to track some type of activity on the computer.
182
profiler
An automated tool that gathers performance data for a program by instrumenting its code or
by sampling.
183
profiling
The process of instrumenting a program to study its speed, memory, disk usage, or other
performance characteristics.
184
regular expression
An expression in a regular expression language that defines a pattern to match.
Regular expressions let a program match patterns and make replacements in strings.
185
sanity check
A test on data to see if the data makes sense. For example, if a user enters the cost
of a ream of paper as $1e10.00, that might be a typographical error, and the user may have meant
$100.00. Sometimes the user might actually have intended an unusual value, so the program must
decide whether to reject the value or ask the user whether the value is correct.
186
tracing
The process of instrumenting a program so that you can track what it is doing.
187
assembly
An assembly is the unit of reuse, deployment, versioning, and security.
188
asymmetric encryption (public key)
A cryptographic algorithm that uses two complementary keys,
one for encryption and one for decryption. Data encrypted with the public key can only be decrypted
using the private key.
189
Certificate Authority (CA)
An entity that issues digital certificates.
190
Certificate Revocation List (CRL)
A list of digital certificates that has been revoked for various
reasons. You shouldn’t use a certificate if it is revoked.
191
certificate stores
A special storage location on your computer, used to store encryption certificates.
192
Common Language Runtime (CLR)
CLR is the component of .NET Framework responsible for
| running .NET applications and managing their running environment.
193
cryptography
The practice and study of techniques for secure communication.
194
decryption
The process of decoding previously encrypted data so that it can be used by your
application.
195
encryption
The process of encoding data so that it cannot be read by an unauthorized person.
196
Global Assembly Cache (GAC)
GAC is a machine-wide code cache.
197
hash bucket
A data structure that holds items that share the same hash value.
198
hashing
Used to map data structures of variable length, to fixed size data structures. Hashing the
same data using the same algorithm will always yield the same hash value.
199
initialization vector (IV)
A data array used by the encryption algorithms to encrypt the first data
block. The IV doesn’t need to be kept secret.
200
Intermediate Language (IL)
The result of compiling a .NET application from source code.
201
Just In Time compiler (JIT)
A component of the .NET that transforms the IL into binary code that
can be run on the target platform.
202
Message Authentication Code (MAC)
A family of cryptographic algorithms used to provide data
| integrity and authenticity.
203
private key
The public and private keys are a pair of complementary keys used together in the
asymmetric encryption. Data encrypted with the private key can only be decrypted using the public
key, and data encrypted with the public key can only be decrypted using the private key.
204
public key
The public and private keys are a pair of complementary keys used together in the
asymmetric encryption. Data encrypted with the private key can only be decrypted using the public
key, and data encrypted with the public key can only be decrypted using the private key.
205
Public Key Infrastructure (PKI)
The infrastructure needed to handle digital certificates.
206
Secured Hash Algorithm (SHA)
A family of cryptographic algorithms used to calculate hashes
published by NIST.
207
Secure Socket Layer (SSL)
A cryptographic protocol used for secure communication over the Internet.
208
symmetric encryption (shared secret)
A cryptographic algorithm that uses the same key for both
| encryption and decryption of data.
209
Transport Layer Security (TLS)
A cryptographic protocol used for secure communication over the
Internet, the successor of SSL.
