excel-txt类型数据读写-RWInterface.cs-连载1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ShootCore.Core
{
    /// <summary>
    /// 读写基类，提供一些基本的读写的接口，将匿名数
    /// 据成员打包成字符串，或者将字符串导入实体数据
    /// </summary>
    public abstract class RWBase
    {
        /// <summary>
        /// 写入的回调函数
        /// </summary>
        /// <param name="target">目标对象</param>
        /// <param name="value">一元数据块</param>
        /// <param name="values">多元数据块</param>
        /// <returns> 返回被写入数据的对象 </returns>
        public delegate object WriteCallBack(object target, string value, string[] values);

        /// <summary>
        /// 读取回调函数
        /// </summary>
        /// <param name="target">目标对象</param>
        /// <returns>返回读取到的内容</returns>
        public delegate string ReadCallBack(object target);

        /// <summary>
        /// 针对的数据类型信息
        /// 该属性由子类提供
        /// </summary>
        protected Type mBaseType;

        /// <summary>
        /// 针对写入变量的名称
        /// 该属性由子类提供
        /// </summary>
        protected string mName;

        /// <summary>
        /// 写入函数回调
        /// 该事件由外部定义
        /// </summary>
        protected WriteCallBack mWriteCallBack;

        /// <summary>
        /// 读取函数回调
        /// 该事件由外部定义
        /// </summary>
        protected ReadCallBack mReadCallBack;

        /// <summary>
        /// 设置一个写入回调
        /// </summary>
        /// <param name="wc">事件实例</param>
        public void SetWriteCallBack(WriteCallBack wc)
        {
            this.mWriteCallBack = wc;
        }

        /// <summary>
        /// 设置一个读取回调
        /// </summary>
        /// <param name="rc">事件实例</param>
        public void SetReadCallBack(ReadCallBack rc)
        {
            this.mReadCallBack = rc;
        }


        /// <summary>
        /// 根据字符串写入任何数据
        /// </summary>
        /// <param name="content">字符串格式数据段</param>
        /// <returns>返回写入实例对象</returns>
        protected object WriteAnyDataFromString(string content)
        {
            object data = null;

            if (this.mBaseType.IsArray)
            {
                string[] results;
                content = content.Trim(new char[] { ' ', '{', '}' });
                if (this.mBaseType.Equals(typeof(string[])))
                {
                    results = content.Split(new string[] { ";;;" }, StringSplitOptions.None);
                }
                else
                {
                    results = content.Split(new char[] { ',' });
                }

                data = System.Activator.CreateInstance(mBaseType, results.Length);

                data = this.mWriteCallBack(data, null, results);
            }
            else
            {
                data = System.Activator.CreateInstance(mBaseType);
                data = this.mWriteCallBack(data, content, null);
            }
            return data;
        }

        /// <summary>
        /// 字段属性的名称
        /// </summary>
        /// <returns></returns>
        public string GetName()
        {
            return mName;
        }

        /// <summary>
        /// 为目标对象写入字符串数据段
        /// 该函数由子类实现
        /// </summary>
        /// <param name="target">目标对象</param>
        /// <param name="content">被写入的字符串数据段</param>
        public abstract void SetValue(object target, string content);

        /// <summary>
        /// 从目标对象身上获得一个经过打包处理
        /// 的字符串数据段，该函数由子类实现
        /// </summary>
        /// <param name="target">目标对象</param>
        /// <returns>经过打包处理的字符串数据段</returns>
        public abstract string GetValue(object target);
    }

    /// <summary>
    /// 读写一个类的变量
    /// </summary>
    public class RWField : RWBase
    {
        /// <summary>
        /// 成员变量的信息
        /// </summary>
        private FieldInfo mFieldInfo;

        /// <summary>
        /// 设置一个变量信息，并重新填充
        /// 名称，类型等基类属性
        /// </summary>
        /// <param name="field"></param>
        public void SetFieldInfo(FieldInfo field)
        {
            this.mName = field.Name;
            this.mFieldInfo = field;
            this.mBaseType = field.FieldType;
        }

        /// <summary>
        /// 向目标对象填充一段字符串数据
        /// </summary>
        /// <param name="target">目标对象</param>
        /// <param name="content">数据段</param>
        public override void SetValue(object target, string content)
        {
            mFieldInfo.SetValue(target, this.WriteAnyDataFromString(content));
        }

        /// <summary>
        /// 从目标身上获得经过打包处理的字符串数据段
        /// </summary>
        /// <param name="target">操作目标</param>
        /// <returns>返回的字符串数据段</returns>
        public override string GetValue(object target)
        {
            return this.mReadCallBack(mFieldInfo.GetValue(target));
        }
    }

    public class RWProperty : RWBase
    {
        private PropertyInfo mFieldInfo;

        public void SetPropertyInfo(PropertyInfo property)
        {
            this.mName = property.Name;
            this.mFieldInfo = property;
            this.mBaseType = property.PropertyType;
        }

        public override void SetValue(object target, string content)
        {
            mFieldInfo.SetValue(target, this.WriteAnyDataFromString(content));
        }

        public override string GetValue(object target)
        {
            return this.mReadCallBack(mFieldInfo.GetValue(target));
        }
    }

    public class ComparerInfo
    {
        public Type BaseType { get; private set; }
        public RWBase.ReadCallBack HowRead { get; private set; }
        public RWBase.WriteCallBack HowWrite { get; private set; }

        public ComparerInfo(Type baseType,RWBase.ReadCallBack readCallback,RWBase.WriteCallBack writeCallBack) 
        {
            this.BaseType = baseType;
            this.HowRead = readCallback;
            this.HowWrite = writeCallBack;
        }
    }

    public class RWCallBack 
    {

        public static List<ComparerInfo> MakeComparerInfo() 
        {
            List<ComparerInfo> result = new List<ComparerInfo>();
            result.Add(new ComparerInfo(typeof(bool),     ReadAnyData,              WriteBoolData       ));
            result.Add(new ComparerInfo(typeof(int),      ReadAnyData,              WriteIntData        ));
            result.Add(new ComparerInfo(typeof(long),     ReadAnyData,              WriteLongData       ));
            result.Add(new ComparerInfo(typeof(float),    ReadAnyData,              WriteFloatData      ));
            result.Add(new ComparerInfo(typeof(double),   ReadAnyData,              WriteDoubleData     ));
            result.Add(new ComparerInfo(typeof(string),   ReadAnyData,              WriteStringData     ));            
            result.Add(new ComparerInfo(typeof(bool[]),   ReadAnyArrayData<bool>,   WriteBoolArrayData  )); 
            result.Add(new ComparerInfo(typeof(int[]),    ReadAnyArrayData<int>,    WriteIntArrayData   ));
            result.Add(new ComparerInfo(typeof(long[]),   ReadAnyArrayData<long>,   WriteLongArrayData  ));
            result.Add(new ComparerInfo(typeof(float[]),  ReadAnyArrayData<float>,  WriteFloatArrayData ));
            result.Add(new ComparerInfo(typeof(double[]), ReadAnyArrayData<double>, WriteDoubleArrayData));
            result.Add(new ComparerInfo(typeof(string[]), ReadStringArrayData,      WriteStringArrayData));
            return result;
        }

        static object WriteBoolData(object target, string value, string[] values)
        {
            bool b = (bool)target;
            bool.TryParse(value,out b);
            return b;
        }

        static object WriteIntData(object target, string value, string[] values)
        {
            int i = (int)target;
            int.TryParse(value, out i);
            return i;
        }

        static object WriteLongData(object target, string value, string[] values)
        {
            long l = (long)target;
            long.TryParse(value, out l);
            return l;
        }

        static object WriteFloatData(object target, string value, string[] values)
        {
            float f = (float)target;
            float.TryParse(value, out f);
            return f;
        }

        static object WriteDoubleData(object target, string value, string[] values)
        {
            double d = (double)target;
            double.TryParse(value, out d);
            return d;
        }

        static object WriteStringData(object target, string value, string[] values)
        {    
            return value;
        } 

        static object WriteBoolArrayData(object target, string value, string[] values)
        {
            bool[] fa = (bool[])target;

            for (int i = 0, max = fa.Length; i < max; ++i)
            {
                if (false == bool.TryParse(values[i], out fa[i]))
                {
                    fa[i] = false;
                }
            }
            return fa;
        }

        static object WriteIntArrayData(object target, string value, string[] values)
        {
            int[] fa = (int[])target;

            for (int i = 0, max = fa.Length; i < max; ++i)
            {
                if (false == int.TryParse(values[i], out fa[i]))
                {
                    fa[i] = 0;
                }
            }
            return fa;
        }

        static object WriteLongArrayData(object target, string value, string[] values)
        {
            long[] fa = (long[])target;

            for (int i = 0, max = fa.Length; i < max; ++i)
            {
                if (false == long.TryParse(values[i], out fa[i]))
                {
                    fa[i] = 0L;
                }
            }
            return fa;
        }

        static object WriteFloatArrayData(object target, string value, string[] values)
        {
            float[] fa = (float[])target;

            for (int i = 0, max = fa.Length; i < max; ++i)
            {
                if (false == float.TryParse(values[i], out fa[i]))
                {
                    fa[i] = 0f;
                }
            }
            return fa;
        }

        static object WriteDoubleArrayData(object target, string value, string[] values)
        {
            double[] fa = (double[])target;

            for (int i = 0, max = fa.Length; i < max; ++i)
            {
                if (false == double.TryParse(values[i], out fa[i]))
                {
                    fa[i] = 0f;
                }
            }
            return fa;
        }

        static string ReadAnyArrayData<T>(object target)
        {
            string result = "{";
            if (target != null)
            {
                T[] fa = (T[])target;

                if (fa.Length > 0)
                {
                    result += fa[0].ToString();
                    for (int i = 1, max = fa.Length; i < max; ++i)
                    {
                        result += ',' + fa[i].ToString();
                    }
                }
            }
            result += "}";
            return result;
        }

        static string ReadAnyData(object target)
        {      
            return target.ToString();
        }

        static string WriteAnyData(object target) 
        {
            return target.ToString();
        }

        static object WriteStringArrayData(object target, string value, string[] values)
        {
            string[] fa = (string[])target;
            Array.Copy(values, fa, fa.Length);
            return fa;
        }

        static string ReadStringArrayData(object target) 
        {
            string result = "{";
            if (target != null)
            {
                string[] fa = (string[])target;

                if (fa.Length > 0)
                {
                    result += fa[0];
                    for (int i = 1, max = fa.Length; i < max; ++i)
                    {
                        result += ";;;" + fa[i];
                    }
                }
            }
            result += "}";
            return result;
        }
    }
}