Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Zazar
Bonjour,
J'ai remarqué que les imports de namespaces peuvent être indiqués comme ceci :
namespace Société.Data { using System;
(...)
}
ou comme ceci :
using System;
(...)
namespace Société.Data { . . . }
Y-a t-il des avantages d'une ou l'autre technique ?
Pour commencer les deux méthodes ne sont pas totalement équivalentes. Dans la première situation, la portée du using est constituée du bloc namespace {}, dans la deuxième, la portée du using est toute l'unité de compilation (le fichier). Dans le cas où vous n'utilisez pas plusieurs espaces de nom dans le même fichier, les deux utilisations sont identiques, vous pouvez choisir celle que vous préfèrez. Personnellement, je trouve que mettre tous les using au début du fichier est plus propre : pour moi le using est un raccourci, il n'appartient pas à un espace de nom.
-- Zazar
Bonjour,
J'ai remarqué que les imports de namespaces peuvent être
indiqués comme ceci :
namespace Société.Data
{
using System;
(...)
}
ou comme ceci :
using System;
(...)
namespace Société.Data
{
. . .
}
Y-a t-il des avantages d'une ou l'autre technique ?
Pour commencer les deux méthodes ne sont pas totalement équivalentes. Dans
la première situation, la portée du using est constituée du bloc namespace
{}, dans la deuxième, la portée du using est toute l'unité de compilation
(le fichier). Dans le cas où vous n'utilisez pas plusieurs espaces de nom
dans le même fichier, les deux utilisations sont identiques, vous pouvez
choisir celle que vous préfèrez. Personnellement, je trouve que mettre tous
les using au début du fichier est plus propre : pour moi le using est un
raccourci, il n'appartient pas à un espace de nom.
J'ai remarqué que les imports de namespaces peuvent être indiqués comme ceci :
namespace Société.Data { using System;
(...)
}
ou comme ceci :
using System;
(...)
namespace Société.Data { . . . }
Y-a t-il des avantages d'une ou l'autre technique ?
Pour commencer les deux méthodes ne sont pas totalement équivalentes. Dans la première situation, la portée du using est constituée du bloc namespace {}, dans la deuxième, la portée du using est toute l'unité de compilation (le fichier). Dans le cas où vous n'utilisez pas plusieurs espaces de nom dans le même fichier, les deux utilisations sont identiques, vous pouvez choisir celle que vous préfèrez. Personnellement, je trouve que mettre tous les using au début du fichier est plus propre : pour moi le using est un raccourci, il n'appartient pas à un espace de nom.
-- Zazar
Ledev
"LEBRUN Thomas" <lebrun_thomas_at_hotmail.com> a écrit dans le message de news:
Je n'ai jamais remarqué la 1ère solution et par défaut, Visual Studio te
propose la 2ème.
Donc, pour être franc, si avantage(s) il y a, je ne le(s) vois pas....
Je pense que la différence doit être lorsqu'il y a plusieurs namespace:
using System; // s'applique à tous les namespaces s'y dessous
namespace ns1 { using System.Web // System est importer, ainsi que System.Web }
namespace ns2 { // Ici, seul System est importer, System.Web ne l'est pas }
Et il peut aussi certainement y avoir des différences lorsqu'on importe dans un namespace enfant, sans le mettre dans le parent:
namespace parent { // Ici, System.Web n'est pas importez namespace enfant { using System.Web /Ici, System.Web est importer } }
J'ai pas testez, mais je pense que la différence doit ce situer là
A+
-- LEBRUN Thomas http://morpheus.developpez.com
"ShadowFil" a écrit :
> Bonjour, > > J'ai remarqué que les imports de namespaces peuvent être > indiqués comme ceci : > > namespace Société.Data > { > using System; > using System.Collections; > using System.Collections.Specialized; > using System.Data; > using System.Reflection; > > . . . > } > > ou comme ceci : > > using System; > using System.Collections; > using System.Collections.Specialized; > using System.Data; > using System.Reflection; > > namespace Société.Data > { > . . . > } > > Y-a t-il des avantages d'une ou l'autre technique ? > > Merci de votre aide. >
"LEBRUN Thomas" <lebrun_thomas_at_hotmail.com> a écrit dans le message de
news: 4C0E9C5C-6140-4A69-8D06-7161E947729E@microsoft.com...
Je n'ai jamais remarqué la 1ère solution et par défaut, Visual Studio te
propose la 2ème.
Donc, pour être franc, si avantage(s) il y a, je ne le(s) vois pas....
Je pense que la différence doit être lorsqu'il y a plusieurs namespace:
using System; // s'applique à tous les namespaces s'y dessous
namespace ns1
{
using System.Web
// System est importer, ainsi que System.Web
}
namespace ns2
{
// Ici, seul System est importer, System.Web ne l'est pas
}
Et il peut aussi certainement y avoir des différences lorsqu'on importe dans
un namespace enfant, sans le mettre dans le parent:
namespace parent
{
// Ici, System.Web n'est pas importez
namespace enfant
{
using System.Web
/Ici, System.Web est importer
}
}
J'ai pas testez, mais je pense que la différence doit ce situer là
A+
--
LEBRUN Thomas
http://morpheus.developpez.com
"ShadowFil" a écrit :
> Bonjour,
>
> J'ai remarqué que les imports de namespaces peuvent être
> indiqués comme ceci :
>
> namespace Société.Data
> {
> using System;
> using System.Collections;
> using System.Collections.Specialized;
> using System.Data;
> using System.Reflection;
>
> . . .
> }
>
> ou comme ceci :
>
> using System;
> using System.Collections;
> using System.Collections.Specialized;
> using System.Data;
> using System.Reflection;
>
> namespace Société.Data
> {
> . . .
> }
>
> Y-a t-il des avantages d'une ou l'autre technique ?
>
> Merci de votre aide.
>
"LEBRUN Thomas" <lebrun_thomas_at_hotmail.com> a écrit dans le message de news:
Je n'ai jamais remarqué la 1ère solution et par défaut, Visual Studio te
propose la 2ème.
Donc, pour être franc, si avantage(s) il y a, je ne le(s) vois pas....
Je pense que la différence doit être lorsqu'il y a plusieurs namespace:
using System; // s'applique à tous les namespaces s'y dessous
namespace ns1 { using System.Web // System est importer, ainsi que System.Web }
namespace ns2 { // Ici, seul System est importer, System.Web ne l'est pas }
Et il peut aussi certainement y avoir des différences lorsqu'on importe dans un namespace enfant, sans le mettre dans le parent:
namespace parent { // Ici, System.Web n'est pas importez namespace enfant { using System.Web /Ici, System.Web est importer } }
J'ai pas testez, mais je pense que la différence doit ce situer là
A+
-- LEBRUN Thomas http://morpheus.developpez.com
"ShadowFil" a écrit :
> Bonjour, > > J'ai remarqué que les imports de namespaces peuvent être > indiqués comme ceci : > > namespace Société.Data > { > using System; > using System.Collections; > using System.Collections.Specialized; > using System.Data; > using System.Reflection; > > . . . > } > > ou comme ceci : > > using System; > using System.Collections; > using System.Collections.Specialized; > using System.Data; > using System.Reflection; > > namespace Société.Data > { > . . . > } > > Y-a t-il des avantages d'une ou l'autre technique ? > > Merci de votre aide. >
Zoury
Salut à tous ! :O)
le "using" n'importe rien et ne charge rien en mémoire non plus. C'est simplement là pour dire au compilateur "Dans le code qui suit, les objets déclarés devrait se trouvé dans les namespaces suivants!". Le compilateur connaissant cette informatique essai les namespace à un à un sur les objets lors de la compile.
donc supposons que j'ai le code suivant :
// using suivants : using System; using System.Text;
// et plus tard le code suivant : StringBuilder sb = new StringBuilder(); sb.Append(new String(5, '0'));
le compilateur va vérifier si StringBuilder existe dans System, si non il essai System.Text, etc.. et il envoit un message dans le cas ou plus d'un namespace offre une classe donnée afin d'éviter toute ambiguité. Donc le "using" ne sert qu'à nous éviter de taper le namespace en entier à chaque fois que l'on accède à des membres d'un classe et l'endroit où ils sont placé ne dérange pas. Toutefois pour raison d'esthétique, je suis du même avis que Zazar, je préfères les placer dans le haut du fichier.
le "using" n'importe rien et ne charge rien en mémoire non plus. C'est
simplement là pour dire au compilateur "Dans le code qui suit, les objets
déclarés devrait se trouvé dans les namespaces suivants!". Le compilateur
connaissant cette informatique essai les namespace à un à un sur les objets
lors de la compile.
donc supposons que j'ai le code suivant :
// using suivants :
using System;
using System.Text;
// et plus tard le code suivant :
StringBuilder sb = new StringBuilder();
sb.Append(new String(5, '0'));
le compilateur va vérifier si StringBuilder existe dans System, si non il
essai System.Text, etc.. et il envoit un message dans le cas ou plus d'un
namespace offre une classe donnée afin d'éviter toute ambiguité. Donc le
"using" ne sert qu'à nous éviter de taper le namespace en entier à chaque
fois que l'on accède à des membres d'un classe et l'endroit où ils sont
placé ne dérange pas. Toutefois pour raison d'esthétique, je suis du même
avis que Zazar, je préfères les placer dans le haut du fichier.
le "using" n'importe rien et ne charge rien en mémoire non plus. C'est simplement là pour dire au compilateur "Dans le code qui suit, les objets déclarés devrait se trouvé dans les namespaces suivants!". Le compilateur connaissant cette informatique essai les namespace à un à un sur les objets lors de la compile.
donc supposons que j'ai le code suivant :
// using suivants : using System; using System.Text;
// et plus tard le code suivant : StringBuilder sb = new StringBuilder(); sb.Append(new String(5, '0'));
le compilateur va vérifier si StringBuilder existe dans System, si non il essai System.Text, etc.. et il envoit un message dans le cas ou plus d'un namespace offre une classe donnée afin d'éviter toute ambiguité. Donc le "using" ne sert qu'à nous éviter de taper le namespace en entier à chaque fois que l'on accède à des membres d'un classe et l'endroit où ils sont placé ne dérange pas. Toutefois pour raison d'esthétique, je suis du même avis que Zazar, je préfères les placer dans le haut du fichier.
C'est écrit noir sur blanc dans la norme (16.3.2): <cite> A using-namespace-directive imports the types contained in a namespace into the immediately enclosing compilation unit or namespace body, enabling the identifier of each type to be used without qualification. </cite> D'ailleurs en VB.NET, le mot-clef équivalent c'est imports :) .
et ne charge rien en mémoire non plus.
Disons plutôt qu'au niveau de l'exécution, il n'y a aucune différence entre si les types ont été utilisés dans le code via leurs noms qualifiés complets ou via des using.
C'est simplement là pour dire au compilateur "Dans le code qui suit, les objets déclarés devrait se trouvé dans les namespaces suivants!".
Ca ne concerne que les types, pas les objets.
Le compilateur connaissant cette informatique essai les namespace à un à un sur les
objets
lors de la compile.
Ou alors, il a une table des types existants ce qui lui de parcourir tous les namespaes importés à chaque déclaration. Personnellement j'ignore totalement comment le compilateur de Ms s'y prend , et en fait l'information n'est pas utile au développement : il suffit de savoir que les types inclus dans les espaces de noms importés peuvent être référencés directement.
(...)
Donc le "using" ne sert qu'à nous éviter de taper le namespace en entier à chaque fois que l'on accède à des membres d'un classe
que l'on fait une référence à un type
et l'endroit où ils sont placé ne dérange pas. Toutefois pour raison d'esthétique, je suis du même avis que Zazar, je préfères les placer dans le haut du fichier.
-- Zazar
Bonsoir,
le "using" n'importe rien
C'est écrit noir sur blanc dans la norme (16.3.2):
<cite>
A using-namespace-directive imports the types contained in a namespace into
the immediately enclosing compilation unit or namespace body, enabling the
identifier of each type to be used without qualification.
</cite>
D'ailleurs en VB.NET, le mot-clef équivalent c'est imports :) .
et ne charge rien en mémoire non plus.
Disons plutôt qu'au niveau de l'exécution, il n'y a aucune différence entre
si les types ont été utilisés dans le code via leurs noms qualifiés complets
ou via des using.
C'est
simplement là pour dire au compilateur "Dans le code qui suit, les objets
déclarés devrait se trouvé dans les namespaces suivants!".
Ca ne concerne que les types, pas les objets.
Le compilateur
connaissant cette informatique essai les namespace à un à un sur les
objets
lors de la compile.
Ou alors, il a une table des types existants ce qui lui de parcourir tous
les namespaes importés à chaque déclaration. Personnellement j'ignore
totalement comment le compilateur de Ms s'y prend , et en fait l'information
n'est pas utile au développement : il suffit de savoir que les types inclus
dans les espaces de noms importés peuvent être référencés directement.
(...)
Donc le
"using" ne sert qu'à nous éviter de taper le namespace en entier à chaque
fois
que l'on accède à des membres d'un classe
que l'on fait une référence à un type
et l'endroit où ils sont
placé ne dérange pas. Toutefois pour raison d'esthétique, je suis du même
avis que Zazar, je préfères les placer dans le haut du fichier.
C'est écrit noir sur blanc dans la norme (16.3.2): <cite> A using-namespace-directive imports the types contained in a namespace into the immediately enclosing compilation unit or namespace body, enabling the identifier of each type to be used without qualification. </cite> D'ailleurs en VB.NET, le mot-clef équivalent c'est imports :) .
et ne charge rien en mémoire non plus.
Disons plutôt qu'au niveau de l'exécution, il n'y a aucune différence entre si les types ont été utilisés dans le code via leurs noms qualifiés complets ou via des using.
C'est simplement là pour dire au compilateur "Dans le code qui suit, les objets déclarés devrait se trouvé dans les namespaces suivants!".
Ca ne concerne que les types, pas les objets.
Le compilateur connaissant cette informatique essai les namespace à un à un sur les
objets
lors de la compile.
Ou alors, il a une table des types existants ce qui lui de parcourir tous les namespaes importés à chaque déclaration. Personnellement j'ignore totalement comment le compilateur de Ms s'y prend , et en fait l'information n'est pas utile au développement : il suffit de savoir que les types inclus dans les espaces de noms importés peuvent être référencés directement.
(...)
Donc le "using" ne sert qu'à nous éviter de taper le namespace en entier à chaque fois que l'on accède à des membres d'un classe
que l'on fait une référence à un type
et l'endroit où ils sont placé ne dérange pas. Toutefois pour raison d'esthétique, je suis du même avis que Zazar, je préfères les placer dans le haut du fichier.
-- Zazar
Zoury
Salut Zazar!
<cite> A using-namespace-directive imports the types contained in a namespace
into
the immediately enclosing compilation unit or namespace body, enabling the identifier of each type to be used without qualification. </cite>
aaah! Merci pour l'info! ;O)
Ca ne concerne que les types, pas les objets.
yep. j'aurais faire plus gaffe à la nomenclature utilisé, désolé. :O)
