MappedMetaModel.cs

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