.Net WebServices et arguments out / ref WebMethod

J'ai reçu de la documentation à partir de l'un de nos fournisseurs pour un webservice ils publient et ils sont très précis sur l'une de leurs WebMethods qu'un argument a le modificateur(? pas sûr si c'est le bon descripteur), par exemple, considérer les points suivants WebMethod signature:

[WebMethod]
public void HelloWorld(out string strVal) 
{ 
    strVal = "Hello World";
}

[Évidemment la méthode n'est pas un Hello World méthode]

Maintenant, je n'avais jamais considéré comme la conception d'un WebMethod avec un/ref argument et il m'a demande pourquoi ils ne l'avons utilisé.

Essayer de comprendre l'application de cette décision de conception, j'ai jeté un prototype avec un peu de basic Bonjour tout le Monde, le style de webmethods...un avec un seul argument de type chaîne, une avec deux arguments de chaîne et qui ne reçoivent pas d'arguments, mais retourne une chaîne de caractères.

Sur essayer de référencer mon webmethods à partir d'une autre application, je remarque que j'ai pour accéder à la méthode avec le seul argument de type chaîne exactement comme si je l'avais défini la méthode à la sortie de la chaîne de sorte que, en effet, aussi loin que le client est concerné:

public string HelloWorld1()
{
  return "Hello World";
}

public void HelloWorld2(out string strVal)
{
  strVal = "Hello World";
}

sont exactement les mêmes...dans ce que j'ai à faire référence à la fois en tant que tel [où x est remplacé par de la bonne méthode]:

string val = HelloWorldX();

Avoir tenté de référence les méthodes de la façon dont je voudrais y accéder s'ils n'étaient pas des méthodes web [comme]:

string val = string.Empty;
MyService1.HelloWorld(out val);
Console.WriteLine(val);

ce qui provoque une erreur de compilation indiquant qu'aucun des arguments de méthode accepter 1 entrée. Pourquoi est-ce? Il y a évidemment une méthode web qui accepte un argument - je suis à la recherche d' [HelloWorld2].

Lors de l'examen de la SAVON de réponses, j'ai remarqué que le contenu de la réponse pour HelloWorld1 est:

<HelloWorld1Response xmlns="http://tempuri.org/">
  <HelloWorld1Result>string</HelloWorld1Result>
</HelloWorld1Response>

Et HelloWorld2 est

<HelloWorld2Response xmlns="http://tempuri.org/">
  <strVal>string</strVal>
</HelloWorld2Response>

Allant plus loin que je pensais, ce que si j'ai 2 ref arguments...

public void HelloWorld3(out string strVal1, out string strVal2)
{
    strVal1 = "Hello World";
    strVal2 = "Hello World Again!";
}

Cela génère de la teneur en SAVON:

<HelloWorld3Response xmlns="http://tempuri.org/">
  <strVal1>string</strVal1>
  <strVal2>string</strVal2>
</HelloWorld3Response>

Je pensais juste assez, donc théoriquement [fournir je peux trouver un moyen de passer/ref arguments de WebMethods] cela signifie que je peux juste passer dans deux arguments qui peuvent être définies par la méthode, mais quand je fais ceci:

string val1 = string.Empty;
string val2 = string.Empty;
MyService1.HelloWorld3(out val1,out val2);
Console.WriteLine(val1);
Console.WriteLine(val2);

Je devrais obtenir la même erreur de compilation que j'ai vu quand j'ai essayé de faire référence à la HelloWorld2 de cette façon. À l'exception évidente qu'elle se plaint de 2 arguments au lieu de 1 [et en fait je fais la même exception, je l'ai testé].

Ce qui donne?
Est-il une raison ou une façon d'utiliser/ref arguments en WebMethods que je suis absent?
Si il y a, comment dois-je faire référence WebMethods avec plusieurs/ref arguments?

source d'informationauteur BenAlabaster

.net c#vb.net web-services

15

Euh... je ne sais pas quel protocole est utilisé pour apporter des réponses à vos propres questions, mais l'article référencé par Steven Behnke a fourni quelques indices pour moi d'en déduire une solution à cette situation bizarre, et plutôt que de laisser tout le monde de comprendre ce que seront les conséquences, je pensais que je voudrais partager mes découvertes...

À envisager la suite webmethods définie dans mon WebService
```
[WebMethod]
public string Method1()
{
    return "This is my return value";
}

[WebMethod]
public void Method2(out string strVal1)
{
    strVal1 = "This is my value passed as an output";
    //No return value
}

[WebMethod]
public void Method3(out string strVal1, out string strVal2)
{
    strVal1 = "This is my strVal1 value passed as an output";
    strVal2 = "This is my strVal2 value passed as an output";
    //No return value
}

[WebMethod]
public string Method4(out string strVal1, out string strVal2)
{
    strVal1 = "This is my strVal1 value passed as an output";
    strVal2 = "This is my strVal2 value passed as an output";
    return "This is my return value";
}
```
Maintenant...selon le document, le premier paramètre défini comme, si la méthode renvoie la valeur nulle, alors le premier paramètre est automatiquement utilisé comme paramètre de retour. Donc, je voudrais accéder à chacune de mes méthodes comme suit:

Method1: public string Method1() {}
```
var str = svc.Method1();
Console.WriteLine(str);
```
Method2: public void Method2(hors chaîne strVal1) {}
```
var str = svc.Method2();
Console.WriteLine(str);
```
De sorte que vous pouvez y accéder à la fois exactement de la même façon...ce qui est extrêmement déroutant. Qui sur la terre ne figure que, sans avoir été informé que par quelqu'un d'autre? C'est au-delà de ma compréhension de la façon dont cela pourrait être une bonne idée...

Method3: public void Method3(hors chaîne strVal1, chaîne strVal) {}
```
var str2 = String.Empty;
var str1 = svc.Method3(out str2);
Console.WriteLine(str1);
Console.WriteLine(str2);
```
Method4: public string Method4(hors chaîne strVal1, chaîne strVal2) {}
```
var str1 = String.Empty;
var str2 = String.Empty;
var str3 = svc.Method4(out str1, out str2);
Console.WriteLine(str1);
Console.WriteLine(str2);
Console.WriteLine(str3);
```
Donc, comme vous le remarquez - si la signature de la méthode ne fournit pas une valeur de retour (void], puis le premier param devient la valeur de retour. Si elle dispose déjà d'un retour de la valeur, alors il n'a pas.

Cela peut être extrêmement déroutant pour quelqu'un qui n'est pas venu à travers ce document. Merci de fournir le lien Steven - j'ai vraiment l'apprécier.

...et à qui a décidé que le modèle de conception était une bonne idée d'être écrite dans le .NET Framework - je ne peux pas penser à ce qui se serait possédée vous de penser que c'était une bonne idée... je n'aime vraiment pas vous assez intensément après tout que.

ADDENDUM:

Ce que je ne viens de réaliser, c'est que pour ajouter à la confusion, si vous utilisez ref au lieu de hors alors vous ne pas ce faire, vous devez traiter le WebMethods exactement comme vous l'auriez si vous aviez utilisé pour appeler une méthode régulière à l'intérieur de votre demande:
```
[WebMethod()]
public void Method3(ref string strVal1, ref string strVal2)
{
    strVal1 = "First argument return value";
    strVal2 = "Second argument return value";
}
```
D'appeler maintenant que vous pouvez utiliser:
```
string val1 = String.Empty;
string val2 = String.Empty;
svc.Method3(ref val1, ref val2);
Console.WriteLine(val1);
Console.WriteLine(val2);
```
Cette incohérence est aberrant...le fait que c'est par la conception est incompréhensible pour moi.
2

Peut-être que cela aidera à:

http://kbalertz.com/322624/Proxy-Class-First-Parameter-Service-Method-Returns-Return-Value-Reference.aspx

Ma partie préférée est:

STATUT

Ce comportement est par la conception.

Vous devez vous connecter pour publier un commentaire.