mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
433 lines
22 KiB
C#
433 lines
22 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="WebReferenceOptions.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Services.Description {
|
|
using System;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.ComponentModel;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.Xml.Serialization;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlType("webReferenceOptions", Namespace = WebReferenceOptions.TargetNamespace)]
|
|
[XmlRoot("webReferenceOptions", Namespace = WebReferenceOptions.TargetNamespace)]
|
|
public class WebReferenceOptions {
|
|
public const string TargetNamespace = "http://microsoft.com/webReference/";
|
|
static XmlSchema schema = null;
|
|
CodeGenerationOptions codeGenerationOptions = CodeGenerationOptions.GenerateOldAsync;
|
|
ServiceDescriptionImportStyle style = ServiceDescriptionImportStyle.Client;
|
|
StringCollection schemaImporterExtensions;
|
|
bool verbose;
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions.CodeGenerationOptions"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlElement("codeGenerationOptions")]
|
|
[DefaultValue(CodeGenerationOptions.GenerateOldAsync)]
|
|
public CodeGenerationOptions CodeGenerationOptions {
|
|
get {
|
|
return codeGenerationOptions;
|
|
}
|
|
set {
|
|
codeGenerationOptions = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions.SchemaImporterExtensions"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlArray("schemaImporterExtensions")]
|
|
[XmlArrayItem("type")]
|
|
public StringCollection SchemaImporterExtensions {
|
|
get {
|
|
if (schemaImporterExtensions == null)
|
|
schemaImporterExtensions = new StringCollection();
|
|
return schemaImporterExtensions;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions.Style"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[DefaultValue(ServiceDescriptionImportStyle.Client)]
|
|
[XmlElement("style")]
|
|
public ServiceDescriptionImportStyle Style {
|
|
get {
|
|
return style;
|
|
}
|
|
set {
|
|
style = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions.Verbose"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlElement("verbose")]
|
|
public bool Verbose {
|
|
get {
|
|
return verbose;
|
|
}
|
|
set {
|
|
verbose = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions.Schema"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public static XmlSchema Schema {
|
|
get {
|
|
if (schema == null) {
|
|
schema = XmlSchema.Read(new StringReader(Schemas.WebRef), null);
|
|
}
|
|
return schema;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions.Read"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public static WebReferenceOptions Read(TextReader reader, ValidationEventHandler validationEventHandler) {
|
|
XmlTextReader readerNew = new XmlTextReader(reader);
|
|
readerNew.XmlResolver = null;
|
|
readerNew.DtdProcessing = DtdProcessing.Prohibit;
|
|
return Read(readerNew, validationEventHandler);
|
|
}
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="WebReferenceOptions.Read1"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public static WebReferenceOptions Read(Stream stream, ValidationEventHandler validationEventHandler) {
|
|
XmlTextReader readerNew = new XmlTextReader(stream);
|
|
readerNew.XmlResolver = null;
|
|
readerNew.DtdProcessing = DtdProcessing.Prohibit;
|
|
return Read(readerNew, validationEventHandler);
|
|
}
|
|
|
|
/// <include file='doc\WebReferenceOptions.uex' path='docs/doc[@for="XmlSchema.Read2"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler) {
|
|
XmlValidatingReader validatingReader = new XmlValidatingReader(xmlReader);
|
|
validatingReader.ValidationType = ValidationType.Schema;
|
|
if (validationEventHandler != null) {
|
|
validatingReader.ValidationEventHandler += validationEventHandler;
|
|
}
|
|
else {
|
|
validatingReader.ValidationEventHandler += new ValidationEventHandler(SchemaValidationHandler);
|
|
}
|
|
validatingReader.Schemas.Add(Schema);
|
|
webReferenceOptionsSerializer ser = new webReferenceOptionsSerializer();
|
|
try {
|
|
return (WebReferenceOptions)ser.Deserialize(validatingReader);
|
|
}
|
|
catch (Exception e) {
|
|
throw e;
|
|
}
|
|
finally {
|
|
validatingReader.Close();
|
|
}
|
|
}
|
|
|
|
private static void SchemaValidationHandler(object sender, ValidationEventArgs args) {
|
|
if (args.Severity != XmlSeverityType.Error)
|
|
return;
|
|
throw new InvalidOperationException(Res.GetString(Res.WsdlInstanceValidationDetails, args.Message, args.Exception.LineNumber.ToString(CultureInfo.InvariantCulture), args.Exception.LinePosition.ToString(CultureInfo.InvariantCulture)));
|
|
}
|
|
}
|
|
|
|
internal class WebReferenceOptionsSerializationWriter : XmlSerializationWriter {
|
|
string Write1_CodeGenerationOptions(System.Xml.Serialization.CodeGenerationOptions v) {
|
|
string s = null;
|
|
switch (v) {
|
|
case System.Xml.Serialization.CodeGenerationOptions.@GenerateProperties: s = @"properties"; break;
|
|
case System.Xml.Serialization.CodeGenerationOptions.@GenerateNewAsync: s = @"newAsync"; break;
|
|
case System.Xml.Serialization.CodeGenerationOptions.@GenerateOldAsync: s = @"oldAsync"; break;
|
|
case System.Xml.Serialization.CodeGenerationOptions.@GenerateOrder: s = @"order"; break;
|
|
case System.Xml.Serialization.CodeGenerationOptions.@EnableDataBinding: s = @"enableDataBinding"; break;
|
|
default: s = FromEnum(((System.Int64)v), new string[] { @"properties",
|
|
@"newAsync",
|
|
@"oldAsync",
|
|
@"order",
|
|
@"enableDataBinding" }, new System.Int64[] { (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateProperties,
|
|
(long)System.Xml.Serialization.CodeGenerationOptions.@GenerateNewAsync,
|
|
(long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOldAsync,
|
|
(long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOrder,
|
|
(long)System.Xml.Serialization.CodeGenerationOptions.@EnableDataBinding }, @"System.Xml.Serialization.CodeGenerationOptions"); break;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
string Write2_ServiceDescriptionImportStyle(System.Web.Services.Description.ServiceDescriptionImportStyle v) {
|
|
string s = null;
|
|
switch (v) {
|
|
case System.Web.Services.Description.ServiceDescriptionImportStyle.@Client: s = @"client"; break;
|
|
case System.Web.Services.Description.ServiceDescriptionImportStyle.@Server: s = @"server"; break;
|
|
case System.Web.Services.Description.ServiceDescriptionImportStyle.@ServerInterface: s = @"serverInterface"; break;
|
|
default: throw CreateInvalidEnumValueException(((System.Int64)v).ToString(System.Globalization.CultureInfo.InvariantCulture), @"System.Web.Services.Description.ServiceDescriptionImportStyle");
|
|
}
|
|
return s;
|
|
}
|
|
|
|
void Write4_WebReferenceOptions(string n, string ns, WebReferenceOptions o, bool isNullable, bool needType) {
|
|
if ((object)o == null) {
|
|
if (isNullable) WriteNullTagLiteral(n, ns);
|
|
return;
|
|
}
|
|
if (!needType) {
|
|
System.Type t = o.GetType();
|
|
if (t == typeof(WebReferenceOptions)) {
|
|
}
|
|
else {
|
|
throw CreateUnknownTypeException(o);
|
|
}
|
|
}
|
|
EscapeName = false;
|
|
WriteStartElement(n, ns, o);
|
|
if (needType) WriteXsiType(@"webReferenceOptions", @"http://microsoft.com/webReference/");
|
|
if (((CodeGenerationOptions)o.@CodeGenerationOptions) != (CodeGenerationOptions.@GenerateOldAsync)) {
|
|
WriteElementString(@"codeGenerationOptions", @"http://microsoft.com/webReference/", Write1_CodeGenerationOptions(((CodeGenerationOptions)o.@CodeGenerationOptions)));
|
|
} {
|
|
System.Collections.Specialized.StringCollection a = (System.Collections.Specialized.StringCollection)((System.Collections.Specialized.StringCollection)o.@SchemaImporterExtensions);
|
|
if (a != null) {
|
|
WriteStartElement(@"schemaImporterExtensions", @"http://microsoft.com/webReference/");
|
|
for (int ia = 0; ia < a.Count; ia++) {
|
|
WriteNullableStringLiteral(@"type", @"http://microsoft.com/webReference/", ((System.String)a[ia]));
|
|
}
|
|
WriteEndElement();
|
|
}
|
|
}
|
|
if (((System.Web.Services.Description.ServiceDescriptionImportStyle)o.@Style) != System.Web.Services.Description.ServiceDescriptionImportStyle.@Client) {
|
|
WriteElementString(@"style", @"http://microsoft.com/webReference/", Write2_ServiceDescriptionImportStyle(((System.Web.Services.Description.ServiceDescriptionImportStyle)o.@Style)));
|
|
}
|
|
WriteElementStringRaw(@"verbose", @"http://microsoft.com/webReference/", System.Xml.XmlConvert.ToString((System.Boolean)((System.Boolean)o.@Verbose)));
|
|
WriteEndElement(o);
|
|
}
|
|
|
|
protected override void InitCallbacks() {
|
|
}
|
|
|
|
internal void Write5_webReferenceOptions(object o) {
|
|
WriteStartDocument();
|
|
if (o == null) {
|
|
WriteNullTagLiteral(@"webReferenceOptions", @"http://microsoft.com/webReference/");
|
|
return;
|
|
}
|
|
TopLevelElement();
|
|
Write4_WebReferenceOptions(@"webReferenceOptions", @"http://microsoft.com/webReference/", ((System.Web.Services.Description.WebReferenceOptions)o), true, false);
|
|
}
|
|
}
|
|
|
|
internal class WebReferenceOptionsSerializationReader : XmlSerializationReader {
|
|
System.Collections.Hashtable _CodeGenerationOptionsValues;
|
|
|
|
internal System.Collections.Hashtable CodeGenerationOptionsValues {
|
|
get {
|
|
if ((object)_CodeGenerationOptionsValues == null) {
|
|
System.Collections.Hashtable h = new System.Collections.Hashtable();
|
|
h.Add(@"properties", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateProperties);
|
|
h.Add(@"newAsync", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateNewAsync);
|
|
h.Add(@"oldAsync", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOldAsync);
|
|
h.Add(@"order", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOrder);
|
|
h.Add(@"enableDataBinding", (long)System.Xml.Serialization.CodeGenerationOptions.@EnableDataBinding);
|
|
_CodeGenerationOptionsValues = h;
|
|
}
|
|
return _CodeGenerationOptionsValues;
|
|
}
|
|
}
|
|
|
|
System.Xml.Serialization.CodeGenerationOptions Read1_CodeGenerationOptions(string s) {
|
|
return (System.Xml.Serialization.CodeGenerationOptions)ToEnum(s, CodeGenerationOptionsValues, @"System.Xml.Serialization.CodeGenerationOptions");
|
|
}
|
|
|
|
System.Web.Services.Description.ServiceDescriptionImportStyle Read2_ServiceDescriptionImportStyle(string s) {
|
|
switch (s) {
|
|
case @"client": return System.Web.Services.Description.ServiceDescriptionImportStyle.@Client;
|
|
case @"server": return System.Web.Services.Description.ServiceDescriptionImportStyle.@Server;
|
|
case @"serverInterface": return System.Web.Services.Description.ServiceDescriptionImportStyle.@ServerInterface;
|
|
default: throw CreateUnknownConstantException(s, typeof(System.Web.Services.Description.ServiceDescriptionImportStyle));
|
|
}
|
|
}
|
|
|
|
System.Web.Services.Description.WebReferenceOptions Read4_WebReferenceOptions(bool isNullable, bool checkType) {
|
|
System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null;
|
|
bool isNull = false;
|
|
if (isNullable) isNull = ReadNull();
|
|
if (checkType) {
|
|
if (xsiType == null || ((object)((System.Xml.XmlQualifiedName)xsiType).Name == (object)id1_webReferenceOptions && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) {
|
|
}
|
|
else
|
|
throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType);
|
|
}
|
|
if (isNull) return null;
|
|
System.Web.Services.Description.WebReferenceOptions o;
|
|
o = new System.Web.Services.Description.WebReferenceOptions();
|
|
System.Collections.Specialized.StringCollection a_1 = (System.Collections.Specialized.StringCollection)o.@SchemaImporterExtensions;
|
|
bool[] paramsRead = new bool[4];
|
|
while (Reader.MoveToNextAttribute()) {
|
|
if (!IsXmlnsAttribute(Reader.Name)) {
|
|
UnknownNode((object)o);
|
|
}
|
|
}
|
|
Reader.MoveToElement();
|
|
if (Reader.IsEmptyElement) {
|
|
Reader.Skip();
|
|
return o;
|
|
}
|
|
Reader.ReadStartElement();
|
|
Reader.MoveToContent();
|
|
int whileIterations0 = 0;
|
|
int readerCount0 = ReaderCount;
|
|
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) {
|
|
if (Reader.NodeType == System.Xml.XmlNodeType.Element) {
|
|
if (!paramsRead[0] && ((object) Reader.LocalName == (object)id3_codeGenerationOptions && (object) Reader.NamespaceURI == (object)id2_Item)) {
|
|
if (Reader.IsEmptyElement) {
|
|
Reader.Skip();
|
|
}
|
|
else {
|
|
o.@CodeGenerationOptions = Read1_CodeGenerationOptions(Reader.ReadElementString());
|
|
}
|
|
paramsRead[0] = true;
|
|
}
|
|
else if (((object) Reader.LocalName == (object)id4_schemaImporterExtensions && (object) Reader.NamespaceURI == (object)id2_Item)) {
|
|
if (!ReadNull()) {
|
|
System.Collections.Specialized.StringCollection a_1_0 = (System.Collections.Specialized.StringCollection)o.@SchemaImporterExtensions;
|
|
if (((object)(a_1_0) == null) || (Reader.IsEmptyElement)) {
|
|
Reader.Skip();
|
|
}
|
|
else {
|
|
Reader.ReadStartElement();
|
|
Reader.MoveToContent();
|
|
int whileIterations1 = 0;
|
|
int readerCount1 = ReaderCount;
|
|
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) {
|
|
if (Reader.NodeType == System.Xml.XmlNodeType.Element) {
|
|
if (((object) Reader.LocalName == (object)id5_type && (object) Reader.NamespaceURI == (object)id2_Item)) {
|
|
if (ReadNull()) {
|
|
a_1_0.Add(null);
|
|
}
|
|
else {
|
|
a_1_0.Add(Reader.ReadElementString());
|
|
}
|
|
}
|
|
else {
|
|
UnknownNode(null, @"http://microsoft.com/webReference/:type");
|
|
}
|
|
}
|
|
else {
|
|
UnknownNode(null, @"http://microsoft.com/webReference/:type");
|
|
}
|
|
Reader.MoveToContent();
|
|
CheckReaderCount(ref whileIterations1, ref readerCount1);
|
|
}
|
|
ReadEndElement();
|
|
}
|
|
}
|
|
}
|
|
else if (!paramsRead[2] && ((object) Reader.LocalName == (object)id6_style && (object) Reader.NamespaceURI == (object)id2_Item)) {
|
|
if (Reader.IsEmptyElement) {
|
|
Reader.Skip();
|
|
}
|
|
else {
|
|
o.@Style = Read2_ServiceDescriptionImportStyle(Reader.ReadElementString());
|
|
}
|
|
paramsRead[2] = true;
|
|
}
|
|
else if (!paramsRead[3] && ((object) Reader.LocalName == (object)id7_verbose && (object) Reader.NamespaceURI == (object)id2_Item)) {
|
|
{
|
|
o.@Verbose = System.Xml.XmlConvert.ToBoolean(Reader.ReadElementString());
|
|
}
|
|
paramsRead[3] = true;
|
|
}
|
|
else {
|
|
UnknownNode((object)o, @"http://microsoft.com/webReference/:codeGenerationOptions, http://microsoft.com/webReference/:schemaImporterExtensions, http://microsoft.com/webReference/:style, http://microsoft.com/webReference/:verbose");
|
|
}
|
|
}
|
|
else {
|
|
UnknownNode((object)o, @"http://microsoft.com/webReference/:codeGenerationOptions, http://microsoft.com/webReference/:schemaImporterExtensions, http://microsoft.com/webReference/:style, http://microsoft.com/webReference/:verbose");
|
|
}
|
|
Reader.MoveToContent();
|
|
CheckReaderCount(ref whileIterations0, ref readerCount0);
|
|
}
|
|
ReadEndElement();
|
|
return o;
|
|
}
|
|
|
|
protected override void InitCallbacks() {
|
|
}
|
|
|
|
internal object Read5_webReferenceOptions() {
|
|
object o = null;
|
|
Reader.MoveToContent();
|
|
if (Reader.NodeType == System.Xml.XmlNodeType.Element) {
|
|
if (((object) Reader.LocalName == (object)id1_webReferenceOptions && (object) Reader.NamespaceURI == (object)id2_Item)) {
|
|
o = Read4_WebReferenceOptions(true, true);
|
|
}
|
|
else {
|
|
throw CreateUnknownNodeException();
|
|
}
|
|
}
|
|
else {
|
|
UnknownNode(null, @"http://microsoft.com/webReference/:webReferenceOptions");
|
|
}
|
|
return (object)o;
|
|
}
|
|
|
|
string id2_Item;
|
|
string id5_type;
|
|
string id4_schemaImporterExtensions;
|
|
string id3_codeGenerationOptions;
|
|
string id6_style;
|
|
string id7_verbose;
|
|
string id1_webReferenceOptions;
|
|
|
|
protected override void InitIDs() {
|
|
id2_Item = Reader.NameTable.Add(@"http://microsoft.com/webReference/");
|
|
id5_type = Reader.NameTable.Add(@"type");
|
|
id4_schemaImporterExtensions = Reader.NameTable.Add(@"schemaImporterExtensions");
|
|
id3_codeGenerationOptions = Reader.NameTable.Add(@"codeGenerationOptions");
|
|
id6_style = Reader.NameTable.Add(@"style");
|
|
id7_verbose = Reader.NameTable.Add(@"verbose");
|
|
id1_webReferenceOptions = Reader.NameTable.Add(@"webReferenceOptions");
|
|
}
|
|
}
|
|
|
|
internal sealed class webReferenceOptionsSerializer : XmlSerializer {
|
|
protected override XmlSerializationReader CreateReader() {
|
|
return new WebReferenceOptionsSerializationReader();
|
|
}
|
|
protected override XmlSerializationWriter CreateWriter() {
|
|
return new WebReferenceOptionsSerializationWriter();
|
|
}
|
|
public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) {
|
|
return true;
|
|
}
|
|
|
|
protected override void Serialize(System.Object objectToSerialize, XmlSerializationWriter writer) {
|
|
((WebReferenceOptionsSerializationWriter)writer).Write5_webReferenceOptions(objectToSerialize);
|
|
}
|
|
protected override System.Object Deserialize(XmlSerializationReader reader) {
|
|
return ((WebReferenceOptionsSerializationReader)reader).Read5_webReferenceOptions();
|
|
}
|
|
}
|
|
}
|