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
609 lines
29 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|