using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Windows.Forms;
using System.Xml.Serialization;
namespace AOI
{
/// <summary>
/// 类赋值、序列化、反序列化
/// </summary>
class DynamicValue
{
/// <summary>
/// 动态赋值
/// </summary>
/// <param name="obj"></param>
/// <param name="fieldName"></param>
/// <param name="value"></param>
public static void SetValue(object obj, string fieldName, object value)
{
FieldInfo info = obj.GetType().GetField(fieldName);
info.SetValue(obj, value);
}
/// <summary>
/// 泛型动态赋值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="fieldName"></param>
/// <param name="value"></param>
public static void SetValue<T>(object obj, string fieldName, T value)
{
FieldInfo info = obj.GetType().GetField(fieldName);
info.SetValue(obj, value);
}
/// <summary>
/// 动态取值
/// </summary>
/// <param name="obj"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
public static object GetValue(object obj, string fieldName)
{
FieldInfo info = obj.GetType().GetField(fieldName);
return info.GetValue(obj);
}
/// <summary>
/// 动态取值泛型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
public static T GetValue<T>(object obj, string fieldName)
{
FieldInfo info = obj.GetType().GetField(fieldName);
return (T)info.GetValue(obj);
}
/// <summary>
/// 两个类之间互相赋值
/// </summary>
/// <param name="SrcClass"></param>
/// <param name="DesClass"></param>
/// <param name="convertProperty"></param>
/// <param name="convertField"></param>
/// <param name="showError"></param>
public static void ConvertObject(object SrcClass, object DesClass, bool convertProperty = true, bool convertField = true, bool showError = true)
{
try
{
if (SrcClass == null)
{
return;
}
if (convertProperty)
{
PropertyInfo[] srcProperties = SrcClass.GetType().GetProperties();
PropertyInfo[] desProperties = DesClass.GetType().GetProperties();
if (srcProperties.Length > 0 && desProperties.Length > 0)
{
foreach (var srcPi in srcProperties)
{
foreach (var desPi in desProperties)
{
if (srcPi.Name == desPi.Name && srcPi.PropertyType == desPi.PropertyType && desPi.CanWrite)
{
Object value = srcPi.GetValue(SrcClass, null);
desPi.SetValue(DesClass, value, null);
//if (srcPi.PropertyType.IsClass)
//{
// ConvertObject(srcPi.GetValue(SrcClass, null), desPi.GetValue(DesClass, null), convertProperty, convertField, showError);
//}
//else
//{
// Object value = srcPi.GetValue(SrcClass, null);
// desPi.SetValue(DesClass, value, null);
//}
}
}
}
}
}
if (convertField)
{
FieldInfo[] srcFields = SrcClass.GetType().GetFields();
FieldInfo[] desFields = DesClass.GetType().GetFields();
if (srcFields.Length > 0 && desFields.Length > 0)
{
foreach (var srcField in srcFields)
{
foreach (var desField in desFields)
{
if (srcField.Name == desField.Name && srcField.FieldType == desField.FieldType)
{
if (srcField.FieldType.IsClass)
{
ConvertObject(srcField.GetValue(SrcClass), desField.GetValue(DesClass), convertProperty, convertField, showError);
}
else
{
Object value = srcField.GetValue(SrcClass);
desField.SetValue(DesClass, value);
}
}
}
}
}
}
}
catch (Exception ex)
{
if (showError)
{
MessageBox.Show($"Convert Error: Method={nameof(ConvertObject)}, Message={ex.Message}");
}
else
{
throw new Exception($"Convert Error: Method={nameof(ConvertObject)}, Message={ex.Message}");
}
}
}
/// <summary>
/// 获取类中的属性
/// </summary>
/// <returns>所有属性名称</returns>
public static List<string> GetProperties<T>(T t)
{
List<string> ListStr = new List<string>();
if (t == null)
{
return ListStr;
}
System.Reflection.PropertyInfo[] properties = t.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
if (properties.Length <= 0)
{
return ListStr;
}
foreach (System.Reflection.PropertyInfo item in properties)
{
string name = item.Name; //名称
object value = item.GetValue(t, null); //值
if (item.PropertyType.IsValueType || item.PropertyType.Name.StartsWith("String"))
{
ListStr.Add(name);
}
else
{
GetProperties(value);
}
}
return ListStr;
}
/// <summary>
/// 获取类中的字段
/// </summary>
/// <returns>所有字段名称</returns>
public static List<string> GetFields<T>(T t)
{
List<string> ListStr = new List<string>();
if (t == null)
{
return ListStr;
}
System.Reflection.FieldInfo[] fields = t.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (fields.Length <= 0)
{
return ListStr;
}
foreach (System.Reflection.FieldInfo item in fields)
{
string name = item.Name; //名称
object value = item.GetValue(t); //值
if (item.FieldType.IsValueType || item.FieldType.Name.StartsWith("String"))
{
ListStr.Add(name);
}
else
{
GetFields(value);
}
}
return ListStr;
}
public static List<string> EnumControls<T>(T t)
{
List<string> ListStr = new List<string>();
if (t == null)
{
return ListStr;
}
System.Reflection.PropertyInfo[] properties = t.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
if (properties.Length <= 0)
{
return ListStr;
}
foreach (System.Reflection.PropertyInfo item in properties)
{
string name = item.Name; //名称
ListStr.Add(name);
}
return ListStr;
}
public static void SerializeToXml<T>(string filePath, T obj)
{
try
{
using (System.IO.StreamWriter writer = new System.IO.StreamWriter(filePath))
{
System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(T));
xs.Serialize(writer, obj);
}
}
catch { }
}
/// 把对象序列化成xml文件
/// </summary>
/// <typeparam name="T">对象的类</typeparam>
/// <param name="outFile">输出的文件和路径</param>
/// <param name="t">对象的实例</param>
public static void SerializerToXML<T>(string outFile, T t) where T : class
{
using (System.IO.FileStream fs = new System.IO.FileStream(outFile, System.IO.FileMode.Create))
{
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
XmlSerializer xs = new XmlSerializer(typeof(T));
xs.Serialize(fs, t, ns);
fs.Flush();
}
}
/// <summary>
/// 将XML文件反序列化
/// </summary>
/// <param name="path"></param>
/// <param name="object_type"></param>
/// <returns></returns>
public static object Deserialize_from_xml(string path, Type object_type)
{
using (StreamReader reader = new StreamReader(path))
{
XmlSerializer serializer = new XmlSerializer(object_type);
return serializer.Deserialize(reader);
}
}
/// <summary>
/// 判断类中属性是否有值
/// </summary>
/// <param name="model">类</param>
/// <param name="name">跳过的属性名称</param>
/// <returns></returns>
public static bool CheckObjectFieldIsNotNull(object model, string name)
{
bool flag = false;
try
{
PropertyInfo[] propers = model.GetType().GetProperties();
foreach (var item in propers)
{
if (item.Name == name)
{
continue;
}
else
{
object stre = item.GetValue(model, null);
if (stre != null)
{
if (stre.ToString() != "")
{
flag = true;
break;
}
}
}
}
}
catch (Exception ex)
{
Logging.logNet.WriteError("<CheckObjectFieldIsNotNull>", ex.Message);
}
return flag;
}
}
}
C#类序列化反序列化、赋值
于 2022-05-18 13:47:04 首次发布