class/System.Web.Services/System.Web.Services.Protocols/Fault12Serializer.cs

   1 #if NET_2_0
   2 using System;
   3 using System.Xml;
   4 using System.Xml.Schema;
   5 using System.Xml.Serialization;
   6 using System.Text;
   7 using System.Collections;
   8 using System.Globalization;
   9
  10 namespace System.Web.Services.Protocols
  11 {
  12         internal class Soap12FaultReader : XmlSerializationReader
  13         {
  14                 public object ReadRoot_Soap12Fault ()
  15                 {
  16                         Reader.MoveToContent();
  17                         if (Reader.LocalName != "Fault" || Reader.NamespaceURI != "http://www.w3.org/2003/05/soap-envelope")
  18                                 throw CreateUnknownNodeException();
  19                         return ReadObject_Fault (true, true);
  20                 }
  21
  22                 public System.Web.Services.Protocols.Soap12Fault ReadObject_Fault (bool isNullable, bool checkType)
  23                 {
  24                         System.Web.Services.Protocols.Soap12Fault ob = null;
  25                         if (isNullable && ReadNull()) return null;
  26
  27                         if (checkType)
  28                         {
  29                                 System.Xml.XmlQualifiedName t = GetXsiType();
  30                                 if (t == null)
  31                                 { }
  32                                 else if (t.Name != "Fault" || t.Namespace != "http://www.w3.org/2003/05/soap-envelope")
  33                                         throw CreateUnknownTypeException(t);
  34                         }
  35
  36                         ob = new System.Web.Services.Protocols.Soap12Fault ();
  37
  38                         Reader.MoveToElement();
  39
  40                         while (Reader.MoveToNextAttribute())
  41                         {
  42                                 if (IsXmlnsAttribute (Reader.Name)) {
  43                                 }
  44                                 else {
  45                                         UnknownNode (ob);
  46                                 }
  47                         }
  48
  49                         Reader.MoveToElement();
  50                         if (Reader.IsEmptyElement) {
  51                                 Reader.Skip ();
  52                                 return ob;
  53                         }
  54
  55                         Reader.ReadStartElement();
  56                         Reader.MoveToContent();
  57
  58                         bool b0=false, b1=false, b2=false, b3=false, b4=false;
  59
  60                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
  61                         {
  62                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
  63                                 {
  64                                         if (Reader.LocalName == "Role" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b3) {
  65                                                 b3 = true;
  66                                                 ob.@Role = Reader.ReadElementString ();
  67                                         }
  68                                         else if (Reader.LocalName == "Detail" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b4) {
  69                                                 b4 = true;
  70                                                 ob.@Detail = ReadObject_Detail (false, true);
  71                                         }
  72                                         else if (Reader.LocalName == "Code" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b0) {
  73                                                 b0 = true;
  74                                                 ob.@Code = ReadObject_Code (false, true);
  75                                         }
  76                                         else if (Reader.LocalName == "Node" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b2) {
  77                                                 b2 = true;
  78                                                 ob.@Node = Reader.ReadElementString ();
  79                                         }
  80                                         else if (Reader.LocalName == "Reason" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b1) {
  81                                                 b1 = true;
  82                                                 ob.@Reason = ReadObject_Reason (false, true);
  83                                         }
  84                                         else {
  85                                                 UnknownNode (ob);
  86                                         }
  87                                 }
  88                                 else
  89                                         UnknownNode(ob);
  90
  91                                 Reader.MoveToContent();
  92                         }
  93
  94                         ReadEndElement();
  95
  96                         return ob;
  97                 }
  98
  99                 public System.Web.Services.Protocols.Soap12FaultDetail ReadObject_Detail (bool isNullable, bool checkType)
 100                 {
 101                         System.Web.Services.Protocols.Soap12FaultDetail ob = null;
 102                         if (isNullable && ReadNull()) return null;
 103
 104                         if (checkType)
 105                         {
 106                                 System.Xml.XmlQualifiedName t = GetXsiType();
 107                                 if (t == null)
 108                                 { }
 109                                 else if (t.Name != "Detail" || t.Namespace != "http://www.w3.org/2003/05/soap-envelope")
 110                                         throw CreateUnknownTypeException(t);
 111                         }
 112
 113                         ob = new System.Web.Services.Protocols.Soap12FaultDetail ();
 114
 115                         Reader.MoveToElement();
 116
 117                         int anyAttributeIndex = 0;
 118                         System.Xml.XmlAttribute[] anyAttributeArray = null;
 119                         while (Reader.MoveToNextAttribute())
 120                         {
 121                                 if (IsXmlnsAttribute (Reader.Name)) {
 122                                 }
 123                                 else {
 124                                         System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) Document.ReadNode(Reader);
 125                                         anyAttributeArray = (System.Xml.XmlAttribute[]) EnsureArrayIndex (anyAttributeArray, anyAttributeIndex, typeof(System.Xml.XmlAttribute));
 126                                         anyAttributeArray[anyAttributeIndex] = ((System.Xml.XmlAttribute) attr);
 127                                         anyAttributeIndex++;
 128                                 }
 129                         }
 130
 131                         anyAttributeArray = (System.Xml.XmlAttribute[]) ShrinkArray (anyAttributeArray, anyAttributeIndex, typeof(System.Xml.XmlAttribute), true);
 132                         ob.@Attributes = anyAttributeArray;
 133
 134                         Reader.MoveToElement();
 135                         if (Reader.IsEmptyElement) {
 136                                 Reader.Skip ();
 137                                 return ob;
 138                         }
 139
 140                         Reader.ReadStartElement();
 141                         Reader.MoveToContent();
 142
 143                         bool b5=false, b6=false;
 144
 145                         System.Xml.XmlElement[] o8;
 146                         o8 = null;
 147                         int n7=0;
 148
 149                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
 150                         {
 151                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
 152                                 {
 153                                         o8 = (System.Xml.XmlElement[]) EnsureArrayIndex (o8, n7, typeof(System.Xml.XmlElement));
 154                                         o8[n7] = ((System.Xml.XmlElement) ReadXmlNode (false));
 155                                         n7++;
 156                                 }
 157                                 else if (Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA)
 158                                 {
 159                                         ob.@Text = ReadString (ob.@Text);
 160                                 }
 161                                 else
 162                                         UnknownNode(ob);
 163
 164                                 Reader.MoveToContent();
 165                         }
 166
 167                         o8 = (System.Xml.XmlElement[]) ShrinkArray (o8, n7, typeof(System.Xml.XmlElement), true);
 168                         ob.@Children = o8;
 169
 170                         ReadEndElement();
 171
 172                         return ob;
 173                 }
 174
 175                 public System.Web.Services.Protocols.Soap12FaultCode ReadObject_Code (bool isNullable, bool checkType)
 176                 {
 177                         System.Web.Services.Protocols.Soap12FaultCode ob = null;
 178                         if (isNullable && ReadNull()) return null;
 179
 180                         if (checkType)
 181                         {
 182                                 System.Xml.XmlQualifiedName t = GetXsiType();
 183                                 if (t == null)
 184                                 { }
 185                                 else if (t.Name != "Code" || t.Namespace != "http://www.w3.org/2003/05/soap-envelope")
 186                                         throw CreateUnknownTypeException(t);
 187                         }
 188
 189                         ob = new System.Web.Services.Protocols.Soap12FaultCode ();
 190
 191                         Reader.MoveToElement();
 192
 193                         while (Reader.MoveToNextAttribute())
 194                         {
 195                                 if (IsXmlnsAttribute (Reader.Name)) {
 196                                 }
 197                                 else {
 198                                         UnknownNode (ob);
 199                                 }
 200                         }
 201
 202                         Reader.MoveToElement();
 203                         if (Reader.IsEmptyElement) {
 204                                 Reader.Skip ();
 205                                 return ob;
 206                         }
 207
 208                         Reader.ReadStartElement();
 209                         Reader.MoveToContent();
 210
 211                         bool b9=false, b10=false;
 212
 213                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
 214                         {
 215                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
 216                                 {
 217                                         if (Reader.LocalName == "Value" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b9) {
 218                                                 b9 = true;
 219                                                 ob.@Value = ReadElementQualifiedName ();
 220                                         }
 221                                         else if (Reader.LocalName == "Subcode" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b10) {
 222                                                 b10 = true;
 223                                                 ob.@Subcode = ReadObject_Code (false, true);
 224                                         }
 225                                         else {
 226                                                 UnknownNode (ob);
 227                                         }
 228                                 }
 229                                 else
 230                                         UnknownNode(ob);
 231
 232                                 Reader.MoveToContent();
 233                         }
 234
 235                         ReadEndElement();
 236
 237                         return ob;
 238                 }
 239
 240                 public System.Web.Services.Protocols.Soap12FaultReason ReadObject_Reason (bool isNullable, bool checkType)
 241                 {
 242                         System.Web.Services.Protocols.Soap12FaultReason ob = null;
 243                         if (isNullable && ReadNull()) return null;
 244
 245                         if (checkType)
 246                         {
 247                                 System.Xml.XmlQualifiedName t = GetXsiType();
 248                                 if (t == null)
 249                                 { }
 250                                 else if (t.Name != "Reason" || t.Namespace != "http://www.w3.org/2003/05/soap-envelope")
 251                                         throw CreateUnknownTypeException(t);
 252                         }
 253
 254                         ob = new System.Web.Services.Protocols.Soap12FaultReason ();
 255
 256                         Reader.MoveToElement();
 257
 258                         while (Reader.MoveToNextAttribute())
 259                         {
 260                                 if (IsXmlnsAttribute (Reader.Name)) {
 261                                 }
 262                                 else {
 263                                         UnknownNode (ob);
 264                                 }
 265                         }
 266
 267                         Reader.MoveToElement();
 268                         if (Reader.IsEmptyElement) {
 269                                 Reader.Skip ();
 270                                 return ob;
 271                         }
 272
 273                         Reader.ReadStartElement();
 274                         Reader.MoveToContent();
 275
 276                         bool b11=false;
 277
 278                         System.Web.Services.Protocols.Soap12FaultReasonText[] o13;
 279                         o13 = null;
 280                         int n12=0;
 281
 282                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
 283                         {
 284                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
 285                                 {
 286                                         if (Reader.LocalName == "Text" && Reader.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope" && !b11) {
 287                                                 o13 = (System.Web.Services.Protocols.Soap12FaultReasonText[]) EnsureArrayIndex (o13, n12, typeof(System.Web.Services.Protocols.Soap12FaultReasonText));
 288                                                 o13[n12] = ReadObject_Text (false, true);
 289                                                 n12++;
 290                                         }
 291                                         else {
 292                                                 UnknownNode (ob);
 293                                         }
 294                                 }
 295                                 else
 296                                         UnknownNode(ob);
 297
 298                                 Reader.MoveToContent();
 299                         }
 300
 301                         o13 = (System.Web.Services.Protocols.Soap12FaultReasonText[]) ShrinkArray (o13, n12, typeof(System.Web.Services.Protocols.Soap12FaultReasonText), true);
 302                         ob.@Texts = o13;
 303
 304                         ReadEndElement();
 305
 306                         return ob;
 307                 }
 308
 309                 public System.Web.Services.Protocols.Soap12FaultReasonText ReadObject_Text (bool isNullable, bool checkType)
 310                 {
 311                         System.Web.Services.Protocols.Soap12FaultReasonText ob = null;
 312                         if (isNullable && ReadNull()) return null;
 313
 314                         if (checkType)
 315                         {
 316                                 System.Xml.XmlQualifiedName t = GetXsiType();
 317                                 if (t == null)
 318                                 { }
 319                                 else if (t.Name != "Text" || t.Namespace != "http://www.w3.org/2003/05/soap-envelope")
 320                                         throw CreateUnknownTypeException(t);
 321                         }
 322
 323                         ob = new System.Web.Services.Protocols.Soap12FaultReasonText ();
 324
 325                         Reader.MoveToElement();
 326
 327                         while (Reader.MoveToNextAttribute())
 328                         {
 329                                 if (Reader.LocalName == "lang" && Reader.NamespaceURI == "http://www.w3.org/XML/1998/namespace") {
 330                                         ob.@XmlLang = Reader.Value;
 331                                 }
 332                                 else if (IsXmlnsAttribute (Reader.Name)) {
 333                                 }
 334                                 else {
 335                                         UnknownNode (ob);
 336                                 }
 337                         }
 338
 339                         Reader.MoveToElement();
 340                         if (Reader.IsEmptyElement) {
 341                                 Reader.Skip ();
 342                                 return ob;
 343                         }
 344
 345                         Reader.ReadStartElement();
 346                         Reader.MoveToContent();
 347
 348                         bool b14=false;
 349
 350                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
 351                         {
 352                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
 353                                 {
 354                                         UnknownNode (ob);
 355                                 }
 356                                 else if (Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA)
 357                                 {
 358                                         ob.@Value = ReadString (ob.@Value);
 359                                 }
 360                                 else
 361                                         UnknownNode(ob);
 362
 363                                 Reader.MoveToContent();
 364                         }
 365
 366                         ReadEndElement();
 367
 368                         return ob;
 369                 }
 370
 371                 protected override void InitCallbacks ()
 372                 {
 373                 }
 374
 375                 protected override void InitIDs ()
 376                 {
 377                 }
 378
 379         }
 380
 381         internal class Soap12FaultWriter : XmlSerializationWriter
 382         {
 383                 const string xmlNamespace = "http://www.w3.org/2000/xmlns/";
 384                 public void WriteRoot_Soap12Fault (object o)
 385                 {
 386                         WriteStartDocument ();
 387                         System.Web.Services.Protocols.Soap12Fault ob = (System.Web.Services.Protocols.Soap12Fault) o;
 388                         TopLevelElement ();
 389                         WriteObject_Fault (ob, "Fault", "http://www.w3.org/2003/05/soap-envelope", true, false, true);
 390                 }
 391
 392                 void WriteObject_Fault (System.Web.Services.Protocols.Soap12Fault ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 393                 {
 394                         if (((object)ob) == null)
 395                         {
 396                                 if (isNullable)
 397                                         WriteNullTagLiteral(element, namesp);
 398                                 return;
 399                         }
 400
 401                         System.Type type = ob.GetType ();
 402                         if (type == typeof(System.Web.Services.Protocols.Soap12Fault))
 403                         { }
 404                         else {
 405                                 throw CreateUnknownTypeException (ob);
 406                         }
 407
 408                         if (writeWrappingElem) {
 409                                 WriteStartElement (element, namesp, ob);
 410                         }
 411
 412                         if (needType) WriteXsiType("Fault", "http://www.w3.org/2003/05/soap-envelope");
 413
 414                         WriteObject_Code (ob.@Code, "Code", "http://www.w3.org/2003/05/soap-envelope", false, false, true);
 415                         WriteObject_Reason (ob.@Reason, "Reason", "http://www.w3.org/2003/05/soap-envelope", false, false, true);
 416                         WriteElementString ("Node", "http://www.w3.org/2003/05/soap-envelope", ((ob.@Node != null) ? (ob.@Node).ToString() : null));
 417                         WriteElementString ("Role", "http://www.w3.org/2003/05/soap-envelope", ((ob.@Role != null) ? (ob.@Role).ToString() : null));
 418                         WriteObject_Detail (ob.@Detail, "Detail", "http://www.w3.org/2003/05/soap-envelope", false, false, true);
 419                         if (writeWrappingElem) WriteEndElement (ob);
 420                 }
 421
 422                 void WriteObject_Code (System.Web.Services.Protocols.Soap12FaultCode ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 423                 {
 424                         if (((object)ob) == null)
 425                         {
 426                                 if (isNullable)
 427                                         WriteNullTagLiteral(element, namesp);
 428                                 return;
 429                         }
 430
 431                         System.Type type = ob.GetType ();
 432                         if (type == typeof(System.Web.Services.Protocols.Soap12FaultCode))
 433                         { }
 434                         else {
 435                                 throw CreateUnknownTypeException (ob);
 436                         }
 437
 438                         if (writeWrappingElem) {
 439                                 WriteStartElement (element, namesp, ob);
 440                         }
 441
 442                         if (needType) WriteXsiType("Code", "http://www.w3.org/2003/05/soap-envelope");
 443
 444                         WriteElementQualifiedName ("Value", "http://www.w3.org/2003/05/soap-envelope", ob.@Value);
 445                         WriteObject_Code (ob.@Subcode, "Subcode", "http://www.w3.org/2003/05/soap-envelope", false, false, true);
 446                         if (writeWrappingElem) WriteEndElement (ob);
 447                 }
 448
 449                 void WriteObject_Reason (System.Web.Services.Protocols.Soap12FaultReason ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 450                 {
 451                         if (((object)ob) == null)
 452                         {
 453                                 if (isNullable)
 454                                         WriteNullTagLiteral(element, namesp);
 455                                 return;
 456                         }
 457
 458                         System.Type type = ob.GetType ();
 459                         if (type == typeof(System.Web.Services.Protocols.Soap12FaultReason))
 460                         { }
 461                         else {
 462                                 throw CreateUnknownTypeException (ob);
 463                         }
 464
 465                         if (writeWrappingElem) {
 466                                 WriteStartElement (element, namesp, ob);
 467                         }
 468
 469                         if (needType) WriteXsiType("Reason", "http://www.w3.org/2003/05/soap-envelope");
 470
 471                         if (ob.@Texts != null) {
 472                                 for (int n15 = 0; n15 < ob.@Texts.Length; n15++) {
 473                                         WriteObject_Text (ob.@Texts[n15], "Text", "http://www.w3.org/2003/05/soap-envelope", false, false, true);
 474                                 }
 475                         }
 476                         if (writeWrappingElem) WriteEndElement (ob);
 477                 }
 478
 479                 void WriteObject_Detail (System.Web.Services.Protocols.Soap12FaultDetail ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 480                 {
 481                         if (((object)ob) == null)
 482                         {
 483                                 if (isNullable)
 484                                         WriteNullTagLiteral(element, namesp);
 485                                 return;
 486                         }
 487
 488                         System.Type type = ob.GetType ();
 489                         if (type == typeof(System.Web.Services.Protocols.Soap12FaultDetail))
 490                         { }
 491                         else {
 492                                 throw CreateUnknownTypeException (ob);
 493                         }
 494
 495                         if (writeWrappingElem) {
 496                                 WriteStartElement (element, namesp, ob);
 497                         }
 498
 499                         if (needType) WriteXsiType("Detail", "http://www.w3.org/2003/05/soap-envelope");
 500
 501                         ICollection o16 = ob.@Attributes;
 502                         if (o16 != null) {
 503                                 foreach (XmlAttribute o17 in o16)
 504                                         if (o17.NamespaceURI != xmlNamespace)
 505                                                 WriteXmlAttribute (o17, ob);
 506                         }
 507
 508                         if (ob.@Children != null) {
 509                                 foreach (XmlNode o18 in ob.@Children) {
 510                                         XmlNode o19 = o18;
 511                                         if (o19 is XmlElement) {
 512                                         }
 513                                         else o19.WriteTo (Writer);
 514                                         WriteElementLiteral (o19, "", "", false, true);
 515                                 }
 516                         }
 517                         WriteValue (ob.@Text);
 518                         if (writeWrappingElem) WriteEndElement (ob);
 519                 }
 520
 521                 void WriteObject_Text (System.Web.Services.Protocols.Soap12FaultReasonText ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 522                 {
 523                         if (((object)ob) == null)
 524                         {
 525                                 if (isNullable)
 526                                         WriteNullTagLiteral(element, namesp);
 527                                 return;
 528                         }
 529
 530                         System.Type type = ob.GetType ();
 531                         if (type == typeof(System.Web.Services.Protocols.Soap12FaultReasonText))
 532                         { }
 533                         else {
 534                                 throw CreateUnknownTypeException (ob);
 535                         }
 536
 537                         if (writeWrappingElem) {
 538                                 WriteStartElement (element, namesp, ob);
 539                         }
 540
 541                         if (needType) WriteXsiType("Text", "http://www.w3.org/2003/05/soap-envelope");
 542
 543                         WriteAttribute ("lang", "http://www.w3.org/XML/1998/namespace", ob.@XmlLang);
 544
 545                         WriteValue (ob.@Value);
 546                         if (writeWrappingElem) WriteEndElement (ob);
 547                 }
 548
 549                 protected override void InitCallbacks ()
 550                 {
 551                 }
 552
 553         }
 554
 555
 556         internal class Soap12FaultBaseSerializer : System.Xml.Serialization.XmlSerializer
 557         {
 558                 protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {
 559                         return new Soap12FaultReader ();
 560                 }
 561
 562                 protected override System.Xml.Serialization.XmlSerializationWriter CreateWriter () {
 563                         return new Soap12FaultWriter ();
 564                 }
 565
 566                 public override bool CanDeserialize (System.Xml.XmlReader xmlReader) {
 567                         return true;
 568                 }
 569         }
 570
 571         internal sealed class Fault12Serializer : Soap12FaultBaseSerializer
 572         {
 573                 protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {
 574                         ((Soap12FaultWriter)writer).WriteRoot_Soap12Fault(obj);
 575                 }
 576
 577                 protected override object Deserialize (System.Xml.Serialization.XmlSerializationReader reader) {
 578                         return ((Soap12FaultReader)reader).ReadRoot_Soap12Fault();
 579                 }
 580         }
 581
 582         internal class Soap12FaultSerializerImplementation : System.Xml.Serialization.XmlSerializerImplementation
 583         {
 584                 System.Collections.Hashtable readMethods = null;
 585                 System.Collections.Hashtable writeMethods = null;
 586                 System.Collections.Hashtable typedSerializers = null;
 587
 588                 public override System.Xml.Serialization.XmlSerializationReader Reader {
 589                         get {
 590                                 return new Soap12FaultReader();
 591                         }
 592                 }
 593
 594                 public override System.Xml.Serialization.XmlSerializationWriter Writer {
 595                         get {
 596                                 return new Soap12FaultWriter();
 597                         }
 598                 }
 599
 600                 public override System.Collections.Hashtable ReadMethods {
 601                         get {
 602                                 lock (this) {
 603                                         if (readMethods == null) {
 604                                                 readMethods = new System.Collections.Hashtable ();
 605                                                 readMethods.Add (@"", @"ReadRoot_Soap12Fault");
 606                                         }
 607                                         return readMethods;
 608                                 }
 609                         }
 610                 }
 611
 612                 public override System.Collections.Hashtable WriteMethods {
 613                         get {
 614                                 lock (this) {
 615                                         if (writeMethods == null) {
 616                                                 writeMethods = new System.Collections.Hashtable ();
 617                                                 writeMethods.Add (@"", @"WriteRoot_Soap12Fault");
 618                                         }
 619                                         return writeMethods;
 620                                 }
 621                         }
 622                 }
 623
 624                 public override System.Collections.Hashtable TypedSerializers {
 625                         get {
 626                                 lock (this) {
 627                                         if (typedSerializers == null) {
 628                                                 typedSerializers = new System.Collections.Hashtable ();
 629                                                 typedSerializers.Add (@"", new FaultSerializer());
 630                                         }
 631                                         return typedSerializers;
 632                                 }
 633                         }
 634                 }
 635
 636                 public override XmlSerializer GetSerializer (Type type)
 637                 {
 638                         switch (type.FullName) {
 639                         case "System.Web.Services.Protocols.Soap12Fault":
 640                                 return (XmlSerializer) TypedSerializers [""];
 641
 642                         }
 643                         return base.GetSerializer (type);
 644                 }
 645
 646                 public override bool CanSerialize (System.Type type) {
 647                         if (type == typeof(System.Web.Services.Protocols.Soap12Fault)) return true;
 648                         return false;
 649                 }
 650         }
 651
 652 }
 653 #endif