C Sharp Mta 98 - 361 Software Development Fundamentals

Front 1

Abstract Classes

Back 1

provide a common definition of a base class that can be shared by multiple derived classes.

Front 2

Checked and unchecked

Back 2

checked, unchecked

Front 3

fixed Statement

Back 3

fixed

Front 4

lock Statement

Back 4

lock

Front 5

!x (Unary Operator) logical negation operator

Back 5

is a unary operator that negates its operand. It is defined for bool and returns true if and only if its operand is false.

Front 6

& operator

Back 6

evaluates both operators regardless of the first one's value.

Front 7

&x (Unary Operator)

Back 7

returns the address of its operand (requires unsafe context)

Front 8

(T)x (Parentheses Unary Operator)

Back 8

In addition to being used to specify the order of operations in an expression, parentheses are used to perform the following tasks: 1. Specify casts, or type conversions. 2. Invoke methods or delegates.

Front 9

* operator

Back 9

can only be used in unsafe contexts, denoted by the use of the unsafe keyword, and requiring the /unsafe compiler option.

Front 10

* operator

Back 10

is also used to declare pointer types and to dereference pointers.

Front 11

*x (Multiplication Unary Operator)

Back 11

computes the product of its operands. Also, the dereference operator, which allows reading and writing to a pointer.

Front 12

++x

Back 12

is a prefix increment operation. The result of the operation is the value of the operand after it has been incremented.

Front 13

++x (Increment Unary Operator)

Back 13

increments its operand by 1. The increment operator can appear before or after its operand

Front 14

+= operator

Back 14

is also used to specify a method that will be called in response to an event; such methods are called event handlers. The use of the += operator in this context is referred to as subscribing to an event.

Front 15

+x (Unary Operator)

Back 15

can function as either a unary or a binary operator. They are predefined for all numeric types. It computes the sum of its two operands. When one or both operands are of type string, it concatenates the string representations of the operands.

Front 16

--variable

Back 16

form is a prefix decrement operation. The result of the operation is the value of the operand "after" it has been decremented.

Front 17

--x

Back 17

form is a prefix decrement operation. The result of the operation is the value of the operand "after" it has been decremented.

Front 18

--x operator (Decrement Unary Operator)

Back 18

decrements its operand by 1. The decrement operator can appear before or after its operand

Front 19

-= operator

Back 19

is also used in C# to unsubscribe from an event.

Front 20

-> (Primary Operator)

Back 20

combines pointer dereferencing and member access. It can be used only in code that is marked as unsafe. It cannot be overloaded.

Front 21

-x (Unary Operator)

Back 21

can function as either a unary or a binary operator.

Front 22

/? (Compiler Option)

Back 22

Displays a usage message to stdout.

Front 23

1 byte

Back 23

8 bits

Front 24

2 bytes

Back 24

16 bits

Front 25

3 bytes

Back 25

32 bits

Front 26

4 bytes

Back 26

64 bits

Front 27

5 bytes

Back 27

128 bits

Front 28

6 bytes

Back 28

256 bits

Front 29

7 bytes

Back 29

512 bits

Front 30

8 bytes

Back 30

1024 bits

Front 31

=> (Lambda expression Operator)

Back 31

is used in lambda expressions to separate the input variables on the left side from the lambda body on the right side. Lambda expressions are inline expressions similar to anonymous methods but more flexible; they are used extensively in LINQ queries that are expressed in method syntax.

Front 32

?: (Conditional Operator)

Back 32

returns one of two values depending on the value of a Boolean expression. Following is the syntax for the conditional operator.

Front 33

@ (Compiler Option)

Back 33

Reads a response file for more options.

Front 34

a[x] (Primary Operator)

Back 34

are used for arrays, indexers, and attributes. They can also be used with pointers.

Front 35

abstract (Class modifier)

Back 35

Specifies that a class only serves as a base class. It must be implemented in inheriting class. Indicates that a class is intended only to be a base class of other classes.

Front 36

abstract classes

Back 36

cannot be instantiated directly, they can serve as base classes for other classes that provide the missing implementation.

Front 37

Abstract Classes

Back 37

provide a common definition of a base class that can be shared by multiple derived classes.

Front 38

abstract keyword

Back 38

enables you to create classes and class members that are incomplete and must be implemented in a derived class.

Front 39

Abstract Method

Back 39

provides a definition but does not offer any implementation (the method body). If any of the members of a class are abstract, the class itself needs to be marked as abstract. An abstract class cannot be instantiated.

Front 40

Acceptance Testing

Back 40

is often performed by the customers themselves.

Front 41

Access Keywords

Back 41

base this

Front 42

Access Modifier

Back 42

specifies what region of the code will have access to a field.

Front 43

Access Modifiers

Back 43

Specifies the declared accessibility of types and type members. 1.public 2.private 3.internal 4.protected

Front 44

Accessibility

Back 44

The Accessibility and all of its exposed members are part of a managed wrapper for the Component Object Model (COM) accessibility interface.

Front 45

ad-hoc SQL queries

Back 45

flexible way to work with a SQL Server database.

Front 46

add (Contextual Keyword)

Back 46

Defines a custom event accessor that is invoked when client code subscribes to the event.

Front 47

add (Contextual Keyword)

Back 47

is used to define a custom event accessor that is invoked when client code subscribes to your event.

Front 48

Additive Operators

Back 48

x + y x - y

Front 49

Algorithm

Back 49

set of ordered and finite steps to solve a given problem.

Front 50

alias (Contextual Keyword)

Back 50

is used to reference two versions of assemblies that have the same fully-qualified type names.

Front 51

All methods, fields, constants, properties, and events must be declared

Back 51

within a type; these are called the members of the type.

Front 52

anonymous types

Back 52

can be used in situations where it is not convenient or necessary to create a named class

Front 53

Anonymous Types

Back 53

provide a convenient way to encapsulate a set of read-only properties into a single object without having to explicitly define a type first.

Front 54

Anonymous Types

Back 54

type name is generated by the compiler and is not available at the source code level.

Front 55

Application Lifecycle Management (Alm)

Back 55

refers to the various activities that revolve around a new software product from its inception to the time when it matures and perhaps retires.

Front 56

Application State

Back 56

is used to store data that is used throughout an application.

Front 57

Apply the normalization process

Back 57

Applies data normalization rules to ensure that any problems that may affect data integrity are resolved. Step 6

Front 58

Array

Back 58

a collection of items in which each item can be accessed by using a unique index.

Front 59

Array

Back 59

common data structure that represents a collection of items of a similar type.

Front 60

Array

Back 60

homogeneous data structure because the all the items of an array are of the same data type.

Front 61

Array Item

Back 61

can be directly accessed by using an index.

Front 62

Arrays

Back 62

are most useful for creating and working with a fixed number of strongly-typed objects.

Front 63

Arrays operations

Back 63

Access Allocation

Front 64

as

Back 64

is like a cast operation. However, if the conversion isn't possible, as returns null instead of raising an exception.

Front 65

as (operator)

Back 65

will attempt to do a silent cast to a given type. If it succeeds it will return the object as the new type, if it fails it will return a null reference.

Front 66

as (Relational and type testing Operator)

Back 66

can be used to perform certain types of conversions between compatible reference types or nullable types.

Front 67

ascending ( Query Keyword (LINQ))

Back 67

Contextual keyword in an orderby clause.

Front 68

ascending (Contextual Keyword)

Back 68

is used in the orderby clause in query expressions to specify that the sort order is from smallest to largest.

Front 69

ASP.NET Methods that are recognized as event handlers by default

Back 69

Page_Init, Page_Load, Page_DataBind, Page_PreRender, Page_Unload.

Front 70

Assembly

Back 70

unit of executable code that can be independently versioned and installed.

Front 71

Assignment and lambda expression Operators

Back 71

x = y x += y x -= y x *= y x /= y x %= y x &= y x |= y x ^= y x <<= y x >>= y =>

Front 72

async (Contextual Keyword)

Back 72

Indicates that the modified method, lambda expression, or anonymous method is asynchronous.

Front 73

async (Contextual Keyword)

Back 73

to specify that a method, lambda expression, or anonymous method is asynchronous.

Front 74

async (modifier)

Back 74

to specify that a method, lambda expression, or anonymous method is asynchronous. If you use this modifier on a method or expression, it's referred to as an async method. Indicates that the modified method, lambda expression, or anonymous method is asynchronous.

Front 75

Attribute

Back 75

distinct properties of an entity.

Front 76

Attribute

Back 76

piece of data that further describes an element.

Front 77

Attributes

Back 77

provide a powerful method of associating metadata, or declarative information, with code (assemblies, types, methods, properties, and so forth).

Front 78

Auto Implemented Properties

Back 78

simplify property declarations.

Front 79

await (Contextual Keyword)

Back 79

Suspends an async method until an awaited task is completed.

Front 80

await (Contextual operator Keyword)

Back 80

is applied to a task in an asynchronous method to suspend the execution of the method until the awaited task completes. The task represents ongoing work.

Front 81

await (Unary Operator)

Back 81

is applied to a task in an asynchronous method to suspend the execution of the method until the awaited task completes. The task represents ongoing work.

Front 82

base (Access Keyword)

Back 82

Accesses the members of the base class.

Front 83

base (access keyword)

Back 83

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.

Front 84

Base Class

Back 84

class whose functionality is inherited

Front 85

Base classes

Back 85

may define and implement virtual methods, and derived classes can override them, which means they provide their own definition and implementation.

Front 86

Binary & operators

Back 86

are predefined for the integral types and bool. For integral types, & computes the logical bitwise AND of its operands. For bool operands, & computes the logical AND of its operands; that is, the result is true if and only if both its operands are true.

Front 87

Binary - operators

Back 87

are predefined for all numeric and enumeration types to subtract the second operand from the first.

Front 88

Binary Code

Back 88

computer program written using the binary number system.

Front 89

Binary Number System

Back 89

each value is represented using only two symbols, 0 and 1

Front 90

Binary Number System

Back 90

system that only uses two numbers, 0 and 1, to express a value.

Front 91

Binary operators

Back 91

operators take two operands. Examples include x + y or x > y.

Front 92

Black-Box Testing

Back 92

focuses solely on inputs and outputs. With this approach, any knowledge of internal system workings is not used during testing.

Front 93

bool 2 bytes

Back 93

True or false

Front 94

bool operands, &

Back 94

computes the logical AND of its operands; that is, the result is true if and only if both its operands are true.

Front 95

bool(Value type)

Back 95

is used to declare variables to store the Boolean values, true and false. Default value= false

Front 96

Both classes and structs can contain

Back 96

static members.

Front 97

break (Jump statement)

Back 97

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.

Front 98

BubbleSort algorithm

Back 98

uses a series of comparison and swap operations to arrange the elements of a list in the correct order.

Front 99

built-in elementary data types

Back 99

(such as bool, int, char, double, etc.) are value types

Front 100

by ( Query Keyword (LINQ))

Back 100

Contextual keyword in a group clause.

Front 101

byte (Integral Type)

Back 101

1 byte Range: 0 to 255 Size: Unsigned 8-bit integer Default value= 0

Front 102

C#

Back 102

part of the .NET Framework and benefits from the runtime support and class libraries provided by the .Framework.

Front 103

C#

Back 103

popular high-level programming language that allows you to write computer programs in a human-readable format.

Front 104

C# 3 categories Types

Back 104

1.Value types 2.Reference types 3.Pointer types

Front 105

C# Keywords

Back 105

Access Keywords Contextual Keywords conversion Keywords Literal Keywords Method Parameters Modifiers Namespace Keywords Operator Keywords Query Keyword (LINQ) Statement Keywords Types

Front 106

C# operators grouped in order of precedence.

Back 106

Primary Unary Multiplicative Additive Shift Relational and type testing Equality Logical AND Logical XOR Assignment and lambda expression

Front 107

Cascading Style Sheets (Css)

Back 107

enables the storage of a Web page’s style and formatting information separate from the HTML code. This separation makes it easier to update the look and feel of the Web site.

Front 108

case (Selection statement)

Back 108

switch statement includes one or more switch sections. Each switch section contains one or more case labels followed by one or more statements. The following example shows a simple switch statement that has three switch sections.

Front 109

Case Statement

Back 109

takes control in a switch statement execution if it matches the value in the switch statement

Front 110

char (Integral Type)

Back 110

2 bytes Range: U+0000 to U+ffff Size: Unicode 16-bit character Default value= '\0'

Front 111

checked (Primary Operator)

Back 111

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

Front 112

Checked and Unchecked

Back 112

checked unchecked

Front 113

class

Back 113

defines a type of object, but it is not an object itself.

Front 114

Class

Back 114

defines the template for an object but is not an object itself.

Front 115

Class

Back 115

definition of a new data type.

Front 116

class

Back 116

is a construct that enables you to create your own custom types by grouping together variables of other events, methods and types.

Front 117

class

Back 117

is like a blueprint. It defines the data and behavior of a type.

Front 118

Class

Back 118

set of data and methods.

Front 119

Class

Back 119

template from which individual objects are created

Front 120

Class Definition

Back 120

sometimes also referred to as a type.

Front 121

Class members

Back 121

can have modifiers such as private, public, and static.

Front 122

class members

Back 122

include all the members declared in the class, along with all members (except constructors and destructors) declared in all classes in its inheritance hierarchy.

Front 123

class or struct

Back 123

can be nested within another class or struct.

Front 124

class that derives from another class (the base class)

Back 124

automatically contains all the public, protected, and internal members of the base class except its constructors and destructors.

Front 125

Classes

Back 125

can also be declared as sealed to prevent other classes from inheriting from them.

Front 126

classes

Back 126

reference types

Front 127

Classes (but not structs) can be declared

Back 127

as static.

Front 128

Classes (but not structs) support

Back 128

the concept of inheritance.

Front 129

Classes and structs

Back 129

can be defined with one or more type parameters.

Front 130

Classes and structs

Back 130

can inherit multiple interfaces.

Front 131

Classes and structs

Back 131

have members that represent their data and behavior.

Front 132

classes are

Back 132

reference types

Front 133

classes are used

Back 133

to model more complex behavior, or data that is intended to be modified after a class object is created.

Front 134

Classes may be declared as abstract, which means

Back 134

that one or more of their methods have no implementation.

Front 135

Clear (Stack Methods)

Back 135

Removes all objects from the Stack.

Front 136

Client-side Programming

Back 136

refers to programs that execute completely on a user’s local computer.

Front 137

Client-side Programs

Back 137

can include the Windows Forms application and JavaScript code that executes within a Web browser.

Front 138

Client-side Programs

Back 138

do not consume server resources.

Front 139

Client-side state management techniques

Back 139

use HTML and the capabilities of Web browsers to store state information on client computers. 1. cookies, 2. hidden fields, 3. query strings, 4. ViewState,

Front 140

collection

Back 140

is a class, it must be declared as a new collection before elements are added to that collection.

Front 141

Collections

Back 141

provide a more flexible way to work with groups of objects than arrays.

Front 142

Command-Line Parameters

Back 142

can be used to provide input to an application at the time of execution

Front 143

Computer Programs (Programs)

Back 143

sets of precise and complete instructions to accomplish a task.

Front 144

concatenate string literals or string constants

Back 144

by using the + operator, the compiler creates a single string.

Front 145

Concatenation

Back 145

is the process of appending one string to the end of another string.

Front 146

Conditional AND Operator

Back 146

x && y

Front 147

Conditional Operator

Back 147

?:

Front 148

Conditional OR Operator

Back 148

x || y

Front 149

Console-Based Application

Back 149

do not have a graphical user interface and use a text-mode console window to interact with the user.

Front 150

const (Class member modifier)

Back 150

Specifies that a variable is a constant value that has to be initialized when it gets declared.

Front 151

const (modifier )

Back 151

Specifies that the value of the field or the local variable cannot be modified.

Front 152

Constant

Back 152

data fields or local variables whose value cannot be modified.

Front 153

Constants

Back 153

are declared by using the const keyword

Front 154

Constraints

Back 154

are specified by using the where contextual keyword.

Front 155

Constraints

Back 155

where T :

where T : where T : class where T : new() where T : U where T: struct

Front 156

Constructors

Back 156

Instance Constructors, Private Constructors, Static Constructors

Front 157

Constructors

Back 157

used to initialize the data members of an object.

Front 158

Contains (Stack Methods)

Back 158

Determines whether an element is in the Stack.

Front 159

contextual keyword

Back 159

used to provide a specific meaning in the code, but it is not a reserved word in C#.

Front 160

Contextual Keywords

Back 160

is used to provide a specific meaning in the code, but it is not a reserved word in C#. Some contextual keywords, such as partial and where, have special meanings in two or more contexts.

Front 161

Contextual Keywords list 1 a-o

Back 161

add alias ascending async await descending dynamic from get global group into join let orderby

Front 162

Contextual Keywords list 2 p-y

Back 162

partial (type) partial (method) remove select set value var where (generic type constraint) where (query clause) yield

Front 163

continue (Jump statement )

Back 163

passes control to the next iteration of the enclosing while, do, for, or foreach statement in which it appears.

Front 164

Continue Statement

Back 164

can be used to pass control to next iteration of the loop without exiting the loop

Front 165

control

Back 165

distinct user interface element that accepts input from the user or displays output to the user.

Front 166

Conversion Keywords

Back 166

explicit implicit operator

Front 167

Cookies

Back 167

small packets of information that are stored by a Web browser locally on the user’s computer.

Front 168

CSS

Back 168

great tool for increasing site-wide consistency and maintainability

Front 169

CSS

Back 169

language that describes information about displaying a Web page.

Front 170

Culture-sensitive comparisons

Back 170

are typically used to compare and sort strings that are input by end users, because the characters and sorting conventions of these strings might vary depending on the locale of the user's computer.

Front 171

Data Normalization Process

Back 171

ensures that a database design is free of any problems that could lead to loss of data integrity.

Front 172

Data Structures

Back 172

are the building blocks of most computer programs, and they allow developers to implement complex functionality.

Front 173

Data structures

Back 173

techniques for organizing and storing data in computer memory.

Front 174

Data Types

Back 174

defines the size of memory needed to store the data and the kinds of operations that can be performed on the data.

Front 175

DataAdapter

Back 175

stores the data connection and data commands needed to connect to the data source.

Front 176

DataAdapter class

Back 176

acts as a bridge between the data source and the DataSet.

Front 177

Database

Back 177

organized collection of interrelated data that is managed as a single unit.

Front 178

Database Integrity

Back 178

means that the data is accurate and consistent at all times.

Front 179

Database Management System (Dbms)

Back 179

software that organizes databases and provides features such as storage, data access, security, backup, etc

Front 180

DataSet Class

Back 180

represents an in-memory representation of relational data.

Front 181

decimal

Back 181

indicates a 128-bit data type.

Front 182

Decision Structures

Back 182

introduce decision-making ability into a program. They enable you to branch to different sections of the code depending on the truth value of a Boolean expression.

Front 183

Decision Table

Back 183

a more compact and readable format for presenting the algorithm.

Front 184

decision-making control structures in C#

Back 184

if, if-else, switch statements.

Front 185

decrement operator

Back 185

can appear before or after its operand

Front 186

default (Jump statement)

Back 186

can be used in the switch statement or in generic code: 1.The switch statement: Specifies the default label. 2.Generic code: Specifies the default value of the type parameter. This will be null for reference types and zero for value types.

Front 187

default constructor

Back 187

constructor without parameters

Front 188

Default Statement

Back 188

is the last statement in a switch block.

Front 189

Default Statement

Back 189

takes control in a switch statement execution if there is no matching case statement

Front 190

default(T) (Primary Operator)

Back 190

will return null for reference types and zero for numeric value types. For structs, it will return each member of the struct initialized to zero or null depending on whether they are value or reference types. For nullable value types, it returns a System.Nullable, which is initialized like any struct.

Front 191

delegate (Primary Operator)

Back 191

is a type that represents references to methods with a particular parameter list and return type. When it is instantiate, it can associate its instance with any method with a compatible signature and return type.

Front 192

Delegate types also provide a binary - operator

Back 192

performs delegate removal.

Front 193

Delegate types also provide a binary - operator,

Back 193

which performs delegate removal.

Front 194

Delegates

Back 194

are special types that are used to encapsulate a method with a specific signature.

Front 195

Delegates

Back 195

are used to pass methods as arguments to other methods.

Front 196

DELETE

Back 196

statements allow you to delete data from a database.

Front 197

Delete Anomaly

Back 197

situation in which the deletion of one piece of data causes unintended loss of other data.

Front 198

Derived Class

Back 198

inherits all the functionality of the base class and can also define additional features that make it different from the base class.

Front 199

derived class

Back 199

inherits from a base class, it gains all the methods, fields, properties and events of the base class.

Front 200

descending ( Query Keyword (LINQ))

Back 200

Contextual keyword in an orderby clause.

Front 201

descending (Contextual Keyword)

Back 201

is used in the orderby clause in query expressions to specify that the sort order is from largest to smallest.

Front 202

Design Process

Back 202

is used to create plans, models, and architecture for how the software will be implemented

Front 203

Destructors

Back 203

are used to destruct instances of classes.

Front 204

Determine the data that needs to be stored

Back 204

Identifies all the different types of data that need to be stored in the database. Generally, this information is collected as part of the requirements analysis task via entity-relationship diagrams. Step 2

Front 205

Develop a mission statement for the database

Back 205

Identifies the purpose of the database, how it will be used, and who will use it. This step sets the tone for the rest of the design process. Step 1

Front 206

Disconnected Applications

Back 206

are applications that can continue to function without a constant connection to network resources such as databases.

Front 207

Divide the data into tables and columns

Back 207

Identifies the tables and the information that you want to store in those tables. Step 3

Front 208

do (Iteration statement)

Back 208

executes a statement or a block of statements repeatedly until a specified expression evaluates to false. The body of the loop must be enclosed in braces, {}, unless it consists of a single statement. In that case, the braces are optional.

Front 209

do-while loop

Back 209

is similar to the while loop but, unlike the while loop, the body of the do-while loop must be executed at least once.

Front 210

Do-While Loop

Back 210

repeatedly executes a block of statements until a specified Boolean expression evaluates to false.

Front 211

do-while loop

Back 211

tests the condition at the bottom of the loop.

Front 212

double (Floating-Point Type)

Back 212

8 bytes signifies a simple type that stores 64-bit floating-point values. Approximate range: ±5.0e-324 to ±1.7e308 Precision: 15-16 digits

Front 213

dynamic (Contextual Keyword)

Back 213

Defines a reference type that enables operations in which it occurs to bypass compile-time type checking.

Front 214

dynamic (Contextual type Keyword)

Back 214

enables the operations in which it occurs to bypass compile-time type checking. Instead, these operations are resolved at run time.

Front 215

E Parameter

Back 215

reference to an event data object that contains no event data.

Front 216

Element

Back 216

opening tag and closing tag together with their contents

Front 217

Encapsulation

Back 217

is sometimes referred to as the first pillar or principle of object-oriented programming. According to the principle of encapsulation, a class or struct can specify how accessible each of its members is to code outside of the class or struct. Methods and variables that are not intended to be used from outside of the class or assembly can be hidden to limit the potential for coding errors or malicious exploits.

Front 218

Encapsulation

Back 218

mechanism to restrict access to a class or class members in order to hide design decisions that are likely to change.

Front 219

Encapsulation

Back 219

provides class designers with the flexibility to change a section of code as needed without changing all other code that makes use of that code.

Front 220

Entity construct

Back 220

for a physical object or a concept. Examples include an order, a customer, an employee, and so on. An entity is generally named for the noun that it represents.

Front 221

Entity-relationship diagrams (ERDS)

Back 221

used to model the entities, their attributes, and the relationships among entities. The entity-relationship diagrams can help you in determine what data needs to be stored in a database.

Front 222

Entity-relationship modeling

Back 222

process used to create the conceptual data model of a system, and entity-relationship diagrams are the graphical modeling tools for accomplishing this modeling.

Front 223

enum (Value Type)

Back 223

Enumeration (Category Type)

Front 224

enumeration type

Back 224

also named an enumeration or an enum

Front 225

enumeration type

Back 225

provides an efficient way to define a set of named integral constants that may be assigned to a variable.

Front 226

Equality Operators

Back 226

x == y x != y

Front 227

equals ( Query Keyword (LINQ))

Back 227

Contextual keyword in a join clause.

Front 228

Equals(Object) (Stack Methods)

Back 228

Determines whether the specified object is equal to the current object. (Inherited from Object.)

Front 229

event (Class member modifier)

Back 229

is used to declare an event in a publisher class.

Front 230

Event handlers

Back 230

are nothing more than methods that are invoked through delegates.

Front 231

Event logs

Back 231

the part of Windows that is used by operating system tasks and applications running in the background to log error or other informational messages.

Front 232

eventId

Back 232

application-specific id used to identify the event.

Front 233

Events

Back 233

enable a class or object to notify other classes or objects when something of interest occurs.

Front 234

Events

Back 234

way for a class to notify other classes or objects when something of interest happens.

Front 235

events

Back 235

provide communication between objects

Front 236

Every entity

Back 236

must have a set of uniquely identifying attributes that is known as the entity’s primary key.

Front 237

Exception

Back 237

is an error condition that occurs during the execution of a program.

Front 238

Exception Handling Statements

Back 238

throw try-catch try-finally try-catch-finally

Front 239

exceptions

Back 239

are handled by code that is outside the normal flow of control.

Front 240

explicit keyword

Back 240

declares a user-defined type conversion operator that must be invoked with a cast.

Front 241

Extensible Markup Language (Xml)

Back 241

text-based format for representing structured data.

Front 242

Extension Methods

Back 242

are a special kind of static method, but they are called as if they were instance methods on the extended type.

Front 243

extern

Back 243

is used as a method modifier, declaring a method written in unmanaged code.

Front 244

extern (Class member modifier)

Back 244

Specify that a method signature without a body uses a DLL-import.

Front 245

extern (modifier)

Back 245

is used to declare a method that is implemented externally. A common use is with the DllImport attribute when you are using Interop services to call into unmanaged code. Indicates that the method is implemented externally.

Front 246

f(x) (Primary Operator)

Back 246

are used to perform the following tasks 1.Specify casts, or type conversions. 2.Invoke methods or delegates.

Front 247

false

Back 247

false Literal false Operator

Front 248

field

Back 248

is a variable of any type that is declared directly in a class or struct.

Front 249

fields

Back 249

cannot be virtual

Front 250

FIFO

Back 250

First-in, First-out

Front 251

final link

Back 251

null value in a linked list

Front 252

Finalize (Stack Methods)

Back 252

Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)

Front 253

Finally Block

Back 253

is always executed regardless of whether an exception is thrown.

Front 254

Finally Block

Back 254

is often used to write clean-up code.

Front 255

Finally Block

Back 255

is used in association with the try block.

Front 256

First Normal Form (1nf)

Back 256

none of the columns in the table should have multiple values in the same row of data.

Front 257

fixed

Back 257

prevents the garbage collector from relocating a movable variable. It is only permitted in an unsafe context. It can also be used to create exact size buffers.

Front 258

Flat Files

Back 258

database table that is stored inside a stand-alone disk file.

Front 259

float (Floating-Point Type)

Back 259

4 bytes signifies a simple type that stores 64-bit floating-point values. Approximate range: ±1.5e-45 to ±3.4e38 Precision: 7 digits

Front 260

floating-point expression

Back 260

can contain what sets of values: 1.Positive and negative zero 2.Positive and negative infinity 3.Not-a-Number value (NaN) 4.The finite set of nonzero values

Front 261

flowchart

Back 261

is a graphical representation of an algorithm.

Front 262

for (Iteration statement)

Back 262

can run a statement or a block of statements repeatedly until a specified expression evaluates to false.

Front 263

for loop

Back 263

combines the three elements of iteration—the initialization expression, the termination condition expression, and the counting expression—into a more readable code.

Front 264

for loop

Back 264

is useful for iterating over arrays and for other applications in which you know in advance how many times you want the loop to iterate.

Front 265

For some collections

Back 265

you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.

Front 266

foreach (Iteration statements)

Back 266

used to iterate through the collection to get the information that you want, but can not be used to add or remove items from the source collection to avoid unpredictable side effects.

Front 267

foreach loop

Back 267

is useful for iterating through the elements of a collection.

Front 268

Foreach Loop

Back 268

provides a simple way to iterate through a collection

Front 269

Fourth Normal Form (4nf)

Back 269

Every non-trivial multivalued dependency in the table is a dependency on a superkey

Front 270

from ( Query Keyword (LINQ))

Back 270

Specifies a data source and a range variable (similar to an iteration variable).

Front 271

from (Contextual clause Keyword)

Back 271

query expression must begin with... It specifies the following: 1. The data source on which the query or sub-query will be run. 2. A local range variable that represents each element in the source sequence.

Front 272

Functional Dependence

Back 272

2NF requires that all non-key columns are functionally dependent on the entire primary key.

Front 273

generic classes

Back 273

common use is with collections like linked lists, hash tables, stacks, queues, trees, and so on.

Front 274

Generic classes

Back 274

encapsulate operations that are not specific to a particular data type.

Front 275

generic delegate

Back 275

can define its own type parameters. Code that references the generic delegate can specify the type argument to create a closed constructed type, just like when instantiating a generic class or calling a generic method

Front 276

generic method

Back 276

is a method that is declared with type parameters

Front 277

generic type or method definition

Back 277

type parameters is a placeholder for a specific type that a client specifies when they instantiate a variable of the generic type.

Front 278

get (Contextual Keyword)

Back 278

Defines an accessor method for a property or an indexer.

Front 279

get (Contextual Keyword)

Back 279

defines an accessor method in a property or indexer that retrieves the value of the property or the indexer element.

Front 280

get accessor

Back 280

is used to return the property value

Front 281

GetEnumerator (Stack Methods)

Back 281

Returns an enumerator for the Stack.

Front 282

GetHashCode (Stack Methods)

Back 282

Serves as the default hash function. (Inherited from Object.)

Front 283

GetType (Stack Methods)

Back 283

Gets the Type of the current instance. (Inherited from Object.)

Front 284

global (Contextual Keyword)

Back 284

Specifies the default global namespace, which is otherwise unnamed.

Front 285

global (Contextual Keyword)

Back 285

when it comes before the :: operator, refers to the global namespace, which is the default namespace for any C# program and is otherwise unnamed.

Front 286

goto (Jump statement)

Back 286

is used to transfer control to a specific switch-case label or the default label in a switch statement.

Front 287

goto (Jump statement)

Back 287

transfers the program control directly to a labeled statement.

Front 288

group ( Query Keyword (LINQ))

Back 288

Groups query results according to a specified key value.

Front 289

group (Contextual Keyword clause )

Back 289

returns a sequence of IGrouping objects that contain zero or more items that match the key value for the group. For example, you can group a sequence of strings according to the first letter in each string. In this case, the first letter is the key and has a type char, and is stored in the Key property of each IGrouping object.

Front 290

head node

Back 290

first node of the linked list

Front 291

High-Level Language

Back 291

languages allow you to write precise instructions in a human-readable form.

Front 292

HTML

Back 292

text-based language used to create web pages.

Front 293

Hypertext Markup Language (HTML)

Back 293

language used by Web servers and browsers to describe a Web page.

Front 294

IComparable namespace

Back 294

common interface defined in the System namespace

Front 295

Identify relationships

Back 295

Identifies how the data in one table is related to the data in another table. For example, for each customer in a Customers table, you may have many orders in the Orders table; this relationship is called a one-to-many relationship.

Front 296

if (Selection statement)

Back 296

identifies which statement to run based on the value of a Boolean expression. In the following example, the Boolean variable result is set to true and then checked in the if statement. The output is The condition is true.

Front 297

if statement

Back 297

will execute a given sequence of statements only if the corresponding Boolean expression evaluates to true.

Front 298

if-else (Selection statement)

Back 298

After the then-statement or the else-statement runs, control is transferred to the next statement after the if statement.

Front 299

if-else (Selection statement)

Back 299

Because condition can’t be simultaneously true and false, the then-statement and the else-statement of an if-else statement can never both run.

Front 300

if-else (Selection statement)

Back 300

if condition evaluates to true, the then-statement runs.

Front 301

if-else (Selection statement)

Back 301

If condition is false, the else-statement runs.

Front 302

If-Else Statement

Back 302

allows your program to perform one action if the Boolean expression evaluates to true and a different action if the Boolean expression evaluates to false.

Front 303

implicit keyword

Back 303

is used to declare an implicit user-defined type conversion operator. Use it to enable implicit conversions between a user-defined type and another type, if the conversion is guaranteed not to cause a loss of data.

Front 304

in ( Query Keyword (LINQ))

Back 304

Contextual keyword in a join clause.

Front 305

in (Iteration statement)

Back 305

specifies that the type parameter is contravariant.

Front 306

In Collections , Unlike arrays,

Back 306

the group of objects you work with can grow and shrink dynamically as the needs of the application change.

Front 307

increment operator (++)

Back 307

increments its operand by 1. The increment operator can appear before or after its operand

Front 308

indirection operator

Back 308

is also known as the dereference operator.

Front 309

Inheritance

Back 309

feature of object-oriented programming that allows you to develop a class once, and then reuse that code over and over as the basis of new classes.

Front 310

initialization stage

Back 310

all the controls on the page are initialized and made available.

Front 311

INSERT

Back 311

statements allow you to add new data to a database.

Front 312

Insert Anomaly

Back 312

situation in which you cannot insert new data into a database because of an unrelated dependency. For example, if you want your database to have a new CategoryId and CategoryName for history books, the current design will not permit that unless you first have a history book to place in that category.

Front 313

Installer

Back 313

When added to a Windows Service project, the ServiceProcessInstaller and the ServiceInstaller classes are added to the project.

Front 314

instance class members

Back 314

can be used only after an instance of a class is created

Front 315

Instance Constructors

Back 315

are used to create and initialize any instance member variables when you use the new expression to create an object of a class.

Front 316

Instance fields

Back 316

are specific to an instance of a type.

Front 317

int

Back 317

4 bytes -2,147,483,648 to 2,147,483,647

Front 318

int (Integral Type)

Back 318

Range: -2,147,483,648 to 2,147,483,647 Size: Signed 32-bit integer

Front 319

Integral types &

Back 319

computes the logical bitwise AND of its operands.

Front 320

Integration Testing

Back 320

assesses the interface between software components.

Front 321

Integration Testing

Back 321

can involve testing the component’s interaction with an external system.

Front 322

Integrity

Back 322

the data in the database is accurate and consistent at all times.

Front 323

interface definition

Back 323

consists of a set of signatures for methods, properties, delegates, events, or indexers. An interface definition cannot consist of any data fields or any implementation details such as method bodies.

Front 324

Interfaces

Back 324

are used to establish contracts through which objects can interact with each other without knowing the implementation details.

Front 325

internal (Access Modifier)

Back 325

Access is limited to the current assembly.

Front 326

Internet

Back 326

global data communications system that provides connectivity among computers.

Front 327

Internet Information Services (IIS)

Back 327

Web server for hosting Web applications on the Windows operating system.

Front 328

into ( Query Keyword (LINQ))

Back 328

Provides an identifier that can serve as a reference to the results of a join, group or select clause.

Front 329

into (Contextual Keyword)

Back 329

can be used to create a temporary identifier to store the results of a group, join or select clause into a new identifier. This identifier can itself be a generator for additional query commands. When used in a group or select clause, the use of the new identifier is sometimes referred to as a continuation.

Front 330

is (Relational and type testing Operator)

Back 330

Checks if an object is compatible with a given type.

Front 331

is expression

Back 331

evaluates to true if the provided expression is non-null, and the provided object can be cast to the provided type without causing an exception to be thrown.

Front 332

is operator

Back 332

cannot be overloaded.

Front 333

Items in an array

Back 333

Stored in contiguous memory locations.

Front 334

Iteration Statements

Back 334

do for foreach, in while

Front 335

iterator

Back 335

can be used to step through collections such as lists and arrays.

Front 336

JavaScript

Back 336

client-side scripting language that runs inside a Web browser to help create far more interactive Web pages than are possible with only HTML.

Front 337

join ( Query Keyword (LINQ))

Back 337

Joins two data sources based on an equality comparison between two specified matching criteria.

Front 338

join (Contextual Keyword clause)

Back 338

is useful for associating elements from different source sequences that have no direct relationship in the object model. The only requirement is that the elements in each source share some value that can be compared for equality.

Front 339

Jump Statements

Back 339

break continue goto return throw

Front 340

Keywords

Back 340

predefined, reserved identifiers that have special meanings to the compiler. They cannot be used as identifiers in your program unless they include @ as a prefix. For example, @if is a valid identifier but if is not because if is a keyword.

Front 341

let ( Query Keyword (LINQ))

Back 341

Introduces a range variable to store sub-expression results in a query expression.

Front 342

let (Contextual Keyword)

Back 342

creates a new range variable and initializes it with the result of the expression you supply. Once initialized with a value, the range variable cannot be used to store another value. However, if the range variable holds a queryable type, it can be queried.

Front 343

LIFO

Back 343

last-in, first-out

Front 344

Linked List

Back 344

collection of nodes arranged so that each node contains a link to the next node in the sequence.

Front 345

linked list item

Back 345

does not need to be contiguous

Front 346

linked list node

Back 346

contains two pieces of information: the data corresponding to the node, and the link to the next node.

Front 347

Literal Keywords

Back 347

null true false default

Front 348

load stage

Back 348

used to restore control properties with information from view state and control state.

Front 349

lock

Back 349

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.

Front 350

Logical AND Operator

Back 350

x & y

Front 351

Logical OR Operator

Back 351

x | y

Front 352

Logical XOR Operator

Back 352

x ^ y

Front 353

long

Back 353

8 bytes -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Front 354

Loop

Back 354

can also be terminated by using one of several control transfer statements that transfer control outside the loop.

Front 355

Main

Back 355

special method in that it also serves as an entry point to the program.

Front 356

Main method

Back 356

must be declared as static.

Front 357

Method

Back 357

block of code containing a series of statements.

Front 358

method

Back 358

is an action that an object can perform.

Front 359

method

Back 359

set of statements that are executed when the ______ is called.

Front 360

method signature

Back 360

method’s name, its parameter list, and the order of data types of the parameters are collectively recognized

Front 361

methods

Back 361

are code blocks containing a series of statements.

Front 362

methods

Back 362

can receive input via arguments and can return a value to the caller.

Front 363

methods

Back 363

specify an object’s behavior

Front 364

methods, properties, events and indexers

Back 364

can be virtual

Front 365

Modifiers

Back 365

Access Modifiers abstract async const event extern in out override readonly sealed static unsafe virtual volatile

Front 366

Multi-line comments

Back 366

start with the characters /* and end with the characters */.

Front 367

Multiple constraints

Back 367

can be applied to the same type parameter, and the constraints themselves can be generic types

Front 368

Multiple document interface (MDI) applications

Back 368

applications in which multiple child windows reside under a single parent window.

Front 369

Multiplicative Operators

Back 369

x * y x / y x % y

Front 370

Namespace

Back 370

language element that allows you to organize code and create globally unique class names.

Front 371

namespace and class names

Back 371

are combined together to create a fully qualified class name.

Front 372

Namespace Keywords

Back 372

namespace using extern alias

Front 373

Namespaces

Back 373

allows for a to organize code and create unique class names.

Front 374

Namespaces

Back 374

are used to organize classes and uniquely identify them.

Front 375

nested type

Back 375

type defined within a class or struct.

Front 376

new

Back 376

Explicitly hides a member inherited from a base class.

Front 377

new

Back 377

new Operator new Modifier new Constraint

Front 378

new (Primary Operator)

Back 378

Used to create objects and invoke constructors

Front 379

new keyword

Back 379

creates a new member of the same name in the derived class and hides the base class implementation.

Front 380

Null-coalescing Operator

Back 380

x ?? y

Front 381

Numeric and enumeration types

Back 381

have predefined increment operators. User-defined types can overload the ++ operator. Operations on integral types are generally allowed on enumeration.

Front 382

Numeric types

Back 382

1.Integral types 2.Floating-point types 3.decimal

Front 383

object

Back 383

concrete instance of a class but is not a class itself.

Front 384

Object

Back 384

instance of a class.

Front 385

object

Back 385

is a concrete entity based on a class, and is sometimes referred to as an instance of a class.

Front 386

Object initializers(Classes and Structs)

Back 386

assign values to any accessible fields or properties of an object at creation time without having to invoke a constructor followed by lines of assignment statements.

Front 387

Object-oriented programming

Back 387

programming technique that makes use of objects.

Front 388

Objects

Back 388

created from the templates defined by classes.

Front 389

Objects

Back 389

self-contained data structures that consist of properties, methods, and events.

Front 390

on ( Query Keyword (LINQ))

Back 390

Contextual keyword in a join clause.

Front 391

One copy of the class

Back 391

is loaded into memory when the program loads, and its members are accessed through the class name.

Front 392

Operator

Back 392

are symbols that specify which operation to perform on the operands before returning a result.

Front 393

operator keyword

Back 393

is used to overload a built-in operator or to provide a user-defined conversion in a class or struct declaration.

Front 394

Operator Keywords

Back 394

as await is new sizeof typeof true false stackalloc

Front 395

operators

Back 395

are symbols that specify which operation to perform on the operands before returning a result.

Front 396

orderby ( Query Keyword (LINQ))

Back 396

Sorts query results in ascending or descending order based on the default comparer for the element type.

Front 397

orderby (Contextual Keyword)

Back 397

causes the returned sequence or subsequence (group) to be sorted in either ascending or descending order. Multiple keys can be specified in order to perform one or more secondary sort operations. The sorting is performed by the default comparer for the type of the element. The default sort order is ascending. You can also specify a custom comparer.

Front 398

out (modifier )

Back 398

specifies that the type parameter is covariant.

Front 399

Output of the Design Process

Back 399

set of technical models and specifications that provide guidance to the developers

Front 400

override (Class member modifier)

Back 400

Specify that a method or property declaration is an override of a virtual member or an implementation of a member of an abstract class.

Front 401

override keyword

Back 401

replaces a base class member in a derived class.

Front 402

override(modifier )

Back 402

modifier that you can use on fields. When a field declaration includes a readonly modifier, assignments to the fields introduced by the declaration can only occur as part of the declaration or in a constructor in the same class. Provides a new implementation of a virtual member inherited from a base class. is required to extend or modify the abstract or virtual implementation of an inherited method, property, indexer, or event.

Front 403

Page request

Back 403

request for a page is received, the page life cycle begins.

Front 404

Parameterized Stored Procedures

Back 404

allow you to pass runtime arguments to the SQL Server.

Front 405

partial

Back 405

Defines partial classes, structs and methods throughout the same assembly.

Front 406

partial (Contextual Keyword)

Back 406

Defines partial classes, structs, and interfaces throughout the same compilation unit.

Front 407

partial (method) (Contextual Keyword)

Back 407

has its signature defined in one part of it, and its implementation defined in another part of the type. It enable class designers to provide method hooks, similar to event handlers, that developers may decide to implement or not. If the developer does not supply an implementation, the compiler removes the signature at compile time.

Front 408

partial (type) (Contextual Keyword)

Back 408

definitions allow for the definition of a class, struct, or interface to be split into multiple files.

Front 409

partial methods

Back 409

1. Signatures in both parts of the partial type must match. 2. The method must return void. 3.No access modifiers are allowed. They are implicitly private.

Front 410

Pointer types

Back 410

can be used only in unsafe mode.

Front 411

Polymorphism

Back 411

ability of derived classes to share common functionality with base classes but still define their own unique behavior.

Front 412

Pop (Stack Methods)

Back 412

Removes and returns the object at the top of the Stack.

Front 413

Postback event handling

Back 413

the control event handlers are called during this stage. Then, the input values are validated and the IsValid property for the Page class is set.

Front 414

Preprocessor Directives

Back 414

#if #else #elif #endif #define #undef #warning #error #line #region #endregion #pragma #pragma warning #pragma checksum

Front 415

Prerendering stage

Back 415

stage signals that the page is just about to render its contents. An event handler for the PreRender event is the last chance to modify the page’s output before it is sent to the client.

Front 416

Primary Key

Back 416

column or set of columns that uniquely identifies each row of data in a table.

Front 417

primary key

Back 417

is a column or set of columns that uniquely identifies each row of data in a table. Step 4

Front 418

private (Access Modifier)

Back 418

Access is limited to the containing type.

Front 419

Private Access Modifier

Back 419

limits access within the class in which the field is defined.

Front 420

private constructor

Back 420

is a special instance constructor. It is generally used in classes that contain static members only.

Front 421

Private Constructors

Back 421

are used to prevent creating instances of a class when there are no instance fields or methods, such as the Math class, or when a method is called to obtain an instance of a class.

Front 422

Processing Instructions

Back 422

XML tags that begin with

Front 423

program

Back 423

causes the statements to be executed by calling the method and specifying any required method arguments.

Front 424

programming language syntax

Back 424

provides its own set of vocabulary and grammar

Front 425

Properties

Back 425

is a member that provides a flexible mechanism to read, write, or compute the value of a private field.

Front 426

Properties

Back 426

specify the data represented by an object,

Front 427

property

Back 427

has two accessors get and set

Front 428

protected (Access Modifier)

Back 428

Access is limited to the containing class or types derived from the containing class.

Front 429

protected internal (Access Modifier)

Back 429

Access is limited to the current assembly or types derived from the containing class.

Front 430

public (Access Modifier)

Back 430

Access is not restricted.

Front 431

Public Access Modifier

Back 431

does not limit access within the class in which the field is defined.

Front 432

publisher

Back 432

event class that sends (or raises) the event

Front 433

publisher class

Back 433

class that sends the notification.

Front 434

Push (Stack Methods)

Back 434

Inserts an object at the top of the Stack.

Front 435

query expression

Back 435

must terminate with either a select clause or a group clause.

Front 436

Query Keyword (LINQ)

Back 436

from clause where clause select clause group clause into orderby clause join clause let clause ascending descending on equals by in

Front 437

QueryString

Back 437

property of the Request object, and it gets the collection of all the query-string variables.

Front 438

Queue

Back 438

collection of items in which the first item added to the collection is the first one to be removed.

Front 439

Queue

Back 439

First-in, First-out data structure.

Front 440

QuickSort algorithm

Back 440

uses partitioning and comparison operations to arrange the elements of a list in the correct order.

Front 441

readonly (Class member modifier)

Back 441

Declare a field that can only be assigned values as part of the declaration or in a constructor in the same class.

Front 442

Recursion

Back 442

programming technique that causes a method to call itself in order to compute a result.

Front 443

Reference Type

Back 443

only stores a reference to an actual value

Front 444

Reference types

Back 444

are also referred to as objects.

Front 445

Reference Types

Back 445

class delegate dynamic interface object string

Front 446

Reference types

Back 446

store only a reference to a memory location

Front 447

Reference types

Back 447

types created by using the keywords object, string, interface, delegate, and class.

Front 448

Regression Testing

Back 448

is used to make sure that each functionality that was already known to work correctly is still working.

Front 449

Relational and type testing Operators

Back 449

x < y x > y x <= y x >= y is as

Front 450

Relational Database

Back 450

collection of interrelated data based on the relational model developed by E. F. Codd.

Front 451

Relational Database Design

Back 451

process of determining the appropriate relational database structure to satisfy the business requirements.

Front 452

Relational Database model

Back 452

defines distinct data entities, their attributes, and relationships among entities.

Front 453

Relational Databases

Back 453

organizes information into tables.

Front 454

Relationship

Back 454

association between entities.

Front 455

Release Management Activity

Back 455

is used to manage the deployment, delivery, and support of software releases.

Front 456

remove (Contextual Keyword)

Back 456

Defines a custom event accessor that is invoked when client code unsubscribes from the event.

Front 457

remove (Contextual Keyword)

Back 457

is used to define a custom event accessor that is invoked when client code unsubscribes from your event. If you supply a custom remove accessor, you must also supply an add accessor.

Front 458

Rendering

Back 458

At this stage, the page calls the Render method for each control and populates the response that will be sent to the Web browser.

Front 459

Repetition Control Statements

Back 459

can be used to execute the statements in the loop body a number of times, depending on the loop termination criterion.

Front 460

Requirements Analysis

Back 460

is the process of determining the detailed business requirements for a new software system.

Front 461

return (Jump statement)

Back 461

can also return an optional value. If the method is a void type, the return statement can be omitted.

Front 462

return (Jump statement)

Back 462

If it is used inside a try block, the finally block, if one exists, will be executed before control returns to the calling method.

Front 463

return (Jump statement)

Back 463

terminates execution of the method in which it appears and returns control to the calling method.

Front 464

runtime process

Back 464

handles the Web request for ASP.NET resources.

Front 465

sbyte (Integral Type)

Back 465

indicates an integral type that stores values according to the size and range shown in the following table. Range: -128 to 127 Size: Signed 8-bit integer

Front 466

Sealed

Back 466

creates a sealed class

Front 467

sealed (Class modifier)

Back 467

Specifies that a class cannot be inherited.

Front 468

Sealed Classes

Back 468

are defined when your implementation is complete and you do not want a class to be inherited.

Front 469

sealed keyword

Back 469

enables you to prevent the inheritance of a class or certain class members that were previously marked virtual.

Front 470

Second Normal Form (2nf)

Back 470

No non-prime attribute in the table is functionally dependent on a proper subset of any candidate key

Front 471

SELECT

Back 471

statements allow you to retrieve data stored in a database.

Front 472

select ( Query Keyword (LINQ))

Back 472

Specifies the type and shape that the elements in the returned sequence will have when the query is executed.

Front 473

select (Contextual Keyword clause)

Back 473

specifies the type of values that will be produced when the query is executed. The result is based on the evaluation of all the previous clauses and on any expressions in the clause itself.

Front 474

SELECT, INSERT, UPDATE, and DELETE statements

Back 474

the four main types of SQL statements used to manipulate SQL Server data.

Front 475

Selection Statements

Back 475

if-else switch

Front 476

Sender Parameter

Back 476

reference to the object that raises the event

Front 477

Server-Side Programming

Back 477

refers to programs that are executed completely on a server and make use of the server’s computational resources.

Front 478

Server-side state management

Back 478

techniques session state and application state use server resources for state management.

Front 479

ServiceInstaller class

Back 479

performs the installation tasks that are specific to a single Windows service, such as setting the ServiceName and StartType.

Front 480

ServiceProcessInstaller class

Back 480

performs installation tasks that are common to all the Windows services in an application. This includes setting the login account for the Windows service.

Front 481

Session State

Back 481

unique session for each user who sends a request to the application.

Front 482

session state of the Web application

Back 482

ability to uniquely identify and relate requests can be used to store session-specific data

Front 483

set (Contextual Keyword)

Back 483

Defines an accessor method for a property or an indexer.

Front 484

set accessor

Back 484

is used to assign a new value to the property

Front 485

Shift Operators

Back 485

x << y x >> y

Front 486

short

Back 486

2 bytes -32,768 to 32,767

Front 487

short (Integral Type)

Back 487

Range: -32,768 to 32,767 Size: Signed 16-bit integer

Front 488

Simple Object Access Protocol

Back 488

SOAP

Front 489

Single-line comments

Back 489

begin with //

Front 490

sizeof (Primary Operator)

Back 490

Used to obtain the size in bytes for an unmanaged type.

Front 491

SOAP

Back 491

protocol for exchanging structured information in a Web service communication between two remote computers.

Front 492

SOAP

Back 492

Simple Object Access Protocol (SOAP)

Front 493

Software Defect aka bug

Back 493

is difference between the expected behavior and the actual behavior of the system

Front 494

Software Development Activity

Back 494

involves implementing design by creating software code, databases, and other related content.

Front 495

Software Object

Back 495

conceptually similar to a real-world object.

Front 496

Software Testing

Back 496

process of verifying software against its requirements.

Front 497

Sorting Algorithms

Back 497

arrange items in a list in a particular order.

Front 498

SQL Avg

Back 498

Returns the average value in a given column

Front 499

SQL column or field

Back 499

specifies the type of data that will stored for each record in the table

Front 500

SQL Count

Back 500

Returns the number of records

Front 501

SQL field

Back 501

is a column in a sql table

Front 502

SQL Max

Back 502

Returns the largest value in a given column

Front 503

SQL Min

Back 503

Returns the smallest value in a given column

Front 504

SQL record

Back 504

is a row sometimes called a tuple

Front 505

SQL Sum

Back 505

Returns the total value in a given column

Front 506

SQL table

Back 506

list of rows and columns that is conceptually similar to a Microsoft Excel worksheet.

Front 507

Stack

Back 507

collection of items in which the last item added to the collection is the first one to be removed.

Front 508

Stack

Back 508

last-in, first-out (LIFO) data structure.

Front 509

stackalloc

Back 509

is used in an unsafe code context to allocate a block of memory on the stack.

Front 510

Start Stage

Back 510

involves determining whether the request is a postback or a new request. Several page properties, such as Request, Response, IsPostBack, and UICulture, are set at this stage.

Front 511

State Management

Back 511

important issue for Web applications because of the disconnected nature of HTTP. There are both client-side and server-side techniques available for state management.

Front 512

State Management

Back 512

process of maintaining state for a Web page across round-trips. The values of the variables and controls collectively make up the state of a Web page.

Front 513

Statement Keywords

Back 513

Selection Statements Iteration Statements Jump Statements Exception Handling Statements Checked and Unchecked fixed Statement lock Statement

Front 514

static (modifier )

Back 514

Declares a member that belongs to the type itself instead of to a specific object. It can be used with classes, fields, methods, properties, operators, events, and constructors, but it cannot be used with indexers, destructors, or types other than classes.

Front 515

static class

Back 515

can be used as a convenient container for sets of methods that just operate on input parameters and do not have to get or set any internal instance fields.

Front 516

static class

Back 516

is basically the same as a non-static class, but there is one difference: a static class cannot be instantiated.

Front 517

static class can contain

Back 517

only static members and cannot be instantiated with the new keyword.

Front 518

static constructor

Back 518

is used to initialize any static data, or to perform a particular action that needs to be performed once only. It is called automatically before the first instance is created or any static members are referenced.

Front 519

static keyword

Back 519

is used to declare members that do not belong to individual objects but to a class itself.

Front 520

Static Method

Back 520

callable on a class even when no instance of the class has been created.

Front 521

Static Numbers

Back 521

belong to a class itself rather than individual objects.

Front 522

Stored Procedure

Back 522

is a set of SQL statements that is stored in a database.

Front 523

Stored Procedure

Back 523

set of SQL statements that is stored in a database. Stored procedures can be used by multiple applications.

Front 524

Stream

Back 524

flow of raw data, and a backing store is the source or destination of the stream.

Front 525

string

Back 525

- Zero or more Unicode characters

Front 526

string

Back 526

is an object of type String whose value is text. Internally, the text is stored as a sequential read-only collection of Char objects.

Front 527

String class

Back 527

provides many methods for safely creating, manipulating, and comparing strings.

Front 528

string keyword

Back 528

is an alias for String

Front 529

strings

Back 529

are immutable, it is not possible (without using unsafe code) to modify the value of a string object after it has been created.

Front 530

struct

Back 530

cannot declare a default constructor (a constructor without parameters) or a destructor.

Front 531

STRUCT

Back 531

used to create user-defined types that consist of small groups of related fields. Structs are value types, whereas classes are reference types.

Front 532

struct (Value type)

Back 532

is a value type that is typically used to encapsulate small groups of related variables, such as the coordinates of a rectangle or the characteristics of an item in an inventory.

Front 533

struct (Value type)

Back 533

Default value= The value produced by setting all value-type fields to their default values and all reference-type fields to null.

Front 534

struct (Value Type)

Back 534

User-defined structure (Category Type)

Front 535

struct can be used as a

Back 535

nullable type and can be assigned a null value.

Front 536

struct can implement

Back 536

interfaces.

Front 537

struct cannot inherit

Back 537

from another struct or class, and it cannot be the base of a class. All structs inherit directly from System.ValueType, which inherits from System.Object.

Front 538

struct type

Back 538

is suitable for representing lightweight objects such as Point, Rectangle, and Color.

Front 539

Structs are

Back 539

value types

Front 540

Structs are copied

Back 540

on assignment.

Front 541

structs are more limited than

Back 541

are more limited than classes:

Front 542

Structs are used

Back 542

for small data structures that contain primarily data that is not intended to be modified after the struct is created.

Front 543

Structs can also contain

Back 543

constructors constants fields methods properties indexers operators events nested types

Front 544

Structs can declare

Back 544

constructors that have parameters.

Front 545

Structs fall into these categories:

Back 545

1.Numeric_types 2.bool 3.User defined structs.

Front 546

structs share most of the same syntax as

Back 546

share most of the same classes

Front 547

Structured Query Language (Sql)

Back 547

provides statements such as SELECT, INSERT, UPDATE, and DELETE to work with relational data.

Front 548

subscriber

Back 548

event class that receive (or handle) the event

Front 549

subscriber class

Back 549

class that receives the notification

Front 550

switch (Selection statement)

Back 550

is a control statement that selects a switch section to execute from a list of candidates.

Front 551

Switch Block

Back 551

can include one or more case statements or a default statement.

Front 552

Switch Statement

Back 552

allows multi-way branching.

Front 553

System namespace

Back 553

contains fundamental classes and base classes that define commonly-used value and reference data types, events and event handlers, interfaces, attributes, and processing exceptions.

Front 554

System namespace

Back 554

contains some of the most commonly used base classes.

Front 555

System Testing

Back 555

is the overall testing of the software system.

Front 556

System.Object class

Back 556

provides a ToString method. By convention, you should use this method to return the human-readable representation for a class. When you create your types, it is good practice to override this method to return readable information about the objects.

Front 557

Table

Back 557

list of rows and columns.

Front 558

Ternary operators

Back 558

operators take three operands. In C#, There is just one ternary operator, ?:

Front 559

Third Normal Form (3nf)

Back 559

is the third step in normalizing a database design to reduce the duplication of data and ensure referential integrity by ensuring that 1. the entity is in second normal form and 2.all the attributes in a table are dependent on the primary key and only the primary key.

Front 560

this (access keyword)

Back 560

refers to the current instance of the class and is also used as a modifier of the first parameter of an extension method.

Front 561

three primary characteristics of object-oriented programming

Back 561

inheritance encapsulation polymorphism

Front 562

throw ( Exception handling statements )

Back 562

is used to signal the occurrence of an anomalous situation (exception) during the program execution.

Front 563

To inherit from an interface means

Back 563

that the type implements all the methods defined in the interface.

Front 564

true

Back 564

true Operator true Literal

Front 565

true Literal

Back 565

Represents the boolean value true.

Front 566

true Operator

Back 566

Returns the bool value true to indicate that an operand is true and returns false otherwise.

Front 567

try ( Exception handling statement)

Back 567

common usage of catch and finally together is to obtain and use resources in a try block, deal with exceptional circumstances in a catch block, and release the resources in the finally block.

Front 568

try-catch( Exception handling statements )

Back 568

consists of a try block followed by one or more catch clauses, which specify handlers for different exceptions.

Front 569

try-catch-finally ( Exception handling statement)

Back 569

The statements within the try block are executed, and if any of them throws an exception, execution of the block is discontinued and the exception is handled by the catch block. The statements within the finally block are always executed after the try and catch blocks, whether or not an exception was thrown. Such blocks are useful for providing clean-up code.

Front 570

try-finally ( Exception handling statement)

Back 570

can be used to clean up any resources that are allocated in a try block, and it can be run code even if an exception occurs in the try block.

Front 571

typeof (Primary Operator)

Back 571

Used to obtain the System.Type object for a type.

Front 572

Types

Back 572

Value Types Reference Types void var

Front 573

UIAutomationClientsideProviders

Back 573

Contains a single type that maps client automation providers.

Front 574

uint (Integral Type)

Back 574

Range: 0 to 4,294,967,295 Size: Unsigned 32-bit integer

Front 575

ulong

Back 575

(Integral Type) Range: 0 to 18,446,744,073,709,551,615 Size: Unsigned 64-bit integer

Front 576

Unary - operators

Back 576

are predefined for all numeric types. The result of a unary - operation on a numeric type is the numeric negation of the operand.

Front 577

unary decrement (- -) operator

Back 577

subtracts 1 from the value of an identifier.

Front 578

unary increment operator (+ +)

Back 578

adds 1 to the value of an identifier

Front 579

Unary Operators

Back 579

+x -x !x ~x ++x --x (T)x await &x *x

Front 580

Unary operators

Back 580

operators work with only one operand. Examples include ++x, x++, or isEven, where x is of integer data type and isEven is of Boolean data type.

Front 581

unchecked (Primary Operator)

Back 581

is used to suppress overflow-checking for integral-type arithmetic operations and conversions.

Front 582

Unlike classes, structs can be

Back 582

instantiated without using a new operator.

Front 583

Unload Stage

Back 583

the response is sent to the client and page cleanup is performed. As part of this cleanup, page properties such as Request and Response are discarded.

Front 584

Unmanaged types

Back 584

include the built-in types 1.Enum types 2.Pointer types 3.User-defined structs that do not contain any fields or properties that are reference types

Front 585

unsafe (Class member modifier)

Back 585

Declares an unsafe context, which allows the use of pointers.

Front 586

UPDATE

Back 586

statements allow you to modify existing data in a database.

Front 587

Update Anomaly

Back 587

situation in which updating a single data value requires multiple rows to be updated.

Front 588

User-defined types

Back 588

can overload the binary * operator. When a binary operator is overloaded, the corresponding assignment operator, if any, is also implicitly overloaded.

Front 589

ushort (Integral Type)

Back 589

Range: 0 to 65,535 Size: Unsigned 16-bit integer

Front 590

using (Namespace Keywords)

Back 590

using Directive using Statement

Front 591

using Directive (Namespace Keyword)

Back 591

is used to allow the use of types in a namespace so that you do not have to qualify the use of a type in that namespace

Front 592

using Statement (Namespace Keyword)

Back 592

ensures that Dispose is called even if an exception occurs while you are calling methods on the object.

Front 593

using Statement (Namespace Keyword)

Back 593

Provides a convenient syntax that ensures the correct use of IDisposable objects.

Front 594

value (Contextual Keyword)

Back 594

is used in the set accessor in ordinary property declarations. It is similar to an input parameter on a method. It references the value that client code is attempting to assign to the property.

Front 595

value (Contextual Keyword)

Back 595

Used to set accessors and to add or remove event handlers.

Front 596

Value Type

Back 596

directly stores a value

Front 597

value type

Back 597

directly stores data within its memory

Front 598

Value Types

Back 598

bool byte char decimal double enum float int long sbyte short struct uint ulong ushort

Front 599

Value types

Back 599

consist of two main categories: 1.Structs 2.Enumerations

Front 600

var (Contextual Keyword)

Back 600

Enables the type of a variable declared at method scope to be determined by the compiler.

Front 601

var (Contextual Keyword)

Back 601

variables that are declared at method scope can have an implicit type

Front 602

Variable

Back 602

must be unique within the scope in which it is defined.

Front 603

Variable

Back 603

provide temporary storage during the execution of a program.

Front 604

Variable Name

Back 604

must begin with a letter or an underscore and can contain only letters, numbers, or underscores. A variable name must not exceed 255 characters.

Front 605

variable--

Back 605

form is a postfix decrement operation. The result of the operation is the value of the operand "before" it has been decremented.

Front 606

Variables

Back 606

value types store data or reference types store references to the actual data.

Front 607

virtual

Back 607

allows the derived classes to override the method.

Front 608

virtual (Class member modifier)-

Back 608

Declares a method or an accessor whose implementation can be changed by an overriding member in a derived class. It is used to modify a method, property, indexer, or event declaration and allow for it to be overridden in a derived class.

Front 609

Virtual Directory

Back 609

alias that maps to a physical directory on the Web server.

Front 610

virtual methods

Back 610

enable you to work with groups of related objects in a uniform way.

Front 611

Visual inheritance

Back 611

allows you to reuse existing functionality and layout for Windows Forms.

Front 612

Visual Studio

Back 612

a drag-and-drop Windows Forms designer that you can use to create applications.

Front 613

void

Back 613

is also used in an unsafe context to declare a pointer to an unknown type.

Front 614

void

Back 614

specifies that the method doesn't return a value.

Front 615

volatile

Back 615

Indicates that a field can be modified in the program by something such as the operating system, the hardware, or a concurrently executing thread.

Front 616

volatile (Class member modifier)-

Back 616

Specifies a field which may be modified by an external process and prevents an optimizing compiler from modifying the use of the field.

Front 617

Web farm

Back 617

collection of Web servers used collectively to serve a Web site.

Front 618

Web page

Back 618

document that is served over the World Wide Web and can be displayed by a Web browser.

Front 619

Web site

Back 619

container of applications and virtual directories.

Front 620

When a derived class

Back 620

overrides a virtual member, that member is called even when an instance of that class is being accessed as an instance of the base class.

Front 621

When a struct is assigned to a new variable

Back 621

all the data is copied, and any modification to the new copy does not change the data for the original copy. This is important to remember when working with collections of value types such as Dictionary.

Front 622

where ( Query Keyword (LINQ))

Back 622

Filters source elements based on one or more Boolean expressions separated by logical AND and OR operators ( && or || ).

Front 623

where (Contextual Keyword)

Back 623

Adds constraints to a generic declaration. (See also where).

Front 624

where (generic type constraint)

Back 624

is used to specify constraints on the types that can be used as arguments for a type parameter defined in a generic declaration.

Front 625

where (query clause)

Back 625

is used in a query expression to specify which elements from the data source will be returned in the query expression. It applies a Boolean condition (predicate) to each source element (referenced by the range variable) and returns those for which the specified condition is true.

Front 626

where T :

(Constraint)

Back 626

The type argument must be or derive from the specified base class.

Front 627

where T : (Constraint)

Back 627

The type argument must be or implement the specified interface. Multiple interface constraints can be specified. The constraining interface can also be generic.

Front 628

where T : class (Constraint)

Back 628

The type argument must be a reference type; this applies also to any class, interface, delegate, or array type.

Front 629

where T : new() (Constraint)

Back 629

The type argument must have a public parameterless constructor. When used together with other constraints, the new() constraint must be specified last.

Front 630

where T : U (Constraint)

Back 630

The type argument supplied for T must be or derive from the argument supplied for U.

Front 631

where T: struct (Constraint)

Back 631

The type argument must be a value type. Any value type except Nullable can be specified. See Using Nullable Types (C# Programming Guide) for more information.

Front 632

while (Iteration statements)

Back 632

executes a statement or a block of statements until a specified expression evaluates to false.

Front 633

While Loop

Back 633

repeatedly executes a block of statements until a specified Boolean expression evaluates to false.

Front 634

White-Box Testing

Back 634

is used to make sure that each method or function has proper test cases available.

Front 635

Windows Event Viewer

Back 635

utility can be used to view the messages in event logs.

Front 636

Windows Form

Back 636

visual surface capable of displaying a variety of controls, including text boxes, buttons, and menus.

Front 637

Windows Forms

Back 637

large collection of common controls that you can readily use to create an excellent user interface.

Front 638

Windows service

Back 638

application that runs in the background and does not have any user interface.

Front 639

Windows' three default event logs

Back 639

System, Application, and Security.

Front 640

Within a struct declaration fields cannot be initialized unless

Back 640

fields cannot be initialized unless they are declared as const or static.

Front 641

World Wide Web (also known as WWW or “the Web”)

Back 641

is a system of interconnected hypertext documents and other resources (such as images and video) that can be accessed via the Internet.

Front 642

WSDL

Back 642

standard by which a Web service can tell its client what kinds of messages it will accept and what results will be returned.

Front 643

WSDL

Back 643

Web Services Description Language (WSDL)

Front 644

x != y (inequality Equality Operator)

Back 644

returns false if its operands are equal, true otherwise. It is predefined for all types, including string and object. User-defined types can overload it.

Front 645

x % y (Multiplicative Operator)

Back 645

computes the remainder after dividing its first operand by its second. All numeric types have predefined remainder operators.

Front 646

x %= y (remainder Assignment Operator)

Back 646

expression using the assignment operator, such as x %= y is equivalent to x = x % y except that x is only evaluated once. The % operator is predefined for numeric types to compute the remainder after division.

Front 647

x & y (Logical AND Operator)

Back 647

returns the address of its operand (requires unsafe context).

Front 648

x && y (Conditional AND Operator)

Back 648

performs a logical-AND of its bool operands, but only evaluates its second operand if necessary.

Front 649

x &= y ( AND Assignment Operator)

Back 649

expression using the assignment operator, such as x &= y is equivalent to x = x & y except that x is only evaluated once. The & operator performs a bitwise logical AND operation on integral operands and logical AND on bool operands.

Front 650

x * y (Multiplicative Operator)

Back 650

computes the product of its operands. Also, the dereference operator, which allows reading and writing to a pointer.

Front 651

x *= y (binary multiplication Assignment Operator)

Back 651

expression using the assignment operator, such as x *= y is equivalent to x = x * y except that x is only evaluated once. The it is predefined for numeric types to perform multiplication.

Front 652

x + y (Additive Operator)

Back 652

can function as either a unary or a binary operator.

Front 653

x += y (Addition Assignment Operator)

Back 653

expression using the += assignment operator, such as x += y is equivalent to x = x + y except that x is only evaluated once. The meaning of the + operator depends on the types of x and y (addition for numeric operands, concatenation for string operands, and so forth).

Front 654

x - y(Additive Operator)

Back 654

can function as either a unary or a binary operator.

Front 655

x -= y (Subtraction Assignment Operator)

Back 655

An expression using the -= assignment operator, such as x -= y is equivalent to x = x - y except that x is only evaluated once. The meaning of the - operator is dependent on the types of x and y (subtraction for numeric operands, delegate removal for delegate operands, and so forth).

Front 656

x / y (division Multiplicative Operator)

Back 656

divides its first operand by its second operand. All numeric types have predefined division operators.

Front 657

x /= y (division Assignment Operator)

Back 657

An expression using the /= assignment operator, such as x /= y is equivalent to x = x / y except that x is only evaluated once. The / operator is predefined for numeric types to perform division.

Front 658

x < y ( "less than" Relational and type testing Operator)

Back 658

All numeric and enumeration types define a relational operator that returns true if the first operand is less than the second, false otherwise.

Front 659

x << y (Left Shift Operator)

Back 659

shifts its first operand left by the number of bits specified by its second operand. The type of the second operand must be an int or a type that has a predefined implicit numeric conversion to int.

Front 660

x <<= y ( left-shift Assignment Operator)

Back 660

expression of the form x <<= y

Front 661

x <= y ( "less than or equal" Relational and type testing Operator)

Back 661

All numeric and enumeration types define a relational operator that returns true if the first operand is less than or equal to the second, false otherwise.

Front 662

x = y (Assignment Operator)

Back 662

stores the value of its right-hand operand in the storage location, property, or indexer denoted by its left-hand operand and returns the value as its result. The operands must be of the same type (or the right-hand operand must be implicitly convertible to the type of the left-hand operand).

Front 663

x == y (Equality Operator)

Back 663

For predefined value types, it returns true if the values of its operands are equal, false otherwise. For reference types other than string, it returns true if its two operands refer to the same object. For the string type, it compares the values of the strings.

Front 664

x > y ( "greater than" Relational and type testing Operator)

Back 664

All numeric and enumeration types define a relational operator that returns true if the first operand is greater than the second, false otherwise.

Front 665

x >= y ( "greater than or equal" Relational and type testing Operator)

Back 665

All numeric and enumeration types define a relational operator, that returns true if the first operand is greater than or equal to the second, false otherwise.

Front 666

x >> y (Right Shift Operator)

Back 666

shifts its first operand right by the number of bits specified by its second operand.

Front 667

x >>= y (right-shift Assignment Operator)

Back 667

expression of the form x >>= y is evaluated as x = x >> y except that x is only evaluated once. The >> operator shifts x right by an amount specified by y.

Front 668

x ?? y (Null-coalescing Operator)

Back 668

returns the left-hand operand if the operand is not null; otherwise it returns the right hand operand.

Front 669

x ^ y (Logical XOR Operator)

Back 669

are predefined for the integral types and bool. For integral types, it computes the bitwise exclusive-OR of its operands. For bool operands, it computes the logical exclusive-or of its operands; that is, the result is true if and only if exactly one of its operands is true.

Front 670

x ^= y ( exclusive-OR Assignment Operator)

Back 670

expression of the form x ^= y is evaluated as x = x ^ y except that x is only evaluated once. The ^ operator performs a bitwise exclusive-OR operation on integral operands and logical exclusive-OR on bool operands.

Front 671

x | y (Logical OR Operator)

Back 671

are predefined for the integral types and bool. For integral types, it computes the bitwise OR of its operands. For bool operands, it computes the logical OR of its operands; that is, the result is false if and only if both its operands are false.

Front 672

x |= y (Assignment Operator)

Back 672

An expression using the |= assignment operator, such as x |= y is equivalent to x = x | y except that x is only evaluated once. The | operator performs a bitwise logical OR operation on integral operands and logical OR on bool operands.

Front 673

x || y(Conditional OR Operator)

Back 673

performs a logical-OR of its bool operands. If the first operand evaluates to true, the second operand isn't evaluated. If the first operand evaluates to false, the second operator determines whether the OR expression as a whole evaluates to true or false.

Front 674

x++ (Primary Operator)

Back 674

increments its operand by 1. The increment operator can appear before or after its operand

Front 675

x++ form

Back 675

is a postfix increment operation. The result of the operation is the value of the operand before it has been incremented.

Front 676

x-- (Primary Operator)

Back 676

decrements its operand by 1.

Front 677

x--form

Back 677

is a postfix decrement operation. The result of the operation is the value of the operand "before" it has been decremented.

Front 678

x.y (Primary Operator)

Back 678

is used for member access. It specifies a member of a type or namespace.

Front 679

XamlGeneratedNamespace

Back 679

Contains compiler-generated types that are not intended to be used directly from your code.

Front 680

XmlDocument class

Back 680

in-memory representation of XML data and allows navigation and editing of the XML document.

Front 681

XmlReader and XmlWriter classes

Back 681

provide a fast, noncached, forward-only way to read or write XML data.

Front 682

yield (Contextual Keyword)

Back 682

is used to indicate that the method, operator, or get accessor in which it appears is an iterator.

Front 683

yield (Contextual Keyword)

Back 683

Used in an iterator block to return a value to the enumerator object or to signal the end of iteration.

Front 684

yield (Contextual Keyword)

Back 684

Using it to define an iterator removes the need for an explicit extra class (the class that holds the state for an enumeration, see IEnumerator for an example) when you implement the IEnumerable and IEnumerator pattern for a custom collection type.

Front 685

yield break (statement)

Back 685

can be used to end an iteration.

Front 686

Tap Static gesture

Back 686

One finger touches the screen and lifts up.

Front 687

Press and hold Static gesture

Back 687

One finger touches the screen and stays in place.

Front 688

Slide Manipulation gesture

Back 688

One or more fingers touch the screen and move in the same direction.

Front 689

Swipe Manipulation gesture

Back 689

One or more fingers touch the screen and move a short distance in the same direction.

Front 690

Turn Manipulation gesture

Back 690

Two or more fingers touch the screen and move in a clockwise or counter-clockwise arc.

Front 691

Pinch Manipulation gesture

Back 691

Two or more fingers touch the screen and move closer together.

Front 692

Stretch Manipulation gesture

Back 692

Two or more fingers touch the screen and move farther apart.

Front 693

manipulation

Back 693

is the immediate, ongoing reaction or response an object or UI has to a gesture.

Front 694

gesture

Back 694

is the physical act or motion performed on, or by, the input device (finger, fingers, pen/stylus, mouse, and so on).

Front 695

a single set of events

Back 695

work for all these input sources.

Front 696

A store app

Back 696

can be written once then set the price in your local currency, and the Windows Store can make it available in the worldwide marketplace in 100+ languages.

Front 697

app bar

Back 697

covers the content of the app and a user can dismiss it with an edge swipe, or by interacting with the app.

Front 698

app bar

Back 698

is hidden by default and appears when users swipe a finger from the bottom edge of the screen.

Front 699

App Bar

Back 699

Used to present commands and tools to users.

Front 700

App contracts

Back 700

Apps can talk to each other

Front 701

App contracts

Back 701

make it easy to access data stored or created by another app by eliminating the need to work with varying standards or app-specific APIs.

Front 702

App contracts

Back 702

provide a way for apps to work together.

Front 703

Apps

Back 703

use tiles instead of icons

Front 704

charm buttons

Back 704

Can be used to connect to devices and send content, stream media, and print.

Front 705

charm buttons

Back 705

Can be used to go directly to the Start screen.

Front 706

charm buttons

Back 706

Can be used to search for content located in your app or in another app, and they can search your app's content from another app.

Front 707

charm buttons

Back 707

Can be used to share content from your app with people or services.

Front 708

charm buttons

Back 708

Can be used to use settings to configure your app to their preferences.

Front 709

charms

Back 709

are a consistent set of buttons that appear in every app: search, share, connect, settings, and start.

Front 710

Microsoft provides two free tools to develop, test, and deploy Windows Store apps:

Back 710

Microsoft Visual Studio Express 2012 for Windows 8 and Blend for Visual Studio.

Front 711

Multiple views

Back 711

Apps support multiple views

Front 712

Navigation Bar

Back 712

can be populated by hard coding entries, programmatically updating it, or by using data binding.

Front 713

Navigation Bar

Back 713

can contain a simple list of links, or it can contain several levels of links organized into categories.

Front 714

Navigation Bar

Back 714

is hidden by default. It appears when users swipe a finger from the top edge of the screen.

Front 715

OneDrive

Back 715

Apps can store data in the cloud

Front 716

OneDrive

Back 716

Give users access to all of their photos, files, and friends at any time and on any device, using their Microsoft account.

Front 717

Store App Components

Back 717

can be written in one programming language and the used in an app written in another programming language.

Front 718

Use the navigation bar

Back 718

to present navigation options to users.

Front 719

When the user installs an app,

Back 719

it shows up as a tile on the Start screen. Touching or clicking the tile starts the app.

Front 720

Windows Azure

Back 720

can be used to quickly build, deploy and manage applications and services, and users can store and share files and communicate with the people most important to them using OneDrive and Outlook.com.

Front 721

Windows Runtime

Back 721

a native API built into the operating system. This API is implemented in C++ and supported in JavaScript, C#, Visual Basic, and C++ in a way that feels natural for each language.

Front 722

Windows Store

Back 722

apps work smoothly with a variety of input sources, including touch, pen, mouse, and keyboard input.

Front 723

Windows Store

Back 723

makes apps available to millions of customers around the world.

Front 724

Windows Store

Back 724

makes it easy to distribute, update, and get paid for the apps that you develop.

Front 725

Windows Store app

Back 725

is a new type of application that runs on Windows 8 devices. Watch this video for a brief introduction to what makes Windows Store apps different from traditional desktop apps.

Front 726

Windows Store apps

Back 726

can search across other apps and even share content with other apps by supporting the right app contracts.

Front 727

Windows Store apps

Back 727

can support different layouts and views to create a great user experience across a variety of form factors and display sizes.

Front 728

Windows Store apps

Back 728

can use the Windows Runtime

Front 729

Windows Store apps

Back 729

get a set of default styles that ensure UI elements work well for touch scenarios.

Front 730

Windows Store apps

Back 730

can be written in the languages like JavaScript, C#, Visual Basic, or C++.

Front 731

Windows Store apps

Back 731

can deliver content through its tile, even when it's not running. Using these live tiles, your app can provide useful, at-a-glance data to the user. Apps can configure the system to periodically ask for updates from a web service, regardless of whether the app is running.