.NET架构小技巧(4)——反射,架构人员法宝II

  上一篇博文中,利用属性反射的特点,用两个方法完成了字符转实体,实体转字符的工作,但有些复杂的场景,上面方法就没那么好用了,就需要更复杂的方式来组装处理。
  先来看一个接口文档,下面是接口的调用方式

long  OltpTransData(unsigned long msgType,unsigned long packageType,
      unsigned long packageLength,char *str,LPTSTR com);

I.msgType:业务请求类型;

II.packageType:数据解析格式类型,系统重组数据时使用

III.packageLength:数据串的长度;

IV. str:数据串;调用时,通过数据串传入参数;函数返回时,数据串中包含返回的数据,数据按字符串方式组合,并且在字符串第一位保留一个空格;另外,除了16位日期右补空格,其他的字段均以左空格补位

V. com:数据请求串口

业务请求类型

数据解析格式类型

数据串最小长度

说明

1001

101

126

实时验卡(读卡、验卡)

1002

12

610

实时结算

1003

7

291

实时明细数据传输

1004

9

253

实时住院登记数据传输

1005

8

309

实时医嘱数据传输

1006

12

610

实时结算预算

1007

2

1101

实时住院首次病程记录传输

1009

504

85

医师信息查询

1010

510

331

出入院标准传输

读卡

序号

定义

数据原型

起始位置

数据长度

备注

数据填充

1

个人编号

CHAR

1

8

医保编号,以’E’开头的为异地社保卡,详见说明

院端

2

姓名

CHAR

9

20

 

中心

3

身份证号

CHAR

29

18

18位或15位

中心

4

IC卡号

CHAR

47

9

 

院端

5

治疗序号

NUM

56

4

 

中心

6

职工就医类别

CHAR

60

1

A在职、B退休、L事业离休、T特诊、Q企业离休、E退老、N农民工、X未成年居民、O老年居民(老年居民、低收入人员、残疾人)、D低保人员、S  三无人员、U 大学生

中心

7

基本个人帐户余额

NUM

61

10

 

中心

8

补助个人帐户余额

NUM

71

10

现用于公务员单独列帐

中心

9

统筹累计

NUM

81

10

 

中心

10

门诊慢病统筹累计

NUM

91

10

 

中心

11

月缴费基数

NUM

101

10

月缴费工资

中心

12

帐户状态

CHAR

111

1

A正常、B半止付、C全止付、D销户

中心

13

参保类别1

CHAR

112

1

是否享受高额:

0 不享受高额、1  享受高额、2 医疗保险不可用

中心

14

参保类别2

CHAR

113

1

是否享受补助(商业补助、公务员补助):0  不享受、1 商业、2  公务员、3事业离休差额拨款人员

中心

15

参保类别3

CHAR

114

1

0 企保、1 事保、2企业慢病、3事业慢病、4异地就医,详见说明

中心

16

参保类别4

CHAR

115

1

0或2生育不可用、1或3生育可用

中心

17

参保类别5

CHAR

116

1

0工伤不可用、1工伤可用

中心

18

住院次数累计

NUM

117

4

 

中心

19

家床次数累计

NUM

121

4

 

中心

查询医师

序号

定义

数据原型

起始位置

数据长度

备注

填写方式

1

医师编码

CHAR

1

8

 

院端

2

医师姓名

CHAR

9

20

 

中心

3

身份证号

CHAR

29

18

 

中心

4

可出诊医院编号

CHAR

47

20

详见说明

中心

5

终止日期

DATETIME

67

16

YYYYMMDDHHMMSS

中心

6

有效标志

CHAR

83

1

‘0’无效,‘1’有效

中心

  这个接口是拼接方式,每个数据项都有固定的长度,有些数据也有固定的格式,比如日期,还有很多类型,都是有固定值固定含义的。这种情况下需要更多的信息来告诉两个转换方法该怎么转换,这里就引出了Attribute——一个专门来给类或属性方法加特征的知识点。

 /// <summary>
    /// 发送报文类型
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    public class PackageTypeAttribute : Attribute
    {
        /// <summary>
        /// 发关报文实体类属性特性类
        /// </summary>
        /// <param name="SN">属性的序号,从1开始</param>
        /// <param name="Length">属性转成字符串后长度</param>
        public PackageTypeAttribute(uint OperationType, uint DataFormaterType, uint MinLength)
        {
            this.OperationType = OperationType;
            this.DataFormaterType = DataFormaterType;
            this.MinLength = MinLength;
        }
        /// <summary>
        /// 业务请求类型
        /// </summary>
        public uint OperationType
        { get; private set; }
        /// <summary>
        /// 数据解析格式类型
        /// </summary>
        public uint DataFormaterType
        { get; private set; }
        /// <summary>
        /// 数据串最小长度
        /// </summary>
        public uint MinLength
        { get; private set; }
    }

    /// <summary>
    /// 报文中属性的顺序SN和长度Length
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class PackageAttribute : Attribute
    {
        /// <summary>
        /// 序号,从1开始
        /// </summary>
        public int SN
        { get; private set; }
        /// <summary>
        /// 转成字符串后的长度
        /// </summary>
        public int Length
        { get; private set; }
        /// <summary>
        /// 发关报文实体类属性特性类
        /// </summary>
        /// <param name="SN">属性的序号,从1开始</param>
        /// <param name="Length">属性转成字符串后长度</param>
        public PackageAttribute(int SN, int Length)
        {
            this.SN = SN;
            this.Length = Length;
        }
        /// <summary>
        /// 是否是时间类型,因为时间类型是左对齐,右补空格
        /// </summary>
        public bool IsDateTime
        { get; set; }
    }

    /// <summary>
    /// 取枚举的值还是
    /// </summary>
    [AttributeUsage(AttributeTargets.Enum)]
    public class EnumValeuNumberAttribute : Attribute
    {
        /// <summary>
        /// 是否把枚举类型属性的的值数转成Char类型
        /// </summary>
        public bool IsChar
        { get; set; }
    }

  定义了三个特性类,PackageTypeAttribute主用来区分不同的交易类型,从实体类上获取不同交易的函数参数;PackageAttribute是在实体类的属性上的,是核心特性类,它标记了属性的序号,和每个属性的长度,和属性是否是DateTime类型;EnumValeuNumberAttribute是用来专门处理枚举类型的属性的。

 /// <summary>
    /// 医师信息查询
    /// </summary>
    [PackageType(1009, 504, 85)]
    public class DoctorQuery : Entity
    {
        /// <summary>
        /// 医师编码
        /// </summary>
        [Package(1, 8)]
        public virtual String DoctorCode
        {
            get; set;
        }
        /// <summary>
        /// 医师姓名
        /// </summary>
        [Package(2, 20)]
        public virtual String DoctorName
        { get; set; }

        /// <summary>
        /// 身份证号
        /// </summary>
        [Package(3, 18)]
        public virtual string PersonID
        { get; set; }

        ///编号为0002的医院, 下属有编号为0113的定点, 在总院注册登记的医师可以在这样的2家医院出诊, 则“可出诊医院编号”为00020113,若长度不足20位则前补空格。
        /// <summary>
        /// 可出诊医院编号
        /// </summary>
        [Package(4, 20)]
        public virtual string CanVisitHospitalCode
        { get; set; }

        /// <summary>
        /// 终止日期
        /// </summary>
        [Package(5, 16, IsDateTime = true)]
        public virtual string TerminationTime
        { get; set; }

        /// <summary>
        /// 有效标志
        /// </summary>
        [Package(6, 1)]
        public virtual DLYBAvailableMarker DLYBAvailableMarker
        { get; set; }
    }

    /// <summary>
    /// 有效标志
    /// </summary>
    [EnumValeuNumber]
    public enum DLYBAvailableMarker
    {
        /// <summary>
        /// 无效
        /// </summary>
        nullity = 0,
        /// <summary>
        /// 有效
        /// </summary>
        Valid = 1
    }

    /// <summary>
    /// 实时验卡(读卡、验卡)
    /// </summary>
    [PackageType(1001, 101, 126)] 
    public  class QueryCardEntity : Entity
    {        
        /// <summary>
        /// 个人编号
        /// </summary>
        [Package(1, 8)]
        public virtual string PersonNumber
        { get; set; }

        /// <summary>
        /// 姓名
        /// </summary>
        [Package(2, 20)]
        public virtual string Name
        { get; set; }

        /// <summary>
        /// 身份证号
        /// </summary>
        [Package(3, 18)]
        public virtual string PersonID
        { get; set; }

        /// <summary>
        /// IC卡号
        /// </summary>
        [Package(4, 9)]
        public virtual string ICCardNumber
        { get; set; }

        long therapyNumber;
        /// <summary>
        /// 治疗序号
        /// </summary>
        [Package(5, 4)]
        public virtual long TherapyNumber
        {
            get
            {
                return therapyNumber;
            }
            set
            {
                if (value >= 0 && value <= 9999)
                {
                    therapyNumber = value;
                }
                else
                {
                    throw new Exception("治疗号在0-9999之间");
                }

            }
        }

        /// <summary>
        /// 职工就医类别
        /// </summary>
        [Package(6, 1)]
        public virtual string TherapyCategory
        { get; set; }

        /// <summary>
        /// 基本个人帐户余额
        /// </summary>
        [Package(7, 10)]
        public virtual decimal BasePersonBalance
        { get; set; }

        /// <summary>
        /// 补助个人帐户余额
        /// </summary>
        [Package(8, 10)]
        public virtual decimal SubsidyPersonBalance
        { get; set; }

        /// <summary>
        /// 统筹累计
        /// </summary>
        [Package(9, 10)]
        public virtual decimal PlannerTotal
        { get; set; }

        /// <summary>
        /// 门诊慢病统筹累计///新
        /// </summary>
        [Package(10, 10)]
        public virtual decimal MZSlowDisease
        { get; set; }

        /// <summary>
        /// 月缴费基数
        /// </summary>
        [Package(11, 10)]
        public virtual decimal BaseFeeByMonth
        { get; set; }

        /// <summary>
        /// 帐户状态
        /// </summary>
        [Package(12, 1)]
        public virtual string AccoutState
        { get; set; }

        /// <summary>
        /// 参保类别1
        /// </summary>
        [Package(13, 1)]
        public virtual string InsuranceCategory1
        { get; set; }

        /// <summary>
        /// 参保类别2
        /// </summary>
        [Package(14, 1)]
        public virtual string InsuranceCategory2
        { get; set; }

        /// <summary>
        /// 参保类别3
        /// </summary>
        [Package(15, 1)]
        public virtual string InsuranceCategory3
        { get; set; }

        /// <summary>
        /// 参保类别4
        /// </summary>
        [Package(16, 1)]
         public virtual string InsuranceCategory4
        { get; set; }

        /// <summary>
        /// 参保类别5
        /// </summary>
        [Package(17, 1)]
        public virtual string InsuranceCategory5
        { get; set; }

        /// <summary>
        /// 住院次数累计////新
        /// </summary>
        [Package(18, 4)]
        public virtual int ZYAddNumber
        { get; set; }

        /// <summary>
        /// 家床次数累计////新
        /// </summary>
        [Package(19, 4)]
        public virtual int AddBedNumber
        { get; set; }
    }

  上面的实体类分别使用了特性类,参照文档就OK。

 public static class StringExtension
    {  
        /// <summary>
        /// 右边不够长度补空格,汉字算两个空格
        /// </summary>
        /// <param name="str"></param>
        /// <param name="length">设定长度</param>
        /// <returns></returns>
        public static string ChineseCharacterLeft(this string str, int length)
        {
            var len = Encoding.Default.GetBytes(str).Length;
            if (len < length)
            {
                for (int i = 0; i < length - len; i++)
                {
                    str = " " + str;
                }
            }
            return str;
        }

        /// <summary>
        /// 右边不够长度补空格,汉字算两个空格
        /// </summary>
        /// <param name="str"></param>
        /// <param name="length">设定长度</param>
        /// <returns></returns>
        public static string ChineseCharacterRight(this string str, int length)
        {
            var len = Encoding.Default.GetBytes(str).Length;
            if (len < length)
            {
                for (int i = 0; i < length - len; i++)
                {
                    str += " ";
                }
            }
            return str;
        }

        /// <summary>
        /// 切除字符串
        /// </summary>
        public static string ChineseCharacterSubstring(this string str, int length, out string remaining)
        {
            var arr = Encoding.Default.GetBytes(str);
            var barr = arr.Take(length).ToArray();
            var valuestr = Encoding.Default.GetString(barr);
            barr = arr.Skip(length).ToArray();
            remaining = Encoding.Default.GetString(barr); ;
            return valuestr;
        }
    }

  上面代码是对某些属性的对齐方式作了处理。

 /// <summary>
    /// 报文类的父类
    /// </summary>
    public abstract class Entity
    {
        /// <summary>
        /// 组装发送报文格式
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            var pros = this.GetType().GetProperties();
            var sortPro = new SortedList<int, PropertyInfo>();  
            foreach (var pro in pros)
            {
                foreach (var att in pro.GetCustomAttributes(false))
                {
                    if (att is PackageAttribute)
                    {
                        var packageAtt = att as PackageAttribute;   
                        sortPro.Add(packageAtt.SN, pro);
                    }
                }
            }
            var content = new StringBuilder();
            #region 组合发送字符串
            //遍历属性 
            foreach (var pro in sortPro)
            {
                //遍历属性上的特性                
                foreach (var att in pro.Value.GetCustomAttributes(false))
                {
                    //判断是否为自定义的PackageAttribute类型
                    if (att is PackageAttribute)
                    {
                        //转换属性上的特性类
                        var packageAtt = att as PackageAttribute;
                        //取拼接时字符长度
                        var length = packageAtt.Length;
                        //取属性的值
                        var proValue = pro.Value.GetValue(this, new Object[0]);

                        //对decimal作处理
                        if (pro.Value.PropertyType.Name.ToLower() == "decimal")
                        {
                            proValue = Math.Round(Convert.ToDecimal(proValue), 2);
                            if (Encoding.Default.GetByteCount(proValue.ToString()) > length)
                            {
                                proValue = "0";
                            }
                        }
                        //判断字符串长度过长
                        if (proValue != null && (pro.Value.PropertyType.Name.ToLower() == "string"))
                        {
                            if (System.Text.Encoding.Default.GetBytes(proValue.ToString()).Length > length)
                            {
                                throw new Exception(string.Format("属性{0}的值{1},长度超过{2}", pro.Value.Name, proValue, length));
                            }
                        }
                        //如果值为非空
                        if (proValue != null)
                        {
                            //日期是右补空格,其他是左补空格
                            if (!packageAtt.IsDateTime)
                            {
                                //这里注册,有些属性是枚举类型,有些属性拼接枚举的值,有些取枚举值对应的枚举数值,这里是从该属性类型上的EnumValeuNumberAttribute特性的IsValue属性来判断的,IsValue为true,就取枚举的值,为false取该值对应的枚举数
                                if (pro.Value.PropertyType.IsEnum)
                                {
                                    foreach (var eatt in pro.Value.PropertyType.GetCustomAttributes(false))
                                    {
                                        if (eatt is EnumValeuNumberAttribute)
                                        {
                                            var enumVaNu = eatt as EnumValeuNumberAttribute;
                                            if (enumVaNu.IsChar)
                                            {
                                                var enumNumber = ((char)(int)Enum.Parse(pro.Value.PropertyType, proValue.ToString())).ToString();
                                                content.Append(enumNumber.ChineseCharacterLeft(length));
                                            }
                                            else
                                            {
                                                var enumNumber = ((int)Enum.Parse(pro.Value.PropertyType, proValue.ToString())).ToString();
                                                content.Append(enumNumber.ChineseCharacterLeft(length));
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    content.Append(proValue.ToString().ChineseCharacterLeft(length));
                                }
                            }
                            else//日期类型右补空格
                            {
                                content.Append(proValue.ToString().ChineseCharacterRight(length));
                            }
                        }
                        else
                        {
                            content.Append("".ChineseCharacterLeft(length));
                        }
                    }
                }
            }
            #endregion
            return content.ToString();
        }


        /// <summary>
        /// 把一个字符串转成一个对象
        /// </summary>
        /// <param name="content"></param>
        /// <returns></returns>
        public  Entity ToEntity(Type entityType,string content)
        {
            var pros = entityType.GetProperties();
            //按照特性类上的SN序号把属性名存入集合proPackageList中
            List<PropertyInfo> proPackageList = new List<PropertyInfo>(pros.Length);
            //初始化属性集合
            for (int i = 0; i < pros.Length; i++)
            {
                foreach (var att in pros[i].GetCustomAttributes(false))
                {
                    if (att is PackageAttribute)
                    {
                        proPackageList.Add(null);
                        break;
                    }
                }
            }
            //按属性顺序排列属性
            foreach (var pro in pros)
            {
                foreach (var att in pro.GetCustomAttributes(false))
                {
                    if (att is PackageAttribute)
                    {
                        var packageAtt = att as PackageAttribute;
                        var index = packageAtt.SN - 1;
                        proPackageList[index] = pro;
                    }
                }
            }

            //创建实体对象
            var constructor = entityType.GetConstructor(new Type[0]);
            var entity = constructor.Invoke(new object[0]);
            foreach (var pro in proPackageList)
            {
                //遍历属性上的特性
                foreach (var att in pro.GetCustomAttributes(false))
                {
                    //判断是否为自定义的PackageAttribute类型
                    if (att is PackageAttribute)
                    {
                        //转换属性上的特性类
                        var packageAtt = att as PackageAttribute;

                        var length = packageAtt.Length;

                        var valuestr = content.ChineseCharacterSubstring(length, out content).Trim();

                        if (pro.PropertyType.IsEnum)
                        {
                            foreach (var eatt in pro.PropertyType.GetCustomAttributes(false))
                            {
                                if (eatt is EnumValeuNumberAttribute)
                                {
                                    var eat = eatt as EnumValeuNumberAttribute;
                                    if (eat.IsChar)
                                    {
                                        var chr = Convert.ToChar(valuestr);

                                        var value = Convert.ChangeType(Enum.Parse(pro.PropertyType, ((int)chr).ToString()), pro.PropertyType);
                                        pro.SetValue(entity, value, null);
                                    }
                                    else
                                    {
                                        var value = Convert.ChangeType(Enum.Parse(pro.PropertyType, valuestr), pro.PropertyType);
                                        pro.SetValue(entity, value, null);
                                    }
                                    break;
                                }
                            }
                        }
                        else
                        {
                            var value = Convert.ChangeType(valuestr, pro.PropertyType);
                            pro.SetValue(entity, value, null);
                        }
                    }
                }
            }
            return (Entity)entity;
        }
    }

  这两个方法核心里通过反射属性上的特性,取特性中定义的固定值,来生成接口要求的字符串,合理的设计特性,可以使两个转换方法更优雅,更简便,在开发过程中,也需要不断调整理,适配,逐渐完善。

  可以用下面的代码完成测试

using System;
namespace ArchitectureDemo04
{
    class Program
    {
        static void Main(string[] args)
        {
            var backQueryCard = Send(new QueryCardEntity { PersonNumber = "0000001", ICCardNumber = "C00000001" });

            var backDoctorQuery = Send(new DoctorQuery { DoctorCode = "0001" });
        }
        /// <summary>
        /// 发送
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        static Entity Send(Entity entity)
        {
            try
            {
                foreach (var att in entity.GetType().GetCustomAttributes(false))
                {
                    if (att is PackageTypeAttribute)
                    {
                        var attPackage = att as PackageTypeAttribute;    
                        Console.WriteLine($"入参:");
                        Console.WriteLine(entity);
                        Console.WriteLine("模拟函数调用:");
                        Console.WriteLine($"OltpTransData({attPackage.OperationType},{attPackage.DataFormaterType},{attPackage.MinLength},{entity})");
                        var backContent = BackOperation(entity);
                        var backEntity = entity.ToEntity(entity.GetType(),backContent);
                        return backEntity;
                    }
                }
                return null;
            }
            catch
            {
                throw;
            }
        }
        /// <summary>
        /// 模拟医保中心返回
        /// </summary>
        /// <param name="entity">参数</param>
        /// <returns></returns>
        static string BackOperation(Entity entity)
        {
            switch (entity.GetType().Name)
            {
                case "QueryCardEntity":
                    return " 0000001                Jack210213198411113111C00000001   1A   1000.66         0         0         0      1800A00131   0   0"; 
                case "DoctorQuery":
                    return "    0001            DcotorLi210211198707182233            0002011320201029190850  1";
            }
            return null;
        }
    }
}
     想要更快更方便的了解相关知识,可以关注微信公众号    .NET架构小技巧(4)——反射,架构人员法宝II
上一篇:.NET架构小技巧(4)——反射,架构人员法宝II


下一篇:C语言用随机函数求平均分(数组)