Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

609 lines
29 KiB
C#

using System;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Linq;
using System.Reflection;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Xml;
using System.Xml.Serialization;
using LinqToSqlShared.Mapping;
namespace System.Data.Linq.Mapping {
using System.Data.Linq.Provider;
using System.Diagnostics.CodeAnalysis;
/// <summary>
/// Represents a source for mapping information.
/// </summary>
public abstract class MappingSource {
MetaModel primaryModel;
ReaderWriterLock rwlock;
Dictionary<Type, MetaModel> secondaryModels;
/// <summary>
/// Gets the MetaModel representing a DataContext and all it's
/// accessible tables, functions and entities.
/// </summary>
public MetaModel GetModel(Type dataContextType) {
if (dataContextType == null) {
throw Error.ArgumentNull("dataContextType");
}
MetaModel model = null;
if (this.primaryModel == null) {
model = this.CreateModel(dataContextType);
Interlocked.CompareExchange<MetaModel>(ref this.primaryModel, model, null);
}
// if the primary one matches, use it!
if (this.primaryModel.ContextType == dataContextType) {
return this.primaryModel;
}
// the rest of this only happens if you are using the mapping source for
// more than one context type
// build a map if one is not already defined
if (this.secondaryModels == null) {
Interlocked.CompareExchange<Dictionary<Type, MetaModel>>(ref this.secondaryModels, new Dictionary<Type, MetaModel>(), null);
}
// if we haven't created a read/writer lock, make one now
if (this.rwlock == null) {
Interlocked.CompareExchange<ReaderWriterLock>(ref this.rwlock, new ReaderWriterLock(), null);
}
// lock the map and look inside
MetaModel foundModel;
this.rwlock.AcquireReaderLock(Timeout.Infinite);
try {
if (this.secondaryModels.TryGetValue(dataContextType, out foundModel)) {
return foundModel;
}
}
finally {
this.rwlock.ReleaseReaderLock();
}
// if it wasn't found, lock for write and try again
this.rwlock.AcquireWriterLock(Timeout.Infinite);
try {
if (this.secondaryModels.TryGetValue(dataContextType, out foundModel)) {
return foundModel;
}
if (model == null) {
model = this.CreateModel(dataContextType);
}
this.secondaryModels.Add(dataContextType, model);
}
finally {
this.rwlock.ReleaseWriterLock();
}
return model;
}
/// <summary>
/// Creates a new instance of a MetaModel. This method is called by GetModel().
/// Override this method when defining a new type of MappingSource.
/// </summary>
/// <param name="dataContextType"></param>
/// <returns></returns>
protected abstract MetaModel CreateModel(Type dataContextType);
}
/// <summary>
/// A mapping source that uses attributes on the context to create the mapping model.
/// </summary>
public sealed class AttributeMappingSource : MappingSource {
public AttributeMappingSource() {
}
protected override MetaModel CreateModel(Type dataContextType) {
if (dataContextType == null) {
throw Error.ArgumentNull("dataContextType");
}
return new AttributedMetaModel(this, dataContextType);
}
}
/// <summary>
/// A mapping source that uses an external XML mapping source to create the model.
/// </summary>
public sealed class XmlMappingSource : MappingSource {
DatabaseMapping map;
[ResourceExposure(ResourceScope.Assembly)] // map parameter contains type names.
private XmlMappingSource(DatabaseMapping map) {
this.map = map;
}
[ResourceExposure(ResourceScope.None)] // Exposure is via map instance variable.
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine, ResourceScope.Assembly | ResourceScope.Machine)] // For MappedMetaModel constructor call.
protected override MetaModel CreateModel(Type dataContextType) {
if (dataContextType == null) {
throw Error.ArgumentNull("dataContextType");
}
return new MappedMetaModel(this, dataContextType, this.map);
}
/// <summary>
/// Create a mapping source from xml string.
/// </summary>
/// <param name="dataContextType">The type of DataContext to base the mapping on.</param>
/// <param name="xml">A string containing XML.</param>
/// <returns>The mapping source.</returns>
[ResourceExposure(ResourceScope.Assembly)] // Xml contains type names.
[ResourceConsumption(ResourceScope.Assembly)] // For FromReader method call.
public static XmlMappingSource FromXml(string xml) {
if (xml == null) {
throw Error.ArgumentNull("xml");
}
XmlTextReader reader = new XmlTextReader(new System.IO.StringReader(xml));
reader.DtdProcessing = DtdProcessing.Prohibit;
return FromReader(reader);
}
/// <summary>
/// Create a mapping source from xml reader.
/// </summary>
/// <param name="dataContextType">The type of DataContext to base the mapping on.</param>
/// <param name="xml">An xml reader.</param>
/// <returns>The mapping source.</returns>
[ResourceExposure(ResourceScope.Assembly)] // reader parameter contains type names.
[ResourceConsumption(ResourceScope.Assembly)] // XmlMappingSource constructor call.
public static XmlMappingSource FromReader(XmlReader reader) {
if (reader == null) {
throw Error.ArgumentNull("reader");
}
reader.MoveToContent();
DatabaseMapping db = XmlMappingReader.ReadDatabaseMapping(reader);
if (db == null) {
throw Error.DatabaseNodeNotFound(XmlMappingConstant.MappingNamespace);
}
return new XmlMappingSource(db);
}
/// <summary>
/// Create a mapping source from xml in a stream.
/// </summary>
/// <param name="dataContextType">The type of DataContext to base the mapping on.</param>
/// <param name="xml">A stream of xml.</param>
/// <returns>The mapping source.</returns>
[ResourceExposure(ResourceScope.Assembly)] // Stream contains type names.
[ResourceConsumption(ResourceScope.Assembly)] // For FromReader method call.
public static XmlMappingSource FromStream(System.IO.Stream stream) {
if (stream == null) {
throw Error.ArgumentNull("stream");
}
XmlTextReader reader = new XmlTextReader(stream);
reader.DtdProcessing = DtdProcessing.Prohibit;
return FromReader(reader);
}
/// <summary>
/// Create a mapping source from xml loaded from a url.
/// </summary>
/// <param name="dataContextType">The type of DataContext to base the mapping on.</param>
/// <param name="url">The Url pointing to the xml.</param>
/// <returns>The mapping source.</returns>
[SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification="Unknown reason.")]
[ResourceExposure(ResourceScope.Machine | ResourceScope.Assembly)] // url parameter which may contain type names.
[ResourceConsumption(ResourceScope.Machine | ResourceScope.Assembly)] // XmlTextReader constructor & FromReader method call.
public static XmlMappingSource FromUrl(string url) {
if (url == null) {
throw Error.ArgumentNull("url");
}
XmlTextReader reader = new XmlTextReader(url);
reader.DtdProcessing = DtdProcessing.Prohibit;
try {
return FromReader(reader);
}
finally {
reader.Close();
}
}
}
class XmlMappingReader {
private static string RequiredAttribute(XmlReader reader, string attribute) {
string result = OptionalAttribute(reader, attribute);
if (result == null) {
throw Error.CouldNotFindRequiredAttribute(attribute, reader.ReadOuterXml());
}
return result;
}
private static string OptionalAttribute(XmlReader reader, string attribute) {
return reader.GetAttribute(attribute);
}
private static bool OptionalBoolAttribute(XmlReader reader, string attribute, bool @default) {
string value = OptionalAttribute(reader, attribute);
return (value != null) ? bool.Parse(value) : @default;
}
private static bool? OptionalNullableBoolAttribute(XmlReader reader, string attribute) {
string value = OptionalAttribute(reader, attribute);
return (value != null) ? (bool?)bool.Parse(value) : null;
}
private static void AssertEmptyElement(XmlReader reader) {
if (!reader.IsEmptyElement) {
string nodeName = reader.Name;
reader.Read();
if (reader.NodeType != XmlNodeType.EndElement) {
throw Error.ExpectedEmptyElement(nodeName, reader.NodeType, reader.Name);
}
}
reader.Skip();
}
internal static DatabaseMapping ReadDatabaseMapping(XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Database) {
return null;
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.Provider
});
DatabaseMapping dm = new DatabaseMapping();
dm.DatabaseName = RequiredAttribute(reader, XmlMappingConstant.Name);
dm.Provider = OptionalAttribute(reader, XmlMappingConstant.Provider);
if (!reader.IsEmptyElement) {
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement) {
if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) {
reader.Skip();
continue;
}
switch (reader.LocalName) {
case XmlMappingConstant.Table:
dm.Tables.Add(ReadTableMapping(reader));
break;
case XmlMappingConstant.Function:
dm.Functions.Add(ReadFunctionMapping(reader));
break;
default:
throw Error.UnrecognizedElement(String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
reader.MoveToContent();
}
if (reader.LocalName != XmlMappingConstant.Database) {
throw Error.UnexpectedElement(XmlMappingConstant.Database, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
reader.ReadEndElement();
}
else {
System.Diagnostics.Debug.Assert(false, "DatabaseMapping has no content");
reader.Skip();
}
return dm;
}
internal static bool IsInNamespace(XmlReader reader) {
return reader.LookupNamespace(reader.Prefix) == XmlMappingConstant.MappingNamespace;
}
internal static void ValidateAttributes(XmlReader reader, string[] validAttributes) {
if (reader.HasAttributes) {
List<string> attrList = new List<string>(validAttributes);
const string xmlns = "xmlns";
for (int i = 0; i < reader.AttributeCount; i++) {
reader.MoveToAttribute(i);
// if the node's in the namespace, it is required to be one of the valid ones
if (IsInNamespace(reader) && reader.LocalName != xmlns && !attrList.Contains(reader.LocalName)) {
throw Error.UnrecognizedAttribute(String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : ":", reader.LocalName));
}
}
reader.MoveToElement(); // Moves the reader back to the element node.
}
}
internal static FunctionMapping ReadFunctionMapping(XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Function) {
throw Error.UnexpectedElement(XmlMappingConstant.Function, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.Method,
XmlMappingConstant.IsComposable
});
FunctionMapping fm = new FunctionMapping();
fm.MethodName = RequiredAttribute(reader, XmlMappingConstant.Method);
fm.Name = OptionalAttribute(reader, XmlMappingConstant.Name);
fm.IsComposable = OptionalBoolAttribute(reader, XmlMappingConstant.IsComposable, false);
if (!reader.IsEmptyElement) {
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement) {
if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) {
reader.Skip();
continue;
}
switch (reader.LocalName) {
case XmlMappingConstant.Parameter:
fm.Parameters.Add(ReadParameterMapping(reader));
break;
case XmlMappingConstant.ElementType:
fm.Types.Add(ReadElementTypeMapping(null, reader));
break;
case XmlMappingConstant.Return:
fm.FunReturn = ReadReturnMapping(reader);
break;
default:
throw Error.UnrecognizedElement(String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
reader.MoveToContent();
}
reader.ReadEndElement();
}
else {
// no content is okay
reader.Skip();
}
return fm;
}
private static ReturnMapping ReadReturnMapping(XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Return) {
throw Error.UnexpectedElement(XmlMappingConstant.Return, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.DbType
});
ReturnMapping rm = new ReturnMapping();
rm.DbType = OptionalAttribute(reader, XmlMappingConstant.DbType);
AssertEmptyElement(reader);
return rm;
}
private static ParameterMapping ReadParameterMapping(XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Parameter) {
throw Error.UnexpectedElement(XmlMappingConstant.Parameter, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.DbType,
XmlMappingConstant.Parameter,
XmlMappingConstant.Direction
});
ParameterMapping pm = new ParameterMapping();
pm.Name = RequiredAttribute(reader, XmlMappingConstant.Name);
pm.ParameterName = RequiredAttribute(reader, XmlMappingConstant.Parameter);
pm.DbType = OptionalAttribute(reader, XmlMappingConstant.DbType);
pm.XmlDirection = OptionalAttribute(reader, XmlMappingConstant.Direction);
AssertEmptyElement(reader);
return pm;
}
private static TableMapping ReadTableMapping(XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Table) {
throw Error.UnexpectedElement(XmlMappingConstant.Table, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.Member
});
TableMapping tm = new TableMapping();
tm.TableName = OptionalAttribute(reader, XmlMappingConstant.Name);
tm.Member = OptionalAttribute(reader, XmlMappingConstant.Member);
if (!reader.IsEmptyElement) {
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement) {
if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) {
reader.Skip();
continue;
}
switch (reader.LocalName) {
case XmlMappingConstant.Type:
if (tm.RowType != null) {
goto default;
}
tm.RowType = ReadTypeMapping(null, reader);
break;
default:
throw Error.UnrecognizedElement(String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
reader.MoveToContent();
}
if (reader.LocalName != XmlMappingConstant.Table) {
throw Error.UnexpectedElement(XmlMappingConstant.Table, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
reader.ReadEndElement();
}
else {
System.Diagnostics.Debug.Assert(false, "Table has no content");
reader.Skip();
}
return tm;
}
private static TypeMapping ReadElementTypeMapping(TypeMapping baseType, XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.ElementType) {
throw Error.UnexpectedElement(XmlMappingConstant.Type, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
return ReadTypeMappingImpl(baseType, reader);
}
private static TypeMapping ReadTypeMapping(TypeMapping baseType, XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Type) {
throw Error.UnexpectedElement(XmlMappingConstant.Type, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
return ReadTypeMappingImpl(baseType, reader);
}
private static TypeMapping ReadTypeMappingImpl(TypeMapping baseType, XmlReader reader) {
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.InheritanceCode,
XmlMappingConstant.IsInheritanceDefault
});
TypeMapping tm = new TypeMapping();
tm.BaseType = baseType;
tm.Name = RequiredAttribute(reader, XmlMappingConstant.Name);
tm.InheritanceCode = OptionalAttribute(reader, XmlMappingConstant.InheritanceCode);
tm.IsInheritanceDefault = OptionalBoolAttribute(reader, XmlMappingConstant.IsInheritanceDefault, false);
if (!reader.IsEmptyElement) {
reader.ReadStartElement();
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement) {
if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) {
reader.Skip();
continue;
}
switch (reader.LocalName) {
case XmlMappingConstant.Type:
tm.DerivedTypes.Add(ReadTypeMapping(tm, reader));
break;
case XmlMappingConstant.Association:
tm.Members.Add(ReadAssociationMapping(reader));
break;
case XmlMappingConstant.Column:
tm.Members.Add(ReadColumnMapping(reader));
break;
default:
throw Error.UnrecognizedElement(String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
reader.MoveToContent();
}
reader.ReadEndElement();
}
else {
// no content is okay
reader.Skip();
}
return tm;
}
private static AssociationMapping ReadAssociationMapping(XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Association) {
throw Error.UnexpectedElement(XmlMappingConstant.Association, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.IsForeignKey,
XmlMappingConstant.IsUnique,
XmlMappingConstant.Member,
XmlMappingConstant.OtherKey,
XmlMappingConstant.Storage,
XmlMappingConstant.ThisKey,
XmlMappingConstant.DeleteRule,
XmlMappingConstant.DeleteOnNull,
});
AssociationMapping am = new AssociationMapping();
am.DbName = OptionalAttribute(reader, XmlMappingConstant.Name);
am.IsForeignKey = OptionalBoolAttribute(reader, XmlMappingConstant.IsForeignKey, false);
am.IsUnique = OptionalBoolAttribute(reader, XmlMappingConstant.IsUnique, false);
am.MemberName = RequiredAttribute(reader, XmlMappingConstant.Member);
am.OtherKey = OptionalAttribute(reader, XmlMappingConstant.OtherKey);
am.StorageMemberName = OptionalAttribute(reader, XmlMappingConstant.Storage);
am.ThisKey = OptionalAttribute(reader, XmlMappingConstant.ThisKey);
am.DeleteRule = OptionalAttribute(reader, XmlMappingConstant.DeleteRule);
am.DeleteOnNull = OptionalBoolAttribute(reader, XmlMappingConstant.DeleteOnNull, false);
AssertEmptyElement(reader);
return am;
}
private static ColumnMapping ReadColumnMapping(XmlReader reader) {
System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);
if (!IsInNamespace(reader) || reader.LocalName != XmlMappingConstant.Column) {
throw Error.UnexpectedElement(XmlMappingConstant.Column, String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}{2}", reader.Prefix, String.IsNullOrEmpty(reader.Prefix) ? "" : "/", reader.LocalName));
}
ValidateAttributes(reader, new[] {
XmlMappingConstant.Name,
XmlMappingConstant.DbType,
XmlMappingConstant.IsDbGenerated,
XmlMappingConstant.IsDiscriminator,
XmlMappingConstant.IsPrimaryKey,
XmlMappingConstant.IsVersion,
XmlMappingConstant.Member,
XmlMappingConstant.Storage,
XmlMappingConstant.Expression,
XmlMappingConstant.CanBeNull,
XmlMappingConstant.UpdateCheck,
XmlMappingConstant.AutoSync
});
ColumnMapping cm = new ColumnMapping();
cm.DbName = OptionalAttribute(reader, XmlMappingConstant.Name);
cm.DbType = OptionalAttribute(reader, XmlMappingConstant.DbType);
cm.IsDbGenerated = OptionalBoolAttribute(reader, XmlMappingConstant.IsDbGenerated, false);
cm.IsDiscriminator = OptionalBoolAttribute(reader, XmlMappingConstant.IsDiscriminator, false);
cm.IsPrimaryKey = OptionalBoolAttribute(reader, XmlMappingConstant.IsPrimaryKey, false);
cm.IsVersion = OptionalBoolAttribute(reader, XmlMappingConstant.IsVersion, false);
cm.MemberName = RequiredAttribute(reader, XmlMappingConstant.Member);
cm.StorageMemberName = OptionalAttribute(reader, XmlMappingConstant.Storage);
cm.Expression = OptionalAttribute(reader, XmlMappingConstant.Expression);
cm.CanBeNull = OptionalNullableBoolAttribute(reader, XmlMappingConstant.CanBeNull);
string updateCheck = OptionalAttribute(reader, XmlMappingConstant.UpdateCheck);
cm.UpdateCheck = (updateCheck == null) ? UpdateCheck.Always : (UpdateCheck)Enum.Parse(typeof(UpdateCheck), updateCheck);
string autoSync = OptionalAttribute(reader, XmlMappingConstant.AutoSync);
cm.AutoSync = (autoSync == null) ? AutoSync.Default : (AutoSync)Enum.Parse(typeof(AutoSync), autoSync);
AssertEmptyElement(reader);
return cm;
}
}
}