通过反射获取xml中的数据，int string bool float list 等类型
目录
通过反射获取xml中的数据，int string bool float list 等类型
1. 常见属性的反射 int， string ， bool 的属性反射给对象
把一个字符串转换为指定类型
val = TypeDescriptor.GetConverter(info.PropertyType).ConvertFromInvariantString(val.ToString())
反射的过程 ：属性和方法的简单描述
反射属性：
1. 通过这个未知对象的反射（属性字符串） 得到这个对象的字段信息，或方法
2. 得到的字段信息 赋值 setvalue（）
PropertyInfo nameInfo = obj.GetType().GetProperty("Name");
nameInfo.SetValue(obj, "20");反射方法：
1. 得到类型，InvokeMember（“方法名字”，设置关键字，null，方法的持有对象实例，参数）
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list, new object[] { addItem });1. 常见属性的反射 int， string ， bool 的属性反射给对象
1. 类对象结构，设置属性
2. 创建类对象
3. 反射对象的字段信息，字段信息方法：转换值的类型（ int， string ， bool）赋值给对象的字段
//对这个类进行反射赋值
public class TestInfo
{
public int Id { get; set; }
public string Name { get; set; }
public bool IsA { get; set; }
//public List<string> AllStrList = new List<string>();
// public List<TestInfoTwo> AllTestInfoList;
}
//测试反射类
public class TestExcelReflection{
[MenuItem("Tools/测试/测试已有数据进行反射")] //从读取数据表里反射得到数据,创建该对象
public static void TestReflection2()
{
object obj = CreatClass("TestInfo");
PropertyInfo info= obj.GetType().GetProperty("Id"); //得到类型,从类型里边获取属性ID名字
info.SetValue(obj,System.Convert.ToInt32( "20")); //设置值为20;
PropertyInfo nameInfo = obj.GetType().GetProperty("Name");
nameInfo.SetValue(obj, "20");
PropertyInfo isInfo = obj.GetType().GetProperty("IsA");
isInfo.SetValue(obj, System.Convert.ToBoolean("false"));
TestInfo testInfo = (obj as TestInfo);
Debug.Log(testInfo.Id + " " + testInfo.Name+" "+testInfo.IsA );
}
/// <summary>
/// 创建反射的实例
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private static object CreatClass(string name)
{
object obj = null;
Type type = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
Type tempType = asm.GetType(name); //得到这个程序集中 name 的类型
if (tempType != null)
{
type = tempType;
break;
}
}
if (type != null)
{
obj = Activator.CreateInstance(type);
}
return obj;
}
}2. 常见数据类型Float，和枚举反射
1. 类对象结构，设置属性
2. 创建类对象
3. 反射对象的字段信息，字段信息方法：转换值的类型（Float，和枚举）赋值给对象的字段
//枚举类型
public enum TestEnum
{
None=0,
Var1=1,
Var2=2
}
public class TestInfo
{
public int Id { get; set; }
public string Name { get; set; }
public bool IsA { get; set; }
public float High { get; set; }
//public List<string> AllStrList = new List<string>();
// public List<TestInfoTwo> AllTestInfoList;
public TestEnum TestType { get; set; }
}
//测试反射类
public class TestExcelReflection{
[MenuItem("Tools/测试/测试已有数据进行反射")] //从读取数据表里反射得到数据,创建该对象
public static void TestReflection2()
{
object obj = CreatClass("TestInfo");
PropertyInfo info= obj.GetType().GetProperty("Id"); //得到类型,从类型里边获取属性ID名字
info.SetValue(obj,System.Convert.ToInt32( "20")); //设置值为20;
PropertyInfo nameInfo = obj.GetType().GetProperty("Name");
nameInfo.SetValue(obj, "20");
PropertyInfo isInfo = obj.GetType().GetProperty("IsA");
isInfo.SetValue(obj, System.Convert.ToBoolean("false"));
PropertyInfo HighInfo = obj.GetType().GetProperty("High");
HighInfo.SetValue(obj, System.Convert.ToSingle("222.5")); //ToSingle 是转型的float类型 float类型
PropertyInfo enumInfo = obj.GetType().GetProperty("TestType"); //得到这个都对象中这个属性的类型
object infoValue= TypeDescriptor.GetConverter(enumInfo.PropertyType).ConvertFromInvariantString("Var1"); //从这个对属性类中获取到这个枚举
enumInfo.SetValue(obj, infoValue); //枚举类型
TestInfo testInfo = (obj as TestInfo);
Debug.Log(testInfo.Id + " " + testInfo.Name+" "+testInfo.IsA +" "+testInfo.High+" " +testInfo.TestType);
}
/// <summary>
/// 创建反射的实例
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private static object CreatClass(string name)
{
object obj = null;
Type type = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
Type tempType = asm.GetType(name); //得到这个程序集中 name 的类型
if (tempType != null)
{
type = tempType;
break;
}
}
if (type != null)
{
obj = Activator.CreateInstance(type);
}
return obj;
}
}
代码优化：给对象赋值时优化一下
1 优化提取新加了一个SetValue 方法，2 修改了一下TestReflection2的赋值
//枚举类型
public enum TestEnum
{
None=0,
Var1=1,
Var2=2
}
public class TestInfo
{
public int Id { get; set; }
public string Name { get; set; }
public bool IsA { get; set; }
public float High { get; set; }
//public List<string> AllStrList = new List<string>();
// public List<TestInfoTwo> AllTestInfoList;
public TestEnum TestType { get; set; }
}
//测试反射类
public class TestExcelReflection{
[MenuItem("Tools/测试/测试已有数据进行反射")] //从读取数据表里反射得到数据,创建该对象
public static void TestReflection2()
{
object obj = CreatClass("TestInfo"); //创建得到这个对象
PropertyInfo info= obj.GetType().GetProperty("Id"); //得到类型,从类型里边获取属性ID名字
SetValue(info, obj, "21", "int");
PropertyInfo nameInfo = obj.GetType().GetProperty("Name");
SetValue(nameInfo, obj, "asaaasasa", "string");
PropertyInfo isInfo = obj.GetType().GetProperty("IsA");
SetValue(isInfo, obj, "false", "bool");
PropertyInfo HighInfo = obj.GetType().GetProperty("High");
HighInfo.SetValue(obj, System.Convert.ToSingle("222.5")); //ToSingle 是转型的float类型 float类型
SetValue(HighInfo, obj, "512.12", "float");
PropertyInfo enumInfo = obj.GetType().GetProperty("TestType"); //得到这个都对象中这个属性的类型
SetValue(enumInfo, obj, "Var1", "enum");
TestInfo testInfo = (obj as TestInfo);
Debug.Log(testInfo.Id + " " + testInfo.Name+" "+testInfo.IsA +" "+testInfo.High+" " +testInfo.TestType);
}
/// <summary>
/// 创建反射的实例
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private static object CreatClass(string name)
{
object obj = null;
Type type = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
Type tempType = asm.GetType(name); //得到这个程序集中 name 的类型
if (tempType != null)
{
type = tempType;
break;
}
}
if (type != null)
{
obj = Activator.CreateInstance(type);
}
return obj;
}
/// <summary>
/// 反射的变量赋值,优化了类型转换
/// </summary>
/// <param name="info"></param>
/// <param name="var"></param>
/// <param name="value"></param>
/// <param name="type"></param>
private static void SetValue(PropertyInfo info,object var, string value,string type)
{
object val = (object)value; //将这个值转换为通用类型
if (type == "int")
{
val = System.Convert.ToInt32(val); //将这个值转换为目标值
}
else if (type == "bool")
{
val = System.Convert.ToBoolean(val);
}else if (type == "float")
{
val = System.Convert.ToSingle(val);
}else if (type == "enum")
{
val = TypeDescriptor.GetConverter(info.PropertyType).ConvertFromInvariantString(val.ToString());
}
info.SetValue(var, val); //给这个对象值设置给这个对象 info 创建的对象类型信息, var 这个类对象,val是这个值.
}
}
3. 常见基本类型的list列表反射
1 通过反射得到列表中对象的类型， 可以自行设置
2 创建这个类型的列表，
3 然后给这个列表添加对象：这里是基本类型直接创建即可
4 最后把这个列表对象 ，应赋值对象的list
修改了两处 1 类结构， 2 测试list创建赋值。
//枚举类型
public enum TestEnum
{
None=0,
Var1=1,
Var2=2
}
public class TestInfo
{
public int Id { get; set; }
public string Name { get; set; }
public bool IsA { get; set; }
public float High { get; set; }
//更改--------------------------------------------------------
public List<string> AllStrList { get; set; }
public List<TestInfoTwo> AllTestInfoList;
public TestEnum TestType { get; set; }
//------------------------------更改--------------------------
}
//测试反射类
public class TestExcelReflection{
[MenuItem("Tools/测试/测试已有数据进行反射")] //从读取数据表里反射得到数据,创建该对象
public static void TestReflection2()
{
object obj = CreatClass("TestInfo"); //创建得到这个对象
PropertyInfo info= obj.GetType().GetProperty("Id"); //得到类型,从类型里边获取属性ID名字
SetValue(info, obj, "21", "int");
PropertyInfo nameInfo = obj.GetType().GetProperty("Name");
SetValue(nameInfo, obj, "asaaasasa", "string");
PropertyInfo isInfo = obj.GetType().GetProperty("IsA");
SetValue(isInfo, obj, "false", "bool");
PropertyInfo HighInfo = obj.GetType().GetProperty("High");
HighInfo.SetValue(obj, System.Convert.ToSingle("222.5")); //ToSingle 是转型的float类型 float类型
SetValue(HighInfo, obj, "512.12", "float");
PropertyInfo enumInfo = obj.GetType().GetProperty("TestType"); //得到这个都对象中这个属性的类型
SetValue(enumInfo, obj, "Var1", "enum");
//更改--------------------------------------------------------
Type type = typeof(string);
Type listType = typeof(List<>);
Type specType = listType.MakeGenericType(new System.Type[] { type }); //设置listType 中的类型为string 类型
object list= Activator.CreateInstance(specType, new object[] { }); //new 出来这个list
for (int i = 0; i < 3; i++)
{
object addItem = "测试填数据" + i;
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list, new object[] { addItem });//调用liat的add 添加数据
}
obj.GetType().GetProperty("AllStrList").SetValue(obj, list); //将这个list 赋值给类对象的list,引用类型不需要转换
TestInfo testInfo = (obj as TestInfo);
foreach (var str in testInfo.AllStrList)
{
Debug.LogError(str);
}
Debug.Log(testInfo.Id + " " + testInfo.Name+" "+testInfo.IsA +" "+testInfo.High+" " +testInfo.TestType);
//------------------------------更改--------------------------
}
/// <summary>
/// 创建反射的实例
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private static object CreatClass(string name)
{
object obj = null;
Type type = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
Type tempType = asm.GetType(name); //得到这个程序集中 name 的类型
if (tempType != null)
{
type = tempType;
break;
}
}
if (type != null)
{
obj = Activator.CreateInstance(type);
}
return obj;
}
/// <summary>
/// 反射的变量赋值,优化了类型转换
/// </summary>
/// <param name="info"></param>
/// <param name="var"></param>
/// <param name="value"></param>
/// <param name="type"></param>
private static void SetValue(PropertyInfo info,object var, string value,string type)
{
object val = (object)value; //将这个值转换为通用类型
if (type == "int")
{
val = System.Convert.ToInt32(val); //将这个值转换为目标值
}
else if (type == "bool")
{
val = System.Convert.ToBoolean(val);
}else if (type == "float")
{
val = System.Convert.ToSingle(val);
}else if (type == "enum")
{
val = TypeDescriptor.GetConverter(info.PropertyType).ConvertFromInvariantString(val.ToString());
}
info.SetValue(var, val); //给这个对象值设置给这个对象 info 创建的对象类型信息, var 这个类对象,val是这个值.
}
}
4. 自定义类型的list列表反射
通过反射得到列表中对象的类型， 可以自行设置
创建这个类型的列表，
然后给这个列表添加对象：对象使用反射方法给这个类创建对象。
最后把这个列表对象 ，应赋值对象的list
修改了三个地方，类结构，提取优化了方法创建列表，在测试方法里测试list<自定义>
//枚举类型
public enum TestEnum
{
None=0,
Var1=1,
Var2=2
}
public class TestInfo
{
public int Id { get; set; }
public string Name { get; set; }
public bool IsA { get; set; }
public float High { get; set; }
public List<string> AllStrList { get; set; }
public List<TestInfoTwo> AllTestInfoList;
public TestEnum TestType { get; set; }
}
//测试反射类
public class TestExcelReflection{
[MenuItem("Tools/测试/测试已有数据进行反射")] //从读取数据表里反射得到数据,创建该对象
public static void TestReflection2()
{
object obj = CreatClass("TestInfo"); //创建得到这个对象
PropertyInfo info= obj.GetType().GetProperty("Id"); //得到类型,从类型里边获取属性ID名字
SetValue(info, obj, "21", "int");
PropertyInfo nameInfo = obj.GetType().GetProperty("Name");
SetValue(nameInfo, obj, "asaaasasa", "string");
PropertyInfo isInfo = obj.GetType().GetProperty("IsA");
SetValue(isInfo, obj, "false", "bool");
PropertyInfo HighInfo = obj.GetType().GetProperty("High");
HighInfo.SetValue(obj, System.Convert.ToSingle("222.5")); //ToSingle 是转型的float类型 float类型
SetValue(HighInfo, obj, "512.12", "float");
PropertyInfo enumInfo = obj.GetType().GetProperty("TestType"); //得到这个都对象中这个属性的类型
SetValue(enumInfo, obj, "Var1", "enum");
//更改--------------------------------------------------------
//这块是基本类型的list
Type type = typeof(string);
object list = CreateList(type);
for (int i = 0; i < 3; i++)
{
object addItem = "测试填数据" + i;
list.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, list, new object[] { addItem });//调用liat的add 添加数据
}
obj.GetType().GetProperty("AllStrList").SetValue(obj, list); //将这个list 赋值给类对象的list,引用类型不需要转换
//这里是我们自定义的list
object twoList = CreateList(typeof(TestInfoTwo)); //创建了一个list
for (int i = 0; i < 3; i++)
{
object addItem = CreateClass("TestInfoTwo");
PropertyInfo itemInfo = addItem.GetType().GetProperty("Id");
SetValue(itemInfo, addItem, "124" + i, "int");
PropertyInfo itemNameInfo = addItem.GetType().GetProperty("Name");
SetValue(itemNameInfo, addItem, "测试类" + i, "string");
twoList.GetType().InvokeMember("Add", BindingFlags.Default | BindingFlags.InvokeMethod, null, twoList, new object[] { addItem });
}
obj.GetType().GetProperty("AllTestInfoList").SetValue(obj, twoList);
TestInfo testInfo = (obj as TestInfo);
foreach (var str in testInfo.AllTestInfoList)
{
Debug.LogError(str.Id+" "+str.Name);
}
//------------------------------更改--------------------------
}
/// <summary>
/// 创建反射的实例
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private static object CreatClass(string name)
{
object obj = null;
Type type = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
Type tempType = asm.GetType(name); //得到这个程序集中 name 的类型
if (tempType != null)
{
type = tempType;
break;
}
}
if (type != null)
{
obj = Activator.CreateInstance(type);
}
return obj;
}
//更改--------------------------------------------------------
/// <summary>
/// 反射创建 类型为type 一个list
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static object CreateList(Type type)
{
Type listType = typeof(List<>);
Type specType = listType.MakeGenericType(new System.Type[] { type }); //设置listType 中的类型为string 类型
return Activator.CreateInstance(specType, new object[] { }); //new 出来这个list
}
//------------------------------更改--------------------------
/// <summary>
/// 反射的变量赋值,优化了类型转换
/// </summary>
/// <param name="info"></param>
/// <param name="var"></param>
/// <param name="value"></param>
/// <param name="type"></param>
private static void SetValue(PropertyInfo info,object var, string value,string type)
{
object val = (object)value; //将这个值转换为通用类型
if (type == "int")
{
val = System.Convert.ToInt32(val); //将这个值转换为目标值
}
else if (type == "bool")
{
val = System.Convert.ToBoolean(val);
}else if (type == "float")
{
val = System.Convert.ToSingle(val);
}else if (type == "enum")
{
val = TypeDescriptor.GetConverter(info.PropertyType).ConvertFromInvariantString(val.ToString());
}
info.SetValue(var, val); //给这个对象值设置给这个对象 info 创建的对象类型信息, var 这个类对象,val是这个值.
}
}
8973
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
