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
1830 lines
76 KiB
C#
1830 lines
76 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq.Expressions;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Linq;
|
|
using System.Data.Linq.Provider;
|
|
using System.Data.Linq.Mapping;
|
|
using System.Data.Linq.SqlClient;
|
|
using System.Threading;
|
|
using System.Runtime.Versioning;
|
|
using LinqToSqlShared.Mapping;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace System.Data.Linq.Mapping {
|
|
|
|
internal class MappedMetaModel : MetaModel {
|
|
ReaderWriterLock @lock = new ReaderWriterLock();
|
|
MappingSource mappingSource;
|
|
Type contextType;
|
|
Type providerType;
|
|
DatabaseMapping mapping;
|
|
HashSet<Module> modules;
|
|
Dictionary<string, Type> types;
|
|
Dictionary<Type, MetaType> metaTypes;
|
|
Dictionary<Type, MetaTable> metaTables;
|
|
Dictionary<MetaPosition, MetaFunction> metaFunctions;
|
|
bool fullyLoaded;
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // mapping parameter contains various type references.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call.
|
|
internal MappedMetaModel(MappingSource mappingSource, Type contextType, DatabaseMapping mapping) {
|
|
this.mappingSource = mappingSource;
|
|
this.contextType = contextType;
|
|
this.mapping = mapping;
|
|
this.modules = new HashSet<Module>();
|
|
this.modules.Add(this.contextType.Module);
|
|
this.metaTypes = new Dictionary<Type, MetaType>();
|
|
this.metaTables = new Dictionary<Type, MetaTable>();
|
|
this.types = new Dictionary<string, Type>();
|
|
// Provider type
|
|
if (this.providerType == null && !String.IsNullOrEmpty(this.mapping.Provider)) {
|
|
this.providerType = this.FindType(this.mapping.Provider, typeof(SqlProvider).Namespace);
|
|
if (this.providerType == null) {
|
|
throw Error.ProviderTypeNotFound(this.mapping.Provider);
|
|
}
|
|
}
|
|
else if (this.providerType == null) {
|
|
this.providerType = typeof(SqlProvider);
|
|
}
|
|
this.Init();
|
|
}
|
|
#region Initialization
|
|
private void Init() {
|
|
if (!fullyLoaded) {
|
|
// The fullyLoaded state is required so that tools like
|
|
// CreateDatabase can get a full view of all tables.
|
|
@lock.AcquireWriterLock(Timeout.Infinite);
|
|
try {
|
|
if (!fullyLoaded) {
|
|
// Initialize static tables and functions.
|
|
this.InitStaticTables();
|
|
this.InitFunctions();
|
|
fullyLoaded = true;
|
|
}
|
|
}
|
|
finally {
|
|
@lock.ReleaseWriterLock();
|
|
}
|
|
}
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.None)] // Exposure is via external mapping file/attributes.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine, ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call.
|
|
private void InitStaticTables() {
|
|
this.InitStaticTableTypes();
|
|
foreach (TableMapping tableMapping in this.mapping.Tables) {
|
|
Type rowType = this.FindType(tableMapping.RowType.Name);
|
|
if (rowType == null) {
|
|
throw Error.CouldNotFindTypeFromMapping(tableMapping.RowType.Name);
|
|
}
|
|
Type rootType = this.GetRootType(rowType, tableMapping.RowType);
|
|
MetaTable table = new MappedTable(this, tableMapping, rootType);
|
|
foreach (MetaType mt in table.RowType.InheritanceTypes) {
|
|
this.metaTypes.Add(mt.Type, mt);
|
|
this.metaTables.Add(mt.Type, table);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void InitStaticTableTypes() {
|
|
for (Type type = this.contextType; type != typeof(DataContext); type = type.BaseType) {
|
|
FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
|
|
foreach (FieldInfo fi in fields) {
|
|
Type ft = fi.FieldType;
|
|
if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(Table<>)) {
|
|
Type rowType = ft.GetGenericArguments()[0];
|
|
if (!this.types.ContainsKey(rowType.Name)) {
|
|
this.types.Add(rowType.FullName, rowType);
|
|
if (!this.types.ContainsKey(rowType.Name)) {
|
|
this.types.Add(rowType.Name, rowType);
|
|
}
|
|
this.modules.Add(rowType.Module);
|
|
}
|
|
}
|
|
}
|
|
PropertyInfo[] props = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
|
|
foreach (PropertyInfo pi in props) {
|
|
Type pt = pi.PropertyType;
|
|
if (pt.IsGenericType && pt.GetGenericTypeDefinition() == typeof(Table<>)) {
|
|
Type rowType = pt.GetGenericArguments()[0];
|
|
if (!this.types.ContainsKey(rowType.Name)) {
|
|
this.types.Add(rowType.FullName, rowType);
|
|
if (!this.types.ContainsKey(rowType.Name)) {
|
|
this.types.Add(rowType.Name, rowType);
|
|
}
|
|
this.modules.Add(rowType.Module);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.None)] // mapping instance variable is set elsewhere.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine, ResourceScope.Assembly | ResourceScope.Machine)] // For GetMethods call.
|
|
private void InitFunctions() {
|
|
this.metaFunctions = new Dictionary<MetaPosition, MetaFunction>();
|
|
if (this.contextType != typeof(DataContext)) {
|
|
foreach (FunctionMapping fmap in this.mapping.Functions) {
|
|
MethodInfo method = this.GetMethod(fmap.MethodName);
|
|
if (method == null) {
|
|
throw Error.MethodCannotBeFound(fmap.MethodName);
|
|
}
|
|
MappedFunction func = new MappedFunction(this, fmap, method);
|
|
this.metaFunctions.Add(new MetaPosition(method), func);
|
|
|
|
// pre-set all known function result types into metaType map
|
|
foreach (MetaType rt in func.ResultRowTypes) {
|
|
foreach (MetaType it in rt.InheritanceTypes) {
|
|
if (!this.metaTypes.ContainsKey(it.Type)) {
|
|
this.metaTypes.Add(it.Type, it);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
public override MappingSource MappingSource {
|
|
get { return this.mappingSource; }
|
|
}
|
|
|
|
public override Type ContextType {
|
|
get { return this.contextType; }
|
|
}
|
|
|
|
public override string DatabaseName {
|
|
get { return this.mapping.DatabaseName; }
|
|
}
|
|
|
|
public override Type ProviderType {
|
|
get { return this.providerType; }
|
|
}
|
|
|
|
public override IEnumerable<MetaTable> GetTables() {
|
|
return this.metaTables.Values.Where(x => x != null).Distinct();
|
|
}
|
|
|
|
public override MetaTable GetTable(Type rowType) {
|
|
if (rowType == null) {
|
|
throw Error.ArgumentNull("rowType");
|
|
}
|
|
MetaTable table = null;
|
|
this.metaTables.TryGetValue(rowType, out table);
|
|
return table;
|
|
}
|
|
|
|
public override MetaType GetMetaType(Type type) {
|
|
if (type == null) {
|
|
throw Error.ArgumentNull("type");
|
|
}
|
|
MetaType mtype = null;
|
|
@lock.AcquireReaderLock(Timeout.Infinite);
|
|
try {
|
|
if (this.metaTypes.TryGetValue(type, out mtype)) {
|
|
return mtype;
|
|
}
|
|
}
|
|
finally {
|
|
@lock.ReleaseReaderLock();
|
|
}
|
|
@lock.AcquireWriterLock(Timeout.Infinite);
|
|
try {
|
|
if (!this.metaTypes.TryGetValue(type, out mtype)) {
|
|
// not known, so must be unmapped type
|
|
mtype = new UnmappedType(this, type);
|
|
this.metaTypes.Add(type, mtype);
|
|
}
|
|
}
|
|
finally {
|
|
@lock.ReleaseWriterLock();
|
|
}
|
|
return mtype;
|
|
}
|
|
|
|
public override MetaFunction GetFunction(MethodInfo method) {
|
|
if (method == null) {
|
|
throw new ArgumentNullException("method");
|
|
}
|
|
MetaFunction func = null;
|
|
this.metaFunctions.TryGetValue(new MetaPosition(method), out func);
|
|
return func;
|
|
}
|
|
|
|
public override IEnumerable<MetaFunction> GetFunctions() {
|
|
return this.metaFunctions.Values;
|
|
}
|
|
|
|
private Type GetRootType(Type type, TypeMapping rootMapping) {
|
|
if (string.Compare(rootMapping.Name, type.Name, StringComparison.Ordinal) == 0
|
|
|| string.Compare(rootMapping.Name, type.FullName, StringComparison.Ordinal) == 0
|
|
|| string.Compare(rootMapping.Name, type.AssemblyQualifiedName, StringComparison.Ordinal) == 0)
|
|
return type;
|
|
if (type.BaseType != typeof(object)) {
|
|
return this.GetRootType(type.BaseType, rootMapping);
|
|
}
|
|
throw Error.UnableToResolveRootForType(type);
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // name parameter will be found on a type.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call.
|
|
private MethodInfo GetMethod(string name) {
|
|
string typeName, methodName;
|
|
this.GetTypeAndMethod(name, out typeName, out methodName);
|
|
Type type = this.FindType(typeName);
|
|
if (type != null) {
|
|
return type.GetMethod(methodName, BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void GetTypeAndMethod(string name, out string typeName, out string methodName) {
|
|
int dotIndex = name.LastIndexOf(".", StringComparison.CurrentCulture);
|
|
if (dotIndex > 0) {
|
|
typeName = name.Substring(0, dotIndex);
|
|
methodName = name.Substring(dotIndex + 1);
|
|
}
|
|
else {
|
|
typeName = this.contextType.FullName;
|
|
methodName = name;
|
|
}
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // name parameter is a type name.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call.
|
|
internal Type FindType(string name) {
|
|
return this.FindType(name, this.contextType.Namespace);
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // name parameter is a type name.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // SearchForType method call.
|
|
internal Type FindType(string name, string defaultNamespace) {
|
|
Type result = null;
|
|
string name2 = null;
|
|
@lock.AcquireReaderLock(Timeout.Infinite);
|
|
try {
|
|
if (this.types.TryGetValue(name, out result)) {
|
|
return result;
|
|
}
|
|
name2 = name.Contains(".") ? null : defaultNamespace + "." + name;
|
|
if (name2 != null && this.types.TryGetValue(name2, out result)) {
|
|
return result;
|
|
}
|
|
}
|
|
finally {
|
|
@lock.ReleaseReaderLock();
|
|
}
|
|
// don't block anyone while we search for the correct type
|
|
Type foundResult = this.SearchForType(name);
|
|
|
|
if (foundResult == null && name2 != null) {
|
|
foundResult = this.SearchForType(name2);
|
|
}
|
|
if (foundResult != null) {
|
|
@lock.AcquireWriterLock(Timeout.Infinite);
|
|
try {
|
|
if (this.types.TryGetValue(name, out result)) {
|
|
return result;
|
|
}
|
|
this.types.Add(name, foundResult);
|
|
return foundResult;
|
|
}
|
|
finally {
|
|
@lock.ReleaseWriterLock();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // name parameter is a type name.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // SearchForType method call.
|
|
private Type SearchForType(string name) {
|
|
// Try search for type using case sensitive.
|
|
Type type = SearchForType(name, false);
|
|
if (type != null) {
|
|
return type;
|
|
}
|
|
|
|
// Try search for type using case in-sensitive.
|
|
return SearchForType(name, true);
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // name parameter is a type name.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // Assembly.GetLoadedModules method call.
|
|
private Type SearchForType(string name, bool ignoreCase) {
|
|
// first try default system lookup
|
|
Type type = Type.GetType(name, false, ignoreCase);
|
|
if (type != null) {
|
|
return type;
|
|
}
|
|
|
|
// try all known modules (modules that other statically known types were found in)
|
|
foreach (Module module in this.modules) {
|
|
type = module.GetType(name, false, ignoreCase);
|
|
if (type != null) {
|
|
return type;
|
|
}
|
|
}
|
|
|
|
// try all loaded modules (is there a better way?)
|
|
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) {
|
|
foreach (Module module in a.GetLoadedModules()) {
|
|
type = module.GetType(name, false, ignoreCase);
|
|
if (type != null) {
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal sealed class MappedTable : MetaTable {
|
|
MappedMetaModel model;
|
|
TableMapping mapping;
|
|
MetaType rowType;
|
|
bool hasMethods;
|
|
MethodInfo insertMethod;
|
|
MethodInfo updateMethod;
|
|
MethodInfo deleteMethod;
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // Parameter contains various type references.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // MappedRootType constructor call.
|
|
internal MappedTable(MappedMetaModel model, TableMapping mapping, Type rowType) {
|
|
this.model = model;
|
|
this.mapping = mapping;
|
|
this.rowType = new MappedRootType(model, this, mapping.RowType, rowType);
|
|
}
|
|
public override MetaModel Model {
|
|
get { return this.model; }
|
|
}
|
|
public override string TableName {
|
|
get { return this.mapping.TableName; }
|
|
}
|
|
public override MetaType RowType {
|
|
get { return this.rowType; }
|
|
}
|
|
public override MethodInfo InsertMethod {
|
|
get {
|
|
this.InitMethods();
|
|
return this.insertMethod;
|
|
}
|
|
}
|
|
public override MethodInfo UpdateMethod {
|
|
get {
|
|
this.InitMethods();
|
|
return this.updateMethod;
|
|
}
|
|
}
|
|
public override MethodInfo DeleteMethod {
|
|
get {
|
|
this.InitMethods();
|
|
return this.deleteMethod;
|
|
}
|
|
}
|
|
private void InitMethods() {
|
|
if (!this.hasMethods) {
|
|
this.insertMethod = MethodFinder.FindMethod(
|
|
this.model.ContextType,
|
|
"Insert" + rowType.Name,
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
new Type[] { rowType.Type }
|
|
);
|
|
this.updateMethod = MethodFinder.FindMethod(
|
|
this.model.ContextType,
|
|
"Update" + rowType.Name,
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
new Type[] { rowType.Type }
|
|
);
|
|
this.deleteMethod = MethodFinder.FindMethod(
|
|
this.model.ContextType,
|
|
"Delete" + rowType.Name,
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
new Type[] { rowType.Type }
|
|
);
|
|
this.hasMethods = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class MappedRootType : MappedType {
|
|
Dictionary<Type, MetaType> derivedTypes;
|
|
Dictionary<object, MetaType> inheritanceCodes;
|
|
ReadOnlyCollection<MetaType> inheritanceTypes;
|
|
MetaType inheritanceDefault;
|
|
bool hasInheritance;
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // Various parameters can contain type names.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // InitInheritedType method call.
|
|
public MappedRootType(MappedMetaModel model, MappedTable table, TypeMapping typeMapping, Type type)
|
|
: base(model, table, typeMapping, type, null) {
|
|
if (typeMapping == null)
|
|
throw Error.ArgumentNull("typeMapping");
|
|
|
|
if (typeMapping.InheritanceCode != null || typeMapping.DerivedTypes.Count > 0) {
|
|
if (this.Discriminator == null) {
|
|
throw Error.NoDiscriminatorFound(type.Name);
|
|
}
|
|
this.hasInheritance = true;
|
|
if (!MappingSystem.IsSupportedDiscriminatorType(this.Discriminator.Type)) {
|
|
throw Error.DiscriminatorClrTypeNotSupported(this.Discriminator.DeclaringType.Name, this.Discriminator.Name, this.Discriminator.Type);
|
|
}
|
|
this.derivedTypes = new Dictionary<Type, MetaType>();
|
|
this.inheritanceCodes = new Dictionary<object, MetaType>();
|
|
this.InitInheritedType(typeMapping, this);
|
|
}
|
|
|
|
if (this.inheritanceDefault == null && (this.inheritanceCode != null || this.inheritanceCodes != null && this.inheritanceCodes.Count > 0))
|
|
throw Error.InheritanceHierarchyDoesNotDefineDefault(type);
|
|
|
|
if (this.derivedTypes != null) {
|
|
this.inheritanceTypes = this.derivedTypes.Values.ToList().AsReadOnly();
|
|
}
|
|
else {
|
|
this.inheritanceTypes = new MetaType[] { this }.ToList().AsReadOnly();
|
|
}
|
|
|
|
this.Validate();
|
|
}
|
|
|
|
private void Validate() {
|
|
Dictionary<object, string> memberToColumn = new Dictionary<object, string>();
|
|
foreach (MetaType type in this.InheritanceTypes) {
|
|
// NB: Table node in XML can have only one Type node -- enforced by XSD
|
|
|
|
foreach (MetaDataMember mem in type.PersistentDataMembers) {
|
|
if (mem.IsDeclaredBy(type)) {
|
|
if (mem.IsDiscriminator && !this.HasInheritance) {
|
|
throw Error.NonInheritanceClassHasDiscriminator(type);
|
|
}
|
|
if (!mem.IsAssociation) {
|
|
// validate that no database column is mapped twice
|
|
if (!string.IsNullOrEmpty(mem.MappedName)) {
|
|
string column;
|
|
object dn = InheritanceRules.DistinguishedMemberName(mem.Member);
|
|
if (memberToColumn.TryGetValue(dn, out column)) {
|
|
if (column != mem.MappedName) {
|
|
throw Error.MemberMappedMoreThanOnce(mem.Member.Name);
|
|
}
|
|
}
|
|
else {
|
|
memberToColumn.Add(dn, mem.MappedName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // typeMap parameter's Name property.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call.
|
|
private MetaType InitDerivedTypes(TypeMapping typeMap) {
|
|
Type type = ((MappedMetaModel)Model).FindType(typeMap.Name);
|
|
if (type == null)
|
|
throw Error.CouldNotFindRuntimeTypeForMapping(typeMap.Name);
|
|
MappedType rowType = new MappedType(this.Model, this.Table, typeMap, type, this);
|
|
return this.InitInheritedType(typeMap, rowType);
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // typeMap parameter's Name property.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // InitDerivedTypes method call.
|
|
private MetaType InitInheritedType(TypeMapping typeMap, MappedType type) {
|
|
this.derivedTypes.Add(type.Type, type);
|
|
|
|
if (typeMap.InheritanceCode != null) { // Mapping with no inheritance code: For example, an unmapped intermediate class in a hierarchy.
|
|
if (this.Discriminator == null)
|
|
throw Error.NoDiscriminatorFound(type.Name);
|
|
|
|
if (type.Type.IsAbstract)
|
|
throw Error.AbstractClassAssignInheritanceDiscriminator(type.Type);
|
|
|
|
object keyValue = DBConvert.ChangeType(typeMap.InheritanceCode, this.Discriminator.Type);
|
|
foreach (object d in inheritanceCodes.Keys) {
|
|
// if the keys are equal, or if they are both strings containing only spaces
|
|
// they are considered equal
|
|
if ((keyValue.GetType() == typeof(string) && ((string)keyValue).Trim().Length == 0 &&
|
|
d.GetType() == typeof(string) && ((string)d).Trim().Length == 0) ||
|
|
object.Equals(d, keyValue)) {
|
|
throw Error.InheritanceCodeUsedForMultipleTypes(keyValue);
|
|
}
|
|
}
|
|
if (type.inheritanceCode != null)
|
|
throw Error.InheritanceTypeHasMultipleDiscriminators(type);
|
|
type.inheritanceCode = keyValue;
|
|
this.inheritanceCodes.Add(keyValue, type);
|
|
if (typeMap.IsInheritanceDefault) {
|
|
if (this.inheritanceDefault != null)
|
|
throw Error.InheritanceTypeHasMultipleDefaults(type);
|
|
this.inheritanceDefault = type;
|
|
}
|
|
}
|
|
|
|
// init sub-inherited types
|
|
foreach (TypeMapping tm in typeMap.DerivedTypes) {
|
|
this.InitDerivedTypes(tm);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
public override bool HasInheritance {
|
|
get { return this.hasInheritance; }
|
|
}
|
|
|
|
public override bool HasInheritanceCode {
|
|
get { return this.InheritanceCode != null; }
|
|
}
|
|
|
|
public override ReadOnlyCollection<MetaType> InheritanceTypes {
|
|
get { return this.inheritanceTypes; }
|
|
}
|
|
|
|
public override MetaType GetInheritanceType(Type type) {
|
|
if (type == this.Type)
|
|
return this;
|
|
MetaType metaType = null;
|
|
if (this.derivedTypes != null) {
|
|
this.derivedTypes.TryGetValue(type, out metaType);
|
|
}
|
|
return metaType;
|
|
}
|
|
|
|
public override MetaType InheritanceDefault {
|
|
get { return this.inheritanceDefault; }
|
|
}
|
|
}
|
|
|
|
internal class MappedType : MetaType {
|
|
MetaModel model;
|
|
MetaTable table;
|
|
Type type;
|
|
TypeMapping typeMapping;
|
|
Dictionary<object, MetaDataMember> dataMemberMap;
|
|
ReadOnlyCollection<MetaDataMember> dataMembers;
|
|
ReadOnlyCollection<MetaDataMember> persistentDataMembers;
|
|
ReadOnlyCollection<MetaDataMember> identities;
|
|
MetaDataMember dbGeneratedIdentity;
|
|
MetaDataMember version;
|
|
MetaDataMember discriminator;
|
|
MetaType inheritanceRoot;
|
|
bool inheritanceBaseSet;
|
|
MetaType inheritanceBase;
|
|
internal object inheritanceCode;
|
|
ReadOnlyCollection<MetaType> derivedTypes;
|
|
ReadOnlyCollection<MetaAssociation> associations;
|
|
bool hasMethods;
|
|
bool hasAnyLoadMethod;
|
|
bool hasAnyValidateMethod;
|
|
MethodInfo onLoadedMethod;
|
|
MethodInfo onValidateMethod;
|
|
|
|
object locktarget = new object(); // Hold locks on private object rather than public MetaType.
|
|
|
|
internal MappedType(MetaModel model, MetaTable table, TypeMapping typeMapping, Type type, MetaType inheritanceRoot) {
|
|
this.model = model;
|
|
this.table = table;
|
|
this.typeMapping = typeMapping;
|
|
this.type = type;
|
|
this.inheritanceRoot = inheritanceRoot != null ? inheritanceRoot : this;
|
|
this.InitDataMembers();
|
|
|
|
this.identities = this.dataMembers.Where(m => m.IsPrimaryKey).ToList().AsReadOnly();
|
|
this.persistentDataMembers = this.dataMembers.Where(m => m.IsPersistent).ToList().AsReadOnly();
|
|
}
|
|
#region Initialization
|
|
private void ValidatePrimaryKeyMember(MetaDataMember mm) {
|
|
//if the type is a sub-type, no member in the type can be primary key
|
|
if (mm.IsPrimaryKey && this.inheritanceRoot != this && mm.Member.DeclaringType == this.type) {
|
|
throw (Error.PrimaryKeyInSubTypeNotSupported(this.type.Name, mm.Name));
|
|
}
|
|
}
|
|
|
|
private void InitMethods() {
|
|
if (!this.hasMethods) {
|
|
this.onLoadedMethod = MethodFinder.FindMethod(
|
|
this.Type,
|
|
"OnLoaded",
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
Type.EmptyTypes,
|
|
false
|
|
);
|
|
this.onValidateMethod = MethodFinder.FindMethod(
|
|
this.Type,
|
|
"OnValidate",
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
new[] { typeof(ChangeAction) },
|
|
false
|
|
);
|
|
|
|
this.hasAnyLoadMethod = (this.onLoadedMethod != null) || (this.InheritanceBase != null && this.InheritanceBase.HasAnyLoadMethod);
|
|
this.hasAnyValidateMethod = (this.onValidateMethod != null) || (this.InheritanceBase != null && this.InheritanceBase.HasAnyValidateMethod);
|
|
|
|
this.hasMethods = true;
|
|
}
|
|
}
|
|
|
|
private void InitDataMembers() {
|
|
if (this.dataMembers == null) {
|
|
Dictionary<object, MetaDataMember> map = new Dictionary<object, MetaDataMember>();
|
|
List<MetaDataMember> dMembers = new List<MetaDataMember>();
|
|
int ordinal = 0;
|
|
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
|
|
|
|
// Map of valid mapped names.
|
|
Dictionary<string, MemberMapping> names = new Dictionary<string, MemberMapping>();
|
|
Type currentType = this.type;
|
|
for (TypeMapping tm = this.typeMapping; tm != null; tm = tm.BaseType) {
|
|
foreach (MemberMapping mmap in tm.Members) {
|
|
names[mmap.MemberName + ":" + currentType.Name] = mmap;
|
|
}
|
|
currentType = currentType.BaseType;
|
|
}
|
|
|
|
HashSet<string> namesSeen = new HashSet<string>(); // Keep track of which names from the mapping file have been seen.
|
|
FieldInfo[] fis = TypeSystem.GetAllFields(this.type, flags).ToArray();
|
|
if (fis != null) {
|
|
foreach (FieldInfo fi in fis) {
|
|
MemberMapping mmap;
|
|
string name = fi.Name + ":" + fi.DeclaringType.Name;
|
|
if (names.TryGetValue(name, out mmap)) {
|
|
namesSeen.Add(name);
|
|
object dn = InheritanceRules.DistinguishedMemberName(fi);
|
|
MetaDataMember mm;
|
|
if (!map.TryGetValue(dn, out mm)) {
|
|
mm = new MappedDataMember(this, fi, mmap, ordinal);
|
|
map.Add(InheritanceRules.DistinguishedMemberName(mm.Member), mm);
|
|
dMembers.Add(mm);
|
|
this.InitSpecialMember(mm);
|
|
}
|
|
ValidatePrimaryKeyMember(mm);
|
|
ordinal++;
|
|
}
|
|
}
|
|
}
|
|
|
|
PropertyInfo[] pis = TypeSystem.GetAllProperties(this.type, flags).ToArray();
|
|
if (pis != null) {
|
|
foreach (PropertyInfo pi in pis) {
|
|
MemberMapping mmap;
|
|
string name = pi.Name + ":" + pi.DeclaringType.Name;
|
|
if (names.TryGetValue(name, out mmap)) {
|
|
namesSeen.Add(name);
|
|
MetaDataMember mm;
|
|
object dn = InheritanceRules.DistinguishedMemberName(pi);
|
|
if (!map.TryGetValue(dn, out mm)) {
|
|
mm = new MappedDataMember(this, pi, mmap, ordinal);
|
|
map.Add(InheritanceRules.DistinguishedMemberName(mm.Member), mm);
|
|
dMembers.Add(mm);
|
|
this.InitSpecialMember(mm);
|
|
}
|
|
ValidatePrimaryKeyMember(mm);
|
|
ordinal++;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.dataMembers = dMembers.AsReadOnly();
|
|
this.dataMemberMap = map;
|
|
|
|
// Finally, make sure that all types in the mapping file were consumed.
|
|
foreach(string name in namesSeen) {
|
|
names.Remove(name);
|
|
}
|
|
foreach(var orphan in names) {
|
|
Type aboveRoot = inheritanceRoot.Type.BaseType;
|
|
while (aboveRoot!=null) {
|
|
foreach(MemberInfo mi in aboveRoot.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) {
|
|
if(String.Compare(mi.Name, orphan.Value.MemberName, StringComparison.Ordinal)==0) {
|
|
throw Error.MappedMemberHadNoCorrespondingMemberInType(orphan.Value.MemberName, type.Name);
|
|
}
|
|
}
|
|
aboveRoot = aboveRoot.BaseType;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private void InitSpecialMember(MetaDataMember mm) {
|
|
// Can only have one auto gen member that is also an identity member,
|
|
// except if that member is a computed column (since they are implicitly auto gen)
|
|
if (mm.IsDbGenerated && mm.IsPrimaryKey && string.IsNullOrEmpty(mm.Expression)) {
|
|
if (this.dbGeneratedIdentity != null) {
|
|
throw Error.TwoMembersMarkedAsPrimaryKeyAndDBGenerated(mm.Member, this.dbGeneratedIdentity.Member);
|
|
}
|
|
this.dbGeneratedIdentity = mm;
|
|
}
|
|
if (mm.IsPrimaryKey && !MappingSystem.IsSupportedIdentityType(mm.Type))
|
|
{
|
|
throw Error.IdentityClrTypeNotSupported(mm.DeclaringType, mm.Name, mm.Type);
|
|
}
|
|
if (mm.IsVersion) {
|
|
if (this.version != null) {
|
|
throw Error.TwoMembersMarkedAsRowVersion(mm.Member, this.version.Member);
|
|
}
|
|
this.version = mm;
|
|
}
|
|
if (mm.IsDiscriminator) {
|
|
if (this.discriminator != null) {
|
|
if (!InheritanceRules.AreSameMember(this.discriminator.Member, mm.Member)) {
|
|
throw Error.TwoMembersMarkedAsInheritanceDiscriminator(mm.Member, this.discriminator.Member);
|
|
}
|
|
}
|
|
else {
|
|
this.discriminator = mm;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
public override MetaModel Model {
|
|
get { return this.model; }
|
|
}
|
|
public override MetaTable Table {
|
|
get { return this.table; }
|
|
}
|
|
public override Type Type {
|
|
get { return this.type; }
|
|
}
|
|
public override string Name {
|
|
get { return this.type.Name; }
|
|
}
|
|
public override bool IsEntity {
|
|
get {
|
|
if (this.table != null) {
|
|
return table.RowType.IdentityMembers.Count > 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|
|
public override bool CanInstantiate {
|
|
get { return !this.type.IsAbstract && (this == this.InheritanceRoot || this.HasInheritanceCode); }
|
|
}
|
|
public override MetaDataMember DBGeneratedIdentityMember {
|
|
get { return this.dbGeneratedIdentity; }
|
|
}
|
|
public override MetaDataMember VersionMember {
|
|
get { return this.version; }
|
|
}
|
|
public override MetaDataMember Discriminator {
|
|
get { return this.discriminator; }
|
|
}
|
|
public override bool HasUpdateCheck {
|
|
get {
|
|
foreach (MetaDataMember member in this.PersistentDataMembers) {
|
|
if (member.UpdateCheck != UpdateCheck.Never) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
public override bool HasInheritance {
|
|
get { return this.inheritanceRoot.HasInheritance; }
|
|
}
|
|
public override object InheritanceCode {
|
|
get { return this.inheritanceCode; }
|
|
}
|
|
public override bool HasInheritanceCode {
|
|
get { return this.InheritanceCode != null; }
|
|
}
|
|
public override bool IsInheritanceDefault {
|
|
get { return this.InheritanceDefault == this; }
|
|
}
|
|
public override MetaType InheritanceDefault {
|
|
get {
|
|
if (this.inheritanceRoot == this)
|
|
throw Error.CannotGetInheritanceDefaultFromNonInheritanceClass();
|
|
return this.InheritanceRoot.InheritanceDefault;
|
|
}
|
|
}
|
|
public override MetaType InheritanceRoot {
|
|
get { return this.inheritanceRoot; }
|
|
}
|
|
public override MetaType InheritanceBase {
|
|
get {
|
|
// LOCKING: Cannot initialize at construction
|
|
if (!this.inheritanceBaseSet && this.inheritanceBase == null) {
|
|
lock (this.locktarget) {
|
|
if (this.inheritanceBase == null) {
|
|
this.inheritanceBase = InheritanceBaseFinder.FindBase(this);
|
|
this.inheritanceBaseSet = true;
|
|
}
|
|
}
|
|
}
|
|
return this.inheritanceBase;
|
|
}
|
|
}
|
|
public override ReadOnlyCollection<MetaType> InheritanceTypes {
|
|
get { return this.inheritanceRoot.InheritanceTypes; }
|
|
}
|
|
public override ReadOnlyCollection<MetaType> DerivedTypes {
|
|
get {
|
|
// LOCKING: Cannot initialize at construction because derived types
|
|
// won't exist yet.
|
|
if (this.derivedTypes == null) {
|
|
lock (this.locktarget) {
|
|
if (this.derivedTypes == null) {
|
|
List<MetaType> dTypes = new List<MetaType>();
|
|
foreach (MetaType mt in this.InheritanceTypes) {
|
|
if (mt.Type.BaseType == this.type)
|
|
dTypes.Add(mt);
|
|
}
|
|
this.derivedTypes = dTypes.AsReadOnly();
|
|
}
|
|
}
|
|
}
|
|
return this.derivedTypes;
|
|
}
|
|
}
|
|
public override MetaType GetInheritanceType(Type inheritanceType) {
|
|
foreach (MetaType mt in this.InheritanceTypes)
|
|
if (mt.Type == inheritanceType)
|
|
return mt;
|
|
return null;
|
|
}
|
|
public override MetaType GetTypeForInheritanceCode(object key) {
|
|
if (this.InheritanceRoot.Discriminator.Type == typeof(string)) {
|
|
string skey = (string)key;
|
|
foreach (MetaType mt in this.InheritanceRoot.InheritanceTypes) {
|
|
if (string.Compare((string)mt.InheritanceCode, skey, StringComparison.OrdinalIgnoreCase) == 0)
|
|
return mt;
|
|
}
|
|
}
|
|
else {
|
|
foreach (MetaType mt in this.InheritanceRoot.InheritanceTypes) {
|
|
if (object.Equals(mt.InheritanceCode, key))
|
|
return mt;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> DataMembers {
|
|
get { return this.dataMembers; }
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> PersistentDataMembers {
|
|
get { return this.persistentDataMembers; }
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> IdentityMembers {
|
|
get { return this.identities; }
|
|
}
|
|
public override ReadOnlyCollection<MetaAssociation> Associations {
|
|
get {
|
|
// LOCKING: Associations are late-expanded so that cycles are broken.
|
|
if (this.associations == null) {
|
|
lock (this.locktarget) {
|
|
if (this.associations == null) {
|
|
this.associations = this.dataMembers.Where(m => m.IsAssociation).Select(m => m.Association).ToList().AsReadOnly();
|
|
}
|
|
}
|
|
}
|
|
return this.associations;
|
|
}
|
|
}
|
|
public override MetaDataMember GetDataMember(MemberInfo mi) {
|
|
if (mi == null)
|
|
throw Error.ArgumentNull("mi");
|
|
MetaDataMember mm;
|
|
if (this.dataMemberMap.TryGetValue(InheritanceRules.DistinguishedMemberName(mi), out mm)) {
|
|
return mm;
|
|
} else {
|
|
if (mi.DeclaringType.IsInterface) {
|
|
throw Error.MappingOfInterfacesMemberIsNotSupported(mi.DeclaringType.Name, mi.Name);
|
|
} else { //the member is not mapped in the base class
|
|
throw Error.UnmappedClassMember(mi.DeclaringType.Name, mi.Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override MethodInfo OnLoadedMethod {
|
|
get {
|
|
this.InitMethods();
|
|
return this.onLoadedMethod;
|
|
}
|
|
}
|
|
|
|
public override MethodInfo OnValidateMethod {
|
|
get {
|
|
this.InitMethods();
|
|
return this.onValidateMethod;
|
|
}
|
|
}
|
|
public override bool HasAnyValidateMethod {
|
|
get {
|
|
this.InitMethods();
|
|
return this.hasAnyValidateMethod;
|
|
}
|
|
}
|
|
public override bool HasAnyLoadMethod {
|
|
get {
|
|
this.InitMethods();
|
|
return this.hasAnyLoadMethod;
|
|
}
|
|
}
|
|
|
|
public override string ToString() {
|
|
return this.Name;
|
|
}
|
|
}
|
|
|
|
internal sealed class MappedDataMember : MetaDataMember {
|
|
MetaType declaringType;
|
|
MemberInfo member;
|
|
MemberInfo storageMember;
|
|
int ordinal;
|
|
Type type;
|
|
bool hasAccessors;
|
|
MetaAccessor accPublic;
|
|
MetaAccessor accPrivate;
|
|
MetaAccessor accDefValue;
|
|
MetaAccessor accDefSource;
|
|
MemberMapping memberMap;
|
|
MappedAssociation assoc;
|
|
bool isNullableType;
|
|
bool isDeferred;
|
|
bool isPrimaryKey;
|
|
bool isVersion;
|
|
bool isDBGenerated;
|
|
bool isDiscriminator;
|
|
bool canBeNull = true;
|
|
string dbType;
|
|
string expression;
|
|
string mappedName;
|
|
UpdateCheck updateCheck = UpdateCheck.Never;
|
|
AutoSync autoSync = AutoSync.Never;
|
|
object locktarget = new object(); // Hold locks on private object rather than public MetaType.
|
|
bool hasLoadMethod;
|
|
MethodInfo loadMethod;
|
|
|
|
internal MappedDataMember(MetaType declaringType, MemberInfo mi, MemberMapping map, int ordinal) {
|
|
this.declaringType = declaringType;
|
|
this.member = mi;
|
|
this.ordinal = ordinal;
|
|
this.type = TypeSystem.GetMemberType(mi);
|
|
this.isNullableType = TypeSystem.IsNullableType(this.type);
|
|
this.memberMap = map;
|
|
if (this.memberMap != null && this.memberMap.StorageMemberName != null) {
|
|
MemberInfo[] mis = mi.DeclaringType.GetMember(this.memberMap.StorageMemberName, BindingFlags.Instance | BindingFlags.NonPublic);
|
|
if (mis == null || mis.Length != 1) {
|
|
throw Error.BadStorageProperty(this.memberMap.StorageMemberName, mi.DeclaringType, mi.Name);
|
|
}
|
|
this.storageMember = mis[0];
|
|
}
|
|
Type storageType = this.storageMember != null ? TypeSystem.GetMemberType(this.storageMember) : this.type;
|
|
this.isDeferred = IsDeferredType(storageType);
|
|
ColumnMapping cmap = map as ColumnMapping;
|
|
if (cmap != null && cmap.IsDbGenerated && cmap.IsPrimaryKey) {
|
|
// auto-gen identities must be synced on insert
|
|
if ((cmap.AutoSync != AutoSync.Default) && (cmap.AutoSync != AutoSync.OnInsert)) {
|
|
throw Error.IncorrectAutoSyncSpecification(mi.Name);
|
|
}
|
|
}
|
|
if (cmap != null) {
|
|
this.isPrimaryKey = cmap.IsPrimaryKey;
|
|
this.isVersion = cmap.IsVersion;
|
|
this.isDBGenerated = cmap.IsDbGenerated || !string.IsNullOrEmpty(cmap.Expression) || this.isVersion;
|
|
this.isDiscriminator = cmap.IsDiscriminator;
|
|
this.canBeNull = cmap.CanBeNull == null ? this.isNullableType || !this.type.IsValueType : (bool)cmap.CanBeNull;
|
|
this.dbType = cmap.DbType;
|
|
this.expression = cmap.Expression;
|
|
this.updateCheck = cmap.UpdateCheck;
|
|
// auto-gen keys are always and only synced on insert
|
|
if (this.IsDbGenerated && this.IsPrimaryKey) {
|
|
this.autoSync = AutoSync.OnInsert;
|
|
}
|
|
else if (cmap.AutoSync != AutoSync.Default) {
|
|
// if the user has explicitly set it, use their value
|
|
this.autoSync = cmap.AutoSync;
|
|
}
|
|
else if (this.IsDbGenerated) {
|
|
// database generated members default to always
|
|
this.autoSync = AutoSync.Always;
|
|
}
|
|
}
|
|
this.mappedName = this.memberMap.DbName != null ? this.memberMap.DbName : this.member.Name;
|
|
}
|
|
private void InitAccessors() {
|
|
if (!this.hasAccessors) {
|
|
lock (this.locktarget) {
|
|
if (!this.hasAccessors) {
|
|
if (this.storageMember != null) {
|
|
this.accPrivate = MakeMemberAccessor(this.member.ReflectedType, this.storageMember, null);
|
|
if (this.isDeferred) {
|
|
MakeDeferredAccessors(this.member.ReflectedType, this.accPrivate, out this.accPrivate, out this.accDefValue, out this.accDefSource);
|
|
}
|
|
this.accPublic = MakeMemberAccessor(this.member.ReflectedType, this.member, this.accPrivate);
|
|
}
|
|
else {
|
|
this.accPublic = this.accPrivate = MakeMemberAccessor(this.member.ReflectedType, this.member, null);
|
|
if (this.isDeferred) {
|
|
MakeDeferredAccessors(this.member.ReflectedType, this.accPrivate, out this.accPrivate, out this.accDefValue, out this.accDefSource);
|
|
}
|
|
}
|
|
this.hasAccessors = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public override MetaType DeclaringType {
|
|
get { return this.declaringType; }
|
|
}
|
|
public override bool IsDeclaredBy(MetaType metaType) {
|
|
if (metaType == null) {
|
|
throw Error.ArgumentNull("metaType");
|
|
}
|
|
return metaType.Type == this.member.DeclaringType;
|
|
}
|
|
public override MemberInfo Member {
|
|
get { return this.member; }
|
|
}
|
|
public override MemberInfo StorageMember {
|
|
get { return this.storageMember; }
|
|
}
|
|
public override string Name {
|
|
get { return this.member.Name; }
|
|
}
|
|
public override int Ordinal {
|
|
get { return this.ordinal; }
|
|
}
|
|
public override Type Type {
|
|
get { return this.type; }
|
|
}
|
|
public override MetaAccessor MemberAccessor {
|
|
get {
|
|
this.InitAccessors();
|
|
return this.accPublic;
|
|
}
|
|
}
|
|
public override MetaAccessor StorageAccessor {
|
|
get {
|
|
this.InitAccessors();
|
|
return this.accPrivate;
|
|
}
|
|
}
|
|
public override MetaAccessor DeferredValueAccessor {
|
|
get {
|
|
this.InitAccessors();
|
|
return this.accDefValue;
|
|
}
|
|
}
|
|
public override MetaAccessor DeferredSourceAccessor {
|
|
get {
|
|
this.InitAccessors();
|
|
return this.accDefSource;
|
|
}
|
|
}
|
|
public override bool IsDeferred {
|
|
get { return this.isDeferred; }
|
|
}
|
|
public override bool IsPersistent {
|
|
get { return this.memberMap != null; }
|
|
}
|
|
public override bool IsAssociation {
|
|
get { return this.memberMap is AssociationMapping; }
|
|
}
|
|
public override bool IsPrimaryKey {
|
|
get { return this.isPrimaryKey; }
|
|
}
|
|
/// <summary>
|
|
/// Returns true if the member is explicitly marked as auto gen, or if the
|
|
/// member is computed or generated by the database server.
|
|
/// </summary>
|
|
public override bool IsDbGenerated {
|
|
get { return this.isDBGenerated; }
|
|
}
|
|
public override bool IsVersion {
|
|
get { return this.isVersion; }
|
|
}
|
|
public override bool IsDiscriminator {
|
|
get { return this.isDiscriminator; }
|
|
}
|
|
public override bool CanBeNull {
|
|
get { return this.canBeNull; }
|
|
}
|
|
public override string DbType {
|
|
get { return this.dbType; }
|
|
}
|
|
public override string Expression {
|
|
get { return this.expression; }
|
|
}
|
|
public override string MappedName {
|
|
get { return this.mappedName; }
|
|
}
|
|
public override UpdateCheck UpdateCheck {
|
|
get { return this.updateCheck; }
|
|
}
|
|
public override AutoSync AutoSync {
|
|
get { return this.autoSync; }
|
|
}
|
|
public override MetaAssociation Association {
|
|
get {
|
|
if (this.IsAssociation) {
|
|
// LOCKING: This deferral isn't an optimization. It can't be done in the constructor
|
|
// because there may be loops in the association graph.
|
|
if (this.assoc == null) {
|
|
lock (this.locktarget) {
|
|
if (this.assoc == null) {
|
|
this.assoc = new MappedAssociation(this, (AssociationMapping)this.memberMap);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return this.assoc;
|
|
}
|
|
}
|
|
public override MethodInfo LoadMethod {
|
|
get {
|
|
if (this.hasLoadMethod == false && this.IsDeferred) {
|
|
// defer searching for this access method until we really need to know
|
|
this.loadMethod = MethodFinder.FindMethod(
|
|
((MappedMetaModel)this.declaringType.Model).ContextType,
|
|
"Load" + this.member.Name,
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
|
new Type[] { this.DeclaringType.Type }
|
|
);
|
|
this.hasLoadMethod = true;
|
|
}
|
|
return this.loadMethod;
|
|
}
|
|
}
|
|
private bool IsDeferredType(Type clrType) {
|
|
if (clrType == null || clrType == typeof(object)) {
|
|
return false;
|
|
}
|
|
if (clrType.IsGenericType) {
|
|
Type gtype = clrType.GetGenericTypeDefinition();
|
|
return gtype == typeof(Link<>) ||
|
|
typeof(EntitySet<>).IsAssignableFrom(gtype) ||
|
|
typeof(EntityRef<>).IsAssignableFrom(gtype) ||
|
|
IsDeferredType(clrType.BaseType);
|
|
}
|
|
return false;
|
|
}
|
|
private static MetaAccessor MakeMemberAccessor(Type accessorType, MemberInfo mi, MetaAccessor storage) {
|
|
FieldInfo fi = mi as FieldInfo;
|
|
MetaAccessor acc = null;
|
|
if (fi != null) {
|
|
acc = FieldAccessor.Create(accessorType, fi);
|
|
}
|
|
else {
|
|
PropertyInfo pi = (PropertyInfo)mi;
|
|
acc = PropertyAccessor.Create(accessorType, pi, storage);
|
|
}
|
|
return acc;
|
|
}
|
|
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
|
|
private static void MakeDeferredAccessors(
|
|
Type declaringType, MetaAccessor accessor,
|
|
out MetaAccessor accessorValue, out MetaAccessor accessorDeferredValue, out MetaAccessor accessorDeferredSource
|
|
) {
|
|
if (accessor.Type.IsGenericType) {
|
|
Type gtype = accessor.Type.GetGenericTypeDefinition();
|
|
Type itemType = accessor.Type.GetGenericArguments()[0];
|
|
if (gtype == typeof(Link<>)) {
|
|
accessorValue = CreateAccessor(typeof(LinkValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
accessorDeferredValue = CreateAccessor(typeof(LinkDefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
accessorDeferredSource = CreateAccessor(typeof(LinkDefSourceAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
return;
|
|
}
|
|
else if (typeof(EntityRef<>).IsAssignableFrom(gtype)) {
|
|
accessorValue = CreateAccessor(typeof(EntityRefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
accessorDeferredValue = CreateAccessor(typeof(EntityRefDefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
accessorDeferredSource = CreateAccessor(typeof(EntityRefDefSourceAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
return;
|
|
}
|
|
else if (typeof(EntitySet<>).IsAssignableFrom(gtype)) {
|
|
accessorValue = CreateAccessor(typeof(EntitySetValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
accessorDeferredValue = CreateAccessor(typeof(EntitySetDefValueAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
accessorDeferredSource = CreateAccessor(typeof(EntitySetDefSourceAccessor<,>).MakeGenericType(declaringType, itemType), accessor);
|
|
return;
|
|
}
|
|
}
|
|
throw Error.UnhandledDeferredStorageType(accessor.Type);
|
|
}
|
|
private static MetaAccessor CreateAccessor(Type accessorType, params object[] args) {
|
|
return (MetaAccessor)Activator.CreateInstance(accessorType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
|
|
}
|
|
}
|
|
|
|
internal class MappedAssociation : MetaAssociationImpl {
|
|
MappedDataMember thisMember;
|
|
MetaDataMember otherMember;
|
|
MetaType otherType;
|
|
ReadOnlyCollection<MetaDataMember> thisKey;
|
|
ReadOnlyCollection<MetaDataMember> otherKey;
|
|
bool isMany;
|
|
bool isForeignKey;
|
|
bool isNullable;
|
|
bool thisKeyIsPrimaryKey;
|
|
bool otherKeyIsPrimaryKey;
|
|
AssociationMapping assocMap;
|
|
|
|
internal MappedAssociation(MappedDataMember mm, AssociationMapping assocMap) {
|
|
this.thisMember = mm;
|
|
this.assocMap = assocMap;
|
|
this.Init();
|
|
this.InitOther();
|
|
//validate the number of ThisKey columns is the same as the number of OtherKey columns
|
|
if (this.thisKey.Count != this.otherKey.Count && this.thisKey.Count > 0 && this.otherKey.Count > 0) {
|
|
throw Error.MismatchedThisKeyOtherKey(thisMember.Name, thisMember.DeclaringType.Name);
|
|
}
|
|
}
|
|
#region Initialization
|
|
private void Init() {
|
|
this.isMany = TypeSystem.IsSequenceType(this.thisMember.Type);
|
|
this.thisKey = (this.assocMap.ThisKey != null)
|
|
? MakeKeys(this.thisMember.DeclaringType, this.assocMap.ThisKey)
|
|
: this.thisMember.DeclaringType.IdentityMembers;
|
|
// this association refers to the parent if thisKey is not our own identity
|
|
this.thisKeyIsPrimaryKey = AreEqual(this.thisKey, this.thisMember.DeclaringType.IdentityMembers);
|
|
this.isForeignKey = this.assocMap.IsForeignKey;
|
|
|
|
// if any key members are not nullable, the association is not nullable
|
|
this.isNullable = true;
|
|
foreach (MetaDataMember mm in this.thisKey) {
|
|
if (mm == null)
|
|
throw Error.UnexpectedNull("MetaDataMember");
|
|
|
|
if (!mm.CanBeNull) {
|
|
this.isNullable = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// validate DeleteOnNull specification
|
|
if (assocMap.DeleteOnNull == true) {
|
|
if (!(isForeignKey && !isMany && !isNullable)) {
|
|
throw Error.InvalidDeleteOnNullSpecification(thisMember);
|
|
}
|
|
}
|
|
}
|
|
private void InitOther() {
|
|
if (this.otherType == null) {
|
|
Type ot = this.isMany ? TypeSystem.GetElementType(this.thisMember.Type) : this.thisMember.Type;
|
|
this.otherType = this.thisMember.DeclaringType.Model.GetMetaType(ot);
|
|
System.Diagnostics.Debug.Assert(this.otherType.IsEntity);
|
|
this.otherKey = (assocMap.OtherKey != null)
|
|
? MakeKeys(this.otherType, this.assocMap.OtherKey)
|
|
: this.otherType.IdentityMembers;
|
|
this.otherKeyIsPrimaryKey = AreEqual(this.otherKey, this.otherType.IdentityMembers);
|
|
foreach (MetaDataMember omm in this.otherType.DataMembers) {
|
|
if (omm.IsAssociation && omm != this.thisMember && omm.MappedName == this.thisMember.MappedName) {
|
|
this.otherMember = omm;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
public override MetaDataMember ThisMember {
|
|
get { return this.thisMember; }
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> ThisKey {
|
|
get { return this.thisKey; }
|
|
}
|
|
public override MetaDataMember OtherMember {
|
|
get { return this.otherMember; }
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> OtherKey {
|
|
get { return this.otherKey; }
|
|
}
|
|
public override MetaType OtherType {
|
|
get { return this.otherType; }
|
|
}
|
|
public override bool IsMany {
|
|
get { return this.isMany; }
|
|
}
|
|
public override bool IsForeignKey {
|
|
get { return this.isForeignKey; }
|
|
}
|
|
public override bool IsUnique {
|
|
get { return this.assocMap.IsUnique; }
|
|
}
|
|
public override bool IsNullable {
|
|
get { return this.isNullable; }
|
|
}
|
|
public override bool ThisKeyIsPrimaryKey {
|
|
get { return this.thisKeyIsPrimaryKey; }
|
|
}
|
|
public override bool OtherKeyIsPrimaryKey {
|
|
get { return this.otherKeyIsPrimaryKey; }
|
|
}
|
|
public override string DeleteRule {
|
|
get {
|
|
return this.assocMap.DeleteRule;
|
|
}
|
|
}
|
|
public override bool DeleteOnNull {
|
|
get {
|
|
return this.assocMap.DeleteOnNull;
|
|
}
|
|
}
|
|
}
|
|
|
|
class MappedFunction : MetaFunction {
|
|
MetaModel model;
|
|
FunctionMapping map;
|
|
MethodInfo method;
|
|
ReadOnlyCollection<MetaParameter> parameters;
|
|
MetaParameter returnParameter;
|
|
ReadOnlyCollection<MetaType> rowTypes;
|
|
static ReadOnlyCollection<MetaParameter> _emptyParameters = new List<MetaParameter>(0).AsReadOnly();
|
|
static ReadOnlyCollection<MetaType> _emptyTypes = new List<MetaType>(0).AsReadOnly();
|
|
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // map parameter contains type names.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // FindType method call.
|
|
internal MappedFunction(MappedMetaModel model, FunctionMapping map, MethodInfo method) {
|
|
this.model = model;
|
|
this.map = map;
|
|
this.method = method;
|
|
this.rowTypes = _emptyTypes;
|
|
|
|
if (map.Types.Count == 0 && this.method.ReturnType == typeof(IMultipleResults)) {
|
|
throw Error.NoResultTypesDeclaredForFunction(method.Name);
|
|
}
|
|
else if (map.Types.Count > 1 && this.method.ReturnType != typeof(IMultipleResults)) {
|
|
throw Error.TooManyResultTypesDeclaredForFunction(method.Name);
|
|
}
|
|
else if (map.Types.Count == 1 && this.method.ReturnType != typeof(IMultipleResults)) {
|
|
Type elementType = TypeSystem.GetElementType(method.ReturnType);
|
|
this.rowTypes = new List<MetaType>(1) { this.GetMetaType(map.Types[0], elementType) }.AsReadOnly();
|
|
}
|
|
else if (map.Types.Count > 0) {
|
|
List<MetaType> rowTypes = new List<MetaType>();
|
|
foreach (TypeMapping rtm in map.Types) {
|
|
Type elementType = model.FindType(rtm.Name);
|
|
if (elementType == null) {
|
|
throw Error.CouldNotFindElementTypeInModel(rtm.Name);
|
|
}
|
|
MetaType mt = this.GetMetaType(rtm, elementType);
|
|
// Only add unique meta types
|
|
if (!rowTypes.Contains(mt)) {
|
|
rowTypes.Add(mt);
|
|
}
|
|
}
|
|
this.rowTypes = rowTypes.AsReadOnly();
|
|
}
|
|
else if (map.FunReturn != null) {
|
|
this.returnParameter = new MappedReturnParameter(method.ReturnParameter, map.FunReturn);
|
|
}
|
|
|
|
// Parameters.
|
|
ParameterInfo[] pis = this.method.GetParameters();
|
|
if (pis.Length > 0) {
|
|
List<MetaParameter> mps = new List<MetaParameter>(pis.Length);
|
|
if (this.map.Parameters.Count != pis.Length) {
|
|
throw Error.IncorrectNumberOfParametersMappedForMethod(this.map.MethodName);
|
|
}
|
|
for (int i = 0; i < pis.Length; i++) {
|
|
mps.Add(new MappedParameter(pis[i], this.map.Parameters[i]));
|
|
}
|
|
this.parameters = mps.AsReadOnly();
|
|
}
|
|
else {
|
|
this.parameters = _emptyParameters;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// For the specified type, if it is a mapped type, use the Table
|
|
/// metatype to get the correct inheritance metatype,
|
|
/// otherwise create a new meta type.
|
|
[ResourceExposure(ResourceScope.Assembly | ResourceScope.Machine)] // Parameter contains various type references.
|
|
[ResourceConsumption(ResourceScope.Assembly | ResourceScope.Machine)] // MappedRootType constructor call.
|
|
private MetaType GetMetaType(TypeMapping tm, Type elementType) {
|
|
MetaTable tbl = model.GetTable(elementType);
|
|
if (tbl != null) {
|
|
return tbl.RowType.GetInheritanceType(elementType);
|
|
}
|
|
return new MappedRootType((MappedMetaModel)model, null, tm, elementType);
|
|
}
|
|
public override ReadOnlyCollection<MetaParameter> Parameters {
|
|
get { return this.parameters; }
|
|
}
|
|
public override string MappedName {
|
|
get { return this.map.Name; }
|
|
}
|
|
public override MethodInfo Method {
|
|
get { return this.method; }
|
|
}
|
|
public override MetaModel Model {
|
|
get { return this.model; }
|
|
}
|
|
public override string Name {
|
|
get { return this.method.Name; }
|
|
}
|
|
public override bool IsComposable {
|
|
get { return this.map.IsComposable; }
|
|
}
|
|
public override MetaParameter ReturnParameter {
|
|
get { return this.returnParameter; }
|
|
}
|
|
public override bool HasMultipleResults {
|
|
get { return this.method.ReturnType == typeof(IMultipleResults); }
|
|
}
|
|
public override ReadOnlyCollection<MetaType> ResultRowTypes {
|
|
get { return this.rowTypes; }
|
|
}
|
|
}
|
|
|
|
internal sealed class MappedParameter : MetaParameter {
|
|
private ParameterInfo parameterInfo;
|
|
private ParameterMapping map;
|
|
|
|
public MappedParameter(ParameterInfo parameterInfo, ParameterMapping map) {
|
|
this.parameterInfo = parameterInfo;
|
|
this.map = map;
|
|
}
|
|
public override ParameterInfo Parameter {
|
|
get { return this.parameterInfo; }
|
|
}
|
|
public override string Name {
|
|
get { return this.parameterInfo.Name; }
|
|
}
|
|
public override string MappedName {
|
|
get { return this.map.Name; }
|
|
}
|
|
public override Type ParameterType {
|
|
get { return this.parameterInfo.ParameterType; }
|
|
}
|
|
public override string DbType {
|
|
get { return this.map.DbType; }
|
|
}
|
|
}
|
|
|
|
internal sealed class MappedReturnParameter : MetaParameter {
|
|
private ParameterInfo parameterInfo;
|
|
private ReturnMapping map;
|
|
|
|
public MappedReturnParameter(ParameterInfo parameterInfo, ReturnMapping map) {
|
|
this.parameterInfo = parameterInfo;
|
|
this.map = map;
|
|
}
|
|
public override ParameterInfo Parameter {
|
|
get { return this.parameterInfo; }
|
|
}
|
|
public override string Name {
|
|
get { return null; }
|
|
}
|
|
public override string MappedName {
|
|
get { return null; }
|
|
}
|
|
public override Type ParameterType {
|
|
get { return this.parameterInfo.ParameterType; }
|
|
}
|
|
public override string DbType {
|
|
get { return this.map.DbType; }
|
|
}
|
|
}
|
|
|
|
internal abstract class MetaAssociationImpl : MetaAssociation {
|
|
|
|
private static char[] keySeparators = new char[] { ',' };
|
|
/// <summary>
|
|
/// Given a MetaType and a set of key fields, return the set of MetaDataMembers
|
|
/// corresponding to the key.
|
|
/// </summary>
|
|
protected static ReadOnlyCollection<MetaDataMember> MakeKeys(MetaType mtype, string keyFields) {
|
|
string[] names = keyFields.Split(keySeparators);
|
|
MetaDataMember[] members = new MetaDataMember[names.Length];
|
|
for (int i = 0; i < names.Length; i++) {
|
|
names[i] = names[i].Trim();
|
|
MemberInfo[] rmis = mtype.Type.GetMember(names[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
if (rmis == null || rmis.Length != 1) {
|
|
throw Error.BadKeyMember(names[i], keyFields, mtype.Name);
|
|
}
|
|
members[i] = mtype.GetDataMember(rmis[0]);
|
|
if (members[i] == null) {
|
|
throw Error.BadKeyMember(names[i], keyFields, mtype.Name);
|
|
}
|
|
}
|
|
return new List<MetaDataMember>(members).AsReadOnly();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two sets of keys for equality.
|
|
/// </summary>
|
|
protected static bool AreEqual(IEnumerable<MetaDataMember> key1, IEnumerable<MetaDataMember> key2) {
|
|
using (IEnumerator<MetaDataMember> e1 = key1.GetEnumerator()) {
|
|
using (IEnumerator<MetaDataMember> e2 = key2.GetEnumerator()) {
|
|
bool m1, m2;
|
|
for (m1 = e1.MoveNext(), m2 = e2.MoveNext(); m1 && m2; m1 = e1.MoveNext(), m2 = e2.MoveNext()) {
|
|
if (e1.Current != e2.Current)
|
|
return false;
|
|
}
|
|
if (m1 != m2)
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override string ToString() {
|
|
return string.Format(Globalization.CultureInfo.InvariantCulture, "{0} ->{1} {2}", ThisMember.DeclaringType.Name, IsMany ? "*" : "", OtherType.Name);
|
|
}
|
|
}
|
|
|
|
internal sealed class UnmappedType : MetaType {
|
|
MetaModel model;
|
|
Type type;
|
|
Dictionary<object, MetaDataMember> dataMemberMap;
|
|
ReadOnlyCollection<MetaDataMember> dataMembers;
|
|
ReadOnlyCollection<MetaType> inheritanceTypes;
|
|
object locktarget = new object(); // Hold locks on private object rather than public MetaType.
|
|
|
|
private static ReadOnlyCollection<MetaType> _emptyTypes = new List<MetaType>().AsReadOnly();
|
|
private static ReadOnlyCollection<MetaDataMember> _emptyDataMembers = new List<MetaDataMember>().AsReadOnly();
|
|
private static ReadOnlyCollection<MetaAssociation> _emptyAssociations = new List<MetaAssociation>().AsReadOnly();
|
|
|
|
internal UnmappedType(MetaModel model, Type type) {
|
|
this.model = model;
|
|
this.type = type;
|
|
}
|
|
|
|
public override MetaModel Model {
|
|
get { return this.model; }
|
|
}
|
|
public override MetaTable Table {
|
|
get { return null; }
|
|
}
|
|
public override Type Type {
|
|
get { return this.type; }
|
|
}
|
|
public override string Name {
|
|
get { return this.type.Name; }
|
|
}
|
|
public override bool IsEntity {
|
|
get { return false; }
|
|
}
|
|
public override bool CanInstantiate {
|
|
get { return !this.type.IsAbstract; }
|
|
}
|
|
public override MetaDataMember DBGeneratedIdentityMember {
|
|
get { return null; }
|
|
}
|
|
public override MetaDataMember VersionMember {
|
|
get { return null; }
|
|
}
|
|
public override MetaDataMember Discriminator {
|
|
get { return null; }
|
|
}
|
|
public override bool HasUpdateCheck {
|
|
get { return false; }
|
|
}
|
|
public override ReadOnlyCollection<MetaType> InheritanceTypes {
|
|
get {
|
|
if (this.inheritanceTypes == null) {
|
|
lock (this.locktarget) {
|
|
if (this.inheritanceTypes == null) {
|
|
this.inheritanceTypes = new MetaType[] { this }.ToList().AsReadOnly();
|
|
}
|
|
}
|
|
}
|
|
return this.inheritanceTypes;
|
|
}
|
|
}
|
|
public override MetaType GetInheritanceType(Type inheritanceType) {
|
|
if (inheritanceType == this.type)
|
|
return this;
|
|
return null;
|
|
}
|
|
public override ReadOnlyCollection<MetaType> DerivedTypes {
|
|
get { return _emptyTypes; }
|
|
}
|
|
public override MetaType GetTypeForInheritanceCode(object key) {
|
|
return null;
|
|
}
|
|
public override bool HasInheritance {
|
|
get { return false; }
|
|
}
|
|
public override bool HasInheritanceCode {
|
|
get { return false; }
|
|
}
|
|
public override object InheritanceCode {
|
|
get { return null; }
|
|
}
|
|
public override MetaType InheritanceRoot {
|
|
get { return this; }
|
|
}
|
|
public override MetaType InheritanceBase {
|
|
get { return null; }
|
|
}
|
|
public override MetaType InheritanceDefault {
|
|
get { return null; }
|
|
}
|
|
public override bool IsInheritanceDefault {
|
|
get { return false; }
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> DataMembers {
|
|
get {
|
|
this.InitDataMembers();
|
|
return this.dataMembers;
|
|
}
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> PersistentDataMembers {
|
|
get { return _emptyDataMembers; }
|
|
}
|
|
public override ReadOnlyCollection<MetaDataMember> IdentityMembers {
|
|
get {
|
|
this.InitDataMembers();
|
|
return this.dataMembers;
|
|
}
|
|
}
|
|
public override ReadOnlyCollection<MetaAssociation> Associations {
|
|
get { return _emptyAssociations; }
|
|
}
|
|
public override MetaDataMember GetDataMember(MemberInfo mi) {
|
|
if (mi == null)
|
|
throw Error.ArgumentNull("mi");
|
|
this.InitDataMembers();
|
|
if (this.dataMemberMap == null) {
|
|
lock (this.locktarget) {
|
|
if (this.dataMemberMap == null) {
|
|
Dictionary<object, MetaDataMember> map = new Dictionary<object, MetaDataMember>();
|
|
foreach (MetaDataMember mm in this.dataMembers) {
|
|
map.Add(InheritanceRules.DistinguishedMemberName(mm.Member), mm);
|
|
}
|
|
this.dataMemberMap = map;
|
|
}
|
|
}
|
|
}
|
|
object dn = InheritanceRules.DistinguishedMemberName(mi);
|
|
MetaDataMember mdm;
|
|
this.dataMemberMap.TryGetValue(dn, out mdm);
|
|
return mdm;
|
|
}
|
|
|
|
private void InitDataMembers() {
|
|
if (this.dataMembers == null) {
|
|
lock (this.locktarget) {
|
|
if (this.dataMembers == null) {
|
|
List<MetaDataMember> dMembers = new List<MetaDataMember>();
|
|
int ordinal = 0;
|
|
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
|
|
foreach (FieldInfo fi in this.type.GetFields(flags)) {
|
|
MetaDataMember mm = new UnmappedDataMember(this, fi, ordinal);
|
|
dMembers.Add(mm);
|
|
ordinal++;
|
|
}
|
|
foreach (PropertyInfo pi in this.type.GetProperties(flags)) {
|
|
MetaDataMember mm = new UnmappedDataMember(this, pi, ordinal);
|
|
dMembers.Add(mm);
|
|
ordinal++;
|
|
}
|
|
this.dataMembers = dMembers.AsReadOnly();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override string ToString() {
|
|
return this.Name;
|
|
}
|
|
|
|
public override MethodInfo OnLoadedMethod {
|
|
get { return null; }
|
|
}
|
|
|
|
public override MethodInfo OnValidateMethod {
|
|
get { return null; }
|
|
}
|
|
public override bool HasAnyValidateMethod {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
public override bool HasAnyLoadMethod {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class UnmappedDataMember : MetaDataMember {
|
|
MetaType declaringType;
|
|
MemberInfo member;
|
|
int ordinal;
|
|
Type type;
|
|
MetaAccessor accPublic;
|
|
object lockTarget = new object();
|
|
|
|
internal UnmappedDataMember(MetaType declaringType, MemberInfo mi, int ordinal) {
|
|
this.declaringType = declaringType;
|
|
this.member = mi;
|
|
this.ordinal = ordinal;
|
|
this.type = TypeSystem.GetMemberType(mi);
|
|
}
|
|
private void InitAccessors() {
|
|
if (this.accPublic == null) {
|
|
lock (this.lockTarget) {
|
|
if (this.accPublic == null) {
|
|
this.accPublic = MakeMemberAccessor(this.member.ReflectedType, this.member);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public override MetaType DeclaringType {
|
|
get { return this.declaringType; }
|
|
}
|
|
public override bool IsDeclaredBy(MetaType metaType) {
|
|
if (metaType == null) {
|
|
throw Error.ArgumentNull("metaType");
|
|
}
|
|
return metaType.Type == this.member.DeclaringType;
|
|
}
|
|
public override MemberInfo Member {
|
|
get { return this.member; }
|
|
}
|
|
public override MemberInfo StorageMember {
|
|
get { return this.member; }
|
|
}
|
|
public override string Name {
|
|
get { return this.member.Name; }
|
|
}
|
|
public override int Ordinal {
|
|
get { return this.ordinal; }
|
|
}
|
|
public override Type Type {
|
|
get { return this.type; }
|
|
}
|
|
public override MetaAccessor MemberAccessor {
|
|
get {
|
|
this.InitAccessors();
|
|
return this.accPublic;
|
|
}
|
|
}
|
|
public override MetaAccessor StorageAccessor {
|
|
get {
|
|
this.InitAccessors();
|
|
return this.accPublic;
|
|
}
|
|
}
|
|
public override MetaAccessor DeferredValueAccessor {
|
|
get { return null; }
|
|
}
|
|
public override MetaAccessor DeferredSourceAccessor {
|
|
get { return null; }
|
|
}
|
|
public override bool IsDeferred {
|
|
get { return false; }
|
|
}
|
|
public override bool IsPersistent {
|
|
get { return false; }
|
|
}
|
|
public override bool IsAssociation {
|
|
get { return false; }
|
|
}
|
|
public override bool IsPrimaryKey {
|
|
get { return false; }
|
|
}
|
|
public override bool IsDbGenerated {
|
|
get { return false; }
|
|
}
|
|
public override bool IsVersion {
|
|
get { return false; }
|
|
}
|
|
public override bool IsDiscriminator {
|
|
get { return false; }
|
|
}
|
|
public override bool CanBeNull {
|
|
get { return !this.type.IsValueType || TypeSystem.IsNullableType(this.type); }
|
|
}
|
|
public override string DbType {
|
|
get { return null; }
|
|
}
|
|
public override string Expression {
|
|
get { return null; }
|
|
}
|
|
public override string MappedName {
|
|
get { return this.member.Name; }
|
|
}
|
|
public override UpdateCheck UpdateCheck {
|
|
get { return UpdateCheck.Never; }
|
|
}
|
|
public override AutoSync AutoSync {
|
|
get { return AutoSync.Never; }
|
|
}
|
|
public override MetaAssociation Association {
|
|
get { return null; }
|
|
}
|
|
public override MethodInfo LoadMethod {
|
|
get { return null; }
|
|
}
|
|
private static MetaAccessor MakeMemberAccessor(Type accessorType, MemberInfo mi) {
|
|
FieldInfo fi = mi as FieldInfo;
|
|
MetaAccessor acc = null;
|
|
if (fi != null) {
|
|
acc = FieldAccessor.Create(accessorType, fi);
|
|
}
|
|
else {
|
|
PropertyInfo pi = (PropertyInfo)mi;
|
|
acc = PropertyAccessor.Create(accessorType, pi, null);
|
|
}
|
|
return acc;
|
|
}
|
|
}
|
|
}
|