public static class DataContextWalker
    {
        public static List<MetaAssociation> GetRelations(DataContext dc, Type outerType, Type innerType)
        {
            return GetRelations(dc, outerType, innerType, null);
        }
        public static List<MetaAssociation> GetRelations(DataContext dc, Type outerType, Type innerType, List<Type> exceptTypes)
        {
            if ( null == exceptTypes )
            {
                exceptTypes = new List<Type>();
            }
            if (innerType == outerType)
            {
                return null;
            }
            MetaModel mm = dc.Mapping;
            MetaTable outerTable = mm.GetTable(outerType);
            if (null == outerTable)
            {
                return null;
            }
            MetaTable innerTable = mm.GetTable(innerType);
            if (null == innerTable)
            {
                return null;
            }
            List<MetaAssociation> usedAssociations = new List<MetaAssociation>();
            Relation relation = new Relation(null, null);
            foreach (MetaAssociation association in outerTable.RowType.Associations.Where( a => !exceptTypes.Contains(a.OtherMember.Type) ))
            {
                Relation childRelation = new Relation(relation, association);
            }
            Relation foundedRelation = _getRelation(relation.Childs, innerTable.RowType, usedAssociations, exceptTypes);


            if (null == foundedRelation)
            {
                return null;
            }
            else
            {
                return foundedRelation.GetAssociations();
            }
        }

        private static Relation _getRelation(IEnumerable<Relation> relations, MetaType innerType, List<MetaAssociation> usedAssociations, List<Type> exceptTypes)
        {
            List<Relation> childRelations = new List<Relation>();
            foreach (Relation relation in relations)
            {
                if (relation.Association.OtherType.Equals(innerType))
                {
                    return relation;
                }
                else
                {
                    usedAssociations.Add(relation.Association);
                    foreach (MetaAssociation childAssociation in relation.Association.OtherType.Associations.Where(a => !usedAssociations.Contains(a) && !usedAssociations.Contains(a.OtherMember.Association) && !exceptTypes.Contains(a.OtherMember.Type) ))
                    {

                        Relation childRelation = new Relation(relation, childAssociation);
                        childRelations.Add(childRelation);
                    }
                }
            }
            if (0 == childRelations.Count())
            {
                return null;
            }
            else
            {
                return _getRelation(childRelations, innerType, usedAssociations, exceptTypes);
            }
        }

        private class Relation
        {
            private readonly Relation _parent;
            private List<Relation> _childs;

            public Relation(Relation parent, MetaAssociation association)
            {
                _parent = parent;
                if (null != _parent)
                {
                    _parent._childs.Add(this);
                }
                _childs = new List<Relation>();
                _association = association;
            }

            public IEnumerable<Relation> Childs
            {
                get { return _childs; }
            }

            private readonly MetaAssociation _association;
            public System.Data.Linq.Mapping.MetaAssociation Association
            {
                get { return _association; }
            }

            public List<MetaAssociation> GetAssociations()
            {
                return _getAssociations(new List<MetaAssociation>());
            }

            private List<MetaAssociation> _getAssociations(List<MetaAssociation> associations)
            {
                if (null != _parent)
                {
                    associations.Add(Association.OtherMember.Association);
                    _parent._getAssociations(associations);
                }
                return associations;
            }
        }
    }