C# - für Java

C#
für Java-Entwickler
Sebastian Gepperth
Seminar LaVida
Wintersemester 2010/2011
Einleitung
Gliederung
1
Ähnlichkeiten und Unterschiede zu Java
2
Überblick über fortgeschrittene Features
3
CLR / Biblioteken
4
Fazit
Sebastian Gepperth
C# für Java-Entwickler
2
Einleitung
Geschichte:
entwickelt von Anders Hejlsberg bei Microsoft
C# 1.0: Januar 2002
aktuelle Version: C# 4.0 : April 2010
C# ist inspiriert von Java:
imperativ, objektorientiert und generisch
starke Typisierung
C-ähnliche Syntax
managed Code, Virtual Machine, Garbage Collector
Sebastian Gepperth
C# für Java-Entwickler
3
Ähnlichkeiten und Unterschiede zu Java
grundlegende Syntax
Beispieldatei
using System ;
using Some . Lib ;
// my awesome stuff
namespace My . Stuff {
public class MyClass {
private int someInt = 4;
private string someString ;
}
}
public MyClass () {
someString = " foo " ;
}
/* multiline
Comment */
public string returnFoo () {
return someString ;
}
Sebastian Gepperth
C# für Java-Entwickler
4
Ähnlichkeiten und Unterschiede zu Java
Kompilationseinheiten
Kompilationseinheiten
Eine Kompilationseinheit (Datei) enthält:
Using-Directiven (Paketimport)
Namespace(s)
Klasse(n)
Felder
Konstruktoren
Methoden
=⇒ Kompiliert zu einem Assembly (.dll)
Sebastian Gepperth
C# für Java-Entwickler
5
Ähnlichkeiten und Unterschiede zu Java
Kompilationseinheiten
Methoden
positionale Parameter
optionale Parameter
benannte Parameter
C# Methode
public int foo ( int req , string optStr = " bar " ,
int optInt = 42)
{
return req * optInt ;
}
// /////////////////////////////
foo (6 , optInt : 9);
Sebastian Gepperth
C# für Java-Entwickler
6
Ähnlichkeiten und Unterschiede zu Java
Kompilationseinheiten
Schleifen
Schleifenvarianten:
while
do while
for
foreach
Steuerbefehle:
break
continue
foreach-Schleife
int [] array = {1 ,2 ,3 ,4};
int sum = 0;
foreach ( int i in array )
sum += i ;
Sebastian Gepperth
C# für Java-Entwickler
7
Ähnlichkeiten und Unterschiede zu Java
Kompilationseinheiten
Sichtbarkeiten und Modifikatoren
Zugriffsmodifikatoren:
public
private
protected
internal
internal protected
Instanzmodifikatoren:
static
const
readonly
Sebastian Gepperth
C# für Java-Entwickler
8
Ähnlichkeiten und Unterschiede zu Java
Typsystem
CTS - Common Type System
Sebastian Gepperth
C# für Java-Entwickler
9
Ähnlichkeiten und Unterschiede zu Java
Typsystem
Werttypen / Value Types
gespeichert im Stack oder in Objekten(als Attribut / Field)
Call By Value
instanziierbar durch Wertzuweisung
eigene Typen möglich (erben von System.ValueType)
nullable Types
Sebastian Gepperth
C# für Java-Entwickler
10
Ähnlichkeiten und Unterschiede zu Java
Typsystem
mitgelieferte Werttypen / Built-in Value Types
C# alias
sbyte
byte
short
ushort
int
uint
long
ulong
float
double
decimal
char
bool
––
object
string
CLR-Typ
SByte
Byte
Int16
UInt16
Int32
UInt32
Int64
UInt64
Single
Double
Decimal
Char
Boolean
IntPtr
Object
String
Sebastian Gepperth
Bitbreite
8
8
16
16
32
32
64
64
32
64
128
16
8
32/64
––
––
Bereich
128 — 127
0 — 255
-32768 — 32767
0 – 65535
-2.147.483.648 – 2.147.483.647
0 – 4.294.967.295
-9.223.372.036.854.775.808 – 9.223.372.036.854.775.807
0 – 18.446.744.073.709.551.615
-3,402823e38 – 3,402823e38
-1,79769313486232e308 – 1,79769313486232e308
±1, 0 × 10e28 − ±7, 9 × 10e28
utf 8
true, false
plattformabhängig
Wurzel der Objekthierarchie
unveränderbarer Unicodestring
C# für Java-Entwickler
Javatyp
byte
———
short
———
int
—––
long
–––
float
double
–––
char
boolean
––
Object
String
11
Ähnlichkeiten und Unterschiede zu Java
Typsystem
Referenztypen , Enumerationen und Structs
Referenztypen
Call By Reference
instanziierbar mit new
Enumerationen
Structs (Ada: Record)
ValueType
Attribute, Konstruktoren, Methoden
keine Vererbung
Sebastian Gepperth
C# für Java-Entwickler
12
Ähnlichkeiten und Unterschiede zu Java
Vererbung
Vererbung
Einfachvererbung von Klassen
Mehrfachvererbung von Schnittstellen
Abstrakte Klassen / Methoden (abstract)
Versiegelte Klassen / Methoden (sealed)
Vererbungsbeispiel
public class MyClass : BaseClass , Interface {
public MyClass ( some , parameters ) : base ( other , parameters ) {
// do some constructing
}
}
Sebastian Gepperth
C# für Java-Entwickler
13
Ähnlichkeiten und Unterschiede zu Java
Vererbung
Polymorphismus
Polymorphismus 1
public class A {
public string ToString () {
return " A " ;
}
}
public class B : A {
public new string ToString () {
return " B " ;
}
}
B b = new B ();
A a = (A)b;
b . ToString (); // returns " B "
a . ToString (); // returns " A "
Sebastian Gepperth
C# für Java-Entwickler
14
Ähnlichkeiten und Unterschiede zu Java
Vererbung
Polymorphismus
Polymorphismus 2
public class A {
public virtual string ToString () {
return " A " ;
}
}
public class B : A {
public override string ToString () {
return " B " ;
}
}
B b = new B ();
A a = (A)b;
b . ToString (); // returns " B "
a . ToString (); // returns " B "
Sebastian Gepperth
C# für Java-Entwickler
15
Ähnlichkeiten und Unterschiede zu Java
Generics
Reified Generics
kein Type Erasure, generische Information bleibt in der VM
erhalten
generische Realisierungen sind komplett eigene Klassen
eigene statische Attribute
benutzbar als Arraytypen
generische Instantiierung
public class GenericCreator <T > where T : new () {
public T Create (){
return new T ();
}
}
Sebastian Gepperth
C# für Java-Entwickler
16
Ähnlichkeiten und Unterschiede zu Java
Exceptions
Fehlerbehandlung / Exception Handling
Syntax:
try
catch
finally
throw (new)
Nur unchecked Exceptions:
Exceptions wandern durch den Stack bis gefangen
keine Deklaration von geworfenen Exceptions an Methoden
vorteilhaft wenn globaler Exceptionhandler existiert (GUIs)
Sebastian Gepperth
C# für Java-Entwickler
17
Ähnlichkeiten und Unterschiede zu Java
Delegates
Delegates
typsichere Funktionsreferenzen
Delegatebeispiel
public delegate void Del ( string message );
// Create a method for a delegate .
public static void DelegateMethod ( string message ) {
System . Console . WriteLine ( message );
}
// Instantiate the delegate .
Del handler = DelegateMethod ;
// Call the delegate .
handler ( " Hello World " );
Vorteile:
keine Interfaces nötig, welche nur eine Methode enthalten
Sebastian Gepperth
C# für Java-Entwickler
18
Ähnlichkeiten und Unterschiede zu Java
Delegates
anonyme Methoden und Events
Eventregistrierung mittels anonymer Methode
public class MyEventPublisher {
public delegate void MyEventHandler ( string message );
public event MyEventHandler SomeEvent ;
public void SomeMethod () {
SomeEvent ( " something happened ! " );
}
}
// /////////////////////////////
publisher . SomeEvent += delegate ( string message ) {
Console . WriteLine ( message );
};
Sebastian Gepperth
C# für Java-Entwickler
19
Überblick über fortgeschrittene Features
Properties
Properties
intuitive Getter und Setter
public class PropertiesClass {
private int foo ;
public int Foo {
get { return foo / 3; }
set { foo = value * 3; }
}
public int Bar { get ; private set ; }
}
// ///////////////////////////////
propertiesInstance . Foo += propertiesInstance . Bar ;
// In Java :
propertiesInstance . setFoo ( propertiesInstance . getFoo ()
+ propertiesInstance . getBar ());
Sebastian Gepperth
C# für Java-Entwickler
20
Überblick über fortgeschrittene Features
Indexer
Indexer
auf Objekte wie auf Arrays zugreifen
public class IndexerClass {
private int [] arr = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 0 };
}
public int this [ int i ] {
get { return arr [ i ]; }
set { arr [ i ] = value ; }
}
// /////////////////////////////////
indexerInstance [4] = propertiesInstance [3] * 5;
Sebastian Gepperth
C# für Java-Entwickler
21
Überblick über fortgeschrittene Features
yield
yield
public static IEnumerable < ulong > Fibonacci () {
yield return 0;
yield return 1;
}
ulong previous = 0 , current = 1;
while ( true ) {
ulong next = checked ( previous + current );
yield return next ;
previous = current ;
current = next ;
}
// ////////////////////////////////////////////////
foreach ( ulong fib in Fibonacci ()) {
Console . WriteLine ( fib );
}
Sebastian Gepperth
C# für Java-Entwickler
22
Überblick über fortgeschrittene Features
var
var
sehr lange Variablendeklaration
MyExtraSuperVeryLongClassName < WithSomeGenerics > foo
= new MyExtraSuperVeryLongClassName < WithSomeGenerics >();
foo . FirstCall ();
foo . LastCall ();
kürzer mit var
var foo
= new MyExtraSuperVeryLongClassName < WithSomeGenerics >();
foo . FirstCall ();
foo . LastCall ();
echter Typ wird zur Compilezeit ermittelt
nur lokale Variablen
Sebastian Gepperth
C# für Java-Entwickler
23
Überblick über fortgeschrittene Features
Operatorüberladung
Operatorüberladung
Beispiel anhand des komplexen Zahlentyps
public struct Complex
{
public int r ;
public int i ;
public Complex ( int real , int imaginary ) {
this . real = r ;
this . imaginary = i ;
}
public static Complex operator +( Complex c1 , Complex c2 ) {
return new Complex ( c1 . r + c2 .r , c1 . i + c2 . i );
}
public static implicit operator Complex ( PolarComplex po ) {
// do the math
return new Complex ( por , poi );
}
Sebastian Gepperth
C# für Java-Entwickler
24
Überblick über fortgeschrittene Features
Partielle Klassen
Partielle Klassen
Partielle Klasse anhand eines generierten SOAP Webservices
public partial class MySoapService {
// Lots of generated code here
}
// /////////////////////////////////////
public partial class MySoapService {
// write your own code here
}
Vorteile / Anwendungen:
Trennung von generiertem und selbst programmiertem Code
Aufteilung von großen Klassen in kleinere Dateien
Sebastian Gepperth
C# für Java-Entwickler
25
Überblick über fortgeschrittene Features
Extension Methods
Extension Methods
public static class MyExtensions {
public static int WordCount ( this String str ) {
return str . Split ( new char [] { ' ', '. ' , '? ' } ,
StringSplitOptions . RemoveEmptyEntries ). Length ;
}
}
// ///////////////////////////////////////////////////
" Ich benutze Extension Methods " . WordCount (); // returns 4
Sebastian Gepperth
C# für Java-Entwickler
26
Überblick über fortgeschrittene Features
sonstige Features
sonstige Features
Reflektion
Generic Covariance / Contravariance
LINQ - Language Integrated Query
dynamic - Late Bound Types
XML - Kommentare
Preprozessoren
Pointer und unsafe
P/Invoke
Sebastian Gepperth
C# für Java-Entwickler
27
CLR / Biblioteken
CLR und Sprachbibliotek
Common Language Runtime (Virtual Machine)
CIL (Common Intermediate Language) : Stackbasierende
Assemblersprache
viele Sprachen unterstützt
C#, Visual Basic, J#, C++/CLI, F#, IronPython, IronRuby, A#, Boo,
L#, P#, Fortran.NET, JScript.NET usw.
plattformunabhängig durch verschiedene Implementierungen
Windows : .NET
*nix: mono
Standardbibliotek mit vielen Features (generische Kollektionen,
Tupel, Math, Date etc.)
Sebastian Gepperth
C# für Java-Entwickler
28
Fazit
Fazit
große Ähnlichkeit mit Java und anderen Programmiersprachen
dennoch viele kleine Verbesserungen
macht coden leichter, schneller und intuitiver
=⇒ Evolution
Sebastian Gepperth
C# für Java-Entwickler
29
Thank you!
Questions?