Example #1
0
        public static Member MemberForExpression(MemberExpression memberExp, Dictionary <String, Member> members)
        {
            var visitedNames = new List <String>();

            var com = new ColumnMember(memberExp.Member as PropertyInfo);

            visitedNames.Add(com.Name);

            var visitedMemberExp = memberExp;

            while (visitedMemberExp.Expression.NodeType == ExpressionType.MemberAccess)
            {
                visitedMemberExp = memberExp.Expression as MemberExpression;
                if (visitedMemberExp.Member is PropertyInfo)
                {
                    ReferencedObjectMember rom = new ReferencedObjectMember(visitedMemberExp.Member as PropertyInfo);
                    visitedNames.Add(rom.Name);
                }
                else
                {
                    return(null); //abort!
                }
            }

            visitedNames.Reverse();
            var fullName = String.Join(".", visitedNames);

            Member member;

            members.TryGetValue(fullName, out member);
            return(member);
        }
Example #2
0
        public static Lazy <T> GenerateLazyReferencedObjectMember <T>(ReferencedObjectMember rom, object instance) where T : new()
        {
            Func <T> func = () =>
            {
                var value = rom.ReferencedColumnProperty.GetValue(instance);
                return(Database.Get <T>(value));
            };

            return(new Lazy <T>(func));
        }
Example #3
0
        string _aliasedColumnName(ReferencedObjectMember m)
        {
            var pks = Model.ColumnsPrimaryKey(m.Type);
            var pk  = pks.FirstOrDefault();

            if (pk == null)
            {
                throw new Exception("No Primary Key to join on.");
            }
            return(String.Format("[{0}].[{1}]", m.TableAlias, pk.Name));
        }
Example #4
0
        string _aliasedParentColumnName(ReferencedObjectMember m)
        {
            var parentAlias = String.Empty;

            if (m.Parent != null)
            {
                parentAlias = m.Parent.TableAlias;
            }
            else if (m.Root != null)
            {
                parentAlias = m.Root.TableAlias;
            }

            return(String.Format("[{0}].[{1}]", parentAlias, m.ReferencedColumnMember.Name));
        }
Example #5
0
        public void DeepPopulate(object instance, Type thisType, Member rootMember = null, ReferencedObjectMember parentMember = null, Dictionary <Type, Dictionary <Object, Object> > objectLookups = null)
        {
            if (HasReferencedObjectMembers || parentMember != null)
            {
                var members = ModelCache.GetColumnMembers(thisType);
                foreach (ColumnMember col in members)
                {
                    var columnName = col.Name;
                    if (parentMember != null)
                    {
                        columnName = String.Format("{0}.{1}", parentMember.FullyQualifiedName, col.Name);
                    }

                    col.SetValue(instance, Get(col, columnName));
                }

                rootMember = rootMember ?? new RootMember(thisType);
                foreach (ReferencedObjectMember rom in Model.GenerateMembers(thisType, rootMember, parentMember).Where(m => m is ReferencedObjectMember && !m.AnyParent(p => p is ChildCollectionMember)))
                {
                    var type = rom.Type;

                    if (!rom.IsLazy)
                    {
                        var newObject = ReflectionHelper.GetNewObject(type);

                        DeepPopulate(newObject, type, rootMember, rom, objectLookups: objectLookups); //recursion.

                        if (objectLookups != null)
                        {
                            if (!objectLookups.ContainsKey(rom.Type))
                            {
                                objectLookups.Add(rom.Type, new Dictionary <Object, Object>());
                            }

                            var pkv = Model.InstancePrimaryKeyValue(rom.Type, newObject);
                            if (pkv != null && !objectLookups[rom.Type].ContainsKey(pkv))
                            {
                                objectLookups[rom.Type].Add(pkv, newObject);
                                rom.Property.SetValue(instance, newObject);
                            }
                            else
                            {
                                var existingObject = objectLookups[rom.Type][pkv];
                                rom.Property.SetValue(instance, existingObject);
                            }
                        }
                        else
                        {
                            rom.Property.SetValue(instance, newObject);
                        }
                    }
                    else
                    {
                        var mi        = typeof(Model).GetMethod("GenerateLazyReferencedObjectMember");
                        var genericMi = mi.MakeGenericMethod(rom.UnderlyingGenericType);
                        var lazy      = genericMi.Invoke(null, new Object[] { rom, instance });
                        rom.SetValue(instance, lazy);
                    }
                }

                if (HasChildCollectionMembers)
                {
                    foreach (ChildCollectionMember cm in Model.GenerateMembers(thisType, rootMember, parentMember).Where(m => m is ChildCollectionMember && m.IsLazy))
                    {
                        var mi        = typeof(Model).GetMethod("GenerateLazyChildCollectionMember");
                        var genericMi = mi.MakeGenericMethod(cm.UnderlyingGenericType);
                        var lazy      = genericMi.Invoke(null, new Object[] { cm, instance });
                        cm.SetValue(instance, lazy);
                    }
                }
            }
            else
            {
                SetInstanceValues(instance);
            }

            if (HasChildCollectionMembers && objectLookups != null)
            {
                if (!objectLookups.ContainsKey(thisType))
                {
                    objectLookups.Add(thisType, new Dictionary <Object, Object>());
                }
                var pkv = Model.InstancePrimaryKeyValue(thisType, instance);
                if (pkv != null && !objectLookups[thisType].ContainsKey(pkv))
                {
                    objectLookups[thisType].Add(pkv, instance);
                }
            }
        }