Lecture 10: Generics & Basic Desktop Programming

Svetla BoytchevaAUBG, Spring 2014

1

COS 240 Object-Oriented Languages

Course Materials – Source Codes http://www.wrox.com/WileyCDA/WroxTitle/productCd-1118314417.html

2

Reminder Next Class – Midterm Exam

3

Midterm Exam Structure Practical task - 20 % (computer)

• 1 task• Basic desktop programming• Chapters 15, 16

Test– 80% (written on paper, computer usage is not allowed) • 10 tasks• Chapters 8-12 (approx. 2 tasks per chapter)

4

More reading:

Karli Watson et all, Beginning Visual C# 2012 Programming, Wrox, Jonh Wiley & Sons, 2013• CHAPTER 12: Generics.• CHAPTER 15: Basic Desktop Programming

5

WHAT YOU WILL LEARN What generics are How to use some of the generic classes provided by

the .NET Framework How to define your own generics How variance works with generics Basic Desktop Programming

6

GENERICS Generics enable you to create flexible types that

process objects of one or more specific types. These types are determined when you instantiate or

otherwise use the generic.

7

Nullable Types One of the ways in which value types (which

include most of the basic types such as int and double as well as all structs) differ from reference types (string and any class) is that they must contain a value.

They can exist in an unassigned state, just after they are declared and before a value is assigned, but you can’t make use of the value type in that state in any way. Conversely, reference types can be null.

8

9

Nullable Types Note that nullable types are so useful that they have

resulted in a modification of C# syntax. Rather than use the syntax shown previously to

declare a nullable type variable, you can instead use the following:

int? nullableInt; int? is simply a shorthand for System.Nullable<int>

but is much more readable.

10

Operators and Nullable Types

11

Resolving Bool? Comparisons with null Value

12

The ?? Operator (null coalescing operator) It is a binary operator that enables you to supply an alternative

value to use for expressions that might evaluate to null. The operator evaluates to its first operand if the first operand is

not null, or to its second operator if the first operand is null. Functionally, the following two expressions are equivalent:

op1 ?? op2op1 == null ? op2 : op1

In this code, op1 can be any nullable expression, including a reference type and, importantly, a nullable type.

Example:int? op1 = null;int result = op1 * 2 ?? 5;

13

The System.Collections.Generic Namespace

14

List<T>

15

List<T> Creating a collection of type T objects

requires the following code:List<T> myCollection = new List<T>();

List<T> also has an Item property, enabling array-like access:T itemAtIndex2 = myCollectionOfT[2];

16

Sorting and Searching Generic Lists

17

Functions - Delegates A delegate is a type that enables you to store references to functions. Although this sounds quite involved, the mechanism is surprisingly simple. The most important purpose of delegates is their usage in events and event handling Delegates are declared much like functions, but with no function body and using the

delegate keyword. The delegate declaration specifies a return type and parameter list. After defining a delegate, you can declare a variable with the type of that delegate. You can then initialize the variable as a reference to any function that has the same

return type and parameter list as that delegate. Once you have done this, you can call that function by using the delegate variable as if it were a function.

When you have a variable that refers to a function, you can also perform other operations that would be otherwise impossible. For example, you can pass a delegate variable to a function as a parameter, and then that function can use the delegate to call whatever function it refers to, without knowing which function will be called until runtime.

18

19

Example

20

21

Dictionary<K, V>

22

Dictionary<K, V>

23

DEFINING GENERIC TYPES You can define the following:

• Generic classes• Generic interfaces• Generic methods• Generic delegates

You’ll also look at the following more advanced techniques for dealing with the issues that come up when defining generic types:• The default keyword• Constraining types• Inheriting from generic classes

24

Defining Generic Classes

25

26

T1 is ADT (class)T1 is basic data type

The default Keyword

27

Constraining Types The types you have used with generic classes until

now are known as unbounded types because no restrictions are placed on what they can be.

By constraining types, it is possible to restrict the types that can be used to instantiate a generic class.

For example, it’s possible to restrict a type to one that inherits from a certain type.

28

29

30

31

Example

32

Inheriting from Generic Classes

33

Generic Operators

34

Generic Structs

35

36

Defining Generic Interfaces

37

Defining Generic Methods A generic method is one in which the return and/or parameter types

are determined by a generic type parameter or parameters:public T GetDefault<T>(){ return default(T);}

This trivial example uses the default keyword you looked at earlier in the chapter to return a default value for a type T. This method is called as follows:

int myDefaultInt = GetDefault<int>(); The type parameter T is provided at the time the method is called.

38

Defining Generic Delegates

39

VARIANCE Variance is the collective term for covariance and

contravariance, two concepts that were introduced in .NET 4. In fact, they have been around longer than that (they were

available in .NET 2.0), but until .NET 4 it was very difficult to implement them, as this required custom compilation procedures.

40

41

Covariance

42

Contravariance

43

Basic Desktop Programming Label Button TextBox, MaskedTextBox, RichTextBox NumericUpDown RadioButton CheckBox GroupBox MessageBox MonthCalendar, DateTimePicker

44

45

Questions?Questions?