Csharp_midterm

Conditional Operators

&& || !

C# Parameter Modifiers

*(None) If a parameter is not marked with a parameter modifier, it is assumed to be passed by value, meaning the called method receives a copy of the original data. *out Output parameters must be assigned by the method being called and, therefore, are passed by reference. If the called method fails to assign output parameters, you are issued a compiler error. *ref The value is initially assigned by the caller and may be optionally modified by the called method (as the data is also passed by reference). No compiler error is generated if the called method fails to assign a ref parameter. *params This parameter modifier allows you to send in a variable number of arguments as a single logical parameter. A method can have only a single params modifier, and it must be the final parameter of the method. In reality, you might not need to use the params modifier all too often; however, be aware that numerous methods within the base class libraries do make use of this C# language feature.

C# Access Modifiers

+++public++++ Types or type members Public items have no access restrictions. A public member can be accessed from an object, as well as any derived class. A public type can be accessed from other external assemblies. ++++private++++ Type members or nested types Private items can be accessed only by the class (or structure) that defines the item. ++++protected++++ Type members or nested types Protected items can be used by the class that defines it and any child class. However, protected items cannot be accessed from the outside world using the C# dot operator. ++++ internal++++ Types or type members Internal items are accessible only within the current assembly. Therefore, if you define a set of internal types within a .NET class library, other assemblies are not able to use them. ++++protected internal ++++ Type members or nested types When the protected and internal keywords are combined on an item, the item is accessible within the defining assembly, within the defining class, and by derived classes.

The 'abstract' keyword in C# can be used on which of the following?

A class A virtual method on a abstract class An automatic property

Useful Types of System.Collections

ArrayList BitArray Hashtable Queue SortedList Stack

.NET Numerical Format Characters

C or c Used to format currency. By default, the flag will prefix the local cultural symbol (a dollar sign [$] for U.S. English). D or d Used to format decimal numbers. This flag may also specify the minimum number of digits used to pad the value. E or e Used for exponential notation. Casing controls whether the exponential constant is uppercase (E) or lowercase (e). F or f Used for fixed-point formatting. This flag may also specify the minimum number of digits used to pad the value. G or g Stands for general. This character can be used to format a number to fixed or exponential format. N or n Used for basic numerical formatting (with commas). X or x Used for hexadecimal formatting. If you use an uppercase X, your hex format will also contain uppercase characters.

Building Blocks of the .NET Platform

CLR, CTS, and CLS

Members of System.Array

Clear() This static method sets a range of elements in the array to empty values (0 for numbers, null for object references, false for Booleans). CopyTo() This method is used to copy elements from the source array into the destination array. Length This property returns the number of items within the array. Rank This property returns the number of dimensions of the current array. Reverse() This static method reverses the contents of a one-dimensional array. Sort() This static method sorts a one-dimensional array of intrinsic types. If the elements in the array implement the IComparer interface, you can also sort your custom types

.NET equivalent of a type-safe, C-style function pointer.

Delegates

Members of the Queue<T> Type

Dequeue() Removes and returns the object at the beginning of the Queue<T> Enqueue() Adds an object to the end of the Queue<T> Peek() Returns the object at the beginning of the Queue<T> without removing it

Classes of System.Collections.Generic

Dictionary<TKey, TValue> LinkedList<T> List<T> Queue<T> SortedDictionary<TKey,TValue> SortedSet<T> Stack<T>

Another handy generic collection is the XXX<TKey,TValue> type, which allows you to hold any number of objects that may be referred to via a unique key.

Dictionary<TKey, TValue> Class

It is good practice to throw an exception on both out of memory errors AND invalid user input.

False

The MemberwiseClone method is defined on the ICloneable interface.

False

named collection of abstract member definitions, which may be supported (i.e., implemented) by a given class or structure.

Interfaces

Key Benefits of the .NET Platform

Interoperability with existing code Support for numerous programming languages A common runtime engine shared by all .NET-aware languages Language integration A comprehensive base class library: A simplified deployment model:

Members of System.String

Length This property returns the length of the current string. Compare() This static method compares two strings. Contains() This method determines whether a string contains a specific substring. Equals() This method tests whether two string objects contain identical character data. Format() This static method formats a string using other primitives (e.g., numerical data, other strings) and the {0} notation examined earlier in this chapter. Insert() This method inserts a string within a given string. PadLeft() These methods are used to pad a string with some characters. PadRight() Remove() These methods are used to receive a copy of a string with modifications (characters removed or replaced). Replace() Split() This method returns a String array containing the substrings in this instance that are delimited by elements of a specified char array or string array. Trim() This method removes all occurrences of a set of specified characters from the beginning and end of the current string. ToUpper() These methods create a copy of the current string in uppercase or lowercase format, respectively. ToLower()

When you create an instance of a generic class or structure, you specify the type parameter when you declare the variable and when you invoke the constructor

List<Person> morePeople = new List<Person>();

Given the code snippet below, what is NOT a valid call to the Log method? enum LogLevel {Info, Warning, Error} static void Log{string message, LogLevel level=LogLevel.Info, string owner ="System") {Console.WriteLine("{0} {1}: {2}", owner, level, message); }

Log(message: "Terminating", level: LogLevel.Error, "Programmer");

Which of the following are NOT core features found in all versions of the C# language?

Named method arguments Optional method parameters Generics String interpolation

core C# features that are found in all versions of the language:

No pointers required! Automatic memory management through garbage collection. Formal syntactic constructs for classes, interfaces, structures, enumerations, and delegates. The C++-like ability to overload operators for a custom type, without the complexity Support for attribute-based programming. The ability to build generic types and generic members. Support for anonymous methods, which allow you to supply an inline function anywhere a delegate type is required The ability to define a single type across multiple code files (or if necessary, as an in- memory representation) using the partial keyword Support for strongly typed queries (e.g., LINQ) used to interact with various forms of data Support for anonymous types that allow you to model the structure of a type (rather than its behavior) on the fly in code. The ability to extend the functionality of an existing type (without subclassing) using extension methods. Inclusion of a lambda operator (=>), which even further simplifies working with .NET delegate types. A new object initialization syntax, which allows you to set property values at the time of object creation. Support for optional method parameters, as well as named method arguments. Support for dynamic lookup of members at runtime via the dynamic keyword. Working with generic types is much more intuitive, given that you can easily map generic data to and from general System.Object collections via covariance and contravariance.

What are the possible ways to use the 'sealed' keyword in C#?

On a class On a virtual method On a property

True

One of the key advantages of the .NET runtime over other runtimes (like Java's JVM) is that the .NET runtime provides a single, well-defined runtime layer that is shared by all .NET-aware languages (e.g., Visual Basic, C#, F#, etc.).

What can be written generically;

Only classes, structures, interfaces, and delegates. enum types cannot.

Having the GiveBonus virtual method respond differently depending on the class is a great example of which of the following?

Polymorphism

The three pillars of object-oriented programming are:

Polymorphism Inheritance Encapsulation

XXXX are containers that ensure items are accessed in a first-in, first-out manner.

Queue<T> Class

The XXX<T> class is useful because it automatically ensures that the items in the set are sorted when you insert or remove items. However, you do need to inform the XXX<T> class exactly how you want it to sort the objects, by passing in as a constructor argument an object that implements the generic IComparer<T> interface.

SortedSet<T> Class

The XXXX<T> class represents a collection that maintains items using a last-in, first-out manner.

Stack<T>. Stack<T> defines members named Push() and Pop() to place items onto or remove items from the stack.

.NET namespace that contains nongeneric collection classes.

System.Collections System.Collections.Specialized

check for 'system.console.Writeline();' in the body of function

The following code will generate a compile time error because it is missing a 'using System;' line at the top.

$36.00, 00047, 58.00, 69.00

The following line of code produces which output? Console.WriteLine("{1:c}, {2:d5}, {3:n}, {4:f2}", 25, 36, 47, 58, 69);

Static constructors allow one to initialize static data members once at run time rather than at compile time.

True

Strings Are Immutable. One of the interesting aspects of System.String is that after you assign a string object with its initial value, the character data cannot be changed.

True

Structure types are well suited for modeling mathematical, geometrical, and other "atomic" entities in your application. A structure (such as an enumeration) is a user-defined type; however, structures are not simply a collection of name-value pairs. Rather, structures are types that can contain any number of data fields and members that operate on these fields.

True

The 'base' keyword can be used to invoke both base class constructors as well as base class methods.

True

The advantage of using data encapsulation comes when the implementation of the class changes but the interface remains the same.

True

The first pillar of OOP is called encapsulation. This trait boils down to the language's ability to hide unnecessary implementation details from the object user.

True

The following code catch block will compile successfully: catch(ApplicationException ae) {Console.WriteLine("Application error{0}, ae); catch(SystemException se) { Console.WriteLine("System error {0}", se); }

True

When using the 'override' keyword on a virtual method, you must use the same parameter passing mechanism (i.e., ref, out, params) as well as the same type for every method parameter.

True

abstract method is a member in a base class that does not provide a default implementation but does provide a signature.

True

array is a set of data items, accessed using a numerical index.

True

implicit typing applies only to local variables in a method or property scope. It is illegal to use the var keyword to define return values, parameters, or field data of a custom type

True

inheritance, boils down to the language's ability to allow you to build new class definitions based on existing class definitions. In essence, inheritance allows you to extend the behavior of a base (or parent) class by inheriting core functionality into the derived subclass (also called a child class).

True

local variables declared with the var keyword must be assigned an initial value at the exact time of declaration and cannot be assigned the initial value of null.

True

polymorphism. This trait captures a language's ability to treat related objects in a similar manner. Specifically, this tenant of an object-oriented language allows a base class to define a set of members (formally termed the polymorphic interface) that are available to all descendants. A class's polymorphic interface is constructed using any number of virtual or abstract members

True

utility class is a class that does not maintain any object-level state and is not created with the new keyword. Rather, a utility class exposes all functionality as class-level (aka static) members.

True

What output does the following program produce? string s1="Hello"; string s2="Hello"; char[] a1={'a','b','c'}; char[] a2={'a','b','c'}; Console.Writeline("{0},{1}", s1==s2, a1==a2);

True, False

The 'yield return' syntax can be used to provide multiple "named iterator" methods.

Ture

1)No direct pointer manipulation required (although possible) 2)Automatic memory management 3)Overload operators on a custom type

Which of the following are core features found in all versions of the C# language?

1)Assembly manifest 2)Type metadata 3)CIL

Which of the following are found in a .NET assembly?

1)static int Main(string[] args); 2)static int Main(); 3)static void Main();

Which of the following is a valid Main signature for an entry point of a C# console application?

static int Main(int args);

Which of the following is not a valid Main signature for an entry point of a C# console application?

Which of the following are good reasons to define an Interface rather than an Abstract class?

You want to specify the behavior of a particular data type, but you are not concerned about who implements its behavior You expect that unrelated classes would implement a common protocol You want to take advantage of multiple inheritance

String Literal Escape Characters

\' Inserts a single quote into a string literal. \" Inserts a double quote into a string literal. \\ Inserts a backslash into a string literal. This can be quite helpful when defining file or network paths. \a Triggers a system alert (beep). For console programs, this can be an audio clue to the user. \n Inserts a new line (on Windows platforms). \r Inserts a carriage return. \t Inserts a horizontal tab into the string literal.

The following code produces which output? string s1="abc"; int[] a1={1,2,3}; s1.ToUpper(); System.Array.Reverse(a1); Console.WriteLine("{0}, |{1},{2},{3}|", s1, a1[0], a1[1], a1[2]);

abc, [3, 2, 1]

The Intrinsic Data Types of C#

bool Yes System.Boolean true or false sbyte No System.S Byte -128 to 127 Signed 8-bit number byte Yes System.Byte 0 to 255 Unsigned 8-bit number short Yes System.Int16 -32,768 to 32,767 Signed 16-bit number ushort No System.UInt16 0 to 65,535 Unsigned 16-bit number int Yes System.Int32 -2,147,483,648 to 2,147,483,647 Signed 32-bit number uint No System.UInt32 0 to 4,294,967,295 Unsigned 32-bit number long Yes System.Int64 -9,223,372,036,854,775, 808 to 9,223,372,036,854,775,807 Signed 64-bit to number ulong No System.UInt64 0 to 18,446,744,073,709,551,615 Unsigned 64-bit number char Yes System.Char U+0000 to U+ffff Single 16-bit Unicode character float Yes System.Single -3.4 10 38 to +3.4 10 38 32-bit floating-point number double Yes System.Double ±5.0 10 -324 to ±1.7 10 308 64-bit floating-point number decimal Yes System.Decimal (-7.9 x 10 28 to 7.9 x 10 28 )/(10 0 to 28 ) 128-bit signed number string Yes System.String Limited by system memory Represents a set of Unicode characters Object Yes System.Object Can store any data type in an object variable The base class of all typ

mechanism to store the data in a value type within a reference variable.

boxing

allows you to specify placeholders (type parameters) that you specify at the time of object creation (or invocation, in the case of generic methods).

generic item

Which lines of code does produce a compile time error?

int myInt = null; bool myBool = null; double myDouble = null;

reference type

is an object allocated on the garbage-collected managed heap.

The relevant C# keywords that support polymorphism are:

override virtual abstract

The relevant C# keywords that support data encapsulation are:

private protected

Which lines of code do NOT produce a compile time error?

string myString = null; int[] myInt = null;

the process of converting the value held in the object reference back into a corresponding value type on the stack.

unboxing

Ccode that cannot be directly hosted by the .NET runtime is termed

unmanaged code.

the .NET platform allows you to use the XXX keyword to get extremely specific about what a given type parameter must look like. Using this keyword, you can add a set of constraints to a given type parameter, which the C# compiler will check at compile time.

where

The type parameter <T> must be derived from the class specified by NameOfBaseClass.

where T : NameOfBaseClass

The type parameter <T> must implement the interface specified by NameOfInterface. You can separate multiple interfaces as a commadelimited list.

where T : NameOfInterface

The type parameter <T> must not have System.ValueType in its chain of inheritance (i.e., <T> must be a reference type).

where T : class

The type parameter <T> must have a default constructor. This is helpful if your generic type must create an instance of the type parameter because you cannot assume you know the format of custom constructors. Note that this constraint must be listed last on a multiconstrained type.

where T : new()

The type parameter <T> must have System.ValueType in its chain of inheritance (i.e., <T> must be a structure).

where T : struct

C# defines two simple constructs to alter the flow of your program, based on various contingencies.

• The if/else statement • The switch statement

the flow of constructor logic is as follows:

• You create your object by invoking the constructor requiring a single int. • This constructor forwards the supplied data to the master constructor and provides any additional startup arguments not specified by the caller. • The master constructor assigns the incoming data to the object's field data. • Control is returned to the constructor originally called and executes any remaining code statements.

the variable default value

• bool variables are set to false. • Numeric data is set to 0 (or 0.0 in the case of floating-point data types). • char variables are set to a single empty character. • BigInteger variables are set to 0. • DateTime variables are set to 1/1/0001 12:00:00 AM. • Object references (including strings) are set to null.

C# provides the following four iteration constructs:

• for loop • foreach/in loop • while loop • do/while loop

handy programming construct that allow you to group name-value pairs

Enumerations

A class can be both sealed and abstract.

False

short list of the benefits generic containers provide over their nongeneric counterparts:

Generics provide better performance because they do not result in boxing or unboxing penalties when storing value types. Generics are type safe because they can contain only the type of type you specify. Generics greatly reduce the need to build custom collection types because you specify the "type of type" when creating the generic container.

Useful Classes of System.Collections.Specialized

HybridDictionary ListDictionary StringCollection BitVector32

Key Interfaces Supported by Classes of System.Collections.Generic

ICollection<T> IComparer<T> IDictionary<TKey, TValue> IEnumerable<T> IEnumerator<T> IList<T> ISet<T>

One of the main differences between abstract classes and interfaces is that abstract classes can include implementations whereas Interfaces cannot.

True

Another use of the this keyword is to design a class using a technique termed constructor chaining.

True

Automatic properties reduce the amount of typing by eliminating the need to define a private backing field.

True

C# class may define any number of static members, which are declared using the static keyword. When you do so, the member in question must be invoked directly from the class level, rather than from an object reference variable.

True

C# language does provide for implicitly typing of local variables using the var keyword. The var keyword can be used in place of specifying a specific data type (such as int, bool, or string).

True

C# supplies a this keyword that provides access to the current class instance. One possible use of the this keyword is to resolve scope ambiguity, which can arise when an incoming parameter is named identically to a data field of the class.

True

Encapsulation provides a way to preserve the integrity of an object's state data. Rather than defining public fields (which can easily foster data corruption), you should get in the habit of defining private data, which is indirectly manipulated using one of two main techniques. • You can define a pair of public accessor (get) and mutator (set) methods. • You can define a public .NET property.

True

Every C# class is provided with a "freebie" default constructor that you can redefine if need be.

True

Like other modern object-oriented languages, C# allows a method to be overloaded. Simply put, when you define a set of identically named methods that differ by the number (or type) of parameters, the method in question is said to be overloaded.

True