-//\r
-// System.Xml.XmlSerializerTestClasses\r
-//\r
-// Author:\r
-// Erik LeBel <eriklebel@yahoo.ca>\r
-//\r
-// (C) 2003 Erik LeBel\r
-//\r
-// Classes to use in the testing of the XmlSerializer\r
-//\r
-\r
-using System;\r
-using System.ComponentModel;\r
-using System.Collections;\r
-using System.Xml.Serialization;\r
-using System.Xml;\r
-\r
-namespace MonoTests.System.Xml.TestClasses\r
-{\r
- public enum SimpleEnumeration { FIRST, SECOND };\r
- \r
- public class SimpleClass\r
- {\r
- public string something = null;\r
- }\r
-\r
- public class StringCollection : CollectionBase\r
- {\r
- public void Add (String parameter) \r
- {\r
- List.Insert (Count, parameter);\r
- }\r
- \r
- public String this [int index]\r
- {\r
- get\r
- { \r
- if (index < 0 || index > Count)\r
- throw new ArgumentOutOfRangeException ();\r
- \r
- return (String) List [index]; \r
- }\r
- set { List [index] = value; }\r
- }\r
- }\r
- \r
- public class StringCollectionContainer\r
- {\r
- StringCollection messages = new StringCollection();\r
- \r
- public StringCollection Messages\r
- {\r
- get { return messages; }\r
- }\r
- }\r
-\r
- public class ArrayContainer\r
- {\r
- public object [] items = null;\r
- }\r
- \r
- public class ClassArrayContainer\r
- {\r
- public SimpleClass [] items = null;\r
- }\r
- \r
- [XmlRoot("simple")]\r
- public class SimpleClassWithXmlAttributes\r
- {\r
- [XmlAttribute("member")]\r
- public string something = null;\r
- }\r
- \r
- [XmlRoot("field")]\r
- public class Field\r
- {\r
- [XmlAttribute("modifiers")]\r
- public MapModifiers Modifiers;\r
- }\r
-\r
- [Flags]\r
- public enum MapModifiers\r
- {\r
- [XmlEnum("public")]\r
- Public = 0,\r
- [XmlEnum("protected")]\r
- Protected = 1,\r
- }\r
- \r
- public class MyList : ArrayList\r
- {\r
- object container;\r
- \r
- // NOTE: MyList has no public constructor\r
- public MyList (object container) : base()\r
- {\r
- this.container = container;\r
- }\r
- }\r
- \r
- public class Container\r
- {\r
- public MyList Items;\r
- \r
- public Container () {\r
- Items = new MyList(this);\r
- }\r
- }\r
- \r
- public class Container2\r
- {\r
- public MyList Items;\r
- \r
- public Container2 () {\r
- }\r
- \r
- public Container2 (bool b) {\r
- Items = new MyList(this);\r
- }\r
- }
-\r
- public class MyElem: XmlElement
- {
- public MyElem (XmlDocument doc): base ("","myelem","", doc)
- {
- SetAttribute ("aa","1");
+//
+// System.Xml.XmlSerializerTestClasses
+//
+// Authors:
+// Erik LeBel <eriklebel@yahoo.ca>
+// Hagit Yidov <hagity@mainsoft.com>
+//
+// (C) 2003 Erik LeBel
+// (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
+//
+// Classes to use in the testing of the XmlSerializer
+//
+
+using System;
+using System.Collections;
+#if NET_2_0
+using System.Collections.Generic;
+#endif
+using System.ComponentModel;
+using System.Xml;
+using System.Xml.Schema;
+using System.Xml.Serialization;
+
+namespace MonoTests.System.Xml.TestClasses
+{
+ public enum SimpleEnumeration { FIRST, SECOND };
+
+ [Flags]
+ public enum EnumDefaultValue { e1 = 1, e2 = 2, e3 = 3 }
+ public enum EnumDefaultValueNF { e1 = 1, e2 = 2, e3 = 3 }
+
+ [Flags]
+ public enum FlagEnum
+ {
+ [XmlEnum ("one")]
+ e1 = 1,
+ [XmlEnum ("two")]
+ e2 = 2,
+ [XmlEnum ("four")]
+ e4 = 4
+ }
+
+ [Flags]
+ [SoapType ("flagenum")]
+ public enum FlagEnum_Encoded
+ {
+ [SoapEnum ("one")]
+ e1 = 1,
+ [SoapEnum ("two")]
+ e2 = 2,
+ [SoapEnum ("four")]
+ e4 = 4
+ }
+
+ [Flags]
+ public enum ZeroFlagEnum
+ {
+ [XmlEnum ("zero")]
+ e0 = 0,
+ [XmlEnum ("o<n>e")]
+ e1 = 1,
+ [XmlEnum ("tns:t<w>o")]
+ e2 = 2,
+ [XmlEnum ("four")]
+ [XmlIgnore]
+ e4 = 4
+ }
+
+ #region GenericsTestClasses
+
+#if NET_2_0
+ public class GenSimpleClass<T>
+ {
+ public T something = default (T);
+ }
+
+ public struct GenSimpleStruct<T>
+ {
+ public T something;
+ public GenSimpleStruct (int dummy)
+ {
+ something = default (T);
+ }
+ }
+
+ public class GenListClass<T>
+ {
+ public List<T> somelist = new List<T> ();
+ }
+
+ public class GenArrayClass<T>
+ {
+ public T[] arr = new T[3];
+ }
+
+ public class GenTwoClass<T1, T2>
+ {
+ public T1 something1 = default (T1);
+ public T2 something2 = default (T2);
+ }
+
+ public class GenDerivedClass<T1, T2> : GenTwoClass<string, int>
+ {
+ public T1 another1 = default (T1);
+ public T2 another2 = default (T2);
+ }
+
+ public class GenDerived2Class<T1, T2> : GenTwoClass<T1, T2>
+ {
+ public T1 another1 = default (T1);
+ public T2 another2 = default (T2);
+ }
+
+ public class GenNestedClass<TO, TI>
+ {
+ public TO outer = default (TO);
+ public class InnerClass<T>
+ {
+ public TI inner = default (TI);
+ public T something = default (T);
+ }
+ }
+
+ public struct GenComplexStruct<T1, T2>
+ {
+ public T1 something;
+ public GenSimpleClass<T1> simpleclass;
+ public GenSimpleStruct<T1> simplestruct;
+ public GenListClass<T1> listclass;
+ public GenArrayClass<T1> arrayclass;
+ public GenTwoClass<T1, T2> twoclass;
+ public GenDerivedClass<T1, T2> derivedclass;
+ public GenDerived2Class<T1, T2> derived2;
+ public GenNestedClass<T1, T2> nestedouter;
+ public GenNestedClass<T1, T2>.InnerClass<T1> nestedinner;
+ public GenComplexStruct (int dummy)
+ {
+ something = default (T1);
+ simpleclass = new GenSimpleClass<T1> ();
+ simplestruct = new GenSimpleStruct<T1> ();
+ listclass = new GenListClass<T1> ();
+ arrayclass = new GenArrayClass<T1> ();
+ twoclass = new GenTwoClass<T1, T2> ();
+ derivedclass = new GenDerivedClass<T1, T2> ();
+ derived2 = new GenDerived2Class<T1, T2> ();
+ nestedouter = new GenNestedClass<T1, T2> ();
+ nestedinner = new GenNestedClass<T1, T2>.InnerClass<T1> ();
+ }
+ }
+
+ public class WithNulls
+ {
+ [XmlElement (IsNullable=true)]
+ public int? nint;
+
+ [XmlElement (IsNullable=true)]
+ public TestEnumWithNulls? nenum;
+
+ [XmlElement (IsNullable=true)]
+ public DateTime? ndate;
+ }
+
+ public enum TestEnumWithNulls
+ {
+ aa,
+ bb
+ }
+
+#endif
+
+ #endregion // GenericsTestClasses
+
+ public class SimpleClass
+ {
+ public string something = null;
+ }
+
+ public class StringCollection : CollectionBase
+ {
+ public void Add (String parameter)
+ {
+ List.Insert (Count, parameter);
+ }
+
+ public String this[int index]
+ {
+ get
+ {
+ if (index < 0 || index > Count)
+ throw new ArgumentOutOfRangeException ();
+
+ return (String) List[index];
+ }
+ set { List[index] = value; }
+ }
+ }
+
+ public class StringCollectionContainer
+ {
+ StringCollection messages = new StringCollection ();
+
+ public StringCollection Messages
+ {
+ get { return messages; }
+ }
+ }
+
+ public class ArrayContainer
+ {
+ public object[] items = null;
+ }
+
+ public class ClassArrayContainer
+ {
+ public SimpleClass[] items = null;
+ }
+
+ [XmlRoot ("simple")]
+ public class SimpleClassWithXmlAttributes
+ {
+ [XmlAttribute ("member")]
+ public string something = null;
+ }
+
+ [XmlRoot ("field")]
+ public class Field
+ {
+ [XmlAttribute ("flag1")]
+ [DefaultValue (1)]
+ public FlagEnum Flags1;
+
+ [XmlAttribute ("flag2")]
+ [DefaultValue (FlagEnum.e1)]
+ public FlagEnum Flags2;
+
+ [XmlAttribute ("flag3", Form = XmlSchemaForm.Qualified)]
+ [DefaultValue (FlagEnum.e1 | FlagEnum.e2)]
+ public FlagEnum Flags3;
+
+ [XmlAttribute ("flag4")]
+ public FlagEnum Flags4;
+
+ [XmlAttribute ("modifiers")]
+ public MapModifiers Modifiers;
+
+ [XmlAttribute ("modifiers2", Form = XmlSchemaForm.Unqualified)]
+ public MapModifiers Modifiers2;
+
+ [XmlAttribute ("modifiers3")]
+ [DefaultValue (0)]
+ public MapModifiers Modifiers3;
+
+ [XmlAttribute ("modifiers4", Form = XmlSchemaForm.Unqualified)]
+ [DefaultValue (MapModifiers.Protected)]
+ public MapModifiers Modifiers4;
+
+ [XmlAttribute ("modifiers5", Form = XmlSchemaForm.Qualified)]
+ [DefaultValue (MapModifiers.Public)]
+ public MapModifiers Modifiers5;
+
+ [XmlAttribute ("names")]
+ public string[] Names;
+
+ [XmlAttribute ("street")]
+ public string Street;
+ }
+
+ [SoapType ("field", Namespace = "some:urn")]
+ public class Field_Encoded
+ {
+ [SoapAttribute ("flag1")]
+ [DefaultValue (FlagEnum_Encoded.e1)]
+ public FlagEnum_Encoded Flags1;
+
+ [SoapAttribute ("flag2")]
+ [DefaultValue (FlagEnum_Encoded.e1)]
+ public FlagEnum_Encoded Flags2;
+
+ [SoapAttribute ("flag3")]
+ [DefaultValue (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e2)]
+ public FlagEnum_Encoded Flags3;
+
+ [SoapAttribute ("flag4")]
+ public FlagEnum_Encoded Flags4;
+
+ [SoapAttribute ("modifiers")]
+ public MapModifiers Modifiers;
+
+ [SoapAttribute ("modifiers2")]
+ public MapModifiers Modifiers2;
+
+ [SoapAttribute ("modifiers3")]
+ [DefaultValue (MapModifiers.Public)]
+ public MapModifiers Modifiers3;
+
+ [SoapAttribute ("modifiers4")]
+ [DefaultValue (MapModifiers.Protected)]
+ public MapModifiers Modifiers4;
+
+ [SoapAttribute ("modifiers5")]
+ [DefaultValue (MapModifiers.Public)]
+ public MapModifiers Modifiers5;
+
+ public string[] Names;
+
+ [SoapAttribute ("street")]
+ public string Street;
+ }
+
+ [Flags]
+ public enum MapModifiers
+ {
+ [XmlEnum ("public")]
+ [SoapEnum ("PuBlIc")]
+ Public = 0,
+ [XmlEnum ("protected")]
+ Protected = 1,
+ }
+
+ public class MyList : ArrayList
+ {
+ object container;
+
+ // NOTE: MyList has no public constructor
+ public MyList (object container)
+ : base ()
+ {
+ this.container = container;
+ }
+ }
+
+ public class Container
+ {
+ public MyList Items;
+
+ public Container ()
+ {
+ Items = new MyList (this);
+ }
+ }
+
+ public class Container2
+ {
+ public MyList Items;
+
+ public Container2 ()
+ {
+ }
+
+ public Container2 (bool b)
+ {
+ Items = new MyList (this);
+ }
+ }
+
+ public class MyElem : XmlElement
+ {
+ public MyElem (XmlDocument doc)
+ : base ("", "myelem", "", doc)
+ {
+ SetAttribute ("aa", "1");
}
[XmlAttribute]
- public int kk=1;
+ public int kk = 1;
}
-\r
- public class MyDocument: XmlDocument
+
+ public class MyDocument : XmlDocument
{
public MyDocument ()
{
}
[XmlAttribute]
- public int kk=1;
+ public int kk = 1;
}
-
+
public class CDataContainer
{
public XmlCDataSection cdata;
}
-
+
public class NodeContainer
{
public XmlNode node;
- }\r
- \r
- public class Choices\r
- {\r
- [XmlElementAttribute("ChoiceZero", typeof(string), IsNullable=false)]\r
- [XmlElementAttribute("ChoiceOne", typeof(string), IsNullable=false)]\r
- [XmlElementAttribute("ChoiceTwo", typeof(string), IsNullable=false)]\r
- [XmlChoiceIdentifier("ItemType")]\r
- public string MyChoice;\r
-\r
- [XmlIgnore]\r
- public ItemChoiceType ItemType;\r
- }\r
- \r
- [XmlType(IncludeInSchema = false)]\r
- public enum ItemChoiceType\r
- {\r
- ChoiceZero,\r
- [XmlEnum ("ChoiceOne")]\r
- StrangeOne,\r
- ChoiceTwo,\r
- }\r
- \r
- public class WrongChoices\r
- {\r
- [XmlElementAttribute("ChoiceZero", typeof(string), IsNullable=false)]\r
- [XmlElementAttribute("StrangeOne", typeof(string), IsNullable=false)]\r
- [XmlElementAttribute("ChoiceTwo", typeof(string), IsNullable=false)]\r
- [XmlChoiceIdentifier("ItemType")]\r
- public string MyChoice;\r
-\r
- [XmlIgnore]\r
- public ItemChoiceType ItemType;\r
}
-
+
+ public class Choices
+ {
+ [XmlElementAttribute ("ChoiceZero", typeof (string), IsNullable = false)]
+ [XmlElementAttribute ("ChoiceOne", typeof (string), IsNullable = false)]
+ [XmlElementAttribute ("ChoiceTwo", typeof (string), IsNullable = false)]
+ [XmlChoiceIdentifier ("ItemType")]
+ public string MyChoice;
+
+ [XmlIgnore]
+ public ItemChoiceType ItemType;
+ }
+
+ [XmlType (IncludeInSchema = false)]
+ public enum ItemChoiceType
+ {
+ ChoiceZero,
+ [XmlEnum ("ChoiceOne")]
+ StrangeOne,
+ ChoiceTwo,
+ }
+
+ public class WrongChoices
+ {
+ [XmlElementAttribute ("ChoiceZero", typeof (string), IsNullable = false)]
+ [XmlElementAttribute ("StrangeOne", typeof (string), IsNullable = false)]
+ [XmlElementAttribute ("ChoiceTwo", typeof (string), IsNullable = false)]
+ [XmlChoiceIdentifier ("ItemType")]
+ public string MyChoice;
+
+ [XmlIgnore]
+ public ItemChoiceType ItemType;
+ }
+
[XmlType ("Type with space")]
public class TestSpace
{
- [XmlElement (ElementName = "Element with space")]
- public int elem;
-
- [XmlAttribute (AttributeName = "Attribute with space")]
- public int attr;
+ [XmlElement (ElementName = "Element with space")]
+ public int elem;
+
+ [XmlAttribute (AttributeName = "Attribute with space")]
+ public int attr;
}
-\r
+
[Serializable]
- public class ReadOnlyProperties {
+ public class ReadOnlyProperties
+ {
string[] strArr = new string[2] { "string1", "string2" };
- public string[] StrArr {
+ public string[] StrArr
+ {
get { return strArr; }
}
-
- public string dat {
+
+ public string dat
+ {
get { return "fff"; }
- }
+ }
}
-
- [XmlRoot("root")]
+
+ [XmlRoot ("root")]
public class ListDefaults
{
public ListDefaults ()
ed = new SimpleClass ();
str = "hola";
}
-
- public ArrayList list2;
-
- public MyList list3;
-
- public string[] list4;
-
- [XmlElement("e", typeof(SimpleClass))]
- public ArrayList list5;
-
+
+ public ArrayList list2;
+
+ public MyList list3;
+
+ public string[] list4;
+
+ [XmlElement ("e", typeof (SimpleClass))]
+ public ArrayList list5;
+
[DefaultValue (null)]
- public SimpleClass ed;
-
+ public SimpleClass ed;
+
[DefaultValue (null)]
- public string str;
+ public string str;
}
-
+
public class clsPerson
{
public IList EmailAccounts;
}
-}\r
+
+ public class ArrayClass
+ {
+ public object names = new object[] { "un", "dos" };
+ }
+
+ public class CompositeValueType
+ {
+ public void Init ()
+ {
+ Items = new object[] { 1, 2 };
+ ItemsElementName = new ItemsChoiceType[] { ItemsChoiceType.In, ItemsChoiceType.Es };
+ }
+
+ [XmlElementAttribute ("Es", typeof (int))]
+ [XmlElementAttribute ("In", typeof (int))]
+ [XmlChoiceIdentifierAttribute ("ItemsElementName")]
+ public object[] Items;
+
+ [XmlElementAttribute ("ItemsElementName")]
+ [XmlIgnoreAttribute ()]
+ public ItemsChoiceType[] ItemsElementName;
+ }
+
+ public enum ItemsChoiceType
+ {
+ In, Es
+ }
+
+ public class ArrayAttributeWithType
+ {
+ [XmlAttribute (DataType = "anyURI")]
+ public string[] at = new string[] { "a", "b" };
+
+ [XmlAttribute (DataType = "base64Binary")]
+ public byte[][] bin1 = new byte[][] { new byte[] { 1, 2 }, new byte[] { 1, 2 } };
+
+ [XmlAttribute (DataType = "base64Binary")]
+ public byte[] bin2 = new byte[] { 1, 2 };
+ }
+
+ public class ArrayAttributeWithWrongType
+ {
+ [XmlAttribute (DataType = "int")]
+ public string[] at = new string[] { "a", "b" };
+ }
+
+ [XmlType ("Container")]
+ public class EntityContainer
+ {
+ EntityCollection collection1;
+ EntityCollection collection2;
+ EntityCollection collection3 = new EntityCollection ("root");
+ EntityCollection collection4 = new EntityCollection ("root");
+
+ [XmlArray (IsNullable = true)]
+ public EntityCollection Collection1
+ {
+ get { return collection1; }
+ set { collection1 = value; collection1.Container = "assigned"; }
+ }
+
+ [XmlArray (IsNullable = false)]
+ public EntityCollection Collection2
+ {
+ get { return collection2; }
+ set { collection2 = value; collection2.Container = "assigned"; }
+ }
+
+ [XmlArray (IsNullable = true)]
+ public EntityCollection Collection3
+ {
+ get { return collection3; }
+ set { collection3 = value; collection3.Container = "assigned"; }
+ }
+
+ [XmlArray (IsNullable = false)]
+ public EntityCollection Collection4
+ {
+ get { return collection4; }
+ set { collection4 = value; collection4.Container = "assigned"; }
+ }
+ }
+
+ [XmlType ("Container")]
+ public class ArrayEntityContainer
+ {
+ Entity[] collection1;
+ Entity[] collection2;
+ Entity[] collection3 = new Entity[0];
+ Entity[] collection4 = new Entity[0];
+
+ [XmlArray (IsNullable = true)]
+ public Entity[] Collection1
+ {
+ get { return collection1; }
+ set { collection1 = value; }
+ }
+
+ [XmlArray (IsNullable = false)]
+ public Entity[] Collection2
+ {
+ get { return collection2; }
+ set { collection2 = value; }
+ }
+
+ [XmlArray (IsNullable = true)]
+ public Entity[] Collection3
+ {
+ get { return collection3; }
+ set { collection3 = value; }
+ }
+
+ [XmlArray (IsNullable = false)]
+ public Entity[] Collection4
+ {
+ get { return collection4; }
+ set { collection4 = value; }
+ }
+ }
+
+ public class Entity
+ {
+ private string _name = string.Empty;
+ private string _parent = null;
+
+ [XmlAttribute]
+ public string Name
+ {
+ get { return _name; }
+ set { _name = value; }
+ }
+
+ [XmlIgnore]
+ public string Parent
+ {
+ get { return _parent; }
+ set { _parent = value; }
+ }
+ }
+
+ public class EntityCollection : ArrayList
+ {
+ public string _container;
+
+ public EntityCollection ()
+ {
+ }
+
+ public EntityCollection (string c)
+ {
+ _container = c;
+ }
+
+ public string Container
+ {
+ get { return _container; }
+ set { _container = value; }
+ }
+
+ public int Add (Entity value)
+ {
+ if (_container != null)
+ value.Parent = _container;
+
+ return base.Add (value);
+ }
+
+ public new Entity this[int index]
+ {
+ get { return (Entity) base[index]; }
+ set { base[index] = value; }
+ }
+ }
+
+ [XmlType ("Container")]
+ public class ObjectWithReadonlyCollection
+ {
+ EntityCollection collection1 = new EntityCollection ("root");
+
+ public EntityCollection Collection1
+ {
+ get { return collection1; }
+ }
+ }
+
+ [XmlType ("Container")]
+ public class ObjectWithReadonlyNulCollection
+ {
+ EntityCollection collection1;
+
+ public EntityCollection Collection1
+ {
+ get { return collection1; }
+ }
+ }
+
+ [XmlType ("Container")]
+ public class ObjectWithReadonlyArray
+ {
+ Entity[] collection1 = new Entity[0];
+
+ public Entity[] Collection1
+ {
+ get { return collection1; }
+ }
+ }
+
+ [XmlInclude (typeof (SubclassTestSub))]
+ public class SubclassTestBase
+ {
+ }
+
+ public class SubclassTestSub : SubclassTestBase
+ {
+ }
+
+ public class SubclassTestExtra
+ {
+ }
+
+ public class SubclassTestContainer
+ {
+ [XmlElement ("a", typeof (SubclassTestBase))]
+ [XmlElement ("b", typeof (SubclassTestExtra))]
+ public object data;
+ }
+
+ public class DictionaryWithIndexer : DictionaryBase
+ {
+ public TimeSpan this[int index]
+ {
+ get { return TimeSpan.MinValue; }
+ }
+
+ public void Add (TimeSpan value)
+ {
+ }
+ }
+
+ [XmlRoot (Namespace = "some:urn")]
+ [SoapTypeAttribute (Namespace = "another:urn")]
+ public class PrimitiveTypesContainer
+ {
+ public PrimitiveTypesContainer ()
+ {
+ Number = 2004;
+ Name = "some name";
+ Index = (byte) 56;
+ Password = new byte[] { 243, 15 };
+ PathSeparatorCharacter = '/';
+ }
+
+ public int Number;
+ public string Name;
+ public byte Index;
+ public byte[] Password;
+ public char PathSeparatorCharacter;
+ }
+
+ public class TestSchemaForm1
+ {
+ public PrintTypeResponse p1;
+
+ [XmlElement (Namespace = "urn:oo")]
+ public PrintTypeResponse p2;
+ }
+
+ [XmlType (Namespace = "urn:testForm")]
+ public class TestSchemaForm2
+ {
+ public PrintTypeResponse p1;
+
+ [XmlElement (Namespace = "urn:oo")]
+ public PrintTypeResponse p2;
+ }
+
+ [XmlType (Namespace = "urn:responseTypes")]
+ public class PrintTypeResponse
+ {
+ [XmlElement (Form = XmlSchemaForm.Unqualified, IsNullable = true)]
+ public OutputType result;
+ public PrintTypeResponse intern;
+
+ public void Init ()
+ {
+ result = new OutputType ();
+ result.data = "data1";
+ intern = new PrintTypeResponse ();
+ intern.result = new OutputType ();
+ intern.result.data = "data2";
+ }
+ }
+
+ [XmlType (Namespace = "urn:responseTypes")]
+ public class OutputType
+ {
+
+ [XmlElement (Form = XmlSchemaForm.Unqualified, IsNullable = true)]
+ public string data;
+ }
+
+ [XmlRootAttribute ("testDefault", Namespace = "urn:myNS", IsNullable = false)]
+ [SoapType ("testDefault", Namespace = "urn:myNS")]
+ public class TestDefault
+ {
+ public string str;
+
+ [DefaultValue ("Default Value")]
+ public string strDefault = "Default Value";
+
+ [DefaultValue (true)]
+ public bool boolT = true;
+
+ [DefaultValue (false)]
+ public bool boolF = false;
+
+ [DefaultValue (typeof (decimal), "10")]
+ public decimal decimalval = 10m;
+
+ [DefaultValue (FlagEnum.e1 | FlagEnum.e4)]
+ public FlagEnum flag = (FlagEnum.e1 | FlagEnum.e4);
+
+ [DefaultValue (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e4)]
+ public FlagEnum_Encoded flagencoded = (FlagEnum_Encoded.e1 | FlagEnum_Encoded.e4);
+ }
+
+ [XmlType ("optionalValueType", Namespace = "some:urn")]
+ [XmlRootAttribute ("optionalValue", Namespace = "another:urn", IsNullable = false)]
+ public class OptionalValueTypeContainer
+ {
+ [DefaultValue (FlagEnum.e1 | FlagEnum.e4)]
+ public FlagEnum Attributes = FlagEnum.e1 | FlagEnum.e4;
+
+ [DefaultValue (FlagEnum.e1)]
+ public FlagEnum Flags = FlagEnum.e1;
+
+ [XmlIgnore]
+ [SoapIgnore]
+ public bool FlagsSpecified;
+
+ [DefaultValue (false)]
+ public bool IsEmpty;
+
+ [XmlIgnore]
+ [SoapIgnore]
+ public bool IsEmptySpecified
+ {
+ get { return _isEmptySpecified; }
+ set { _isEmptySpecified = value; }
+ }
+
+ [DefaultValue (false)]
+ public bool IsNull;
+
+ private bool _isEmptySpecified;
+ }
+
+ public class Group
+ {
+ [SoapAttribute (Namespace = "http://www.cpandl.com")]
+ public string GroupName;
+
+ [SoapAttribute (DataType = "base64Binary")]
+ public Byte[] GroupNumber;
+
+ [SoapAttribute (DataType = "date", AttributeName = "CreationDate")]
+ public DateTime Today;
+
+ [SoapElement (DataType = "nonNegativeInteger", ElementName = "PosInt")]
+ public string PostitiveInt;
+
+ [SoapIgnore]
+ public bool IgnoreThis;
+
+ [DefaultValue (GroupType.B)]
+ public GroupType Grouptype;
+ public Vehicle MyVehicle;
+
+ [SoapInclude (typeof (Car))]
+ public Vehicle myCar (string licNumber)
+ {
+ Vehicle v;
+ if (licNumber == string.Empty) {
+ v = new Car ();
+ v.licenseNumber = "!!!!!!";
+ }
+ else {
+ v = new Car ();
+ v.licenseNumber = licNumber;
+ }
+ return v;
+ }
+ }
+
+ [SoapInclude (typeof (Car))]
+ public abstract class Vehicle
+ {
+ public string licenseNumber;
+ [SoapElement (DataType = "date")]
+ public DateTime makeDate;
+ [DefaultValue ("450")]
+ public string weight;
+ }
+
+ public class Car : Vehicle
+ {
+ }
+
+ public enum GroupType
+ {
+ [SoapEnum ("Small")]
+ A,
+ [SoapEnum ("Large")]
+ B
+ }
+}
+