datagrid 绑定动态列
如题, 许多时候我们渴望绑定一个不确定的列到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);
}
}
}