wpf - C# 可序列化动态对象

Question

我需要在我的 WPF 应用程序和 Silverlight 应用程序之间进行通信（Silverlight 托管在我的 WPF 应用程序的 Web 浏览器控件中）。

基本上，我在 WPF 中有 DataTable 对象，并且在 Silverlight 中需要这些数据（列是动态的）。由于 Silverlight 中不提供 DataTable，因此我无法直接序列化/反序列化此 DataTable。

我查看了一些轻量级的 DataTable 类实现（示例在这里，但它们不可序列化。

有人可以指导我，我有哪些选择来序列化/反序列化动态数据？

Answer 1

使用此类转换为数据表，

  public class DataTable : IEnumerable
    {
         public DataTable(IEnumerable<Dictionary<string, object>> source)
        {
            if (source != null)
            {
                var firstItem = source.FirstOrDefault();

                if (firstItem != null)
                {
                    foreach (var key in firstItem)
                    {
                        Columns.Add(new DataColumn() { ColumnName = key.Key, DataType = key.Value.GetType() });
                    }

                    foreach (var item in source)
                    {
                        var row = new DataRow();

                        foreach (var key in item)
                        {
                            row[key.Key] = key.Value;
                        }
                        Rows.Add(row);
                    }
                }
            }
        }

        List<DataColumn> columns = null;
        public List<DataColumn> Columns
        {
            get
            {
                if (columns == null)
                {
                    columns = new List<DataColumn>();
                }

                return columns;
            }
        }

        List<DataRow> rows = null;
        public List<DataRow> Rows
        {
            get
            {
                if (rows == null)
                {
                    rows = new List<DataRow>();
                }

                return rows;
            }
        }

        public object NewRow()
        {
            if (queryable != null)
            {
                return Activator.CreateInstance(queryable.ElementType);
            }

            return null;
        }

        #region IEnumerable Members

        IQueryable queryable = null;
        public IEnumerator GetEnumerator()
        {
            if (queryable == null)
            {
                var type = ClassFactory.Instance.GetDynamicClass(this.Columns.Select(c => new DynamicProperty(c.ColumnName, c.DataType)));
                var propertyInfos = type.GetProperties().ToList();

                var list = (IList) Activator.CreateInstance(typeof(List<>).MakeGenericType(type));
                foreach (var row in this.Rows)
                {
                    var item = Activator.CreateInstance(type);
                    propertyInfos.ForEach(p => p.SetValue(item, row[p.Name], null));

                    list.Add(item);
                }

                queryable = list.AsQueryable();
            }

            return queryable.GetEnumerator();
        }

        #endregion

        public IList ToList()
        {
            var enumerator = GetEnumerator();
            var list = (IList) Activator.CreateInstance(typeof(List<>).MakeGenericType(queryable.ElementType));
            while (enumerator.MoveNext())
            {
                list.Add(enumerator.Current);
            }
            return list;
        }
    }

    public class DataColumn
    {
        public DataColumn()
        {
            DataType = typeof(object);
        }

        public Type DataType { get; set; }
        public string ColumnName { get; set; }
    }

    public class DataRow : Dictionary<string, object>
    {
        //
    }