C# 5 versus Java 8... Quand C++ 11 s'invite à la fête

Fabrice JEAN-FRANCOIS – NovenciaTS

Java,C#,C++ : Architectures, plateformes et évolutions

Java,C#,C++ : Architectures et évolutions

Depuis octobre 2013, Framework 4.5.1 :
- surtout des fonctionnalités
d’infrastructures (ASP.NET suspend
state, amélioration Garbage Collect, …)
et programmation en parallèle àVS 2013
- de nouveaux types et API à la marge
Microsoft.NET : vue d’ensemble
Sources Microsoft

 Même si HTML5/Javascript est proposée en
véritable alternative et poussé par Microsoft…
 Windows est codé sur un noyau C++/C/Assembleur…
Idem pourWinRT
 WinRT est en réalité une évolution de COM
 C++/CX pour WinRT ou C++ etWRL
 C#,VB.NET, C++ ou C++/CLI pour applications de
bureau
 .NET Native pour compiler en natif via C# !! (En
preview pour le moment, pour leWindows Store)

JVM
JSE 8
Java JEE 7 : vue d’ensemble 1/2
Sources Oracle

Java JEE 7 : vue d’ensemble 2/2
Sources Oracle

 C++ Standards Commitee Evolution
 1998 C++ devient standard ISO (c++ 98)
 2003 :TC1 = Corrections C++ 98, notion POD
 2005 :TR1 = LibrairieTechnical Report 1
 2008 : Drafts C++ Ox
 2011 : Approbation du standard C++ Ox qui
devient C++ 11

Template meta-programming
Des macros et de goto !
C’est du C !
Un langage orienté objet
compliqué !
Bas niveau !
Non sécurisée, dangereux !
Code dur à maintenir
Code crado mais je continue
sur le même modèle…
Compliqué à apprendre !
cast
pointers
Un bon code
principes et techniques Structure de données
compactes et efficaces
le style C++ 11
gestion des erreurs
C++ : mythes et réalités
Sources Microsoft

 Tourne à peu près partout (WOCA)… Il y a
même un NDK Android !
 Utilisé
 pour la création des OS (avec le C et assembleur)
 V8 de Google est en C++
 Chakra Engine de Microsoft codé en C++
 Et surtout offre le plus de souplesse et
puissance (mais exige un temps de
développement plus long et des
compétences langages accrues)
Surtout C++

 Elles sont très nombreuses
 Multi-objectif : pas que du graphique
 Contrairement à ce que présupposent des développeurs non C++,
elles peuvent concurrencer sans encombre du JEE, .NET

 C# compile le MSIL en binaire avant l’execution (précompilation via Ngen)
 Plusieurs implémentations/profils de JVM : Hotspot, JRockit, etc.
 Java est résolument multiplateformes:
 Write once, run everywhere /anywhere
 C++ se retrouve partout (woca)
 .NET est résolument multi-langages (les implémentations Mono, FreeBSD n’ont
pas de communes mesures avec l’implémentation Microsoft)
 C# est à mi-chemin entre C++ et Java:
 Manipulation de pointeurs, surcharge d’opérateurs
 Delegate pour les pointeurs de fonctions
 Type signés/non signés
 Struct, etc
 Paramètre optionnels
 La gestion des exceptions Java est plus fine
 Exceptions « Error » : problèmes liés à l’environnement (ex: OutOfMemoryError)
 RuntimeException : exceptions « unchecked »
 Checked exception : ces exceptions doivent être traitées ou propagées.

 C# n’est qu’un des langages de la plateforme .NET
 Par rapport àVB.NET:
▪ Structure With, Notion de ModuleEspace de nom Microsoft.VisualBasic
▪ XML Literal, Support du mot-clé When dans le bloc Catch
▪ Mot clés My (appel WMI, IO…) et MyClass (Me = this, MyBase = base) , etc.
 Par rapport à F#:
▪ Programmation fonctionnelle (non impérative)
▪ LOP (Langage Oriented Programming)
▪ Lexing et Parsing (FsLex et FxYacc) …
 Par rapport à C++/CLI:
▪ C++/CLI ne supporte pas LINQ
▪ Mais il permet une interopérabilité totale avec C++
 Ce petit monde est interopérable
 C# peut appeler des fonctions exportées binaires via P/Invoke
 C# peut appeler duC++ via C++/CLI
 Java peut appeler des fonctions exportées binaires via JNA
 Java peut appeler du C++ via JNI
 C++ peut appeler des composants .NET grâce à C++/CLI
 C++ peut appeler du Java via JNI

C# Java
public public
protected
private private
internal Ne rien mettre
protected internal protected
Visibilité
C++ se contente de public/protected/private, n’a pas la notion de package/assembly mais
offre énormément plus de possibilités au niveau conceptualisation POO (et donc
visibilité)

C# Java C# Java C# Java
as X explicit X lock synchronized
base super extern native namespac
e
package
bool boolean fixed X object
byte/ushor
t/ulong…
± Java 8 foreach for operator X
checked X get X out X
const const goto goto override
decimal implicit X params …
delegate Java 8 in X partial X
event ± Java 8 is instanceof readonly final
Mot « réservé » mais
inexistant dans le langage
Géré par des interfaces, classes,
annotation / attribute

C# Java C# Java C# Java
ref X uint, ulong,
ushort
X : implements
sbyte/shor
t/long…
byte/short
/long…
unchecked X X strictfp
sealed final unsafe X X throws
set X using import transient
sizeof X value X X assert
stackalloc X virtual async X
string where extends await X
struct X yield X
typeof X : extends
Mot « réservé » mais
inexistant dans le langage
Géré par des interfaces, classes,
annotation / attribute

alignas (depuis C++11)
alignof (depuis C++11)
and
and_eq
asm
auto(modification C++11)
bitand
bitor
bool
break
case
catch
char
char16_t (depuis C++11)
char32_t (depuis C++11)
class
compl
const
constexpr (depuis C++11)
const_cast
continue
decltype (depuis C++11)
default(modificationC++11)
delete(modificationC++11)
do
double
dynamic_cast
else
enum
explicit
export(1)
extern
false
float
for
friend
goto
if
inline
int
long
mutable
namespace
new
noexcept (depuis C++11)
not
not_eq
nullptr (depuis C++11)
operator
or
or_eq
private
protected
public
register
reinterpret_cast
return
short
signed
sizeof
static
static_assert (depuis C++11)
static_cast
struct
switch
template
this
thread_local (depuis C++11)
throw
true
try
typedef
typeid
typename
union
unsigned
using(modification C++11)
virtual
void
volatile
wchar_t
while
xor
xor_eq

 Vers une simplification du code
 En minimisant les pertes de performance
 En garantissant la stabilité
 Des concepts avancés
 Covariance/Contravariance
 Lambdas
 Closure
 Generics (template)…
 Parallélisme, threads
 Asynchronisme
 Interaction avec d’autres langages
 Renforcement des API

 Des concepts objets et C++
 Pointeurs de fonction
 Foncteurs (Function Object)
 Prédicats, Unary Functions, etc
 Covariance
 Contravariance
 Et un peu d’Assembleur pour redescendre sur
terre !

 Le lambda est juste une fonction anonyme :
 En clair : une fonction qui n’a pas nom
 Mais qui peut prendre des paramètres
 Java possède le concept de classes anonymes
depuis Java 1.1
 C# possède des méthodes anonymes depuis
C# 2 (mais possède des delegates depuis la
version 1)
 C++ (avant 0X, s’appuyait sur les foncteurs)

 Une closure est n’importe quelle fonction qui
capture l’environnement dans laquelle elle est
déclarée !
 Elle peut accéder aux variables qui ne sont
pas dans sa liste de paramètre

 Lambda et closures sont présentes dans Java
8, C# (depuis la version 3) et C++ 11 (depuis
C++ 0X)
 Avec des syntaxes différentes
 Avec des possibilités différentes
 Avec plus ou moins de limitation

 Oracle a racheté SUN Microsystems 2009
 James Gosling a quitté Oracle
 Doug LEA a quitté la JCP
 Flottement sur l’avenir Java, MySQL, etc
 Java 7 prévoyait initialement quasiment toutes
les évolutions de Java 8
 Java 7 a été « fractionné » en Java 7 et 8 !
 On été supprimé :
▪ Jigsaw (toujours pas là avec Java 8)
▪ Lambda
▪ Defender Methods

 Nouveautés du Langage
 Interfaces fonctionnelles
 Lambdas
 Références de méthode
 Defender Methods (Méthodes par défaut)
 Méthodes static dans les interfaces

 Stream et parallel Stream
 API java.time
 Annotations multiples
 Nashorn

 Throws
▪ Une gestion d’erreur précise et impressionnante
▪ Pas d’équivalent C#/C++
▪ Mais jugé inutile par les architectes C#/C++
 Instance initializer/ Double brace initialization
▪ Pour faciliter l’instanciation
 Covariance du type de retour
▪ Comme en C++. Pas d’équivalent C#
 Enum
▪ Comme une classe, avec des méthodes
▪ En C#, ReferenceType
 nested class
 Type inference
 Local et anonymous Classes
 Final parameters et static import
 Generics (use-site variance) :Travail des pecs !!

 Mots clés async/await
 Attributs Caller Information
 C#5 fait parti de l’évolution du framework
Microsoft .NET 4.5
 Evolution des APIWPF, WCF, Entity Framework, etc
 Windows 8 et 8.1… WinRT !!

namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
public sealed class CallerMemberNameAttribute : Attribute
{
public CallerMemberNameAttribute();
}
public sealed class CallerFilePathAttribute : Attribute
{
public CallerFilePathAttribute();
}
public sealed class CallerLineNumberAttribute : Attribute
{
public CallerLineNumberAttribute();
}
}

 Indexer :
 Faire un objet quelconque se comporter comme un
tableau
 Inférence de type
 Déterminer automatiquement le type d’un objet
 La syntaxe Diamond de Java s’en rapproche
 Type Nullable
 Gère le cas de figure Null
 A été créé pour lesValueTypes
 Type « Struct »
 A l’image d’une structure C++ mais pas complètement
 Attention à ce type

 Linq (sur objets, XML, SQL, Entity
Framework)
 A l’image de la nouvelle API Stream Java
 Mais plus puissant : peut réaliser des arbres
d’expression
 Classes partielles
 Scinder une classe en 2
 Pratique pour les frameworks
 Evite de se baser sur l’héritage, implémentation
d’interface seules

 Méthodes d’extension
 Possibilité de rajouter des méthodes sur n’importe
quel type existant
 En java, possibilité de passer par l’AOP, CDI (JEE 6
et 7) ou des frameworks spécifiques non dans la
norme
 Surcharge d’opérateurs
 La communauté Java ne veut en majorité pas en
entendre parlé
 S’avère pourtant bien pratique

 Définition d’opérateur de Cast (implicite ou
explicite)
 À l’image du C++
 Permet de convertir n’importe quel type en en
autre sans notion de hiérarchie ou d’interface
 Renvoie sous forme d’itérateurs
(Enumerable, IEnumerator)
 Mot clé « yield »
 En Java, exige le respect de patterns (plus de
syntaxe)

 La DLR
 Mot clé « dynamic »
 Possibilité de découvrir en runtime
méthodes/propriétés d’un objet
 Implémentation explicite d’interface
 Possibilité de masquer les méthodes d’interface
 Pratique pour les frameworks, pour le cas où 2
interfaces implémentées possèdent la même
méthode
 En Java, nécessité de créer des wrappers (composition
ou agrégation)

 Struct vs Class
 Out et ref
 Indexer, surcharge d’opérateur et
Implémentation explicite d’interface
 Explicit vs implicit cast
 Classes et méthodes partielles
 Nullable
 Delegate et Anonymous method
 Yield return
 Using (IDisposable.Dispose)
 Pointeurs

 DLR
 Méthodes d’extension
 Indexeur
 Inférence de type
 LINQ
 Lambdas
 Entity Framework
 Classes partielles

static void Main(string[] args) {
var values = new List<int>() { 1, 2, 3, 4, 5 };
var funcs = new List<Func<int>>();
foreach (var v in values)
{
funcs.Add(() => v * 10);
}
foreach (var f in funcs)
{
Console.WriteLine(f());
}
}

 Appel statique
Calculator calculator = GetCalculator();
int sum = calculator.Add(10, 20);
 Reflection
object calculator = GetCalculator();
Type calculatorType = calculator.GetType();
object res = calculatorType.InvokeMember("Add", BindingFlags.InvokeMethod,
null, calculator,
new object[] { 10, 20 });
int sum = Convert.ToInt32(res);
 Javascript Object
ScriptObject calculator = GetCalculator();
object res = calculator.Invoke("Add", 10, 20);
int sum = Convert.ToInt32(res);
 DLR
dynamic calculator = GetCalculator();
int sum = calculator.Add(10, 20);

 C++ « classique »  C#
CPolygon *Search(int x, int y)
{
CPoint pt(x,y);
vector<CPolygon*> polys;
ReadPolys(polys);
CPolygon *ret = NULL;
for (vector<CPolygon*>::iterator
beg = polys.begin();
beg!=polys.end();++beg) {
if ((*beg)->Contains(pt)) {
ret = *beg;
break;
}
}
for (vector<CPolygon*>::iterator
beg = polys.begin();
beg!=polys.end();++beg)
if ((*beg) && (*bet != ret)) delete
*beg;
return ret;
}
Polygon Search(int x,
int y)
{
Point pt
= new Point(x,y);
List<Polygon> polys
= ReadPolys();
return polys.FirstOrDefault(
p => p.Contains(pt));
}
Sources Microsoft

TR1.. C++0x.. C++ 11
TR1 - Technical Report 1
shared_ptr<T>
weak_ptr<T>
unique_ptr<T>
regex
tuple
array
…
C++ 0x
lambdas
r-value reference
auto
decltype
static_assert
Thread
mutex
future<T>
vector<vector<int>>
variadic templates
…
Sources Microsoft

gcc est quasiment entièrement compatible c++ 11 !
Manque Minimal support for GC & Reachability-based leak detection
Sources Microsoft

 C++ 11  C#
shared_ptr<CPolygon> Search(int x,
int y)
{
CPoint pt(x,y);
auto polys = ReadPolys();
auto found = find_if(begin(polys),
end(polys),
[pt](shared_ptr<CPolygon> pol) {
return pol->Contains(pt);
});
return (found != polys.end())
? *found : nullptr;
}
Polygon Search(int x,
int y)
{
Point pt = new Point(x,y);
List<Polygon> polys
= ReadPolys();
return polys.FirstOrDefault(
p => p.Contains(pt));
}
Sources Microsoft

 Override
 Enumérations fortement typées
 Fonctions anonymes et fermetures
 Initialisation d’un pointeur
 Mot clé auto
 Nullptr
 Gestion du temps
 Initialisateurs d’attributs
 Etc

 auto_ptr deprecated
 Nouveaux types
 unique_ptr
 shared_ptr / weak_ptr
 Garbarge Collection
 Expression idiomatique RAII
 Exception Safe, STL Safe
 Fonctionne avec des tableaux

 Gère les problématiques de move et création
temporaire d’objets (Lvalue = expression
relative à une localisation mémoire. Rvalue =
le reste)
 int* p = &i; //i est une lvalue
 int* p1 = &foo(); //foo est une lvalue
 j = foobar(); //foobar est rvalue
 int c = a * b; //a*b est rvalue
 Nouveau symbole syntaxique : &&

 En c++11, std::move pour convertir lvalue en
rvalue
 Move constructeur
 Move assignment operator
 std::swap pour les templates (utilise en réalité
std::move)

 Idiom RAII pour créer unThread
 Compatible avec boost
 Support des atomics, mutexes, locks
 std::async, futures, packaged_tasks et
promises
 Thread-local storage
 Thread-safe Initialization (objects w/static
 storage, std::call_once)

 Non C++11 mais déjà opérationnel
 Du parallélisme, oui !!
 Dans la 3D
 Pour accélérer les calculs :
▪ Scientifique
▪ Financier : cas de laVaR par exemple
▪ Idéalement, utiliser les capacités des GPU (GPGPU),
APU

 C++ AMP (Accelerated Massive Parallelism)
 Librairie sur DirectX crée par Microsoft
 Open Specification
 Orientée GPU
 Création de la fonctionnalité restrict(amp)
 CUDA :
 Développé par NVIDIA
 OpenACC
 Standard développé par PGI, Cray, NVIDIA…
 Directives pour GPU, APU, CPU

 OpenMP (Open Multi-Processing)
 API de calcul parallèle sur mémoire partagée
 Portable, scalaben supportée sur Unix,Windows,
HP, Mac, etc
 A base de pragma

C# 5 versus Java 8... Quand C++ 11 s'invite à la fête

Contenu connexe

Tendances

En vedette

Similaire à C# 5 versus Java 8... Quand C++ 11 s'invite à la fête

C# 5 versus Java 8... Quand C++ 11 s'invite à la fête