如题, 许多时候我们渴望绑定一个不确定的列到datagrid,
如果你真想这样那么10分钟后你将实现,
缺点是你不可能在datagrid的一行中得到一个完整的类了.
她借助了一个国外的源码类,DataGridDataSource.cs
--------------------------------------------------------------------------
代码:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Windows.Controls;
using DataGridDataSource;
namespace GridTestSilverlight
{
public partial class MainPage : UserControl
{
public MainPage()
{
InitializeComponent();
this .TheGrid.ItemsSource = GenerateData( " 这里传入数据 " ).ToDataSource();
}
public IEnumerable < IDictionary > GenerateData( string xml)
{
// 注意此处的for循环,只是为了模拟数据格式,
// 卑微的我只是提供了一种绑定多列的方式,
// 伟大而牛B的您可以根据自己需求满足这种格式,
for ( int j = 200 ; j < 215 ;j ++ )
{
var dict = new Dictionary < object , object > ();
for (var i = 1 ; i <= 4 ; i ++ )
{
dict[ " 当前列 " + i] = " --- " + j ;
}
yield return dict;
}
}
}
}
/*
我自己实际工程中用到的.
* 数据格式为
* <Temp>
* <时间>2011-3-14 10:21:52</时间>
* <时间>2011-3-16 10:21:52</时间>
* <时间>2011-3-17 10:21:52</时间>
* <时间>2011-3-18 10:21:52</时间>
* </Temp>
* <Temp>
* <时间>2011-3-19 10:21:52</时间>
* <时间>2011-3-21 10:21:52</时间>
* <时间>2011-3-31 10:21:52</时间>
* <时间>2011-3-22 10:21:52</时间>
* </Temp>
* private IEnumerable<IDictionary> GenerateData(XDocument xml)
{
var element = xml.Descendants("Temp");
foreach (XElement item in element)
{
var dict = new Dictionary<object, object>();
var nodes = item.Elements();
foreach (XElement node in nodes)
{
dict[node.Name] = node.Value;
}
yield return dict;
}
}
*
*/
DataGridDataSource.cs 类
对于此文件, 类中注释部分为源码,注释下方是我添加的,不难看出是为了能够让DataGrid的表头出现中文.
自此皆大欢喜. 我用到了我想用的.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using System.Text.RegularExpressions;
namespace DataGridDataSource
{
public static class DataSourceCreator
{
// private static readonly Regex PropertNameRegex =
// new Regex(@"^[A-Za-z]+[A-Za-z0-9_]*$", RegexOptions.Singleline);
private static readonly Regex PropertNameRegex =
new Regex( @" ^[\u4e00-\u9fa5]+$ " , RegexOptions.Singleline);
private static readonly Dictionary < string , Type > _typeBySigniture =
new Dictionary < string , Type > ();
public static IEnumerable ToDataSource( this IEnumerable < IDictionary > list)
{
IDictionary firstDict = null ;
bool hasData = false ;
foreach (IDictionary currentDict in list)
{
hasData = true ;
firstDict = currentDict;
break ;
}
if ( ! hasData)
{
return new object [] { };
}
if (firstDict == null )
{
throw new ArgumentException( " IDictionary entry cannot be null " );
}
string typeSigniture = GetTypeSigniture(firstDict);
Type objectType = GetTypeByTypeSigniture(typeSigniture);
if (objectType == null )
{
TypeBuilder tb = GetTypeBuilder(typeSigniture);
ConstructorBuilder constructor =
tb.DefineDefaultConstructor(
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName);
foreach (DictionaryEntry pair in firstDict)
{
// if (PropertNameRegex.IsMatch(Convert.ToString(pair.Key), 0))
if ( true )
{
CreateProperty(tb,
Convert.ToString(pair.Key),
GetValueType(pair.Value));
}
else
{
throw new ArgumentException(
@" Each key of IDictionary must be
alphanumeric and start with character. " );
}
}
objectType = tb.CreateType();
_typeBySigniture.Add(typeSigniture, objectType);
}
return GenerateEnumerable(objectType, list, firstDict);
}
private static Type GetTypeByTypeSigniture( string typeSigniture)
{
Type type;
return _typeBySigniture.TryGetValue(typeSigniture, out type) ? type : null ;
}
private static Type GetValueType( object value)
{
return value == null ? typeof ( object ) : value.GetType();
}
private static string GetTypeSigniture(IDictionary firstDict)
{
StringBuilder sb = new StringBuilder();
foreach (DictionaryEntry pair in firstDict)
{
sb.AppendFormat( " _{0}_{1} " , pair.Key, GetValueType(pair.Value));
}
return sb.ToString().GetHashCode().ToString().Replace( " - " , " Minus " );
}
private static IEnumerable GenerateEnumerable(
Type objectType, IEnumerable < IDictionary > list, IDictionary firstDict)
{
var listType = typeof (List <> ).MakeGenericType( new [] { objectType });
var listOfCustom = Activator.CreateInstance(listType);
foreach (var currentDict in list)
{
if (currentDict == null )
{
throw new ArgumentException( " IDictionary entry cannot be null " );
}
var row = Activator.CreateInstance(objectType);
foreach (DictionaryEntry pair in firstDict)
{
if (currentDict.Contains(pair.Key))
{
PropertyInfo property =
objectType.GetProperty(Convert.ToString(pair.Key));
var value = currentDict[pair.Key];
try
{
if (value != null && value.GetType() != property.PropertyType && ! property.PropertyType.IsGenericType)
value = Convert.ChangeType(
currentDict[pair.Key],
property.PropertyType,
null );
} catch
{
}
property.SetValue(
row,
value,
null );
}
}
listType.GetMethod( " Add " ).Invoke(listOfCustom, new [] { row });
}
return listOfCustom as IEnumerable;
}
private static TypeBuilder GetTypeBuilder( string typeSigniture)
{
AssemblyName an = new AssemblyName( " TempAssembly " + typeSigniture);
AssemblyBuilder assemblyBuilder =
AppDomain.CurrentDomain.DefineDynamicAssembly(
an, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule( " MainModule " );
TypeBuilder tb = moduleBuilder.DefineType( " TempType " + typeSigniture
, TypeAttributes.Public |
TypeAttributes.Class |
TypeAttributes.AutoClass |
TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit |
TypeAttributes.AutoLayout
, typeof ( object ));
return tb;
}
private static void CreateProperty(
TypeBuilder tb, string propertyName, Type propertyType)
{
if (propertyType.IsValueType && ! propertyType.IsGenericType)
{
propertyType = typeof (Nullable <> ).MakeGenericType( new [] { propertyType });
}
FieldBuilder fieldBuilder = tb.DefineField( " _ " + propertyName,
propertyType,
FieldAttributes.Private);
PropertyBuilder propertyBuilder =
tb.DefineProperty(
propertyName, PropertyAttributes.HasDefault, propertyType, null );
MethodBuilder getPropMthdBldr =
tb.DefineMethod( " get_ " + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
propertyType, Type.EmptyTypes);
ILGenerator getIL = getPropMthdBldr.GetILGenerator();
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, fieldBuilder);
getIL.Emit(OpCodes.Ret);
MethodBuilder setPropMthdBldr =
tb.DefineMethod( " set_ " + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null , new Type[] { propertyType });
ILGenerator setIL = setPropMthdBldr.GetILGenerator();
setIL.Emit(OpCodes.Ldarg_0);
setIL.Emit(OpCodes.Ldarg_1);
setIL.Emit(OpCodes.Stfld, fieldBuilder);
setIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
}
}