C#

C# is a type-safe, managed and object oriented language, which is compiled by .Net framework for generating intermediate language (IL).

• Easy to learn
  
• Object oriented
  
• Component oriented
  
• Part of .NET framework
  

1. Single Line Comment Eg : //
   
2. Multiline Comments Eg: /* */
   
3. XML Comments Eg : ///
   

sealed is used to either:

1. prevent the class from being inherited from other classes.
2. prevent the methods being overridden in child classes.

class x {}

sealed class y:x {}

class ClassA {

protected virtual void First() {}

}

class ClassB : ClassA {

sealed protected override void First() {}

}

class ClassC : ClassB {

protected override void First() {} //error

}

1. Arrays store values or elements of same data type whereas arraylists store values of different datatypes.
   
2. Arrays use fixed lengths but arraylists don't.
   

1. As a directive to create an alias for a namespace or to import types defined in other namespaces.
   
2. As a statement to define a scope that will dispose of an object when it ends.
   

Namespaces are containers for grouping related user-defined types.

To create a constant assigned at compile-time that cannot be reassigned.

const is assigned at compile-time.

readonly is assigned at run-time declaration or in a constructor.

1. classes
   
2. fields
   
3. methods
   
4. properties
   
5. operators
   
6. events
   
7. constructors
   

1. indexers
   
2. finalizers
   
3. types other than classes (eg struct, interface)
   

consts; they behave just like static members.

Not without first creating an instance of the class.

dispose is called explicitly by client code to clean up resources immediately.

finalize is called implicitly by the garbage collector and cannot be called explicitly by client code.

No, C# executes the first exception block that handles an exception in the InnerException stack.

Catch the most general exception and then loop through the InnerExceptions and handle appropriately.

To ensure a block of code is executed regardless of the way the try block is exited.

Especially to clean up resources.

normal flow of code execution

break

continue

goto

return

propagation of exception

throw preserves the exception stack

"throw {e}" resets the exception stack and only passes the information from the point of "throw {e}"

Compile time error

Run time error

Yes.

Let it propagate or manage with "try...catch".

mscorlib.dll

1. To modify a method parameter

2. To modify a generic type parameter as covariant (this has certain usage constraints)

An out parameter may be modified by the method it is passed to but does not need to be initialised when passed to said method.

A ref parameter may be modified by the method it is passed to but is initialised before it is passed to said method.

1. In a method signature and call to pass an argument by reference.
   
2. In a method signature to return a value by reference.
   
3. In a member body to indicate that return value from 2. is stored locally and the caller intends to modify it.
   

An array of arrays of different sizes and dimensions.

No.

1. Structs

a. Numeric types

b. char

c. bool

d. User defined

2. Enumerations

• Used to declare reference types:
  

1. array
2. class
   
3. delegate
4. interface

• Inbuilt reference types:
  

1. dynamic
   
2. object
   
3. string
   

On the stack.

The reference is stored on the stack and points to the data on the heap.

A reference type that encapsulates a type-safe and secure named or anonymous method.

Delegate types are the basis for Events.

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/delegate

object is a reference type that is a C# alias for System.Object in the .NET framework.

A reference type that is identical to the object type but operations that contain dynamic types are not resolved or type checked at compile-time.

string is an object of type System.String whose value is text that is stored as a sequential read-only collection of Char objects.

It can also be defined as a reference type that is an alias for System.String in the .NET framework.

String is the .NET CLR type that is declared in System namespace. Use this type when declaring a public API that will be available to anyone using any language.

A string that doesn't need any escaping except double quotation marks when quotation marks need to be included.

Prefix the string with "@" to declare verbatim string:

@"c:\program files\"

notice the backslashes do not need to be escaped.

e.g.

Hello

World!

would be represented as:

"\tHello\r\n\tWorld!\r\n"

System.Byte

System.SByte

System.Int16

System.UInt16

System.Int32

System.UInt32

System.Int64

System.UInt64

System.Single

System.Double

System.Decimal

System.Char

float is a simple type that stores 32-bit floating point values with range of -3.4 × 1038 to +3.4 × 1038 with a precision of 7 digits

double is a simple type that stores a 64-bit floating point values with a range of ±5.0 × 10−324 to ±1.7 × 10308 with a precision of 15-16 digits

decimal is 128-bit data type with more precision but smaller range (-7.9 x 1028 to 7.9 x 1028) / (100 to 1028) with a precision of 28-29 significant digits

x is a double

A compile-time error.

By default, if the literal is a real, or by adding a "D" or "d" if the literal is an integer:

e.g.

double x = 3.5D;

or

double x = 3D;

By adding a suffix of "F" or "f":

e.g.

float x = 3.5F;

or

float x = 3F;

By adding a suffix of "M" or "m":

e.g.

decimal x = 3.5M;

or

decimal x = 3M;

decimal because it has more precision and smaller range then double and float.

Positive and negative zero.

Positive and negative infinity.

NaN.

The finite set of nonzero values.

Or null if it's a nullable variable.

A decimal can only contain the finite set of nonzero values or null if it's a nullable variable.

sbyte

byte

char

short

ushort

int

uint

long

ulong

signed 8-bit integer

-128 to 127

Die kNaVe

unsigned 8-bit integer

0 to 255

NuLL

unicode 16-bit character

U+0000 to U+ffff

signed 16-bit integer

-32,768 to 32,767

MooN, CaSH-oaF

unsigned 16-bit integer

0 to 65,535

JeweL, Low-MoLe

signed 32-bit integer

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

SuN, DRaG, eaRFoaM, JaR-oaF

unsigned 32-bit integer

0 to 4,294,967,295

SeaR, NeighBouR, PayCHeCK, NeBuLa

signed 64-bit integer

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

ZiP, NuN Mow, MohiCaN, SMaSH, FLoweR, CaKehoLe, oaf-SoFa

unsigned 64-bit integer

0 to18,446,744,073,709,551,615

DoVe, eaR-RaSH, CouRieR, SCuM, GaSP, LiLT, aSH-hoTeL

An enumeration; a distinct type that consists of a set of named constants called "the enumerator list".

Yes.

int

Any integral type except char.

enum Days: byte {Sat, Sun, Mon, Tue, Wed, Thu, Fri}

0

enum Days: byte {Sat = 1, Sun, Mon, Tue, Wed, Thu, Fri}

enum Options {black = 1, red = 7, green = 13}

Yes

Indicates that an enumeration can be treated as a bit field (a set of flags):

[Flags] enum CarOptions { SunRoof = 0x01, Spoiler = 0x02, FogLights = 0x04, TintedWindows = 0x08 }

var options = CarOptions.SunRoof | CarOptions.FogLights

(CarOptions could be declared with 1, 2, 4 & 8 as the values, they don't have to be hex)

SunRoof, FogLights

5

The modified type or member can be accessed by any other code in the same assembly or assembly that references the containing assembly.

The modified type or member can be accessed only by code in the same class or struct.

The modified type or member can be accessed only by code in the same class or in a class that is derived from that original class.

Because a struct is sealed and therefore cannot be inherited from.

The modified type or member cannot be accessed from another assembly but can be accessed from any code in the same assembly.

The modified type or member can be accessed by any code in the assembly in which it is declared or from within a derived class in another assembly.

Internal.

Private.

By identifying another assembly as a "friend assembly" using the "InternalsVisibleToAttribute":

[assembly: InternalsVisibleTo("AssemblyB")]

A public member of an internal class might be accessible outside the assembly if the member is part of the class's implementation of publicly accessible interface methods or overridden virtual methods defined in a public base class.

At least as accessible as the member itself.

Public.

No.

None, they are public by default and design.

Public by default and design; no access modifier can be applied to an enumeration member.

InnerException is a property of the Exception class and gives detail about the exception including child exception detail.

Yes.

No, the referred member within the called type is not modified with the ref keyword.

StringBuilder is used to operate on a mutable string of characters because a string is immutable and therefore expensive when its value needs to be manipuated.

Default capacity = 16 chars

Default MaxCapacity = Int32.MaxValue (2,147,483,647)

When it is known that the final string will be larger than a doubling sequence value (ie: larger than 16, 32, 64, 128 etc).

It is faster to initialise to a known capacity because otherwise a new buffer is created when a doubling value is reached and the old buffer is copied in.

When the app will be running on a device with limited memory capacity.

No.

Yes.

The number of Char objects it contains.

It does not, necessarily, represent the number of Unicode characters the string contains because one character may be represented by multiple Char objects.

Two examples of a Char not representing a Unicode character are when a character is encoded as a base character and

1. is part of a surrogate pair
2. is part of a combining character sequence

By using the StringInfo object.

1. By assigning a string literal to a string variable.
   
2. By calling a string class constructor.
3. By using the string concatenation operator on any combination of string instances or literals.
4. Retrieving a property or calling a method that returns a string.
5. By calling a formatting method to convert a value or object to its string representation.

Casting a variable to an object.

Casting an object to a value type.

When a character is represented in UTF-32 by a 21-bit value that includes a plane.

A surrogate pair is handled by converting it to a string using Char.ConvertFromUtf32(int utf32)

System.Globilisation.UnicodeCategory Char.GetUnicodeCategory(char c);

string.Normalize();

Instantiate a new StringInfo instance and call StringInfo.LengthInTextElements:

StringInfo si = new StringInfo(stringVar);

Console.WriteLine(si.LengthInTextElements);

Equals returns boolean indicating whehter the passed obj is an instance of Char and equals the value of this instance.

CompareTo indicates whether this instance precedes, follows or is in the same position in the sort order as the specified Char by returning an int.

This is an eXclusive OR.

The result of a logical ^ (XOR) is true if, and only if, exactly one of its operands is true.

The result of a bitwise ^ (XOR) compares each bit and outputs 1 whenever the inputs do not match and 0 when they do.

The result of a logical | (OR) is false if, and only if, both operands are false.

The result of a bitwise | (OR) compares each bit and outputs 0 if both inputs are false otherwise the output is 1.

If the first operand of a || (logical-conditional-OR) evaluates to true, the second operand isn't evaluated. If the first operand evaluates to false the second operand determines the result.

The result of a logical & (AND) is true if, and only if, both operands are true.

The result of a bitwise & (AND) compares each bit and outputs 1 if both inputs are 1, otherwise the output is 0.

If the first operand evaluates to false, the second operand isn't evaluated. If the first operand evaluates to true the second operand determines the result.

The Main method.

void

An int

By declaring a finalizer with the name of the class prefix by a tilde:

~ClassAName() {

//clean up code

}

By declaring an expression body definition:

~ClassAName() => Console.WriteLine($"destroying");

When the class instantiates unmanaged resources such as windows, files or network connections.

Dispose() from IDisposable because it gives the client code the means to dispose of the resource immediately without relying on the garbage collector to call the finalizer.

A finalizer should still be implemented to ensure the resource is released when the client doesn't explicitly call Dispose().

1. Methods
   
2. Operators
3. Constructors
4. Properties
5. Events
6. Indexers
7. Finalizers

csc.exe

call from the command line:

csc MyProgramFile.cs

or

csc /target:library MyProgramFile.cs

An optional array of strings.

An underscore or a letter.

1. parameters
2. local variables
3. private fields

Pascal case.

By qualifying it with the @ prefix:

class @class {...}

Contextual keywords because ambiguity can not arise.

Predefined value types:

• all integral types
• all floating point types
• bool

Predefined reference types:

• object
• string

Built-in types.