Post on 29-Dec-2015
transcript
Outline
Array types Enum types Value types
differences from classes boxing and unboxing
Delegate types Base structure Multicast delegates Event model using delegates
Event type
Outline
Array types Enum types Value types
differences from classes boxing and unboxing
Delegate types Base structure Multicast delegates Event model using delegates
Event type
Arrays
C# provides several kind of arrays:Single dimensionalMultidimensionalJagged
Arrays can also be specified as in/out A method could fill the content of an array Arrays derive from System.Array class
Array initialization
Empty arrays are created as follows:int[] a = new int[10];
Empty arrays are initialized with empty values or null for non-value types
C# provides the following syntax to initialize an array:string[] a = {"a","b","c"};a = new string{"a","b","d"};
Multidimensional arrays
C# allows defining n-dimensional arrays:int[,,] a = new int[2, 3, 4];
Initializers can be defined as before:int[,] a = {{1, 2}, {1,2}};int[,] a = new int[,]{{1,2},{1,2}};
Multidimensional arrays are more efficient than arrays of arrays although Jagged arrays may save memory
Jagged arrays
Arrays of arrays are called jagged:int[][] a = new int[3][];a[0] = new int[5];a[1] = new int[3];a[2] = new int[0];
In this case the rank of the array is not defined because rows can contain array of different size
Passing arrays as arguments
Array can be passed using out and ref. For instance:void Fill(out int[] a) {
a = new int[]{1,2,3};
}
int[] a;
Fill(out a);
Outline
Array types
Enum types Value types
differences from classes boxing and unboxing
Delegate types Base structure Multicast delegates Event model using delegates
Event type
Enumeration types
Nearly C++ enumeration, but more expressive Example:
enum AccessMode {
Read, Write, Execute }; By default enumeration are equivalent to integer Each label is associated with a value; if
unspecified the previous value incremented by 1 Enumeration values start from 0 (if unspecified)
Controlling values
Enumerations are used to define set of semantically related integral constants
Example:enum AccessMode { Read = 0x01, Write = 0x02, Execute = 0x04}
Values can be used to form bit-masks
Specifying enumeration type
Enumeration may be derived from: byte, sbyte, short, ushort, int, uint, long or ulong
Example:enum Foo : byte { A = -1, // Error! B = 2, C}
The following operators can be used on enumerated values: ==, !=, <, >, <=, >=, +, -, ^, &, |, ~, ++, --, sizeof
Enumeration are types! Explicit cast are needed to cast to the type from which derive
Outline
Array types Enum types
Value types differences from classes boxing and unboxing
Delegate types Base structure Multicast delegates Event model using delegates
Event type
Memory management
Traditionally allocation of data structures could be static; automatic or dynamic
Static allocation consists in memory areas allocated during program loading
Automatic allocation allocates room for local variables on the stack
Dynamic allocation makes use of a memory area called heap handled by language runtime
How do I allocate my data?
Allocation models have costs distributed over: Allocation Effective use (memory is finite) Free
Programs use memory (either directly or indirectly) and its use influences performance: Static allocation is efficient but not flexible Automatic allocation is related to a method invocation
and not under program control Dynamic allocation is optimal in terms of allocation
but is expensive
Values and objects
C# and CLR distinguish between values and objects
Values are usually allocated on the stack (automatic) and are copied by default during method call
Besides objects are allocated on the heap and their lifetime is controlled by the garbage collector
Values and objects
Values have an associated type inherited from System.ValueType
Although they appear to be objects this is not true because identity is not preserved
A special technique called boxing is used to treat a value as an object only if needed
Values are helpful to reduce overhead in memory allocation when identity is not required
Example
using System;
namespace Foo {struct Complex { public double re; public double im;}public class MainClass { public static void Main(string[]
args) { Complex c = new Complex(); c.re = 1; c.im = 0;
Console.WriteLine( "c before boxing is {0} + {1}i", c.re, c.im); object o = c; // BOXING c.re = 2; Console.WriteLine( "c is {0} + {1}i", c.re, c.im); c = (Complex)o; // UNBOXING Console.WriteLine("unboxed c is
{0} + {1}i", c.re, c.im); }}}
Output
How do you explain the following output?C:\> vtc before boxing is 1 + 0ic is 2 + 0iunboxed c is 1 + 0iC:\> _
The value is copied into an object on the heap and then copied back
Value Types
A value type is similar to a class: allow definition of methods, properties and operators
Inheritance is not allowed because values cannot support the same structure of objects
Empty constructor cannot be overridden! Value types are useful when
automatic allocation is appropriate the overhead of copy is less than overhead of GC
Looks very like classes! Examples: complex numbers, pairs, points, …
Outline
Array types Enum types Value types
differences from classes boxing and unboxing
Delegate types Base structure Multicast delegates Event model using delegates
Event type
Delegate types
A delegate is a type that describes a class of methods Example:
class Foo { delegate int MyFun(int i, int j); static int Add(int i, int j) { return i + j; } static void Main(string[] args) { MyFun f = new MyFun(Foo.Add); Console.WriteLine(f(2, 3)); }}
Is it a function pointer?
NOOOOOOOOOOOOOOOOOOOOOOOO A delegate is more than a pointer! It is a special
object To understand what a delegate really is try to
answer to: “How a delegate can invoke an instance method?”
An instance method must be invoked on an object! We may use a pair (object, method)
Delegates as types
A delegate type allows building delegate objects on methods with a specified signature
The type exposes an Invoke method with the appropriate signature at CLR level
C# exposes delegates with a special syntax in the declaration (not class like)
The pair is built using the new operator and the pair is specified using an invocation-like syntax
Delegates like closures?
In functional programming it is possible to define a function that refers external variables
The behavior of the function depends on those external values and may change
Closures are used in functional programming to close open terms in functions
Delegates are not equivalent to closures although are a pair (env, func): the environment should be of the same type to which the method belongs
Functional programming in C#?
Delegates allow representing static and instance methods as values
Those values can be passed over the stack to methods
In some sense methods become first class values: the program can manipulate them
Great implications: introduction of FP elements in the mainstream, cleaner event model (call-backs can be naturally expressed as delegates)
Example: Aggregate function
The following method maps a function on an array:delegate int MyFun(int);int[] ApplyInt(MyFun f, int[] a) { int[] r = new int[a.Length]; for (int i = 0;i < a.Length;i++) r[i] = f(a[i]); return r;}
Events using delegates?
Event system are built on the notion of notification (call-back)
A method invocation can be seen as a notification
In graphic frameworks such as OWL, MFC, Java 1.0.2 were made using virtual methods
Java 1.1 introduces delegation event model: There are source of events There are listeners that ask sources for notifications Event fires: a method is invoked for all subscribers
Delegate event model in Java
Which method should call the event source to notify the event?
In Java there are no delegates and interfaces are used instead (XXXListener)
The listener should implement an interface and the source implements a method for (un)subscription.
A vector of subscribed listeners is kept by the event source
Delegates to handle events
Delegates allows connecting event sources to listeners from outside the involved types
In C# we can use a delegate object to specify which method should be invoked when an event is notified
A first approach could be using an array of delegates into source to represents subscribers
Some component (not necessarily the listener) builds a delegate on the listener and performs subscription
Multicast delegates
Event notification is in general one-to-many CLR provides multicast delegates to support
notification to many listeners A multicast delegate is a kind of delegate that
holds inside a list of ‘delegate objects’ Multicast delegates keep track of subscriptions
to event sources reducing the burden of replicating the code
Multicast delegates: Example
delegate void Event();class EventSource { public Event evt; // … evt(); // fires the event // …}
class Foo { public void MyMethod() {} }
// Some code somewhere!EventSource src = new EventSource();Foo f = new Foo();src.evt += new Event(f.MyMethod);
Unrelated types!
C# and delegates
In C# there is no way to choose between single and multicast delegates
The compiler always generates multicast delegates
In principle JIT could get rid off possible inefficiencies
Introduction of delegates will have the same impact as the introduction of interfaces in Java with respect to programming patterns
Outline
Array types Enum types Value types
differences from classes boxing and unboxing
Delegate types Base structure Multicast delegates Event model using delegates
Event type
Event keyword
C# introduces the event keyword to control access to a delegate member.
If a delegate field of a class is labeled with event then outside code will be able to use only += and -= operators on it
Listener would not be allowed to affect the subscribers list in other ways
Event infrastructures can be easily implemented by means of this keyword and delegates
Event delegates: Example
delegate void Event();class EventSource { public event Event evt; // … evt(); // fires the event // …}
class Foo { public void MyMethod() {} }
// Some code somewhere!EventSource src = new EventSource();Foo f = new Foo();src.evt += new Event(f.MyMethod);src.evt = null; // ERROR!