Dans un de ses posts Brad Abrams (Un des architectes des classes du Framework .NET http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise, <<que la différence entre String.Empty et "" est très petite, mais il y à une différence. "" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire occupée, mais que la différence est tellement infime que l'on ne verra sans doute pas la différence dans son propre code>>
(En fin de compte String.Empty est un champ static de la classe String qui est initialisé à "" dans un constructeur static)
A+
Eric Vernié Microsoft France
"ShadowFil" a écrit dans le message de news:
Bonjour,
Quel est l'intérêt d'utiliser "String.Empty" plutôt que "" ?
Merci de votre aide.
Bonjour,
Dans un de ses posts Brad Abrams (Un des architectes des classes du
Framework .NET
http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise,
<<que la différence entre String.Empty et "" est très petite, mais il y à
une différence.
"" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation
de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire
occupée, mais que la différence est tellement infime que l'on ne verra sans
doute pas la différence dans son propre code>>
(En fin de compte String.Empty est un champ static de la classe String qui
est initialisé à "" dans un constructeur static)
A+
Eric Vernié
Microsoft France
"ShadowFil" <ShadowFil@discussions.microsoft.com> a écrit dans le message de
news: B52E7234-644C-480F-B93F-5625F06E961F@microsoft.com...
Bonjour,
Quel est l'intérêt d'utiliser "String.Empty" plutôt que "" ?
Dans un de ses posts Brad Abrams (Un des architectes des classes du Framework .NET http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise, <<que la différence entre String.Empty et "" est très petite, mais il y à une différence. "" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire occupée, mais que la différence est tellement infime que l'on ne verra sans doute pas la différence dans son propre code>>
(En fin de compte String.Empty est un champ static de la classe String qui est initialisé à "" dans un constructeur static)
A+
Eric Vernié Microsoft France
"ShadowFil" a écrit dans le message de news:
Bonjour,
Quel est l'intérêt d'utiliser "String.Empty" plutôt que "" ?
Merci de votre aide.
Zazar
> Dans un de ses posts Brad Abrams (Un des architectes des classes du Framework .NET http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise, <<que la différence entre String.Empty et "" est très petite, mais il y à une différence. "" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire occupée, mais que la différence est tellement infime que l'on ne verra sans doute pas la différence dans son propre code>>
(En fin de compte String.Empty est un champ static de la classe String qui est initialisé à "" dans un constructeur static)
Contrairement à ce que Brad dit, "" ne crée pas d'objet lors d'une utilisation courante. ->Quand le JIT compile une méthode, chaque objet string constant qui est trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool) ->Le compilateur static de la classe String affecte "" à String.Empty
Lors de la compilation du constructeur de String, le JIT place donc l'objet "" dans le pool interne. ->Par conséquent quand on écrit str = ""; à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le pool; il n'y aura pas de création de nouvel objet.
Pour s'en convaincre : object obj1 = ""; object obj2 = String.Empty; Console.WriteLine(obj1 == obj2); Ce code affiche true.
-- Zazar
> Dans un de ses posts Brad Abrams (Un des architectes des classes du
Framework .NET
http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise,
<<que la différence entre String.Empty et "" est très petite, mais il y à
une différence.
"" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation
de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire
occupée, mais que la différence est tellement infime que l'on ne verra
sans
doute pas la différence dans son propre code>>
(En fin de compte String.Empty est un champ static de la classe String qui
est initialisé à "" dans un constructeur static)
Contrairement à ce que Brad dit, "" ne crée pas d'objet lors d'une
utilisation courante.
->Quand le JIT compile une méthode, chaque objet string constant qui est
trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool
(si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
->Le compilateur static de la classe String affecte "" à String.Empty
Lors de la compilation du constructeur de String, le JIT place donc l'objet
"" dans le pool
interne.
->Par conséquent quand on écrit
str = "";
à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le
pool; il n'y aura pas de création de nouvel objet.
Pour s'en convaincre :
object obj1 = "";
object obj2 = String.Empty;
Console.WriteLine(obj1 == obj2);
Ce code affiche true.
> Dans un de ses posts Brad Abrams (Un des architectes des classes du Framework .NET http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise, <<que la différence entre String.Empty et "" est très petite, mais il y à une différence. "" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire occupée, mais que la différence est tellement infime que l'on ne verra sans doute pas la différence dans son propre code>>
(En fin de compte String.Empty est un champ static de la classe String qui est initialisé à "" dans un constructeur static)
Contrairement à ce que Brad dit, "" ne crée pas d'objet lors d'une utilisation courante. ->Quand le JIT compile une méthode, chaque objet string constant qui est trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool) ->Le compilateur static de la classe String affecte "" à String.Empty
Lors de la compilation du constructeur de String, le JIT place donc l'objet "" dans le pool interne. ->Par conséquent quand on écrit str = ""; à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le pool; il n'y aura pas de création de nouvel objet.
Pour s'en convaincre : object obj1 = ""; object obj2 = String.Empty; Console.WriteLine(obj1 == obj2); Ce code affiche true.
-- Zazar
LEBRUN Thomas
Je me permet une petite remarque car j'avoue ne plus comprendre..
Zazar nous dit:
à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le pool; il n'y aura pas de création de nouvel objet.
mais juste avant, il nous explique:
chaque objet string constant qui est trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
Donc, si j'ai bien saisi ce qu'il dit: - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé puis placer dans le pool
Pr conséquent, il y a bien création d'objet : Ou j'ai raté un épisode ?
Merci :)
A+
------------------- LEBRUN Thomas http://morpheus.developpez.com http://blog.developpez.com/index.php?blog=9
"Zazar" a écrit :
> Dans un de ses posts Brad Abrams (Un des architectes des classes du > Framework .NET > http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise, > <<que la différence entre String.Empty et "" est très petite, mais il y à > une différence. > "" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation > de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire > occupée, mais que la différence est tellement infime que l'on ne verra > sans > doute pas la différence dans son propre code>> > > (En fin de compte String.Empty est un champ static de la classe String qui > est initialisé à "" dans un constructeur static)
Contrairement à ce que Brad dit, "" ne crée pas d'objet lors d'une utilisation courante. ->Quand le JIT compile une méthode, chaque objet string constant qui est trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool) ->Le compilateur static de la classe String affecte "" à String.Empty
Lors de la compilation du constructeur de String, le JIT place donc l'objet "" dans le pool interne. ->Par conséquent quand on écrit str = ""; à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le pool; il n'y aura pas de création de nouvel objet.
Pour s'en convaincre : object obj1 = ""; object obj2 = String.Empty; Console.WriteLine(obj1 == obj2); Ce code affiche true.
-- Zazar
Je me permet une petite remarque car j'avoue ne plus comprendre..
Zazar nous dit:
à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le
pool; il n'y aura pas de création de nouvel objet.
mais juste avant, il nous explique:
chaque objet string constant qui est
trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool
(si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
Donc, si j'ai bien saisi ce qu'il dit:
- à la compilation, si l'objet ne se trouve pas dans le pool, il est créé
puis placer dans le pool
Pr conséquent, il y a bien création d'objet :
Ou j'ai raté un épisode ?
Merci :)
A+
-------------------
LEBRUN Thomas
http://morpheus.developpez.com
http://blog.developpez.com/index.php?blog=9
"Zazar" a écrit :
> Dans un de ses posts Brad Abrams (Un des architectes des classes du
> Framework .NET
> http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise,
> <<que la différence entre String.Empty et "" est très petite, mais il y à
> une différence.
> "" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation
> de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire
> occupée, mais que la différence est tellement infime que l'on ne verra
> sans
> doute pas la différence dans son propre code>>
>
> (En fin de compte String.Empty est un champ static de la classe String qui
> est initialisé à "" dans un constructeur static)
Contrairement à ce que Brad dit, "" ne crée pas d'objet lors d'une
utilisation courante.
->Quand le JIT compile une méthode, chaque objet string constant qui est
trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool
(si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
->Le compilateur static de la classe String affecte "" à String.Empty
Lors de la compilation du constructeur de String, le JIT place donc l'objet
"" dans le pool
interne.
->Par conséquent quand on écrit
str = "";
à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le
pool; il n'y aura pas de création de nouvel objet.
Pour s'en convaincre :
object obj1 = "";
object obj2 = String.Empty;
Console.WriteLine(obj1 == obj2);
Ce code affiche true.
Je me permet une petite remarque car j'avoue ne plus comprendre..
Zazar nous dit:
à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le pool; il n'y aura pas de création de nouvel objet.
mais juste avant, il nous explique:
chaque objet string constant qui est trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
Donc, si j'ai bien saisi ce qu'il dit: - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé puis placer dans le pool
Pr conséquent, il y a bien création d'objet : Ou j'ai raté un épisode ?
Merci :)
A+
------------------- LEBRUN Thomas http://morpheus.developpez.com http://blog.developpez.com/index.php?blog=9
"Zazar" a écrit :
> Dans un de ses posts Brad Abrams (Un des architectes des classes du > Framework .NET > http://blogs.msdn.com/brada/archive/2003/04/22/49997.aspx), précise, > <<que la différence entre String.Empty et "" est très petite, mais il y à > une différence. > "" crée un objet alors que String.Empty n'en crée pas >>. L'utilisation > de String.Empty, d'après Brad <<semble plus efficace en terme de mémoire > occupée, mais que la différence est tellement infime que l'on ne verra > sans > doute pas la différence dans son propre code>> > > (En fin de compte String.Empty est un champ static de la classe String qui > est initialisé à "" dans un constructeur static)
Contrairement à ce que Brad dit, "" ne crée pas d'objet lors d'une utilisation courante. ->Quand le JIT compile une méthode, chaque objet string constant qui est trouvé est remplacé par l'objet de même valeur qui se trouve dans le pool (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool) ->Le compilateur static de la classe String affecte "" à String.Empty
Lors de la compilation du constructeur de String, le JIT place donc l'objet "" dans le pool interne. ->Par conséquent quand on écrit str = ""; à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le pool; il n'y aura pas de création de nouvel objet.
Pour s'en convaincre : object obj1 = ""; object obj2 = String.Empty; Console.WriteLine(obj1 == obj2); Ce code affiche true.
-- Zazar
Zazar
Bonjour,
Zazar nous dit:
> à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le > pool; il n'y aura pas de création de nouvel objet.
mais juste avant, il nous explique:
> chaque objet string constant qui est > trouvé est remplacé par l'objet de même valeur qui se trouve dans le
pool
> (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
Donc, si j'ai bien saisi ce qu'il dit: - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé puis placer dans le pool
Pr conséquent, il y a bien création d'objet : Ou j'ai raté un épisode ?
Désolé si je n'ai pas été clair. Il y a une et une seule création d'objet dans tout le process. Quand le JIT va compiler le constructeur static de String, il va créer la string "", la mettre dans le pool et modifier le code du constructeur pour transformer le String.Empty = "" en String.Empty ObjetPlacéDansLePoolInterne. Ensuite à chaque fois que le JIT va compiler du code contenant une affectation du style, str = "", il va s'apercevoir que la string "" se trouve dans le pool interne et va faire la même modification que précédemment. Affecter String.Empty ou "" à une variable revient donc au même, dans les 2 cas, on se retrouve avec le même objet. Ceci n'est valable que quand on utilise directement "". Si on fait quelque chose comme str = "FOOBAR".Substring(1,0); là une nouvelle String va être créé au moment de l'exécution.
-- Zazar
Bonjour,
Zazar nous dit:
> à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le
> pool; il n'y aura pas de création de nouvel objet.
mais juste avant, il nous explique:
> chaque objet string constant qui est
> trouvé est remplacé par l'objet de même valeur qui se trouve dans le
pool
> (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
Donc, si j'ai bien saisi ce qu'il dit:
- à la compilation, si l'objet ne se trouve pas dans le pool, il est créé
puis placer dans le pool
Pr conséquent, il y a bien création d'objet :
Ou j'ai raté un épisode ?
Désolé si je n'ai pas été clair.
Il y a une et une seule création d'objet dans tout le process.
Quand le JIT va compiler le constructeur static de String, il va créer la
string "", la mettre dans le pool et modifier le code du constructeur pour
transformer le String.Empty = "" en String.Empty ObjetPlacéDansLePoolInterne.
Ensuite à chaque fois que le JIT va compiler du code contenant une
affectation du style, str = "", il va s'apercevoir que la string "" se
trouve dans le pool interne et va faire la même modification que
précédemment. Affecter String.Empty ou "" à une variable revient donc au
même, dans les 2 cas, on se retrouve avec le même objet.
Ceci n'est valable que quand on utilise directement "". Si on fait quelque
chose comme str = "FOOBAR".Substring(1,0); là une nouvelle String va être
créé au moment de l'exécution.
> à la compilation, le JIT va remplacer "" par l'objet se trouvant dans le > pool; il n'y aura pas de création de nouvel objet.
mais juste avant, il nous explique:
> chaque objet string constant qui est > trouvé est remplacé par l'objet de même valeur qui se trouve dans le
pool
> (si l'objet ne s'y trouve pas, il est créé puis placé dans le pool)
Donc, si j'ai bien saisi ce qu'il dit: - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé puis placer dans le pool
Pr conséquent, il y a bien création d'objet : Ou j'ai raté un épisode ?
Désolé si je n'ai pas été clair. Il y a une et une seule création d'objet dans tout le process. Quand le JIT va compiler le constructeur static de String, il va créer la string "", la mettre dans le pool et modifier le code du constructeur pour transformer le String.Empty = "" en String.Empty ObjetPlacéDansLePoolInterne. Ensuite à chaque fois que le JIT va compiler du code contenant une affectation du style, str = "", il va s'apercevoir que la string "" se trouve dans le pool interne et va faire la même modification que précédemment. Affecter String.Empty ou "" à une variable revient donc au même, dans les 2 cas, on se retrouve avec le même objet. Ceci n'est valable que quand on utilise directement "". Si on fait quelque chose comme str = "FOOBAR".Substring(1,0); là une nouvelle String va être créé au moment de l'exécution.
-- Zazar
Bruno Jouhier [MVP]
> Donc, si j'ai bien saisi ce qu'il dit: - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé puis placer dans le pool
Pr conséquent, il y a bien création d'objet : Ou j'ai raté un épisode ?
Il y a aura en tout et pour tout UN SEUL objet "" dans le pool. Et même si tu n'utilises jamais "" dans ton code, cet objet sera créé lorsque la classe System.String sera initialisée.
Attention, dans le test que Zazar met à la fin de son post:
Il est important d'utiliser des variables de type "object". Si on remplace ça par des variables string, le test ne veut plus rien dire (car la classe String surcharge l'opérateur == ). Je trouve que la variante suivante est un peu plus claire:
> Donc, si j'ai bien saisi ce qu'il dit:
- à la compilation, si l'objet ne se trouve pas dans le pool, il est créé
puis placer dans le pool
Pr conséquent, il y a bien création d'objet :
Ou j'ai raté un épisode ?
Il y a aura en tout et pour tout UN SEUL objet "" dans le pool. Et même si
tu n'utilises jamais "" dans ton code, cet objet sera créé lorsque la classe
System.String sera initialisée.
Attention, dans le test que Zazar met à la fin de son post:
Il est important d'utiliser des variables de type "object". Si on remplace
ça par des variables string, le test ne veut plus rien dire (car la classe
String surcharge l'opérateur == ). Je trouve que la variante suivante est un
peu plus claire:
> Donc, si j'ai bien saisi ce qu'il dit: - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé puis placer dans le pool
Pr conséquent, il y a bien création d'objet : Ou j'ai raté un épisode ?
Il y a aura en tout et pour tout UN SEUL objet "" dans le pool. Et même si tu n'utilises jamais "" dans ton code, cet objet sera créé lorsque la classe System.String sera initialisée.
Attention, dans le test que Zazar met à la fin de son post:
Il est important d'utiliser des variables de type "object". Si on remplace ça par des variables string, le test ne veut plus rien dire (car la classe String surcharge l'opérateur == ). Je trouve que la variante suivante est un peu plus claire:
Le premier imprime True car la concaténation des deux littéraux est faite à la compilation.
Le second imprime False car la concaténation est faite à l'exécution (mais je ne suis pas sûr que ça soit garanti car un compilateur plus malin pourrait la faire en utilisant le fait que String.Empty est readonly -- la spec C# autorise t'elle ça? Si elle l'autorise, alors on a le risque d'avoir du code qui donne des résultats différents avec des compilateurs différents).
Bruno.
"ShadowFil" <ShadowFil@discussions.microsoft.com> a écrit dans le message de
news: B52E7234-644C-480F-B93F-5625F06E961F@microsoft.com...
Bonjour,
Quel est l'intérêt d'utiliser "String.Empty" plutôt que "" ?
Merci de votre aide.
Il n'y a "pratiquement" aucune différence.
En cherchant la petite bête, on peut cependant trouver des cas où on
n'obtient pas le même résultat en remplaçant "" par String.Empty. Par
exemple:
Le premier imprime True car la concaténation des deux littéraux est faite à
la compilation.
Le second imprime False car la concaténation est faite à l'exécution (mais
je ne suis pas sûr que ça soit garanti car un compilateur plus malin
pourrait la faire en utilisant le fait que String.Empty est readonly -- la
spec C# autorise t'elle ça? Si elle l'autorise, alors on a le risque d'avoir
du code qui donne des résultats différents avec des compilateurs
différents).
Le premier imprime True car la concaténation des deux littéraux est faite à la compilation.
Le second imprime False car la concaténation est faite à l'exécution (mais je ne suis pas sûr que ça soit garanti car un compilateur plus malin pourrait la faire en utilisant le fait que String.Empty est readonly -- la spec C# autorise t'elle ça? Si elle l'autorise, alors on a le risque d'avoir du code qui donne des résultats différents avec des compilateurs différents).
Bruno.
LEBRUN Thomas
OK donc en fait, il y a bien une premièr ecréation d'objet, puis ensuite, le compilateur va réutiliser l'objet qui se trouve dans le pool.
Merci pour les explications, car, même si j'ai pour habitude d'utiliser String.Empty, je me suis également poser la question de savoir s'il y avait ou non une différence :)
A+
------------------- LEBRUN Thomas http://morpheus.developpez.com http://blog.developpez.com/index.php?blog=9
"Bruno Jouhier [MVP]" a écrit :
> Donc, si j'ai bien saisi ce qu'il dit: > - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé > puis placer dans le pool > > Pr conséquent, il y a bien création d'objet : > Ou j'ai raté un épisode ?
Il y a aura en tout et pour tout UN SEUL objet "" dans le pool. Et même si tu n'utilises jamais "" dans ton code, cet objet sera créé lorsque la classe System.String sera initialisée.
Attention, dans le test que Zazar met à la fin de son post:
Il est important d'utiliser des variables de type "object". Si on remplace ça par des variables string, le test ne veut plus rien dire (car la classe String surcharge l'opérateur == ). Je trouve que la variante suivante est un peu plus claire:
OK donc en fait, il y a bien une premièr ecréation d'objet, puis ensuite, le
compilateur va réutiliser l'objet qui se trouve dans le pool.
Merci pour les explications, car, même si j'ai pour habitude d'utiliser
String.Empty, je me suis également poser la question de savoir s'il y avait
ou non une différence :)
A+
-------------------
LEBRUN Thomas
http://morpheus.developpez.com
http://blog.developpez.com/index.php?blog=9
"Bruno Jouhier [MVP]" a écrit :
> Donc, si j'ai bien saisi ce qu'il dit:
> - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé
> puis placer dans le pool
>
> Pr conséquent, il y a bien création d'objet :
> Ou j'ai raté un épisode ?
Il y a aura en tout et pour tout UN SEUL objet "" dans le pool. Et même si
tu n'utilises jamais "" dans ton code, cet objet sera créé lorsque la classe
System.String sera initialisée.
Attention, dans le test que Zazar met à la fin de son post:
Il est important d'utiliser des variables de type "object". Si on remplace
ça par des variables string, le test ne veut plus rien dire (car la classe
String surcharge l'opérateur == ). Je trouve que la variante suivante est un
peu plus claire:
OK donc en fait, il y a bien une premièr ecréation d'objet, puis ensuite, le compilateur va réutiliser l'objet qui se trouve dans le pool.
Merci pour les explications, car, même si j'ai pour habitude d'utiliser String.Empty, je me suis également poser la question de savoir s'il y avait ou non une différence :)
A+
------------------- LEBRUN Thomas http://morpheus.developpez.com http://blog.developpez.com/index.php?blog=9
"Bruno Jouhier [MVP]" a écrit :
> Donc, si j'ai bien saisi ce qu'il dit: > - à la compilation, si l'objet ne se trouve pas dans le pool, il est créé > puis placer dans le pool > > Pr conséquent, il y a bien création d'objet : > Ou j'ai raté un épisode ?
Il y a aura en tout et pour tout UN SEUL objet "" dans le pool. Et même si tu n'utilises jamais "" dans ton code, cet objet sera créé lorsque la classe System.String sera initialisée.
Attention, dans le test que Zazar met à la fin de son post:
Il est important d'utiliser des variables de type "object". Si on remplace ça par des variables string, le test ne veut plus rien dire (car la classe String surcharge l'opérateur == ). Je trouve que la variante suivante est un peu plus claire:
je me demande bien d'ou viennent ces infos sur le JIT ? un lien ?
A+
Bruno Jouhier [MVP]
AMA, ce n'est pas le JIT, mais plutôt le compilateur qui "interne" les litéraux dans le pool. En Java par exemple, on peut (pouvait?) fonctionnner avec ou sans le JIT, et dans les deux cas, les litéraux était "internés", ce qui est normal car ça fait partie des specs du langage (le fait que 2 "Hello World" à 2 endroits différents sont le même objet String).
Bruno.
"Ambassadeur Kosh" a écrit dans le message de news:
Salut
je me demande bien d'ou viennent ces infos sur le JIT ? un lien ?
A+
AMA, ce n'est pas le JIT, mais plutôt le compilateur qui "interne" les
litéraux dans le pool. En Java par exemple, on peut (pouvait?) fonctionnner
avec ou sans le JIT, et dans les deux cas, les litéraux était "internés", ce
qui est normal car ça fait partie des specs du langage (le fait que 2 "Hello
World" à 2 endroits différents sont le même objet String).
Bruno.
"Ambassadeur Kosh" <kosh.naranek@babylon5.net> a écrit dans le message de
news: OxCKxGWyEHA.2540@TK2MSFTNGP09.phx.gbl...
Salut
je me demande bien d'ou viennent ces infos sur le JIT ? un lien ?
AMA, ce n'est pas le JIT, mais plutôt le compilateur qui "interne" les litéraux dans le pool. En Java par exemple, on peut (pouvait?) fonctionnner avec ou sans le JIT, et dans les deux cas, les litéraux était "internés", ce qui est normal car ça fait partie des specs du langage (le fait que 2 "Hello World" à 2 endroits différents sont le même objet String).
Bruno.
"Ambassadeur Kosh" a écrit dans le message de news:
Salut
je me demande bien d'ou viennent ces infos sur le JIT ? un lien ?
A+
Ambassadeur Kosh
> AMA, ce n'est pas le JIT, mais plutôt le compilateur qui "interne" les litéraux dans le pool. En Java par exemple, on peut (pouvait?) fonctionnner avec ou sans le JIT, et dans les deux cas, les litéraux était "internés", ce qui est normal car ça fait partie des specs du langage (le fait que 2 "Hello World" à 2 endroits différents sont le même objet String).
tout ça, je l'ai deduit avec mes petits neurones à moi, mais je n'en ai jamais vu la couleur dans un document quelque part. s'il y'en a un, par pitié, montrez moi ou :)
A+
> AMA, ce n'est pas le JIT, mais plutôt le compilateur qui "interne" les
litéraux dans le pool. En Java par exemple, on peut (pouvait?)
fonctionnner avec ou sans le JIT, et dans les deux cas, les litéraux était
"internés", ce qui est normal car ça fait partie des specs du langage (le
fait que 2 "Hello World" à 2 endroits différents sont le même objet
String).
tout ça, je l'ai deduit avec mes petits neurones à moi, mais je n'en ai
jamais
vu la couleur dans un document quelque part. s'il y'en a un, par pitié,
montrez moi ou :)
> AMA, ce n'est pas le JIT, mais plutôt le compilateur qui "interne" les litéraux dans le pool. En Java par exemple, on peut (pouvait?) fonctionnner avec ou sans le JIT, et dans les deux cas, les litéraux était "internés", ce qui est normal car ça fait partie des specs du langage (le fait que 2 "Hello World" à 2 endroits différents sont le même objet String).
tout ça, je l'ai deduit avec mes petits neurones à moi, mais je n'en ai jamais vu la couleur dans un document quelque part. s'il y'en a un, par pitié, montrez moi ou :)
