ADO.NET实体框架Entity Framework模型-基于元数据解析

       上一篇简单介绍了EF的XML模型结构，在基于xml解析一文中，主要使用xml查询技术Xpath，XQuery来得到实体模型中相应信息的，由于这种方式在数据库庞大，表关系复杂的情况下，有诸多弊端，所有使用基于元数据解析EF将更加简单便捷，适用性强。

本文主要介绍EDM元数据及其操作，实现功能与ADO.NET实体框架Entity Framework模型-基于XML解析类似，有些增强。

操作元数据一般使用以下几个步骤：

1. 读取EDM模型
2. 获取实体结构
3. 获取功能结构
4. 组织需要数据

通过API访问EDM主要通过下面三个类：

ObjectContext，EntityConnection和MetadataWorkspace。

在我的程序中主要使用左右一个MeadataWorkspace，该类的功能是暴露API以访问元数的。

DEM结果与元数据类的对应关系:

使用以下方法，可以访问XML模型中<!-- SSDL content -->下EntityType节点下的所有元数据。

var items=ctx.MetadataWorkspace.GetItems<EntityType>(DataSpace.CSpace);

在上篇文章中，对xmlhelper类更新为如下代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Collections;
//using EF_XML_TableRelation;
using System.Data.Metadata.Edm;
using MvcApplication3.Models;

namespace EF_XML_TableRelation.XML
{
    public class XmlHelper
    {
        /// <summary>
        /// 获取所有表的主键
        /// </summary>
        /// <returns>key：表名 value：主键</returns>
        public static SortedList<string, string> GetTableKEY()
        {
            SortedList<string, string> list = new SortedList<string, string>();
            using (testEntities context = new testEntities())
            {
                var entities = context.MetadataWorkspace.GetItems<EntityType>(DataSpace.CSpace);
                foreach (var item in entities)
                {
                    foreach (var prop in item.Members)
                    {
                        var entityItem = item as EntityType;
                        if (entityItem.KeyMembers.Any(p => p.Name == prop.Name))
                        {
                            list.Add(item.Name, prop.Name);
                        }
                    }
                }
            }
            return list;
        }
        /// <summary>
        /// 获取表的关系
        /// </summary>
        /// <param name="tablename"></param>
        /// <param name="IsRelation"></param>
        /// <returns></returns>
        public static List<TableRelation> GetTable(string tablename, bool IsRelation)
        {
            List<TableRelation> list = new List<TableRelation>();
            using (testEntities context = new testEntities())
            {
                var entities = context.MetadataWorkspace.GetItems<EntityType>(DataSpace.CSpace);
                EntityType entityItem = null;
                if (IsRelation)
                {
                    foreach (var item in entities)
                    {
                        if (entityItem == null)
                        {
                            entityItem = item as EntityType;
                        }
                        if (entityItem.NavigationProperties.Contains(item.Name) || item.Name.Equals(tablename))
                            list.Add(WriteProperties(item, context, DataSpace.CSpace));
                    }
                }
                else
                {
                    foreach (var item in entities)
                    {
                        if (entityItem == null)
                        {
                            entityItem = item as EntityType;
                        }
                        if (item.Name.Equals(tablename))
                            list.Add(WriteProperties(item, context, DataSpace.CSpace));
                    }
                }
            }
            return list;
        }
        /// <summary>
        /// 表的关系合集
        /// </summary>
        /// <param name="item"></param>
        /// <param name="ctx"></param>
        /// <param name="space"></param>
        /// <returns></returns>
        public static TableRelation WriteProperties(StructuralType item, testEntities ctx, DataSpace space)
        {
            TableRelation tr = new TableRelation();
            var node = (space == DataSpace.CSpace) ? "Properties" : "Columns";
            List<Column> list = new List<Column>();

            foreach (var prop in item.Members)
            {
                var entityItem = item as EntityType;
                Column column = new Column();

                if (entityItem != null && entityItem.Properties.Contains(prop))
                {
                    column.columnname = prop.Name;
                    column.title = prop.Documentation != null ? prop.Documentation.Summary : null;
                    column.type = prop.TypeUsage.EdmType != null ? prop.TypeUsage.EdmType.Name : null;
                    column.maxlength = prop.TypeUsage.Facets.Contains("MaxLength") ? prop.TypeUsage.Facets["MaxLength"].Value.ToString() : null;
                    if (ctx.MetadataWorkspace
                      .GetItems<AssociationType>(space)
                        .Where(a => a.IsForeignKey).Any(a =>
                          a.ReferentialConstraints[0]
                           .ToProperties[0].Name == prop.Name &&
                          a.ReferentialConstraints[0].ToRole.Name.Contains(item.Name)))
                    {
                        for (int i = 0; i < Realation(item, ctx, DataSpace.CSpace).Count; i++)
                        {
                            if (Realation(item, ctx, DataSpace.CSpace).Values[i].Values[0].Equals(prop.Name) &&
                               Realation(item, ctx, DataSpace.CSpace).Values[i].Values[2].Contains(item.Name))
                            {

                                column.mainrole = Realation(item, ctx, DataSpace.CSpace).Values[i].Values[6].ToString();
                                column.mainmultiplicity = Realation(item, ctx, DataSpace.CSpace).Values[i].Values[5].ToString();
                                column.mainkey = Realation(item, ctx, DataSpace.CSpace).Values[i].Values[4].ToString();
                                column.relationname = Realation(item, ctx, DataSpace.CSpace).Values[i].Values[3].ToString();

                            }

                        }
                    }
                    list.Add(column);
                }
                tr.tablename = item.Name;
                tr.tabletitle = item.Documentation != null ? item.Documentation.Summary : item.Name;
                tr.columns = list;
            }
            return tr;
        }
        /// <summary>
        /// 返回所有主表的关系
        /// </summary>
        /// <param name="item"></param>
        /// <param name="ctx"></param>
        /// <param name="space"></param>
        /// <returns></returns>
        public static SortedList<string, SortedList<string, string>> Realation(StructuralType item, testEntities ctx, DataSpace space)
        {
            SortedList<string, SortedList<string, string>> list1 = new SortedList<string, SortedList<string, string>>();
            var entity = ctx.MetadataWorkspace.GetItems<AssociationType>(space);
            foreach (var a in entity)
            {
                var entityItem = item as EntityType;
                for (int i = 0; i < entityItem.NavigationProperties.Count; i++)
                {
                    if (entityItem.NavigationProperties[i].RelationshipType.Name.Equals(a.Name))
                    {
                        SortedList<string, string> list = new SortedList<string, string>();
                        list.Add("mainrole", a.ReferentialConstraints[0].ToRole.Name);
                        list.Add("mainkey", a.ReferentialConstraints[0].ToProperties[0].Name);
                        list.Add("mainmultiplicity", a.ReferentialConstraints[0].ToRole.RelationshipMultiplicity.ToString());
                        list.Add("subrole", a.ReferentialConstraints[0].FromRole.Name);
                        list.Add("subkey", a.ReferentialConstraints[0].FromProperties[0].Name);
                        list.Add("submultiplicity", a.ReferentialConstraints[0].FromRole.RelationshipMultiplicity.ToString());
                        list.Add("relationname", a.Name);
                        if (!list1.ContainsKey(a.Name))
                        {
                            list1.Add(a.Name, list);
                        }
                    }
                }
            }
            return list1;
        }
    }
}

以上为使用元数据方式查询EF框架的信息属性等。