A modifier used to create data and functions that can be accessed without creating an instance of the class. Can be used to separate data and behavior that is independent of any object identity: the data and functions do not change regardless of what happens to the object.
Back
try-catch-finally
Front
An exception handling statement where code is executed in the first block, any exceptions are handled in the second block, and resources are released in the final block.
Back
Int
Front
A value type with a range of -2,147,483,648 to 2,147,483,647.
Back
Public
Front
Keyword with the most permissive access level. There are no restrictions on accessing these members.
Back
Class
Front
Defines the data and behavior of a type, like a blueprint. Must have at least one method and one field. Classes can be such as a integer class.
Back
Switch
Front
A selection statement that transfers control to the case section whose label contains a constant value that matches the value of the expression evaluated.
Back
Void
Front
The return type for a method that does not return a value.
Back
Byte
Front
A value type with a range of 0 to 255.
Back
Private
Front
Keyword with the least permissive access level. Members are accessible only within the body of the class or the struct in which they are declared.
Back
Variable
Front
Word (storage location) that holds a value. The data type and name must be declared in a statement. Must be explicitly declared before use. Uses CamelCase notation.
Back
Interface
Front
Contains only the signatures of methods, delegates or events. The implementation of the methods is done in the class that implements this. Is a contract.
Back
Decimal
Front
A 128-bit value data type with great precision and a range which makes it appropriate for financial and monetary calculations.
Back
Property
Front
A member that provides read and/or write access to a private field. Contains get/set accessors.
Back
Char
Front
A value type that represents a Unicode character.
Back
For
Front
Executes a block repeatedly until a specified expression evaluates to false. This loop is handy for iterating over arrays and for sequential processing. (Hint: More compact version of another iteration statement.)
Back
Method
Front
A code block containing a series of statements. Takes an input, performs some action, and sometimes produces an output. Something an object can do.
Back
Stack
Front
Block of memory allocated when a program is executed, is sequential (LIFO), and used for value data types (e.g., int).
Back
Operator
Front
Symbol which transforms and combines expressions
Back
Member
Front
Represents the data or behavior of a class or struct (e.g., field, property, method, constant, event, etc.).
Back
Assembly
Front
Compilation of classes. In C#, usually ends in .dll or .exe
Back
Bool
Front
A value type that evaluates to true or false.
Back
Argument
Front
The value of the parameter passed to a method. Information given to methods for manipulation.
Back
Override
Front
A modifier used with a method, a property, an indexer, or an event to create a new implementation of a virtual member inherited from a base class. Must have the same signature.
Back
Constructor
Front
Class method that has the same name as the class, is executed when an object is created, and can set default values for the object.
Back
Access Modifier
Front
Keyword used to specify the declared accessibility of a member or a type.
Back
Object
Front
Instance of a type/class created when a program runs. Can be visible or invisible. Has properties, events and methods.
Back
Protected
Front
Keyword where members are accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.
Back
Heap
Front
Block of memory allocated on the fly when the 'new' operator is called, or with reference data types (e.g., strings).
Back
Abstract
Front
A modifier used in a class declaration to indicate that the class is intended only to be a base class of other classes and cannot be instantiated.
Back
Parameter
Front
Used to pass values or variable references into a method.
Back
Overloading
Front
Using the same name for multiple class methods within the same class but with different parameters.
Back
Expression
Front
A sequence of one or more operands and zero or more operators that can be evaluated to a single value, object, method, or namespace.
Back
Keyword
Front
Name reserved by the compiler that coders are not allowed to use as identifier.
Back
Foreach
Front
Statement used to iterate through every element in an array or collection. Should not be used to change the contents of the collection to avoid unpredictable side effects.
Back
Const
Front
A modifier used with a declaration of a field or local variable, and specifying the value of which cannot be modified.
Back
Array
Front
A data structure that contains several variables of the same type. Can be Single-Dimensional, Multidimensional or Jagged.
Back
Virtual
Front
A modifier used with a method or property declaration, the implementation of which can be changed by an overriding member in a derived class. When invoked, the run-time type of the object is checked for an overriding member.
Back
Encapsulation
Front
A characteristic of OOP that restricts access to class members to prevent users from misusing objects. While hiding the internal functionalities, it allows the class to service requests or modify its code to suit changing requirements.
*It is a technique of packaging an objects attributes and methods into a cohesive unit that can be used as a undivided entity.
Back
Do-While
Front
Executes a block repeatedly until a specified expression evaluates to false, but is always executed once before the conditional expression is evaluated.
Back
Inheritance
Front
A characteristic of OOP that allows the creation of new classes that reuse, extend, and modify the behavior that is defined in other classes. Implemented with a colon followed by the parent class (e.g., public class B : A)
Back
Namespace
Front
Groups classes together so that they have a unique identifier. like .WriteLine()
Back
Polymorphism
Front
A characteristic of OOP that allows objects belonging to different types to respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior (speak()!). Uses the same public interface for different types.
Back
Field
Front
Variable of any type, declared directly in a class. Should be private or protected, and store data needed by more than one method.
Back
Indexer
Front
Allows an instance of a class or struct to behave like an array. Resembles a property except that its accessors take parameters. Defined with this and value keywords.
Back
If-else
Front
A selection statement that identifies which block of code to run based on the value of a Boolean expression.
Back
Struct
Front
A value type that can behave like a class but is instatiated on the stack, is lightweight, and is passed by value instead of reference.
Back
Generic
Front
A way to create a collection that is type-safe at compile-time (as opposed to casting types to and from the universal base type Object). Defined with a <T>.
Back
Collection
Front
A specialized class for data storage and retrieval. Provides support for stacks, queues, lists, and hash tables, increased type-safety and better performance.
Back
Internal
Front
Keyword where members are accessible only within files in the same assembly.
Back
While
Front
Executes a block repeatedly until a specified expression evaluates to false. (Hint: Less compact version of another iteration statement.)
Back
Section 2
(17 cards)
Float
Front
A value type that stores 32-bit floating-point values with a range of -3.4 × 1038 to +3.4 × 1038.
Back
Is
Front
An operator that checks if an object is compatible with a given type. Evaluates to false if the object is not convertible, but does NOT perform conversion.
Back
Parse
Front
A method used to convert data from one type to another.
Back
Factory
Front
An object for creating other objects. It is an abstraction of a constructor, and typically has a method for every kind of object it is capable of creating. These methods optionally accept parameters defining how the object is created, and then return the created object.
Back
method body
Front
The statements that implement a method surrounded by {} of our method header:
Ex:
method header name ()
{
Method Body
}
Back
Reflection
Front
Dynamically creates an instance of a type, binds the type to an existing object, or gets the type from an existing object and invokes its methods or accesses its fields and properties. Enables you to access attributes.
Back
Using the System Namespace
Front
Generally when coding in C# you may print a line as such:
System.Console.WriteLine("Hello);
However we can use name-spacing to globally make these directives available and shorten our code.
We can repeat the code as follows:
using System;
.....
Console.WriteLine("Hello")
We used a using clause or using directive to shorten our code. We can shorten it even further:
using static System.Console;
.....
WriteLine("Hello")
Back
Double
Front
A value type that stores 64-bit floating-point values with a range of ±5.0 × 10−324 to ±1.7 × 10308
Back
Singleton
Front
A class pattern that creates a single instance of itself. Allows other objects to access this instance through a class method that returns a reference to the instance. Declares the class constructor as private so that no other object can create a new instance. (Example = mouse pointer)
Back
Enum
Front
A value type consisting of a set of named constants. By default, the first element has the int value 0, and each successor is increased by 1.
Back
method header
Front
Includes the method name and information about what will pass into and be returned from a method
Back
Attribute
Front
A powerful method of associating metadata, or declarative information, with code (assemblies, types, methods, properties, and so forth).
Back
static void
Front
A method of the class and does not generate a value
Back
Boxing
Front
The implicit process where the CLR wraps a value type inside a System.Object and stores it on the managed heap.
Back
Var
Front
An implicit type. It aliases any type in the C# programming language. The aliased type is determined by the C# compiler. This has no performance penalty.
Back
Sealed
Front
A modifier that prevents other classes from inheriting from the modified class.
Back
As
Front
An operator that is used to perform certain types of conversions between compatible reference or nullable types. Acts like a cast operation. However, if the conversion is not possible, it returns null instead of raising an exception.