Lecture 10: Generics & Basic Desktop Programming

1. COS 240 Object-Oriented Languages Lecture 10:Generics & Basic Desktop Programming Svetla Boytcheva AUBG, Spring 2014

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

3. Reminder • Next Class – Midterm Exam

4. 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)

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

6. 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

7. 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.

8. 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.

10. 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.

11. Operators and Nullable Types

12. Resolving Bool? Comparisons with null Value

13. 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 ?? op2 op1 == 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;

14. The System.Collections.Generic Namespace

15. List<T>

16. 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];

17. Sorting and Searching Generic Lists

18. 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.

20. Example

22. Dictionary<K, V>

23. Dictionary<K, V>

24. 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

25. Defining Generic Classes

26. T1 is basic data type T1 is ADT (class)

27. The default Keyword

28. 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.

32. Example

33. Inheriting from Generic Classes

34. Generic Operators

35. Generic Structs

37. Defining Generic Interfaces

38. 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: intmyDefaultInt = GetDefault<int>(); • The type parameter T is provided at the time the method is called.

39. Defining Generic Delegates

40. 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.

42. Covariance

43. Contravariance

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

45. Questions?