En passant juste un type comme paramètre en C#

Hypothétiquement ce serait pratique pour moi de le faire:

foo.GetColumnValues(dm.mainColumn, int)
foo.GetColumnValues(dm.mainColumn, string)

où la GetColumns méthode appelle une méthode différente à l'intérieur en fonction du type passé.

Oui, je pourrais le faire comme un indicateur booléen ou similaire, je me demandais si il y avait un moyen de peut-être passer cela, et de se demander:

typeof(arg[1]) ou similaire...

Je pourrais aussi remplacer la méthode, l'utilisation des génériques, etc - je sais qu'il y a différentes façons de le faire, j'étais juste curieux de savoir si cela était possible.

Les génériques???????
Ma pensée exactement, en fonction de ce que foo est en réalité. foo.GetColumnValues<int>(dm.mainColumn) peut être le chemin à parcourir.
Comme je l'ai dit, je me rends compte il y a d'autres façons de le faire (indicateur booléen, médicaments génériques, en substitution de la méthode), je me demandais si il était possible en tant que paramètre.
Je ne comprends pas la question si vous savez que vous pouvez aussi remplacer la méthode, l'utilisation des génériques, etc, et vous savez qu'il y a différentes façons de le faire, vous étiez juste curieux de savoir si c'était possible". Donc, vous savez tout cela, mais vous êtes curieux de savoir si c'est possible???
dans la forme que je décris. c'est à dire en 2ème paramètre. Comme il s'avère, Reed a un peu dit ce que j'étais après - lorsque vous utilisez (..., de Type type). C'est ce que je cherchais.
Bonne question, upvoted, je vois MS en utilisant le Type des paramètres intégrés dans les opérateurs dans VB.NET par exemple, trycast, et ont souvent souhaité que je pouvais le faire moi-même en C#/VB - dans la mode que vous décrivez.

InformationsquelleAutor Mark Mayo | 2012-06-08

c#methods parameters types

171

Il y a deux méthodes courantes. Tout d'abord, vous pouvez passer System.Type
```
object GetColumnValue(string columnName, Type type)
{
    //Here, you can check specific types, as needed:

    if (type == typeof(int)) { //...
```
Ce serait appelé comme: int val = (int)GetColumnValue(columnName, typeof(int));

L'autre option serait d'utiliser des génériques:
```
T GetColumnValue<T>(string columnName)
{
    //If you need the type, you can use typeof(T)...
```
Cela a l'avantage d'éviter la boxe et le type de sécurité, et serait appelé comme: int val = GetColumnValue<int>(columnName);
- Vous pouvez également faire une méthode d'extension, public static T GetColumnValue<T>(cette chaîne columnName){...} alors vous pouvez dire foo.GetColumnValues<string>(dm.mainColumn)
- Mais comment définir une méthode qui a plusieurs arguments et l'un d'eux doit être un générique? Depuis le générique est défini avant la méthode de la liste d'arguments, comment savez-vous que l'on devrait l'être générique, alors?
- Foo<T,U>(string arg1, U arg2) ou similaire
- Lors de l'utilisation de la première approche, est-il possible d'attribuer une valeur par défaut pour le type? (par exemple, quelque chose comme object GetColumnValue(string columnName, Type type = object)? Qui n'est pas tout semble fonctionner pour moi mais il serait utile de connaître.
InformationsquelleAutor Reed Copsey
16

foo.GetColumnValues(dm.mainColumn, typeof(string))

Sinon, vous pouvez utiliser une méthode générique:
```
public void GetColumnValues<T>(object mainColumn)
{
    GetColumnValues(mainColumn, typeof(T));
}
```
et vous pouvez ensuite l'utiliser comme:
```
foo.GetColumnValues<string>(dm.mainColumn);
```
InformationsquelleAutor Peter Ritchie
11

Vous pouvez passer d'un type comme un argument, mais pour ce faire, vous devez utiliser typeof:
```
foo.GetColumnValues(dm.mainColumn, typeof(int))
```
La méthode devra accepter un paramètre de type Type.

où la GetColumns méthode appelle une méthode différente à l'intérieur en fonction du type passé.

Si vous voulez que ce comportement alors vous ne devriez pas passer le type d'un argument, mais au lieu d'utiliser un paramètre de type.
```
foo.GetColumnValues<int>(dm.mainColumn)
```
- Pourquoi le downvote?
- Upvote pour compenser le downvote 🙂
InformationsquelleAutor Mark Byers
8
```
foo.GetColumnValues(dm.mainColumn, typeof(int));
foo.GetColumnValues(dm.mainColumn, typeof(string));
```
Ou l'utilisation de génériques:
```
foo.GetColumnValues<int>(dm.mainColumn);
foo.GetColumnValues<string>(dm.mainColumn);
```
- Quelle est la voix vers le bas pour?
- Je n'ai pas dv vous, mais c'est probablement parce que vous êtes en montrant comment il serait appelé et n'a pas de préciser la définition de la fonction
- Je déteste quand les gens ont besoin de la cuiller. La réponse + une très brève lecture de MSDN est assez. Je soupçonne que les électeurs sont answerers concurrence de rep - comment la petite.
- Upvote pour compenser le downvote 🙂
InformationsquelleAutor Danny Varod
1

Vous pouvez faire cela, il suffit de l'envelopper dans typeof()
```
foo.GetColumnValues(typeof(int))

public void GetColumnValues(Type type)
{
    //logic
}
```
InformationsquelleAutor Kevin DiTraglia
0

Vous pouvez utiliser un argument de type type - oie, passer typeof(int). Vous pouvez également utiliser des génériques pour un (probablement la plus efficace) approche.

InformationsquelleAutor 500 - Internal Server Error

Vous devez vous connecter pour publier un commentaire.