C# Flashcards

Question

Advantages of OOPs over Procedure Oriented Programming

Answer 1

~OOPs makes development and maintenance easier whereas in a procedure-oriented programming language it is not easy to manage if code grows as project size increases. ~OOPs provides data hiding whereas in a procedure-oriented programming language a global data can be accessed from anywhere.

Answer 2

``` ~classes are specialized classes for data storage and retrieval. These classes provide support for stacks, queues, lists, and hash tables. Most collection classes implement the same interfaces. ~classes serve various purposes, such as allocating memory dynamically to elements and accessing a list of items on the basis of an index etc. These classes create collections of objects of the Object class, which is the base class for all data types in C#. ```

Answer 3

ArrayList HashTable Stack Queue

Answer 4

~MAKES DATATYPES OPTIONAL ~DENOTES BY USING '?' ~ENABLES OTION FOR DATATYPE TO HOLD A NULL VALUE ~USEFUL FOR COMPILER TO HELP OUT, CONSIDER GIVING A NULL... bool? x -means 'x' can hold true, false, or null value int? y -means 'y' can hold numbers or null string? i- 'i' can hold characters or null

Answer 5

``` remember....V.A.R.O.S. ~VIRTUAL ~ABSTRACT ~READONLY ~OVERRIDE ~STATIC ```

Answer 6

~USE A CLASS AS A TYPE THEY CAN HOLD THE ADDRESS OF ANY OBJECT THAT IS AN INSTANCE OF THAT CLASS Dog myDog= new Dog( ); ~OBJECTS ARE STORED IN HEAP MEMORY & THEIR ADDESSES ARE STORED IN.....? ~SOMEWHAT LIKE A MASK OVER OBJECTS CODE ex: Polymorphism

Answer 7

~STORE IN DIRECT VALUE; ~STORED IN MEMORY STACK ~STACK IS ALWAYS FASTER TO RETRIEVE DATA THAN HEAP ~SET OF MEMORY SET ASIDE FOR IT TO OCCUPY ex predefined: (int, long, short, byte, data type, char) structs - like a class but gets stored in the stack for memory retrieval efficiency enums - defines a set of named integral constants

Answer 8

~DATATYPES STORED IN THE HEAP & REFERENCE VARIABLES STORED IN THE STACK ~THE ACTUAL OBJECT ITSELF IS STORED IN THE HEAP ~RETRIEVING A VALUE FROM HEAP IS AN EXPENSIVE PROCESS ~HEAP IS DYNAMICALLY CHANGING ex predefined: string, arrays, collections, classes, interfaces, delegates

Answer 9

ALLOWS FOR THE CHILD CLASSES TO PROVIDE NEW IMPLEMENTATION FOR THEIR PARENT FUNCTIONALITY hint: useful for polymorphic references

Answer 10

~CREATION OF METHODS WITH THE SAME NAME AS ANOTHER IN THE SAME CLASSBUT DIFFERS IN PARAMETERS (order number, type) ~EXAMPLE OFSTATIC/ COMPILE TIME POLYMORPHISM; ~METHOD WITH SAME NAME BEHAVES DIFFERENTLY BASED ON SIGNATURES(parameters) Signatures can be different in 3 ways: Number of parameters. Datatype of parameters. Sequence of parameters.

Answer 11

~METHOD OVERRIDING IS AN EXAMPLE OF RUNTIME POLYMORPHISM; WHICH IS REDEFINIG THE METHOD OF THE PARENT CLASS INTO CHILD CLASS ~TO OVERRIDE A METHOD YOU MUST FIRST HAVE A METHOD ON A PARENT CLASS. IN THE CHILD CLASS YOU NEED TO SPECIFY A METHOD OF THE SAME SIGNATURE ``` ~It is also known as dynamic/runtime polymorphism. Redefining the method of base class in child class. ``` ~necessary to make a method overridable by using abstract or virtual keyword in base class In child class use the keyword override to override these methods.

Answer 12

~PROGRAMMING PARADIGGM TO MAKE PROGRAMS BETTER ~ORGANIZED INTO CLASSES ACCESSED BY OBJECTS suited for large complex projects ; actively updated ~BENEFITS: READABILITY, REUSABILITY (inheritance), SCALABILITY, & EFFICIENCY ~STRUCTUE "building blocks": CLASSES, OBJECTS, METHODS, ATTRIBUTES ~CLASSES w/ ATTRIBUTES/ PROPERTY ~TYPES w/ BEHAVIORS AND OPERATIONS (methods) ~OBJECTS ARE AN INSTANCE OF A CLASS, ALLOCATED MEMORY ~WHEN CLASS INSTANTIATED OBJECTS COMES TO LIFE ~ATTRIBUTES CAN BE STATIC OR DYNAMIC

Answer 13

``` "A PIE" ~ABSTRACTION ~POLYMORPHISM ~INHERITANCE ~ENCAPSULATION ```

Answer 14

occurs when you simplify a complex thought or complex system ~like a template ~shows only essential features of the program instead of unnecessary details ~in c# it is achieved by "abstract" classes and interfaces hint ex: "tax system" ... the black box is the functionality

Answer 15

"WRAPPING OF DATA" ~methods enclose data field ~class/type encloses a method ~namespace encapsulates the type "DATA HIDING" ~provide protection from outside members/world -use access modifiers to provide levels of access

Answer 16

~GIVE ACCESS TO THE VARIABLES AND METHODS OF ONE CLASS TO ANOTHER (extends a type so its properties & behaviors can be extended/branched further) ~Child and Parent relationship "is-a(n)" relationship ~a class can only extend one other class ``` ~Single = A>B ~Multi-Level = A>B>C ~Hierarchal = "FAMILY TREE" ~Multiple Inheritance (A,B...) >C ~2 or more parents ~Hybrid (all of the above) ``` C# doesn't support MULTIPLE OR HYBRID INHERITANCE

Answer 17

``` ~ABILITY TO IMPLEMENT INHERITED PROPERTIES OR METHODS IN DIFFERENT WAYS ACROSS MULTIPLE ABSTRACTIONS "is a(n)" relationship; when one class extends another, an instance of that child class is also an instance of the parent class ex: dog is an instance of an animal sn: if one class can be described as an example or subtype of another class than it can probably inherit from it ```

Answer 18

~STATIC/ COMPILE TIME or DYNAMIC/ RUNTIME COMPILE TIME POLYMORPHISM = METHOD OVERLOADING (remember the "L's") RUNTIME = METHOD OVERRIDINIG (remember the "R's")

Answer 19

THE ACCESSIBILITY IS BASED ON THE ASSEMBLY WHICH MATTERS IN PRIVATE PROTECTED PRIVATE PROTECTED METHODS CAN BE ACCESSED INSIDE SAME ASSEMBLY private protected is that it must live in the same assembly to be accessible: private: The type or member can be accessed only by code in the same class or struct . protected: The type or member can be accessed only by code in the same class , or in a class that is derived from that class .

Answer 20

"TYPES" (ex: class) is INTERNAL | "TYPES MEMBERS" (ex: methods and variables) is PRIVATE

Answer 21

~USED TO GUARENTEE THE AVAILABILITY OF METHODS IN IMPLEMENTING CLASS ~ALL METHODS ARE PUBLIC ABSTRACT ~ALL VARIABLES ARE PUBLIC, STATIC, FINAL these tools declare specific behavior for objects ~ABSTRACT ENTITY; WRITTEN SIMILAR TO CLASSES ~IMPLEMENT KEYWORD IN CLASS DECLARATION AFTER EXTENDING CLASS ~MAKES COMPILER ENFORCED CONTRACTS. ~A CLASS THAT IMPLEMENTS AN INTERFACE MUST PROVIDE AN IMPLEMENTATION FOR EVERY INTERFACE METHOD OR BE AN ABSTRACT CLASS because the implementing class would till have an abstract method & your not allowed to have a concrete class that doesn't implement every method it declares

Answer 22

~A CLASS CAN ONLY EXTEND ONE OTHER CONCRETE OR ABSTRACT CLASS BUT CAN IMPLEMENTS MULTIPLE INTERFACES ~INTERFACES EXTEND OTHER INTERFACES WITH NO LIMITS TO QUANTITY, BUT CAN'T EXTEND OTHER CLASSES ~NON-TRADITIONAL INHERITANCE; ~said to have "type" inheritance. A class that implements an interface is polymorphically considered an instance of the interface " is- a(n)" relationship when an interface is implemented interface methods do not have implementations & interface variables are static, so no states or behaviors are inherited ~AN INTERFACE DESCRIBES WHAT BEHAVIORS (verb) A CLASS SHOULD HAVE; it provides none of its own ~

Answer 23

~HELPS COMPILER RESOLVE NAMESPACES BUT REQUIRE FEWER KEYSTROKES ~INSTRUCTS COMPILER WHERE TO LOOK FOR REFERENCES TO CLASSES

Answer 24

An Error "indicates serious problems that a reasonable application should not try to catch." A serious problem that for the most part cannot be handled by the developer -They are fatal to the program at runtime Ex: A stack overflow error and that usually occurs when your computer has run out of memory to store information 3 types of errors ~Usage error - error in your program logic and can be solve by modifying/restructuring your code ~Program Error - run-time error that cannot be avoided even with a bug-free code (Ex: Your SDK is corrupt and can't compile or translate it to machine code properly) ~System Failures - run-time error that cannot be handled programmatically in a meaningful way (Ex: your ram hardware is faulty)

Answer 25

~are problems which can occur at runtime/compile time ~indicates conditions that a reasonable application might want to catch. ~Exceptions can be generated by the common language runtime (CLR), by .NET or third-party libraries, or by application code. ex: ~ArgumentExceptions ~ArgumentOutOfRangeException SYSTEM EXCEPTIONS: ~NullReferenceException ~InvalidOperationException IO EXCEPTIONS: * DivideByZeroException * OutofMemoryException * StackOverFlowException * IndexOutOfRangeException APPLICATION EXCEPTION: (Anticipated by developer) CustomExceptions

Answer 26

~HANDLED GRACEFULLY SO THAT USER IS PROVIDED WITH INFORMATION AS WHY THE APPLICATION IS NOT RESPONDING AS ANTICIPATED WHY: *better user experience *make program robust *log exceptions to learn from the reason and fix them IN C#: TRY, CATCH, FINALLY, THROW(keyword) ; must have at least one catch block or one finally block The catch block will then "catch" that exception and will run instead of its block of code Once an exception occurs in the try block, the flow of control jumps to the first associated exception handler that is present anywhere in the call stack. In C#, the catch keyword is used to define an exception handler. If no exception handler for a given exception is present, the program stops executing with an error message. Don't catch an exception unless you can handle it and leave the application in a known state. Optionally, you can add a finally block that will run regardless if your code throws an exception or not Mostly used to clean up any resources you used in the try blcok

Answer 27

I. aka EXCEPTIONS THAT CAUSE THE PROGRAM TO TERMINATE | II. SYNTAX ERRORS

Answer 28

~type-safe at compile time. Because of this, generic collections typically offer better performance. ~Generic collections accept a type parameter when they are constructed and do not require that you cast to and from. ~The "T" you see in documentation is where you put what data type that collection will hold ~All collections provide methods for adding, removing, or finding items in the collection. ~All collections can be enumerated by virtue of Enumerator. ~An enumerator can be thought of as a movable pointer to any element in the collection. ************** LIST ************** SORTED LIST ************** LINKED LIST ************** HASHSETS ************** DICTIONARIES ************** STACK; ************** QUEUE

Answer 29

Common Language Specification It has defined rules and restrictions that every langauge must follow for it to be able to run the .NET framework Essentially a standardization to make sure a language won't do anything that will make it incompatible with .NET framework

Answer 30

Common Type System Provides a library of the basic value data types It is a standardization of data types to ensure every language will follow the same datatype Ex: int in C# is the same 32-bit memory as the int in Visual Basic Helps create Language Interoperability Fancy way of saying .NET has the capability to develop application using two or more programming languages You can create apps using Visual Basic, C#, J# (Java-like language that can run in .NET), etc. NEVER SAY JAVA ITSELF J# IS NOT JAVA

Answer 31

Common Language Runtime implements VES so anything in VES, CLR also has it plus more Essentially, it is .NET's version of VES Run-time environment that provides services that make the development process easier Some servies it includes: Automatic memory management (older languages you have to manually release unused resources) JIT compilation (Just-inTime compilation that involves compliation during execution for optimization) It just means any new compile code gets executed immediately, it doesn't have to wait until your entire code has been compiled to run your app Exception handling support Security

Answer 32

a run-time system of the Common Language Infrastructure CLI which provides an environment for executing managed code.

Answer 33

Logical grouping of classes that follow a certain theme of functionality To utilize the classes located in a different namespace, you must use the 'using' keyword

Answer 34

They contain all the files that are actual executables These files will differ depending on what operating system you are using but as for windows, it will be .exe and .dll (dynamic link library) files If you open the auto-generated bin folders, you can file the assembly files located there So main difference with projects are that projects are the .cs files and .csproj and other configurations while assembly is the actual files that gets run since that is what your operating system understands

Answer 35

The final grouping mechanism in that it will group multiple projects as one application They are the final packaging of your application

Answer 36

I. with only get block. II. with only set block. III. with both get and set block.

Answer 37

A. ~It is when a value type gets casted into an object Useful if you want a value type to have reference type like functionalities It is implicit conversion ~refers to conversion Value type to reference types. B. ~When you extract the value from an object and convert it into a value type instead It is explicit conversion ~refers to conversion of reference types to value types.

Answer 38

Generally, it is when you can convert the type without any data loss Mostly used with numerical datatypes No special syntax needed to write and compiler will do it for you no need to type cast manually/explicitly. ex: byte value can be placed in int; converting an int into a double

Answer 39

If there is a risk of losing information, you must perform a Cast Special syntax is needed to write to tell the compiler to do it anyway Casting is denoted with (datatype) type cast it using .Parse(value), Convert.(value). You can have a data loss if its not fitting in the type. The Parse method returns the converted number; the TryParse method returns a boolean value that indicates whether the conversion succeeded, and returns the converted number in an out parameter.

Answer 40

Used to store a datatype and have fixed sizes Zero-based index 0 is the starting position of the array Other arrays you can make: Multidimensional arrays - int[,] ex = new int[4,2]; would create [ [0, 0], [0, 0], [0, 0], [0, 0] ] Jagged arrays - arrays inside of an array are different sizes [ [0, 0, 0], [0, 0], [0, 0, 0], [0, 0 , 0, 0] ]

Answer 41

~Like any array which can grow and shrink dynamically. ~Items in the list can be accessed by index. ~It can accept null as a valid value for reference types and it also allows duplicate elements. ~List class is not sorted by default and elements are accessed by zero-based index. Properties ~Capacity - Gets or sets the total number of elements the internal data structure can hold without resizing. ~Count - Gets the number of elements contained in the List ~Methods: ~Add(T) - Adds an object to the end of the List ~Clear() - Removes all elements from the List ~Insert(index, T) - Inserts an element into the List at the specified index ~Remove(T) - Removes the first occurrence of a specific object from the List ~RemoveAt(index) - Removes the element at the specified index of the List ~Reverse() - Reverses the order of the elements in the List or a portion of it

Answer 42

It stores key/value pairs | Keys must be Unique

Answer 43

It is a sorted list of key/value pairs

Answer 44

It allows fast inserting and removing of elements. It implements a classic linked list. Each element is separately allocated. Properties Count - Gets the number of nodes actually contained in the LinkedList. First - Gets the first node of the LinkedList. Last - Gets the last node of the LinkedList. Methods AddFirst - Adds a new node or value at the start of the LinkedList. AddLast - Adds a new node or value at the end of the LinkedList. Clear() - Removes all nodes from the LinkedList. Contains(T) - Determines whether a value is in the LinkedList. Remove(LinkedListNode) - Removes the specified node from the LinkedList. Remove(T) - Removes the first occurrence of the specified value from the LinkedList. RemoveFirst() - Removes the node at the start of the LinkedList. RemoveLast() - Removes the node at the end of the LinkedList.

Answer 45

``` An interface defines a contract. Any class or struct that implements that contract must provide an implementation of the members defined in the interface. Abstract class allows you to implement a spectrum of abstraction like full abstraction, partial abstraction etc.... Abstract class allows you to have all types of members. Like you can have data variables and assign values to it and can create methods with definition. But interface can only have methods, properties, events, indexers, which means interfaces cannot have variables or methods with implementation (except C# 8.0 or later version allow you to have static methods with implementation). Abstract class and interface cannot be instantiated but meant to be implemented/inherited. Abstract/Concrete class can implement one or more interfaces by which multiple inheritance is achieved. But class can only inherit from 1 class. A class can inherit 1 class and one or more interfaces. ```

Answer 46

CAN'T CHANGE VALUE WHEN SET CAN BE INITIALIZED AT A LATER TIME LIKE IN A CONSTRUCTOR "READONLY" YOU CAN ONLY READ THE VALUE NOT WRITE IT

Answer 47

~EXECUTES ITS STATEMENT AT LEAST ONCE, WHILE THE CONDITION IS TRUE ITERATES THROUGH A BLOCK OF CODE & CONTINUES REPEATING THEM BASED ON A CONDITION UNTIL FALSE ~THE CONDITION IS NOTED ON THE BOTTOM AFTER THE WHILE PORTION OF THE STATEMENT

Answer 48

EXECUTES BLOCK OF CODE BASED ON CONDITIONS WHILE TRUE UNTIL FALSE

Answer 49

Design patterns provide typical solutions/ blueprints to solving commonly occurring problems in software design.

Answer 50

Creational design patterns are a category of design patterns that provide object creation mechanisms that increase flexibility and reusability of existing code.

Answer 51

This design pattern is a Creational design pattern. It lets the programmer ensure a class has only a one single instance while also providing a global access point to this instance.

Answer 52

* Use the Singleton pattern when a class in your program should have just a single instance available to all clients; for example, a single database object shared by different parts of the program. * Use the Singleton pattern when you need stricter control over global variables.

Answer 53

* You can be sure that a class has only a single instance. * You gain a global access point to that instance. * The singleton object is initialized only when it’s requested for the first time.

Answer 54

* Violates the Single Responsibility Principle. The pattern solves two problems at the time. * The Singleton pattern can mask bad design, for instance, when the components of the program know too much about each other. * The pattern requires special treatment in a multithreaded environment so that multiple threads won’t create a singleton object several times. * It may be difficult to unit test the client code of the Singleton because many test frameworks rely on inheritance when producing mock objects. Since the constructor of the singleton class is private and overriding static methods is impossible in most languages, you will need to think of a creative way to mock the singleton. Or just don’t write the tests. Or don’t use the Singleton pattern.

Answer 55

The Factory Method design pattern is a Creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created.

Answer 56

* You avoid tight coupling between the creator and the concrete products. * Single Responsibility Principle. You can move the product creation code into one place in the program, making the code easier to support. * Open/Closed Principle. You can introduce new types of products into the program without breaking existing client code.

Answer 57

The code may become more complicated since you need to introduce a lot of new subclasses to implement the pattern. The best case scenario is when you’re introducing the pattern into an existing hierarchy of creator classes.

Answer 58

Structural design patterns explain how to assemble objects and classes into larger structures, while keeping these structures flexible and efficient. ex: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, etc.

Answer 59

* Use the Factory Method when you don’t know beforehand the exact types and dependencies of the objects your code should work with. * Use the Factory Method when you want to provide users of your library or framework with a way to extend its internal components. * Use the Factory Method when you want to provide users of your library or framework with a way to extend its internal components.

Answer 60

The Facade Design Pattern is a Structural design pattern that provides a simplified interface to a library, a framework, or any other complex set of classes.

Answer 61

* Use the Facade pattern when you need to have a limited but straightforward interface to a complex subsystem. * Use the Facade when you want to structure a subsystem into layers.

Answer 62

You can isolate your code from the complexity of a subsystem.

Answer 63

A Facade can become a god object coupled to all classes of an app.

Answer 64

Behavioral design patterns are concerned with algorithms and the assignment of responsibilities between objects.

Answer 65

Mediator is a behavioral design pattern that lets you reduce chaotic dependencies between objects. The pattern restricts direct communications between the objects and forces them to collaborate only via a mediator object.

Answer 66

- Single Responsibility Principle. You can extract the communications between various components into a single place, making it easier to comprehend and maintain. - Open/Closed Principle. You can introduce new mediators without having to change the actual components. - You can reduce coupling between various components of a program. - You can reuse individual components more easily.

Answer 67

Over time a mediator can evolve into a God Object. **i.e. God object (sometimes also called an Omniscient or All-knowing object) is an object that references a large number of distinct types, has too many unrelated or uncategorized methods or some combination of both. The God object is an example of an anti-pattern and a code smell.

Answer 68

* Use the Mediator pattern when it’s hard to change some of the classes because they are tightly coupled to a bunch of other classes. * Use the pattern when you can’t reuse a component in a different program because it’s too dependent on other components. * Use the Mediator when you find yourself creating tons of component subclasses just to reuse some basic behavior in various contexts.

Answer 69

The Strategy is a behavioral design pattern that lets you define a family of algorithms, put each of them into a separate class, and make their objects interchangeable.

Answer 70

- You can swap algorithms used inside an object at runtime. - You can isolate the implementation details of an algorithm from the code that uses it. - You can replace inheritance with composition. - Open/Closed Principle. You can introduce new strategies without having to change the context.

Answer 71

- If you only have a couple of algorithms and they rarely change, there’s no real reason to overcomplicate the program with new classes and interfaces that come along with the pattern. - Clients must be aware of the differences between strategies to be able to select a proper one. - A lot of modern programming languages have functional type support that lets you implement different versions of an algorithm inside a set of anonymous functions. Then you could use these functions exactly as you’d have used the strategy objects, but without bloating your code with extra classes and interfaces.

Answer 72

* Use the Strategy pattern when you want to use different variants of an algorithm within an object and be able to switch from one algorithm to another during runtime. * Use the Strategy when you have a lot of similar classes that only differ in the way they execute some behavior. * Use the pattern to isolate the business logic of a class from the implementation details of algorithms that may not be as important in the context of that logic. * Use the pattern when your class has a massive conditional statement that switches between different variants of the same algorithm.

Answer 73

The Adapter is a structural design pattern that allows objects with incompatible interfaces to collaborate.

Answer 74

- Single Responsibility Principle. You can separate the interface or data conversion code from the primary business logic of the program. - Open/Closed Principle. You can introduce new types of adapters into the program without breaking the existing client code, as long as they work with the adapters through the client interface.

Answer 75

The overall complexity of the code increases because you need to introduce a set of new interfaces and classes. Sometimes it’s simpler just to change the service class so that it matches the rest of your code.

Answer 76

* Use the Adapter class when you want to use some existing class, but its interface isn’t compatible with the rest of your code. * Use the pattern when you want to reuse several existing subclasses that lack some common functionality that can’t be added to the superclass.

C# Flashcards

(100 cards)