WsReadValue-Funktion (webservices.h)

Liest Text aus einem Reader und analysiert ihn entsprechend dem angegebenen Werttyp.

Der Reader liest von seiner aktuellen Position bis zum nächsten Start- oder End-Element und analysiert sie entsprechend dem angegebenen Werttyp. Wenn der Reader bereits auf einem Start- oder End-Element positioniert ist, bleibt der Puffer leer.

Kommentare werden übersprungen, und CDATA-Inhalte werden genauso behandelt wie andere Elementinhalte.

Führende und nachfolgende Leerzeichen werden ignoriert. Wenn der Wert nicht gemäß dem angegebenen Werttyp analysiert werden kann, gibt die Funktion einen WS_E_INVALID_FORMAT Fehlercode zurück. (Siehe Rückgabewerte für Windows-Webdienste.)

Syntax

HRESULT WsReadValue(
  [in]           WS_XML_READER *reader,
  [in]           WS_VALUE_TYPE valueType,
                 void          *value,
  [in]           ULONG         valueSize,
  [in, optional] WS_ERROR      *error
);

Parameter

[in] reader

Ein Zeiger auf den XML-Reader , aus dem der Wert gelesen wird.

[in] valueType

Der Textinterpretationstyp.

value

Ein Zeiger auf die analysierten Daten, wenn die Analyse gemäß dem angegebenen Werttyp erfolgreich war. Die erforderliche Größe wird durch den Werttyp bestimmt. Weitere Informationen finden Sie unter WS_VALUE_TYPE .

[in] valueSize

Die Bytegröße des abgerufenen Werts.

[in, optional] error

Ein Zeiger auf ein WS_ERROR-Objekt , in dem zusätzliche Informationen zum Fehler gespeichert werden sollen, wenn die Funktion fehlschlägt.

Rückgabewert

Diese Funktion kann einen dieser Werte zurückgeben.

Hinweise

Ein Beispiel, das ein Element liest, das einen ganzzahligen Wert enthält.

// Advance the reader to the element
HRESULT hr = WsReadToStartElement(reader, localName, ns, NULL, error);
if (FAILED(hr))
{
    return hr;
}
// Advance past the element to the content
hr = WsReadStartElement(reader, error);
if (FAILED(hr))
{
    return hr;
}
// Read the content as an integer
__int32 i;
hr = WsReadValue(reader, WS_INT32_VALUE_TYPE, &i, sizeof(i), error);
if (FAILED(hr))
{
    return hr;
}
// Read the end element
hr = WsReadEndElement(reader, error);
if (FAILED(hr))
{
    return hr;
}

Die Grammatik für die Wertetypen.

WS_BOOL_VALUE_TYPE     = "true"
                       | "false"
                       | "1"
                       | "0"
WS_INTxxx_VALUE_TYPE   = sign? digits
WS_UINTxxx_VALUE_TYPE  = digits
WS_FLOAT_VALUE_TYPE    = WS_DOUBLE_VALUE_TYPE
WS_DOUBLE_VALUE_TYPE   = sign? digits ("." digits)? exponent?
                       | "NaN"
                       | "INF"
                       | "-INF"
WS_DECIMAL_VALUE_TYPE  = sign? digits ("." digits)?
WS_GUID_VALUE_TYPE     = xxxxxxxx "-" xxxx "-" xxxx "-" xxxx "-" xxxxxxxxxxxx
WS_TIMESPAN_VALUE_TYPE = sign? (digits ".")? hh ":" mm ":" ss ("." d7)?
WS_DATETIME_VALUE_TYPE = yyyy "-" MM "-" dd "T" hh ":" mm ":" ss  ("." d7)? tz?
WS_DURATION_VALUE_TYPE = sign? "P" (digits "Y")  (digits "M")? (digits "D")?
                       | sign? "P" (digits "Y")? (digits "M")? (digits "D")?
                       | sign? "P" (digits "Y")? (digits "M")? (digits "D") 
                       | sign? "P" (digits "Y")? (digits "M")? (digits "D")? "T" (digits "H")  (digits "M")? (digits ("." digits)? "S")?
                       | sign? "P" (digits "Y")? (digits "M")? (digits "D")? "T" (digits "H")? (digits "M")  (digits ("." digits)? "S")?
                       | sign? "P" (digits "Y")? (digits "M")? (digits "D")? "T" (digits "H")? (digits "M")? (digits ("." digits)? "S")
sign                   = "-"
                       | "+"
exponent               = E sign? digits
                       | e sign? digits
digits                 = [0-9]+
x                      = [0-9]
                       | [A-F]
                       | [a-f]
yyyy                   = 1-9999
hh                     = 0-23
mm                     = 0-59
ss                     = 0-59
MM                     = 1-31
tz                     = "Z"
                       | sign hh ":" mm
d7                     = digit digit? digit? digit? digit? digit? digit?

Anforderungen