C# longueur variable args, ce qui est mieux et pourquoi: __arglist, array params, ou Dictionnaire<T,K>?
J'ai lu récemment le dépassement de capacité suivants post:
Les Fonctions cachées de C#
Une des caractéristiques relevé est l'arglist. Pourquoi serait-on choisir ce ou les solutions de rechange comme un moyen d'utiliser une variable longueur de la liste d'arguments pour une méthode? Notez également que je n'aurais probablement pas utiliser ce genre de construction dans mon code, à moins qu'un cas de coin justifié de le faire. C'est plus une question de sémantique que s'il est même pratique ou prudent de même utiliser de longueur variable d'arguments. Donc, personne ne sait ce qui est mieux et pourquoi?
[Test]
public void CanHandleVariableLengthArgs()
{
TakeVariableLengthArgs(__arglist(new StringBuilder(), 12));
object[] arr = { new StringBuilder() };
TakeVariableLengthArgs2(arr);
TakeVariableLengthArgs3(
new Dictionary<string, object>
{ { "key", new StringBuilder() } });
}
public void TakeVariableLengthArgs(__arglist)
{
var args = new ArgIterator(__arglist);
var a = (StringBuilder)TypedReference.ToObject(args.GetNextArg());
a.Append(1);
}
public void TakeVariableLengthArgs2(params object[] args)
{
var a = (StringBuilder)args[0];
a.Append(1);
}
public void TakeVariableLengthArgs3(Dictionary<string, object> args)
{
var a = (StringBuilder)args["StringBuilder"];
a.Append(1);
}
La seule de par sa conception objet d' __arglist est de sorte que vous pouvez faire en toute sécurité l'interopérabilité des appels vers et à partir des bibliothèques écrites en C++ qui utilisent de style C var args. Ne l'utilisez pas pour rien, mais que.
Si vous voulez pinvoke wsprintf fonction tu dois utiliser
Si vous voulez pinvoke wsprintf fonction tu dois utiliser
__arglist
.OriginalL'auteur mkelley33 | 2009-05-26
Vous devez vous connecter pour publier un commentaire.
Je serais certainement jamais utiliser __arglist, car il est sans-papiers et personne ne sait ce que cela signifie en tout cas.
Je voudrais aussi éviter de longueur variable des listes d'arguments pour aussi longtemps que possible, et au lieu de retravailler mon dessin pour comprendre ce qui est vraiment variable, et de modéliser la variabilité de moins en moins la plate-forme dépendant de la manière.
L'un est de ne jamais être utilisés, l'un est un tableau, on est un dictionnaire. Toutes sont souvent un signe de mauvaise conception.
Hahaha, ok, donc je vois où vous vous situez. J'étais juste curieux de savoir où l'on sera préférée à une autre. J'ai complètement au clair sur les types. Je recherche une explication un peu plus en profondeur. J'apprécie votre critique de l'aide de l'un d'eux. Je suis d'accord à 100%, mais nous avons parfois interagir avec les autres, participer à une mauvaise conception, serrant les dents et en espérant pour le mieux!
À l'aide d'un dictionnaire ou
params
est une mauvaise conception? Quoi?J'ai dit "souvent" signe d'une mauvaise conception. Pas "toujours" signe d'une mauvaise conception.
OriginalL'auteur John Saunders
C# 4 aura un meilleur mécanisme pour cela; nommé et arguments optionnels:
OriginalL'auteur bzlm
Il dépend du cas. J'ai utilisé params dans les cas où j'ai un nombre variable d'arguments et il ajoute considérablement à la lisibilité du code appelant.
Par exemple, j'ai une classe qui représente un document TIFF et permet l'accès à un ensemble de pages qui peuvent être réorganisés et intercalés avec d'autres documents TIFF. Depuis l'une des tâches les plus courantes de nos clients veulent, c'est la capacité de combiner facilement plusieurs TIFF documents en un seul, nous fournissons également les deux méthodes de l'utilitaire:
qui, dans l'usage de faire le code client se sent vraiment bien:
Assurez-vous - C# n'est pas vraiment bon à faire des listes dynamiques sans l'utilisation lourde de la nouvelle (new Foo[] { new Foo (), new Foo(b) }). Params bandes d'un niveau de nouveau, supprime certains syntaxique désordre, et dans cet exemple se sent bien à travers les cas d'utilisation. IEnumerable est mieux quand la liste des choses doit être construit et manipulé par programmation de la première (c'est à dire ajouter, supprimer, trier). Dictionnaire<> est mieux pour les non homogeonous paramaterization, mais c'est désagréable pour moi. __arglist est à droite.
OriginalL'auteur plinth
En général, vous êtes probablement mieux éviter de sans-papiers, les caractéristiques de la langue - et ce pour plusieurs raisons.
Dans le cas spécifique de l' __arglist, vous pouvez obtenir les mêmes fonctionnalités avec la langue prise en charge params mot-clé, qui permet de créer des type-safe listes d'arguments variable pour les méthodes en C#. En pratique, cependant, je serais prudent en l'utilisant comme il peut dissimuler votre code si utilisé inpropertly - bon cas d'utilisation (comme ceux de la chaîne.Format (), qui accepte les variable d'arguments) - sont de moins en moins fréquentes que vous ne le pensez.
OriginalL'auteur LBushkin
Je préfère ne pas utiliser tout de trois techniques décrites ici. Je serais à la place de la conception d'un objet de valeur qui a des types dans la mesure du possible, et peut-être même des types nullables. Si la poussée vient pour pousser, vous pouvez créer un des génériques de type de la valeur de l'objet de trop.
Il y a juste tous tellement l'odeur de code dans cette façon de coder pour moi. Un de longueur variable collection de objet ? Ne pas passer inaperçue dans la mon de la revue de code.
Modifier:
Et si il a FAIT passer mon examen de code du paramètre dans tous les probabilité d'être un IEnumerable instance et aucun des trois suggestions d'articles. IEnumerable est le plus mince chose qui pourrait encapsuler mes besoins.
Ok, cédé avec une modification 🙂
OriginalL'auteur krosenvold