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;
|
|
}
|
|
}
|
|
}
|