C#

Front 1

constructor chaining

Back 1

this design patter is helpful when you have a class that defines multiple constructors.

Front 2

#this keyword

Back 2

this keyword provides access top the current class instance.'used to resolve scope ambiguity

Front 3

if you do not define a custom constructor, the C# compiler will

Back 3

grant you a default in order to allow the object user to allocate an instance of your type with field data set to the correct default value

Front 4

Objects must be allocated into memory using the new keyword. If you do not make use of the new keyword and attempt to make use of your class variable in a subsequent code statement you will receive a compiler error. The following Main() method will not compile

Back 4

static void Main(string[] args) { Console.WriteLine("--------------------"); //error, we need to use new to create object Car myCar; myCar.petName = "Fred"; } ----------------------- static void Main(string[] args) { Console.WriteLine("--------------------"); //Correct Car myCar = new Car(); myCar.petName = "Fred"; }

Front 5

The ?? Operator

Back 5

allows you to assign a value to a nullable type if the retried value is in fact null. Example - assume you want to assign a local nullable integer to 100 if the value returned from GetIntFromDatabase() is null DatabaseReader dr = new DatabaseReader(); int myData = dr.GetIntFromDatabase() ?? 100; equivalent using ? int? moreData = dr.GetIntFromDatabase(); if (!moreData.HasValue) moreData = 100;

Front 6

The 3 core principals of OOP

Back 6

Encapsulation - how does the language hides an object's internal implementation details and preserve data integrity Inheritance - how does this language promotes code reuse Polymorphism - how does this language let you treat related objects in a similar way

Front 7

Defining static classes

Back 7

it is possible to apply the static keyword directly on the class level. When a class has been defined as static, it is not creatable using the new keyword. and it can contain only member or data fields marked with the static keyword

Front 8

A given class may define only a single static constructor. In other words, the static constructor cannot be ____________

Back 8

overloaded

Front 9

A static constructor does not take _________________________

Back 9

A static constructor does not take an access modifier and cannot take any parameter

Front 10

How many times a static constructor executes?

Back 10

Once, regardless of how many objects of the type are created The run-time invokes the static constructor when it creates of the class or before accessing the first static member invoked by the caller

Front 11

C# demands that a given class have ___________ base class

Back 11

one hence C# does not have multiple inheritance //Illegal! class WontWork : BaseClassOne, BassClassTwo {}

Front 12

c# sealed keyword

Back 12

prevents inheritance from occuring // The MiniVan class cannot be extended! sealed class Minivan : Car { }

Front 13

c# inheritance

Back 13

// MiniVan is-a Car class MiniVan : Car {}

Front 14

readonly field

Back 14

read-only field data cannot be change after the initial assignment. Unlike constant, the value assigned to a read-only field can be determined at runtime and therefore can legally be assigned within the scope of a constructor class MyMathClass { //Read-only fields can be assinged in ctor, but nowhere else public readonly double PI; public myMathClass () { PI = 3.14; } }

Front 15

C# partial keyword

Back 15

Using partial classes, you could choose to move the constructors and field data into a brand new file. Use when a class is thousands of line and it is too unconvenient for one file class Emploee { //field data //constructors } //-------------------- vs //Employee.cs partial class Employee { //field data } //Employee.Internal.css partial class Employee { //constructors }

Front 16

automatic property syntax

Back 16

class Car { public stirng PetName { get; set; } public int Speed { get; set; } public string Color { get; set; } }

Front 17

public c# access modifier

Back 17

public items have no access restrictions. A public member can be accessed fro man object, as well as any derived class. A public type can be accessed from other external assemblies.

Front 18

private c# access modifier

Back 18

private items can only be accessed by the class that defines the item

Front 19

protected c# access modifier

Back 19

protected items can be used by the class which defined it, and any child class. However, protected items cannot be accessed from the outside world using the C# dot operator

Front 20

internal c# access modifier

Back 20

internal items are accessible only within the current assembly. Therefor, if you define a set of internal types within a .Net class library, other assemblies are not able to make use of htem

Front 21

protected internal c# access modifier

Back 21

when the protected and internal keywords are combined on an item, the item is accessible within the defining assembly, the defining class, and be derived classes

Front 22

virtual member def

Back 22

is a member of a base class that defines a default implementation that may be changed by derived class

Front 23

abstract method def

Back 23

abstract method is a member in a base class that does not provide a default implementation, but does proved a signature. When a class derives from a base class defining an abstract method, it must be overridden by a derived type

Front 24

Managed code is executed by _____________

CLR

FCL

Back 24

Managed code is executed by the Common Language Runtime (CLR) Managed languages depend on services provided by a runtime environment.

CLR - Common Language Runtime

FCL - Framework Class Library

Front 25

What are Dynamics?

Back 25

Instructs the compiler to ignore type checking at compile-time Defers type checking until runtime

Front 26

struct def

Back 26

public struct Point { public int X { get; set; } public int Y { get; set; } }

Front 27

When to use structs

Back 27

-instance of the type are small -the struct is commonly embedded in another type -the struct is logically representing a single value -the value don't change (immutable) -it is rarely "boxed" Structs can have performance benefits in computational intensive applications

Front 28

Static class

Back 28

expose static member of the class cannot be instantiated

Front 29

Abstract class

Back 29

cannot be instantiated it is actually an incomplete class defines behavior for anyone that inherits from this class

Front 30

Sealed class

Back 30

cannot be inherited from

Front 31

Partial classes

Back 31

a class definition can be split into multiple source files at compile time, these multiple parts are combined of the used in code generation

Front 32

internal access modifier

Back 32

internals - can be accessed by any code in the same assembly, but not from any other assembly.

Front 33

C# short hand implementation

Back 33

public class Animal { public string Name { get; set; } private string _name; private string Name { get { return _name; } set { _name = value; } } }

Front 34

public class Animal { public string Name { get; set; } private string _name; private string Name { get { return _name; } private set { _name = value; } } } What the private in front of set does?

Back 34

We tell that you cannot change name during the life of the object. It can be set only from within the class but it can be used publicly

Front 35

default parameters

Back 35

public class Customer { public int AddPoints(int pointsToAdd =1) { points += pointsToAdd; return points; } } When declaring methods with default values the default method comes as last parameter in the method's signature

Front 36

named arguments allows to specify arguments in any order allows to easily handle

Back 36

public class Customer { public int AddPoints(int pointsToAdd, int maxPoints) { points += pointsToAdd; if ( points > maxPoints ) { return maxPoints; } return points; } } usage: int newPoints1 = AddPoint(1, 10); int newPoints2 = AddPoints(maxPoints:10, pointsToAdd: 1); int newPoints3 = AddPoints(1, maxPoints: 10);

Front 37

public event EventHandler HasSpoken;

Back 37

event - lets the object to talk back to the developer in an implementation of a method if (HasSpoke != null ) // we check if someone is listening HasSpoken(this, EventArgs.Empty);

Front 38

Boxing def

Back 38

boxing is the act of converting a value type to a reference type unboxing is the reverse it requires a cast int count = 1; // the value of count is copied and boxed object countObject = count; count += 1 // countObject(1) is unboxed and copied to count count = (int)countObject;

Front 39

sample hello world

Back 39

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace helloWorld { class Program { static void Main(string[] args) { Console.WriteLine("Hello World!"); Console.ReadLine(); } } }

Front 40

foreach

Back 40

var list= new[] {1,2,3,4,5,6}; foreach (var item in list) { if (item % 2 == 0) continue; }

Front 41

use enum

Back 41

enum Dogs { hund, coly, shepard } var snoopy = Dogs.hund; switch (snoopy) { case Dogs.hund: case Dog.coly: Console.WritLine("hund or coly"); break; }

Front 42

is operator

Back 42

C# provides us with the is operator returns true if an objects is an instance of a type

Front 43

as operator

Back 43

the as operator attempts to cast an object to a specified type returning the instance cast to the type null if not possible does not raise an exception

Front 44

string class Substring

Back 44

var source = "The quick brown fox jumped over the lazy dog"; var value = source.Substring(4,5); // value == quick

Front 45

string class Concat

Back 45

var source = "quick"; var value = string.Concat(value, " fox"); // value == quick fox

Front 46

string class Replace

Back 46

var source = "The quick brown fox jumped over the lazy dog"; var value = value.Replace("fox","dog"); //value == "quick dog"

Front 47

string class ToUpper

Back 47

var source = "quick dog"; var value = value.ToUpper(); // value == "QUICK DOG"

Front 48

string class ToArray

Back 48

var src = "dog"; var array = src.ToArray(); // array == {'d', 'o','g'}

Front 49

string class Split

Back 49

var source ="The quick brown fox"; var split = source.Split(' '); var value = split[1]; // value = "quick"

Front 50

How to get the total number of elements in an array?

Back 50

By using the Length property Numbers.Lenght

Front 51

What are the access-specifiers available in C#?

Back 51

private, protected, public, internal, protected internal

Front 52

Difference between Static and ReadOnly?

Back 52

Static:A variable that retains the same data throughout the execution of a program. ReadOnly:you can't change its value.

Front 53

Write a single line of code to read the entire content of the text file.

Back 53

User following codestring strContent = System.IO.File.ReadAllText(Server.MapPath(~/MyTextFile.txt));

Front 54

What is the advantage of using System.Text.StringBuilder over System.String?

Back 54

String Builder is more efficient in the cases, where a lot of manipulation is done to the text. Strings are immutable, so each time it's being operated on, a new instance is created.

Front 55

Can a class have static constructor?

Back 55

Yes, a class can have static constructor. Static constructors are called before when any static fields are executed. These are used to initialize static class members and called automatically before the first instance is created or any static members are referenced. This is also known as before instance constructor. Below is one example of above described theory. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SampApp{class Sample{static int i;static Sample(){i = 10;Console.WriteLine(In Static Constructor);} public Sample(){Console.WriteLine(In Instance Constructor);}public static void Main(){Sample s = new Sample();}}}

Front 56

What is difference between var and Dynamic ?

Back 56

Var word was introduced with C#3.5(specifically for LINQ) while dynamic is introduced in C#4.0. variables declared with var keyword will get compiled and you can have all its related methods by intellisense while variables declared with dynamic keyword will never get compiled. All the exceptions related to dynamic type variables can only be caught at runtime.

Front 57

What is the difference between object pooling and connection pooling?

Back 57

In case of object pooling, you can control the number of connections. In this case the pool will decide whether the maximum is reached or not for creation of objects. If it reached to the maximum level then the next available object will returned back. The drawback is, it increases the time complexity for heavy objects.In case of connection pooling, you can control the maximum number of connections reached. When you are using this pool, since there is nothing in the pool, still it will create connection on the same thread.

Front 58

Can you allow class to be inherited, but prevent the method from being over-ridden?

Back 58

Yes, we can allow the class to be inherited without over-riding the method.Just leave the class as public and make the method sealed.

Front 59

What are the different C# preprocessor directives?

Back 59

#region,#endregion:- Used to mark sections of code that can be collapsed. #define,#undef:-Used to define and undefine conditional compilation symbols. #if,#elif,#else,#endif:- These are used to conditionally skip sections of source code.

Front 60

Can you prevent a class from overriding ?

Back 60

Yes you can prevent a class from overriding if you define a class asSealedthen you can not inherit the class any further.

Front 61

Why we are using System.Environment class?

Back 61

The aim of usingSystem.Environmentclass is to get the command-line arguments.This class also helps us to retrieve the environment variable settings for a particular contents of the call stack. It can also find the time of last system boot and version of the CLR.

Front 62

What is partial class?

Back 62

Partial class is a new functionality added in since .NET Framework 2.0 version. It allows to split us to split the definition of once class, struct, interface into multiple source files. Each source file contains a section of definition, and all parts are combined when the application is compiled

Front 63

What is ILDASM?

Back 63

The ILDASM stands for Intermediate Language Disassembler. This is a de-compiler which helps to get the source code from the assembly.This ILDASM converts an assembly to instructions from which source code can be obtained.The ILDASM can analyze the .dll or .exe files and converts into human readable form. This is used to examine assemblies and understanding the assembly capability.

Front 64

Explain about abstract property

Back 64

A property with abstract keyword is considered as abstract property. An abstract property cannot have any implementation in the class. In derived classes you must have to write their own implementation

Front 65

What is Jagged Array?

Back 65

An array whose elements are arrays is known as a jagged array.The elements of this jagged array can be of different dimensions and sizes.A jagged array is sometimes called as an array-of-arrays.

Front 66

What is an ArrayList?

Back 66

ArrayList is a dynamic array. Elements can be added&removed from an arraylist at the runtime. In this elements are not automatically sorted.

Front 67

Write an equivalent of exit() for quitting a C# .NET application?

Back 67

Yes, in case of windows forms application you can exit the application with the help of System.Environment.Exit(datatype exitCode) or Application.Exit().

Front 68

Where the global assembly cache located on the system?

Back 68

Usually the global assembly cache located at C:\winnt\assembly or C:\windows\assembly.

Front 69

What is virtual function?

Back 69

To provide a specialized implementation in a class, we can mark the member function name as virtual which can be overridden in the subclasses. We can declare methods, indexers, events, and properties as virtual in a class.It implements the concept of polymorphism. If a class that overrides the virtual method then it has to use the override keyword.

Front 70

What is private constructor? What is the use of it?

Back 70

Private constructor are the special kind of constructor, which are allowed to not set create instance of a class from outside of the class. They are basically created when a class only have static members.when you want to create a single instance of class than use private constructor, basically they are used for Singlton pattern also.

Front 71

What is Primary Interop Assembly (PIA)?

Back 71

This is an assembly that contains the type definitions that is metadata of types, which is implemented with COM. This can snatch up multiple versions of the same type library. These are needs to be signed with a strong name by the publisher of the COM type library. This library imported as an assembly when it has been signed.

Front 72

Are all methods virtual in C# ?

Back 72

No. Like C++, methods are non-virtual by default, but those methods can be marked as virtual methods.

Front 73

Are private class-level variables inherited?

Back 73

Yes, but they are not accessible. Although they are not visible or accessible via the class interface, they are inherited.

Front 74

By default which class is inherited by a class in C#?

Back 74

If no class is inherited, by default a class inherit System.Object.

Front 75

Can 'this' be used within a static method?

Back 75

No 'This' cannot be used in a static method. This is because, only static variables/methods can be used in a static method.

Front 76

Can multiple catch blocks be executed ?

Back 76

No, once the proper catch code fires off, the control is transferred to the finally block (if there are any), and then whatever follows the finally block.

Front 77

Can we call a base class method without creating instance ?

Back 77

Yes,It is possible,1) If it is a static method.2) By inheriting from that class.3) From derived classes using base keyword.

Front 78

Can we create a class private?

Back 78

No, we can not create a class private, it will give runtime error. Example:private classclassname{}compile time error. class can not be defined as private, protected and internal.

Front 79

Can we create constructor for static class?

Back 79

No, we can not create constructor for static class, as it its member are called by class name itself.

Front 80

can we create instance of an abstract class?

Back 80

No, we can not create instance of an abstract class.

Front 81

Can we declare a class as Protected?

Back 81

No, a class can not be declared as Protected. A class can be declared with only following access modifiers. Abstract Internal Public Sealed Static Extern

Front 82

Can we declare abstract keyword on fields in a class ?

Back 82

No we cannot.

Front 83

Can we declare an array variable with var keyword in C# 3.0?

Back 83

No, var keyword is used to declare implicitly typed local variable. An implicitly typed local variable is strongly typed just as if you had declared the type yourself, but the compiler determines the type. So you can declare a local variable of any type usingvarkeyword but you can't declare an array of variable using var keyword.

Front 84

Can we define generics for any class?

Back 84

No, generics is not supported for the classes which does not inherits collect class.

Front 85

Can we force Garbage Collector to run ?

Back 85

Yes we can,It is Possible to force Garbage Collector this can be done by calling a method called Collect().But this makes a performance barrier since this is not a good programming practice.Generally we have no control over garbage collector when it runs. The main work of this GC is it checks if there are any objects which are not used by the application it calls a Destructor which frees the memory allocated to that unused objects.

Front 86

Can we inherit a private class into the public class?

Back 86

No, In C#, a derived class can't be more accessible than it's base class. It means that you can't inherit a private class into a public class. So always the base class should be more or equal accessible than a derived class.

Front 87

Can we Inherit the class defined with private constructor?

Back 87

No, we can not inherit the class defined with private constructor.public class A:B{}public class B{private B(){}}Here if we will compile this code error will come:Namespace.B.B() is inaccessible due to its protection level

Front 88

Can we overload static constructors?

Back 88

No, static constructors are parameter less constructors and so they cannot be overloaded. Static constructors are called before any other class members are called and called once only. Their main purpose is to initialize only the static members of a class.

Front 89

Difference between Abstract class and interface?

Back 89

1.Through the abstract class we cannot achieve the multiple inheritance in c-sharp. while by interface we can.2. We can declare the access modifier in abstract class but not in interface. Because by default everything in interface is public

Front 90

Difference between static variable and constant in c#?

Back 90

Static Variable:1.Variable set at run time 2.Can be assigned for reference types. 3.Initialized on constructors Constant: 1.Variable set at compile time itself. 2.Assigned for value types only 3.must be initialized at declaration time 4.only primitive data types.

Front 91

What is Microsoft Intermediate Language (MSIL)?

Back 91

A .NET programming language (C#, VB.NET, J# etc.) does not compile into executable code; instead it compiles into an intermediate code called Microsoft Intermediate Language (MSIL). As a programmer one need not worry about the syntax of MSIL - since our source code in automatically converted to MSIL. The MSIL code is then send to the CLR (Common Language Runtime) that converts the code to machine language, which is, then run on the host machine. MSIL is similar to Java Byte code.MSIL is the CPU-independent instruction set into which .NET Framework programs are compiled. It contains instructions for loading, storing, initializing, and calling methods on objects.Combined with metadata and the common type system, MSIL allows for true cross- language integration Prior to execution, MSIL is converted to machine code. It is not interpreted.

Front 92

What is IDisposable interface in .NET?

Back 92

IDisposable interface is used to release the unmanaged resources in a program.The garbage collector has no knowledge of unmanaged resourcessuch as window handles, or open files and streams.To release these type of resources we make use of the Dispose method by implementing the IDisposable interface.IDisposable interface, defines a single method named Dispose():public interface IDisposable{void Dispose();}

Front 93

What is HashTable?

Back 93

A Hashtable is a collection of key-value pairs. Entries in this are instance of DictionaryEntry type. It implements IDictionary, ISerilizable, IDeserializable callback interface.

Front 94

What is dynamic keyword ?

Back 94

Its newly introduced keyword of C#4.0. To indicate that all operations will be performed runtime.

Front 95

What is difference between throw and throw ex?

Back 95

When you use throw ex to throw exception, it will update stack trace but in throw it will not update stack trace

Front 96

What is difference between read only and const variable?

Back 96

A const field can only be initialized only at declaration time of that field but read only field can be initialized at the time of declaration or in constructor also. a const field will have only one constant value but read only field can have different value depending on the constructor. Read only is runtime constant and cons field is compile time constant.

Front 97

What is Delegates?

Back 97

A delegate in C# allows you to pass method of one class to objects of other class that can call these methods.ORA delegate is an object that holds the reference to a method.In C++ it is called function pointer.

Front 98

What is Co-Variance in C#4.0? Explain with example

Back 98

Converting from a broader type to a specific type is called co-variance.

Front 99

What is CLS-Compliant?

Back 99

CLSCompliant attribute on an assembly (or a program element) and have the compiler check if your code is CLS (Common Language System) compliant. This means it works properly when consumed by other .NET languages.

Front 100

What is BitArray?

Back 100

The BitArray collection is a composite of bit values. It stores 1 or 0 where 1 is true and 0 is false. This collection provides an efficient means of storing and retrieving bit values.

Front 101

I want to format these number: 123456 to look like this: 1,234.56. Which expression accomplish this? a)string.Format("0:C}", 12345); b)string.Format("0:N}", 12345); c)string.Format("0:P}", 12345); d)string.Format("0:#,###.##}", 12345);

Back 101

d

Front 102

Which of the following is not a method available to the string data type? a)ToUpper() b)Append() c)Replace() d)Trim()

Back 102

b

Front 103

#1: When to Use a struct vs Class

Back 103

structs are value types that can contain data and functionsstructs are value types and do not require heap allocation. structs directly store their data in the struct, classes store a reference to a dynamically allocated object. structs are useful for small data structures structs can affect performanceConstructors are invoked with the new operator, but that does not allocate memory on the heapA struct constructor simply returns the struct value itself (typically in a temporary location on the stack), and this value is then copied as necessaryWith classes, multiple variables may have a reference to the same objectIt is possible for operations on one variable to affect the object referenced by the other variable.With structs, the variables each have their own copy of the data, and it is not possible for operations on one to affect the other. structs do not support user-specified inheritance, and they implicitly inherit from type object

Front 104

everything in .NET is an object of a specific class that derives from the root class called

Back 104

System.Object

Front 105

CLS

Back 105

CLS Common Language Specification (CLS), which provides a series of basic rules that are required for language integration. The CLS determines the minimum requirements for being a .NET language. Compilers that conform to the CLS create objects that can interoperate with one another. The entire Framework Class Library (FCL) can be used by any language that conforms to the CLS.

Front 106

the .NET Framework consists of Four official languages

Back 106

the .NET Framework consists of Four official languages: C#, VB .NET, Managed C++, and JScript .NET

Front 107

the .NET Framework consists of:

Back 107

Four official languages: C#, VB .NET, Managed C++, and JScript .NET
The Common Language Runtime (CLR), an object-oriented platform for Windows and web development that all these languages share
A number of related class libraries, collectively known as the Framework Class Library (FCL).

Front 108

the layer on top of the CLR is a set of framework base classes, followed by an additional layer of data and XML classes, plus another layer of classes intended for web services, web forms, and Windows forms.

Back 108

Collectively, these classes are known as the Framework Class Library (FCL), one of the largest class libraries in history and one that provides an object-oriented API to all the functionality that the .NET platform encapsulates. With more than 5,000 classes, the FCL facilitates rapid development of desktop, client/server, and other web services and applications.

Front 109

In .NET, programs are not compiled into executable files; they are compiled into

Back 109

Microsoft Intermediate Language (MSIL) files, which the CLR then executes

files that C# produces are identical to the IL files that other .NET languages produce

Front 110

Just In Time (JIT)

Back 110

C# code is compiled into IL when you build your project. The IL is saved in a file on disk. When you run your program, the IL is compiled again, using the Just In Time (JIT) compiler (a process often called JIT'ing). The result is machine code, executed by the machine's processor.

Front 111

C# language was developed by

Back 111

Anders Hejlsberg and Scott Wiltamuth

Front 112

In C#, a class can inherit from _____________ parent/s

Back 112

In C#, a class can inherit from only a single parent, but a class can implement multiple interfaces.

When it implements an interface, a C# class in effect promises to provide the functionality the interface specifies.

Front 113

In C#, a struct is a

Back 113

In C#, a struct is a restricted, lightweight type that, when instantiated, makes fewer demands on the operating system and on memory than a conventional class does. A struct can't inherit from a class or be inherited from, but a struct can implement an interface.

Front 114

assembly def

Back 114

An assembly is a collection of files that appear to the programmer to be a single dynamic link library (DLL) or executable (EXE). In .NET, an assembly is the basic unit of reuse, versioning, security, and deployment. The CLR provides a number of classes for manipulating assemblies

Front 115

"Hello World" program in C#

Back 115

using System;

namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("Hello World");

// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
}

Front 116

Hold C# application

Back 116

using System;

namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("Hello World");

// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
}

Front 117

namespace.

Back 117

A namespace restricts a name's scope, Rather than writing the word System before Console, you could specify that you will be using
types from the System namespace by writing the statementmaking it meaningful only within the defined namespace.

Front 118

Rather than writing the word System before Console, you could specify that you will be using types from the System namespace by writing the statement

Back 118

using System;

Front 119

Is C# case sensitive

Back 119

Yes

Front 120

static void Main( )

the static keyword indicates

Back 120

The static keyword indicates that you can invoke Main( )without first creating an object of type Hello.

Front 121

intrinsic types

Back 121

intrinsic (built-in) types that the language offers and user-defined types that the programmer defines

Front 122

value types vs reference types

Back 122

The principal difference between value and reference types is the manner in which their values arestored in memory. A value type holds its actual value in memory allocated on the stack (or it is allocated as part of a larger reference type object). The address of a reference type variable sits onthe stack, but the actual object is stored on the heap.

Front 123

C# also supports C++ style pointer types, but

Back 123

these are rarely used, and only when working with unmanaged code. Unmanaged code is code created outside of the .NET platform, such as COM objects.

Front 124

Byte

Char
Boolean

Sbyte

Int16

Uint16

Uint32

Back 124

Byte - size 1 - Unsigned (values 0-255).
Char - size 1 - Unicode characters.
Boolean - size 1 - true or false.
Sbyte - size 1 - Signed (values -128 to 127).
Int16 - size 2 Int16 - Signed (short) (values -32,768 to 32,767).
Unit16 - size 2 - Uint16 Unsigned (short) (values 0 to 65,535).
Int32 - size 4 - Int32 Signed integer values between -2,147,483,647 and 2,147,483,647.
uint 4 Uint32 Unsigned integer values between 0 and 4,294,967,295.

Front 125

Single

Double

Decimal

Int64

Uint64

Back 125

Single - size 4 - Floating point number.

Double - size 8 - Double-precision floating point;

Decimal - size 8 - Fixed-precision up to 28 digits and the position of the decimal point. This is typically used in financial calculations. Requires the suffix "m" or "M."

Int64 - size 8 - Signed integers ranging from -9,223,372,036,854,775,808 to
9,223,372,036,854,775,807.

Uint64 - size 8 - Unsigned integers ranging from 0 to 0xffffffffffffffff.

Front 126

stack def

Back 126

stack is a data structure used to store items on a last-in first-out basis (like a stack of dishes at the buffet line in a restaurant). The stack refers to an area of memory supported by the processor, on which the local variables are stored.

In C#, value types (e.g., integers) are allocated on the stack—an area of memory is set aside for their value, and this area is referred to by the name of the variable.

Reference types (e.g., objects) are allocated on the heap. When an object is allocated on the heap its address is returned, and that address is assigned to a reference.

Front 127

garbage collector

Back 127

garbage collector destroys objects on the stack sometime after the stack frame they are declared within ends. Typically a stack frame is defined by a function. Thus, if you declare a local variable within a function the object will be marked for garbage collection after the function ends.

Objects on the heap are garbage collected sometime after the final reference to them is destroyed.

Front 128

Implicit conversions

Back 128

Implicit conversions happen automatically

short x = 5;
int y = x; // implicit conversion

The compiler will not perform an implicit conversion from int to short:
short x;
int y = 500;
x = y; // won't compile

Front 129

Explicit conversions happens

Back 129

Explicit conversions happen when you "cast" a value to a different type.

Front 130

substitution parameter

Back 130

System.Console.WriteLine("After assignment, myInt: {0}", myInt);

location of the substitution parameter {0} specifies where the value of the first output variable, myInt, will be displayed, in this case at the end of the string.

Front 131

An enumeration begins with the keyword enum, which is generally followed by an identifier, such as:
enum Temperatures

Back 131

The base type is the underlying type for the enumeration. If you leave out this optional value (and often you will) it defaults to integer, but you are free to use any of the integral types (e.g., ushort, long) except for char. For example, the following fragment declares an enumeration of unsigned integers (uint):
enum ServingSizes :uint
{
Small = 1,
Regular = 2,
Large = 3
}

Front 132

C# (like C and C++) offers two flavors of the increment and decrement operators: prefix and postfix

Back 132

firstV = secondV++; //postfix assign then incr

firstV = ++secondV; //prefix incr then assign

Front 133

C# provides a mechanism for declaring that a field holds a constant value, and will never, ever change

Back 133

const double kilometersPerMile = 1.609344;

The platform now takes advantage of the fact that this can never change, and allocates
storage for it only once, no matter how many instances are there.
This isn’t just a storage optimization, though. By making the field const, there’s no danger that someone might accidentally change it for some reason inside another function he’s building in the class—the C# compiler prevents you from assigning a value to a const field anywhere other than at the point of declaration.

Front 134

Inheritance in C#

Back 134

class FireChief : Firefighter
{
public void TellFirefighterToExtinguishFire (Firefighter colleague)
{
colleague.ExtinguishFire();
}
}

Front 135

The is Operator Versus the as Operator

Back 135

If your design pattern is to test the object to see if it is of the type you need and if so you will immediately cast it, the as operator is more efficient. At times, however, you might want to test the type of an operator but not cast it immediately. Perhaps you want to test it but not cast it at all; you simply want to add it to a list if it fulfills the right interface. In that case, the is operator will be a better choice.

Front 136

Interface Versus Abstract Class

Back 136

Interfaces are very similar to abstract classes

in C# you're stuck; you can't inherit from both the Storable abstract class and also the List class because C# does not allow multiple inheritance with classes.
However, C# does allow you to implement any number of interfaces and derive from one base class. Thus, by making Storable an interface, you can inherit from the List class and also from IStorable, as StorableList does in the following example:
public class StorableList : List, IStorable
{
// List methods here ...
public void Read( ) {...}
public void Write(object obj) {...}
// ...
}

Front 137

struct is a

Back 137

struct is a simple user-defined type, a lightweight alternative to classes. Structs are similar to classes in that they may contain structors, properties, methods, fields, operators, nested types and indexers

Front 138

Defining Structs

Back 138

public struct Location
{
public Location(int xCoordinate, int yCoordinate)

{
xVal = xCoordinate;
yVal = yCoordinate;
}
public int x
{
get
{
return xVal;
}
set
{
xVal = value;
}
}
public int y
{
get
{
return yVal;
}
set
{
yVal = value;
}
}
public override string ToString( )
{
return (String.Format("{0}, {1}", xVal,yVal));
}
private int xVal;
private int yVal;
}

Front 139

Structs and destructors

Back 139

Structs cannot have destructors, nor can they have a custom parameterless (default) constructor. If you supply no constructor at all, your struct will in effect be provided with a default constructor which will zero all the data members or set them to default values appropriate to their type

Front 140

in C#, the new keyword does not always create
objects on the heap.

Back 140

Classes are created on the heap, and structs are created on the stack. Also, when new is omitted a constructor is never called. Because C# requires definite assignment, you must
explicitly initialize all the member variables before using the struct.

Front 141

Creating Structs Without new

Back 141

Location loc1 = new Location(200,300);
the resulting Location object is created on the stack.

The new operator calls the Location constructor. However, unlike with a class, it is possible to create a struct without using new at all. This is consistent with how built-in type variables

Front 142

interface

Back 142

interface is a contract that guarantees to a client how a class or struct will behave. When a class
implements an interface, it tells any potential client "I guarantee I'll support the methods, properties, events, and indexers of the named interface

Front 143

interface keyword

Back 143

The interface keyword is followed by the name of the interface. It is common (but not required)
to begin the name of your interface with a capital I. Thus, IStorable, ICloneable, IClaudius,
etc.

Front 144

base-list

interface-body

Back 144

The base-list lists the interfaces that this interface extends

interface-body is the implementation of the interface

Front 145

Suppose you wish to create an interface that describes the methods and properties a class needs to be stored to and retrieved from a database or other storage such as a file. You decide to call this interface IStorable

Back 145

In this interface you might specify two methods: Read( ) and Write( ), which appear in the
interface-body:
interface IStorable
{
void Read( );
void Write(object);
}
The purpose of an interface is to define the capabilities that you want to have available in a class.

For example, you might create a class, Document. It turns out that Document types can be stored in a
database, so you decide to have Document implement the IStorable interface.
To do so, you use the same syntax as if the new Document class were inheriting from IStorable—
a colon (:), followed by the interface name:
public class Document : IStorable
{
public void Read( ) {...}
public void Write(object obj) {...}
// ...
}

Front 146

Implementing More Than One Interface

Back 146

interfaces. To do so, you change the declaration (in the base-list) to indicate that
both interfaces are implemented, separating the two interfaces with commas:
public class Document : IStorable, ICompressible

Front 147

C# extensions methods

Back 147

C# allows programmers to user static methods as if they were methods from a class's method table, allowing programmers to add methods to an object that they feel should exist on that object and its derivative

Front 148

C# & type dynamic

Back 148

type dynamic allows for run-time method binding, allowing for JS like methods calls and run-time object composition

Front 149

C# & global variables/functions

Back 149

C# languages does not allow for global variables or functions. All methods and members must be declared within classes.

Static members of public classes can substitute for global variables and functions

Front 150

Shadowing

Back 150

local variables cannot shadow variables of the enclosing block unlike c and c++

Front 151

C# support strongly typed implicit variable declaration with the keyword

Back 151

var for variable declaration

new[] for impliocitly typed arrays

Front 152

How to enable method for overriding by a subclass

Back 152

must use the KW virtual

Front 153

How to check if today is Monday?

Back 153

if (DateTime.Now.DayOfWeek == DayOfWeek.Monday) {

// do something

}

Front 154

Hold console and wait of user to press enter?

Back 154

Console.ReadLine();

Front 155

access modifies

public

protected

internal

Back 155

public - to class or member, no restriction

protected - to member, access limited to the class and derived classes

internal - to class or member, access limited to the current assembly

Front 156

access modifies

protected internal

private

Back 156

protected internal - to member, access limited to current assembly and derived types

private - to member, access limited to the class

Front 157

abstract keyword

Back 157

can apply to a class

can also apply to members

abstract class cannot be instantiated

Abstract class is designed as a base class

Front 158

concrete class

Back 158

Must implement abstract members to make a concrete class

Front 159

ildasm.exe

Back 159

Intermediate Language Disassembler utility
allows you to load up any .NET assembly and investigate its contents, including the associated manifest, CIL code, and type metedata

Front 160

short circuit evaluation (general)

Back 160

stop evaluating boolean expression as soon as we know the answer
consider: p = (5 > 3) || (4 <+ 2);
the test ($ <= 2) is not performed!

Example of useful case:
p = ( x!= 0) && ((y / x) == 0);

Front 161

CLR def + expl

Back 161

CLR - Common Language Runtime

used to locate, load and manage .NET objects
used for memory management, application hosting, coordinating threads and performing security checks

Front 162

CTS def + expl

Back 162

CTS - Common Type System
CTS specification fully describe all possible data types and all programming constructs supported by the runtime,
specifies how these entities can interact with each other and details how they are represented in the .NET metadata

Front 163

CLS

Back 163

CLS - Common Language Specification
defines a subset of common types and programming constructs that all .NET programming languages can agree on.
If you build .NET types that expose only CLS-compliant feature, you can rest assured that all .NET-aware languages can consume them

Front 164

Hello World VBA vs C++

Back 164

Public Module MyApp
Sub Main()
Console.WriteLine("Hello World!")
End Sub
End Module
------------------
#include "stdfax.h"
using namespace System;
int main(array ^args)
{ Console::WriteLine(L"Hello World");
return 0; }

Front 165

CTS Enumeration def

Back 165

programming constructs that allow you to group name/value par
enum CharacterType {
Wizard = 100,
Fighter = 200,
Thief = 300
}

Front 166

CTS Structure Tpes

Back 166

//A C# structure type
struct Poin {
//Structure can contain fields
public int xPos, yPox;
//Structure can contain parameterized constructor
public Point(int x, int y)
{ xPos=x; yPos=y; }
//Structure may define methods
public void PrintPosition() {
Console.WriteLine("({0},{1})", xPos, yPos);
}
}

Front 167

CTS class Characteristics
Is the class sealed or not?
Does the class implement any interfaces?
Is the class abstract or concrete?
What is the visibility of this class?

Back 167

Is the class sealed or not? - Sealed classes cannot function as base class to other class

Does the class implement any interfaces? - An interface is a collection of abstract members that provide a contract between the object and user. The CTS allows a class to implement any number of interfaces

Is the class abstract or concrete? - Abstract classes cannot be directly instantiated, but are intended to define common behaviors for derived type. Concrete classes can be instantiated directly

What is the visibility of this class? - Each class must be configured with a visibility keyword. Controls if the class may be used by external assemblies or only from within the defining assembly.