Transcript Document

Java2C#
Antonio Cisternino
Part II
Outline



Array types
Enum types
Value types



Delegate types




differences from classes
boxing and unboxing
Base structure
Multicast delegates
Event model using delegates
Event type
Outline

Array types

Enum types
Value types




Delegate types




differences from classes
boxing and unboxing
Base structure
Multicast delegates
Event model using delegates
Event type
Arrays

C# provides several kind of arrays:
 Single
dimensional
 Multidimensional
 Jagged
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



Delegate types




differences from classes
boxing and unboxing
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




Delegate types




differences from classes
boxing and unboxing
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
 Free

(memory is finite)
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:\> vt
c before boxing is 1 + 0i
c is 2 + 0i
unboxed c is 1 + 0i
C:\> _

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



Delegate types




differences from classes
boxing and unboxing
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)
CLR delegates
Delegate object
Object
Object
Method
Method code
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 (callbacks 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
 There
are source of events
are listeners that ask sources for notifications
 Event fires: a method is invoked for all subscribers
Delegation Event Model
Subscribe
Event Source
Subscribed listeners
Subscriber
Notification
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
// …
}
Unrelated types!
class Foo { public void MyMethod() {} }
// Some code somewhere!
EventSource src = new EventSource();
Foo f = new Foo();
src.evt += new Event(f.MyMethod);
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



Delegate types




differences from classes
boxing and unboxing
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!
Next lecture

Classes
 virtual methods
 Properties
 Fields
 new names
 operator

overloading
Reflection
 Custom
attributes
 Generation of code using reflection

Statements and other new operators