Formattazione di HTTP Web WCF
Il modello di programmazione HTTP Web WCF consente di determinare in modo dinamico il formato migliore in cui un'operazione di servizio debba restituire la risposta. Vengono supportati due metodi per determinare un formato appropriato: automatico ed esplicito.
Formattazione automatica
Se abilitata, la formattazione automatica sceglie il formato migliore nel quale verrà restituita la risposta, controllando gli elementi seguenti, in ordine:
i tipi di supporto nell'intestazione Accept del messaggio di richiesta;
il valore content-type del messaggio di richiesta;
l'impostazione del formato predefinita nell'operazione;
l'impostazione del formato predefinita in WebHttpBehavior.
Se il messaggio di richiesta contiene un'intestazione Accept, l'infrastruttura di Windows Communication Foundation (WCF) cerca un tipo supportato. Se l'intestazione Accept specifica le priorità per i propri tipi di supporto, queste vengono rispettate. Se non viene individuato alcun formato adatto nell'intestazione Accept, viene utilizzato il valore content-type del messaggio di richiesta. Se non viene specificato alcun valore content-type adatto, viene utilizzata l'impostazione del formato predefinita per l'operazione. Il formato predefinito viene impostato con il parametro ResponseFormat degli attributi WebGetAttribute e WebInvokeAttribute. Se non viene specificato alcun formato predefinito nell'operazione, viene utilizzato il valore della proprietà DefaultOutgoingResponseFormat. La formattazione automatica si basa sulla proprietà AutomaticFormatSelectionEnabled. Se tale proprietà è impostata su true, l'infrastruttura di WCF determina il formato migliore da utilizzare. La selezione automatica del formato è disabilitata per impostazione predefinita per la compatibilità con le versioni precedenti. La selezione automatica del formato automatica può essere abilitata a livello di codice o tramite la configurazione. Nell'esempio seguente viene mostrato come abilitare la selezione automatica del formato nel codice.
// This code assumes the service name is MyService and the service contract is IMyContract
Uri baseAddress = new Uri("https://localhost:8000");
WebServiceHost host = new WebServiceHost(typeof(MyService), baseAddress)
try
{
ServiceEndpoint sep = host.AddServiceEndpoint(typeof(IMyContract), new WebHttpBinding(), "");
// Check it see if the WebHttpBehavior already exists
WebHttpBehavior whb = sep.Behaviors.Find<WebHttpBehavior>();
if (whb != null)
{
whb.AutomaticFormatSelectionEnabled = true;
}
else
{
WebHttpBehavior webBehavior = new WebHttpBehavior();
webBehavior.AutomaticFormatSelectionEnabled = true;
sep.Behaviors.Add(webBehavior);
}
// Open host to start listening for messages
host.Open();
// ...
}
catch(CommunicationException ex)
{
Console.WriteLine(“An exception occurred: “ + ex.Message());
}
La formattazione automatica può inoltre essere abilitata tramite la configurazione. È possibile impostare la proprietà AutomaticFormatSelectionEnabled direttamente nell'elemento WebHttpBehavior o mediante l'elemento WebHttpEndpoint. Nell'esempio seguente viene indicato come abilitare la selezione automatica del formato nell'elemento WebHttpBehavior.
<system.serviceModel>
<behaviors>
<endpointBehaviors>
<behavior>
<webHttp automaticFormatSelectionEnabled="true" />
</behavior>
</endpointBehaviors>
</behaviors>
<standardEndpoints>
<webHttpEndpoint>
<!-- the "" standard endpoint is used by WebServiceHost for auto creating a web endpoint. -->
<standardEndpoint name="" helpEnabled="true" />
</webHttpEndpoint>
</standardEndpoints>
</system.serviceModel>
Nell'esempio seguente viene mostrato come abilitare la selezione automatica del formato mediante WebHttpEndpoint.
<system.serviceModel>
<standardEndpoints>
<webHttpEndpoint>
<!-- the "" standard endpoint is used by WebServiceHost for auto creating a web endpoint. -->
<standardEndpoint name="" helpEnabled="true" automaticFormatSelectionEnabled="true" />
</webHttpEndpoint>
</standardEndpoints>
</system.serviceModel>
Formattazione esplicita
Come indicato nel nome, nella formattazione esplicita lo sviluppatore determina il formato migliore da utilizzare all'interno del codice operativo. Se il formato migliore è XML o JSON, lo sviluppatore imposta Format su Xml o Json. Se la proprietà Format non è impostata in modo esplicito, viene utilizzato il formato predefinito dell'operazione.
Nell'esempio seguente viene verificato il parametro della stringa di query di formato per un formato da utilizzare. Se è stato specificato, viene impostato il formato dell'operazione mediante Format.
public class Service : IService
{
[WebGet]
public string EchoWithGet(string s)
{
// if a format query string parameter has been specified, set the response format to that. If no such
// query string parameter exists the Accept header will be used
string formatQueryStringValue = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
if (!string.IsNullOrEmpty(formatQueryStringValue))
{
if (formatQueryStringValue.Equals("xml", System.StringComparison.OrdinalIgnoreCase))
{
WebOperationContext.Current.OutgoingResponse.Format = WebMessageFormat.Xml;
}
else if (formatQueryStringValue.Equals("json", System.StringComparison.OrdinalIgnoreCase))
{
WebOperationContext.Current.OutgoingResponse.Format = WebMessageFormat.Json;
}
else
{
throw new WebFaultException<string>(string.Format("Unsupported format '{0}'", formatQueryStringValue), HttpStatusCode.BadRequest);
}
}
return "You said " + s;
}
Se è necessario supportare formati diversi da XML o JSON, definire l'operazione per ottenere un tipo restituito di Message. All'interno del codice operativo, determinare il formato appropriato da utilizzare e creare quindi un oggetto Message utilizzando uno dei metodi seguenti:
WebOperationContext.CreateAtom10ResponseWebOperationContext.CreateJsonResponseWebOperationContext.CreateStreamResponseWebOperationContext.CreateTextResponseWebOperationContext.CreateXmlResponse
Ognuno di questi metodi utilizza il contenuto e crea un messaggio con il formato appropriato. Il metodo WebOperationContext.Current.IncomingRequest.GetAcceptHeaderElements può essere utilizzato per ottenere un elenco di formati preferiti dal client in ordine di preferenza decrescente. Nell'esempio seguente viene indicato come utilizzare WebOperationContext.Current.IncomingRequest.GetAcceptHeaderElements per determinare il formato da utilizzare e viene quindi impiegato il metodo di risposta di creazione appropriato per creare il messaggio di risposta.
public class Service : IService
{
public Message EchoListWithGet(string list)
{
List<string> returnList = new List<string>(list.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
IList<ContentType> acceptHeaderElements = WebOperationContext.Current.IncomingRequest.GetAcceptHeaderElements();
for (int x = 0; x < acceptHeaderElements.Count; x++)
{
string normalizedMediaType = acceptHeaderElements[x].MediaType.ToLowerInvariant();
switch (normalizedMediaType)
{
case "image/jpeg": return CreateJpegResponse(returnList);
case "application/xhtml+xml": return CreateXhtmlResponse(returnList);
case "application/atom+xml": return CreateAtom10Response(returnList);
case "application/xml": return CreateXmlResponse(returnList);
case "application/json": return CreateJsonResponse(returnList);
}
}
// Default response format is XML
return CreateXmlResponse(returnList);
}
}
Vedere anche
Riferimento
Concetti
UriTemplate e UriTemplateTable
Panoramica sul modello di programmazione HTTP Web WCF
Modello a oggetti per la programmazione HTTP Web di WCF