Exemplo n.º 1
0
        /// <summary>
        /// Maps a cast to appropriate path
        /// </summary>
        public Expression MapTypeCast(UnaryExpression sourceExpression, Expression accessExpression)
        {
            // First we find the map for the specified type
            ClassMap classMap = this.m_mapFile.GetModelClassMap(sourceExpression.Operand.Type);

            PropertyMap castMap = classMap.Cast?.Find(o => o.ModelType == sourceExpression.Type);

            if (castMap == null)
            {
                throw new InvalidCastException();
            }
            Expression accessExpr = Expression.MakeMemberAccess(accessExpression, accessExpression.Type.GetRuntimeProperty(castMap.DomainName));

            while (castMap.Via != null)
            {
                castMap    = castMap.Via;
                accessExpr = Expression.MakeMemberAccess(accessExpr, accessExpr.Type.GetRuntimeProperty(castMap.DomainName));
            }
            return(accessExpr);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Map domain instance
        /// </summary>
        public object MapDomainInstance(Type tDomain, Type tModel, object domainInstance, bool useCache = true, HashSet <Guid> keyStack = null)
        {
            ClassMap classMap = this.m_mapFile.GetModelClassMap(tModel, tDomain);

            if (domainInstance == null)
            {
                return(null);
            }
            else
            {
                var cType = tModel;
                while (cType != null && classMap == null || !tDomain.IsAssignableFrom(Type.GetType(classMap.DomainClass)))
                {
                    cType = cType.BaseType;
                    if (cType != null)
                    {
                        classMap = this.m_mapFile.GetModelClassMap(cType);
                    }
                } // work up the tree
            }

            // Now the property maps
            object retVal = Activator.CreateInstance(tModel);

            // Key?
            if (classMap == null)
            {
                return(retVal);
            }

            // Cache lookup
            var idEnt  = retVal as IIdentifiedEntity;
            var vidEnt = retVal as IVersionedEntity;

            PropertyMap iKeyMap = null;

            if (idEnt != null)
            {
                classMap.TryGetModelProperty("Key", out iKeyMap);
            }
            if (iKeyMap != null)
            {
                object keyValue = tDomain.GetRuntimeProperty(iKeyMap.DomainName).GetValue(domainInstance);
                while (iKeyMap.Via != null)
                {
                    keyValue = keyValue.GetType().GetRuntimeProperty(iKeyMap.Via.DomainName).GetValue(keyValue);
                    iKeyMap  = iKeyMap.Via;
                }
                if (keyValue is byte[])
                {
                    keyValue = new Guid(keyValue as byte[]);
                }

                // Set key vaue
                idEnt.Key = (Guid)keyValue;

                var cache = FireMappingToModel(this, (Guid)keyValue, retVal as IdentifiedData);
                if (cache != null && useCache)
                {
                    return(cache);
                }
            }

            // Classifier value
            String classifierValue   = null;
            String classPropertyName = String.Empty;

            if (!m_domainClassPropertyName.TryGetValue(tModel, out classPropertyName))
            {
                classPropertyName = tModel.GetCustomAttribute <ClassifierAttribute>()?.ClassifierProperty;
                lock (m_domainClassPropertyName)
                    if (!m_domainClassPropertyName.ContainsKey(tModel))
                    {
                        m_domainClassPropertyName.Add(tModel, classPropertyName);
                    }
            }

            if (classPropertyName != null)
            {
                // Key value
                classPropertyName = tModel.GetRuntimeProperty(classPropertyName)?.GetCustomAttribute <SerializationReferenceAttribute>()?.RedirectProperty ?? classPropertyName;

                if (classMap.TryGetModelProperty(classPropertyName ?? "____XXX", out iKeyMap))
                {
                    object keyValue = tDomain.GetRuntimeProperty(iKeyMap.DomainName).GetValue(domainInstance);
                    while (iKeyMap.Via != null)
                    {
                        keyValue = keyValue.GetType().GetRuntimeProperty(iKeyMap.Via.DomainName).GetValue(keyValue);
                        iKeyMap  = iKeyMap.Via;
                    }
                    classifierValue = keyValue?.ToString();
                }
            }

            // Are we currently processing this?
            if (idEnt != null)
            {
                if (keyStack == null)
                {
                    keyStack = new HashSet <Guid>();
                }
                if (idEnt.Key.HasValue)
                {
                    if (keyStack.Contains(idEnt.Key.Value))
                    {
                        return(null);
                    }
                    else
                    {
                        keyStack.Add(idEnt.Key.Value);
                    }
                }
            }

            // Properties
            // Properties
            PropertyInfo[] properties = null;
            Dictionary <String, PropertyInfo[]> propertyClassMap = null;

            if (!s_modelPropertyCache.TryGetValue(tModel, out propertyClassMap))
            {
                lock (s_modelPropertyCache)
                {
                    if (!s_modelPropertyCache.TryGetValue(tModel, out propertyClassMap))
                    {
                        propertyClassMap = new Dictionary <string, PropertyInfo[]>();
                    }

                    if (!s_modelPropertyCache.ContainsKey(tModel))
                    {
                        s_modelPropertyCache.Add(tModel, propertyClassMap);
                    }
                }
            }
            if (!propertyClassMap.TryGetValue(classifierValue ?? String.Empty, out properties))
            {
                lock (s_modelPropertyCache)
                {
                    properties = tModel.GetRuntimeProperties().Where(m => m != null &&
                                                                     m.GetCustomAttribute <DataIgnoreAttribute>() == null &&
                                                                     (primitives.Contains(m.PropertyType) || m.PropertyType.IsEnum ||
                                                                      m.GetCustomAttributes <AutoLoadAttribute>().Any(o => o.ClassCode == classifierValue || o.ClassCode == null)) &&
                                                                     m.CanWrite).ToArray();
                    if (!propertyClassMap.ContainsKey(classifierValue ?? String.Empty))
                    {
                        propertyClassMap.Add(classifierValue ?? String.Empty, properties);
                    }
                }
            }


            // Iterate the properties and map
            foreach (var modelPropertyInfo in properties)
            {
                // Map property
                PropertyMap propMap = null;
                classMap.TryGetModelProperty(modelPropertyInfo.Name, out propMap);

                if (propMap?.DontLoad == true)
                {
                    continue;
                }
                var propInfo = tDomain.GetRuntimeProperty(propMap?.DomainName ?? modelPropertyInfo.Name);
                if (propInfo == null)
                {
#if VERBOSE_DEBUG
                    Debug.WriteLine("Unmapped property ({0}[{1}]).{2}", typeof(TDomain).Name, idEnt.Key, modelPropertyInfo.Name);
#endif
                    continue;
                }

                var originalValue = propInfo.GetValue(domainInstance);
#if VERBOSE_DEBUG
                Debug.WriteLine("Value property ({0}[{1}]).{2} = {3}", typeof(TDomain).Name, idEnt.Key, modelPropertyInfo.Name, originalValue);
#endif

                // Property info
                try
                {
                    if (originalValue == null)
                    {
                        continue;
                    }
                }
                catch (Exception e) // HACK: For some reason, some LINQ providers will return NULL on EntityReferences with no value
                {
                    Debug.WriteLine(e.ToString());
                }

                // Traversal stuff
                PropertyInfo modelProperty  = propMap == null ? modelPropertyInfo : tModel.GetRuntimeProperty(propMap.ModelName);;
                object       sourceObject   = domainInstance;
                PropertyInfo sourceProperty = propInfo;

                // Go through the via elements in the object map. This code traces a path
                // through the domain class instantiating any necessary associative entity
                // Example when a model entity is really two or three tables in the DB..
                // This piece of code does whatever is necessary to traverse the data model,
                // kinda reminds me of a song:
                // 🎶 Ah for just one time, I would take the northwest passage
                // To find the hand of Franklin reaching for the Beaufort Sea.
                // Tracing one warm line, through a land so wide and savage
                // And make a northwest passage to the sea. 🎶
                if (propMap != null)
                {
                    var via = propMap.Via;
                    List <PropertyMap> viaWalk = new List <PropertyMap>();
                    while (via?.DontLoad == false)
                    {
                        viaWalk.Add(via);
                        via = via.Via;
                    }

                    sourceProperty = propInfo;
                    foreach (var p in viaWalk.Select(o => o))
                    {
                        if (!(sourceObject is IList))
                        {
                            sourceObject = sourceProperty.GetValue(sourceObject);
                        }
                        sourceProperty = this.ExtractDomainType(sourceProperty.PropertyType).GetRuntimeProperty(p.DomainName);
                    }
                }

                // validate property type
                if (propMap?.DontLoad == true)
                {
                    continue;
                }

#if VERBOSE_DEBUG
                Debug.WriteLine("Mapping property ({0}[{1}]).{2} = {3}", typeof(TDomain).Name, idEnt.Key, modelPropertyInfo.Name, originalValue);
#endif
                // Set value
                object pValue = null;

                //DebugWriteLine("Unmapped property ({0}).{1}", typeof(TDomain).Name, propInfo.Name);
                if (sourceProperty.PropertyType == typeof(byte[]) && modelProperty.PropertyType.StripNullable() == typeof(Guid)) // Guid to BA
                {
                    modelProperty.SetValue(retVal, new Guid((byte[])sourceProperty.GetValue(sourceObject)));
                }
                else if (modelProperty.PropertyType.IsAssignableFrom(sourceProperty.PropertyType))
                {
                    modelProperty.SetValue(retVal, sourceProperty.GetValue(sourceObject));
                }
                else if (sourceProperty.PropertyType == typeof(String) && modelProperty.PropertyType == typeof(Type))
                {
                    modelProperty.SetValue(retVal, Type.GetType(sourceProperty.GetValue(sourceObject) as String));
                }
                else if (MapUtil.TryConvert(originalValue, modelProperty.PropertyType, out pValue))
                {
                    modelProperty.SetValue(retVal, pValue);
                }
                // Handles when a map is a list for example doing a VIA over a version relationship
                else if (originalValue is IList)
                {
                    var modelInstance = Activator.CreateInstance(modelProperty.PropertyType) as IList;
                    modelProperty.SetValue(retVal, modelInstance);
                    var instanceMapFunction = typeof(ModelMapper).GetGenericMethod("MapDomainInstance", new Type[] { sourceProperty.PropertyType.GenericTypeArguments[0], modelProperty.PropertyType.GenericTypeArguments[0] },
                                                                                   new Type[] { sourceProperty.PropertyType.GenericTypeArguments[0], typeof(bool), typeof(HashSet <Guid>) });
                    foreach (var itm in originalValue as IList)
                    {
                        // Traverse?
                        var instance = itm;
                        var via      = propMap?.Via;
                        while (via != null)
                        {
                            instance = instance?.GetType().GetRuntimeProperty(via.DomainName)?.GetValue(instance);
                            if (instance is IList)
                            {
                                var        parm          = Expression.Parameter(instance.GetType());
                                Expression aggregateExpr = parm;
                                if (!String.IsNullOrEmpty(via.OrderBy))
                                {
                                    aggregateExpr = parm.Sort(via.OrderBy, via.SortOrder);
                                }
                                aggregateExpr = aggregateExpr.Aggregate(via.Aggregate);

                                // Get the generic method for LIST to be widdled down
                                instance = Expression.Lambda(aggregateExpr, parm).Compile().DynamicInvoke(instance);
                            }
                            via = via.Via;
                        }
                        modelInstance.Add(instanceMapFunction.Invoke(this, new object[] { instance, useCache, keyStack }));
                    }
                }
                // Flat map list 1..1
                else if (typeof(IList).IsAssignableFrom(modelProperty.PropertyType) &&
                         typeof(IList).IsAssignableFrom(sourceProperty.PropertyType))
                {
                    var modelInstance = Activator.CreateInstance(modelProperty.PropertyType) as IList;
                    modelProperty.SetValue(retVal, modelInstance);
                    var instanceMapFunction = typeof(ModelMapper).GetGenericMethod("MapDomainInstance", new Type[] { sourceProperty.PropertyType.GenericTypeArguments[0], modelProperty.PropertyType.GenericTypeArguments[0] },
                                                                                   new Type[] { sourceProperty.PropertyType.GenericTypeArguments[0], typeof(bool), typeof(HashSet <Guid>) });
                    var listValue = sourceProperty.GetValue(sourceObject);

                    // Is this list a versioned association??
                    if (tDomain.GetRuntimeProperty("VersionSequenceId") != null &&
                        sourceProperty.PropertyType.GenericTypeArguments[0].GetRuntimeProperty("EffectiveVersionSequenceId") != null) // Filter!!! Yay!
                    {
                        var        parm          = Expression.Parameter(listValue.GetType());
                        Expression aggregateExpr = null;
                        aggregateExpr = parm.IsActive(domainInstance);
                        listValue     = Expression.Lambda(aggregateExpr, parm).Compile().DynamicInvoke(listValue);
                    }

                    foreach (var itm in listValue as IEnumerable)
                    {
                        modelInstance.Add(instanceMapFunction.Invoke(this, new object[] { itm, useCache, keyStack }));
                    }
                }
                else if (m_mapFile.GetModelClassMap(modelProperty.PropertyType) != null)
                {
                    // TODO: Clean this up
                    var instance = originalValue; //sourceProperty.GetValue(sourceObject);

                    var via = propMap?.Via;
                    while (via != null)
                    {
                        instance = instance?.GetType().GetRuntimeProperty(via.DomainName)?.GetValue(instance);
                        if (instance is IList)
                        {
                            var        parm          = Expression.Parameter(instance.GetType());
                            Expression aggregateExpr = parm;
                            if (!String.IsNullOrEmpty(via.OrderBy))
                            {
                                aggregateExpr = parm.Sort(via.OrderBy, via.SortOrder);
                            }
                            aggregateExpr = aggregateExpr.Aggregate(via.Aggregate);

                            // Get the generic method for LIST to be widdled down
                            instance = Expression.Lambda(aggregateExpr, parm).Compile().DynamicInvoke(instance);
                        }
                        via = via.Via;
                    }
                    if (instance != null)
                    {
                        var instanceMapFunction = typeof(ModelMapper).GetGenericMethod("MapDomainInstance", new Type[] { instance?.GetType(), modelProperty.PropertyType },
                                                                                       new Type[] { instance?.GetType(), typeof(bool), typeof(HashSet <Guid>) });
                        modelProperty.SetValue(retVal, instanceMapFunction.Invoke(this, new object[] { instance, useCache, keyStack }));
                    }
                }
            }

#if VERBOSE_DEBUG
            Debug.WriteLine("Leaving: {0}>{1}", typeof(TDomain).FullName, typeof(TModel).FullName);
#endif
            if (idEnt != null && useCache)
            {
                keyStack.Remove(idEnt.Key.Value);
                FireMappedToModel(this, vidEnt?.VersionKey ?? idEnt?.Key ?? Guid.Empty, retVal as IdentifiedData);
            }
            // (retVal as IdentifiedData).SetDelayLoad(true);

            return(retVal);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Map model instance
        /// </summary>
        public TDomain MapModelInstance <TModel, TDomain>(TModel modelInstance) where TDomain : new()
        {
            ClassMap classMap = this.m_mapFile.GetModelClassMap(typeof(TModel), typeof(TDomain));

            if (classMap == null)
            {
                classMap = this.m_mapFile.GetModelClassMap(typeof(TModel));
            }

            if (classMap == null || modelInstance == null)
            {
                return(default(TDomain));
            }

            // Now the property maps
            TDomain retVal = new TDomain();

            // Properties
            PropertyInfo[] properties = null;
            Dictionary <String, PropertyInfo[]> propertyClassMap = null;

            if (!s_modelPropertyCache.TryGetValue(typeof(TModel), out propertyClassMap))
            {
                lock (s_modelPropertyCache)
                {
                    if (!s_modelPropertyCache.TryGetValue(typeof(TModel), out propertyClassMap))
                    {
                        propertyClassMap = new Dictionary <string, PropertyInfo[]>();
                    }
                    if (!s_modelPropertyCache.ContainsKey(typeof(TModel)))
                    {
                        s_modelPropertyCache.Add(typeof(TModel), propertyClassMap);
                    }
                }
            }

            if (!propertyClassMap.TryGetValue(String.Empty, out properties))
            {
                lock (s_modelPropertyCache)
                {
                    properties = typeof(TModel).GetRuntimeProperties().Where(m => m != null &&
                                                                             m.GetCustomAttribute <DataIgnoreAttribute>() == null &&
                                                                             (primitives.Contains(m.PropertyType) || m.PropertyType.IsEnum) &&
                                                                             m.CanWrite).ToArray();
                    if (!propertyClassMap.ContainsKey(String.Empty))
                    {
                        propertyClassMap.Add(String.Empty, properties);
                    }
                }
            }

            // Iterate through properties
            foreach (var propInfo in properties)
            {
                var propValue = propInfo.GetValue(modelInstance);
                // Property info
                if (propValue == null)
                {
                    continue;
                }

                if (!propInfo.PropertyType.IsPrimitive && propInfo.PropertyType != typeof(Guid) &&
                    (!propInfo.PropertyType.IsGenericType || propInfo.PropertyType.GetGenericTypeDefinition() != typeof(Nullable <>)) &&
                    propInfo.PropertyType != typeof(String) &&
                    propInfo.PropertyType != typeof(DateTime) &&
                    propInfo.PropertyType != typeof(DateTimeOffset) &&
                    propInfo.PropertyType != typeof(Type) &&
                    propInfo.PropertyType != typeof(Decimal) &&
                    propInfo.PropertyType != typeof(byte[]) &&
                    !propInfo.PropertyType.IsEnum)
                {
                    continue;
                }

                // Map property
                PropertyMap propMap = null;
                classMap.TryGetModelProperty(propInfo.Name, out propMap);
                PropertyInfo domainProperty = null;
                Object       targetObject   = retVal;

                // Set
                if (propMap == null)
                {
                    domainProperty = typeof(TDomain).GetRuntimeProperty(propInfo.Name);
                }
                else
                {
                    domainProperty = typeof(TDomain).GetRuntimeProperty(propMap.DomainName);
                }

                object domainValue = null;
                // Set value
                if (domainProperty == null || !domainProperty.CanWrite)
                {
                    continue;
                }
                //Debug.WriteLine ("Unmapped property ({0}).{1}", typeof(TModel).Name, propInfo.Name);
                else if (domainProperty.PropertyType == typeof(byte[]) && propInfo.PropertyType.StripNullable() == typeof(Guid))
                {
                    domainProperty.SetValue(targetObject, ((Guid)propValue).ToByteArray());
                }
                else if (
                    (domainProperty.PropertyType == typeof(DateTime) || domainProperty.PropertyType == typeof(DateTime?)) &&
                    (propInfo.PropertyType == typeof(DateTimeOffset) || propInfo.PropertyType == typeof(DateTimeOffset?)))
                {
                    domainProperty.SetValue(targetObject, ((DateTimeOffset)propValue).DateTime);
                }
                else if (domainProperty.PropertyType.IsAssignableFrom(propInfo.PropertyType))
                {
                    domainProperty.SetValue(targetObject, propValue);
                }
                else if (propInfo.PropertyType == typeof(Type) && domainProperty.PropertyType == typeof(String))
                {
                    domainProperty.SetValue(targetObject, (propValue as Type).AssemblyQualifiedName);
                }
                else if (MapUtil.TryConvert(propValue, domainProperty.PropertyType, out domainValue))
                {
                    domainProperty.SetValue(targetObject, domainValue);
                }
            }

            return(retVal);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Map member
        /// </summary>
        public Expression MapModelMember(MemberExpression memberExpression, Expression accessExpression, Type modelType = null)
        {
            ClassMap classMap = this.m_mapFile.GetModelClassMap(modelType ?? memberExpression.Expression.Type);

            if (classMap == null)
            {
                return(accessExpression);
            }

            // Expression is the same class? Collapse if it is a key
            MemberExpression accessExpressionAsMember = accessExpression as MemberExpression;
            CollapseKey      collapseKey = null;
            PropertyMap      propertyMap = null;

            if (memberExpression.Member.Name == "Key" && classMap.TryGetCollapseKey(accessExpressionAsMember?.Member.Name, out collapseKey))
            {
                return(Expression.MakeMemberAccess(accessExpressionAsMember.Expression, accessExpressionAsMember.Expression.Type.GetRuntimeProperty(collapseKey.KeyName)));
            }
            else if (classMap.TryGetModelProperty(memberExpression.Member.Name, out propertyMap))
            {
                // We have to map through an associative table
                if (propertyMap.Via != null)
                {
                    Expression viaExpression = Expression.MakeMemberAccess(accessExpression, accessExpression.Type.GetRuntimeProperty(propertyMap.DomainName));
                    var        via           = propertyMap.Via;
                    while (via != null)
                    {
                        MemberInfo viaMember = viaExpression.Type.GetRuntimeProperty(via.DomainName);
                        if (viaMember == null)
                        {
                            break;
                        }
                        viaExpression = Expression.MakeMemberAccess(viaExpression, viaMember);

                        if (via.OrderBy != null && viaExpression.Type.FindInterfaces((o, _) => o == typeof(IEnumerable), null).Length > 0)
                        {
                            viaExpression = viaExpression.Sort(via.OrderBy, via.SortOrder);
                        }
                        if (via.Aggregate != AggregationFunctionType.None)
                        {
                            viaExpression = viaExpression.Aggregate(via.Aggregate);
                        }
                        via = via.Via;
                    }
                    return(viaExpression);
                }
                else
                {
                    return(Expression.MakeMemberAccess(accessExpression, this.ExtractDomainType(accessExpression.Type).GetRuntimeProperty(propertyMap.DomainName)));
                }
            }
            else
            {
                // look for idenical named property
                Type domainType = this.MapModelType(modelType ?? memberExpression.Expression.Type);

                // Get domain member and map
                MemberInfo domainMember = accessExpression.Type.GetRuntimeProperty(memberExpression.Member.Name);
                if (domainMember != null)
                {
                    return(Expression.MakeMemberAccess(accessExpression, domainMember));
                }
                else
                {
                    // Try on the base?
                    if (classMap.ParentDomainProperty != null)
                    {
                        domainMember = domainType.GetRuntimeProperty(classMap.ParentDomainProperty.DomainName);
                        return(MapModelMember(memberExpression, Expression.MakeMemberAccess(accessExpression, domainMember), (modelType ?? memberExpression.Expression.Type).BaseType));
                    }
                    else
                    {
                        //Debug.WriteLine(String.Format("Cannot find property information for {0}({1}).{2}", memberExpression.Expression, memberExpression.Expression.Type.Name, memberExpression.Member.Name));
                        return(null);
                    }
                }
            }
        }