• 【C#】【Demo】.net使用GDI绘图帮助类


    GDI绘图帮助类 GDIHelper

    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Linq;
    
    namespace CommonUtil.GraphicsDrawString
    {
        /// <summary>
        /// GDI绘图帮助类
        /// </summary>
        public class GDIHelper
        {
            private float y;//当前y坐标
            private readonly float ratio;//整体全局的缩放
            private Graphics graphics;//绘制执行对象
    
            /// <summary>
            /// GDI将要绘制的对象
            /// </summary>
            private List<GDIDataModel> Models { get; set; }
    
            private GDIHelper() { }
    
            /// <summary>
            /// GDI绘图帮助类
            /// </summary>
            /// <param name="startX">起点坐标</param>
            /// <param name="startY"></param>
            public GDIHelper(float startY, float ratio, Graphics graphics)
            {
                y = startY;
                this.ratio = ratio;
                this.graphics = graphics;
                Models = new List<GDIDataModel>();
            }
    
            /// <summary>
            /// 添加待绘制对象,并返回计算占距大小
            /// </summary>
            /// <param name="model"></param>
            /// <returns></returns>
            public SizeF Add(GDIDataModel m)
            {
                Models.Add(m);
    
                return GetSizeF(m);
            }
    
            /// <summary>
            /// 添加待绘制对象,x坐标计算为当前内容的中点,即x=x-内容宽/2
            /// </summary>
            /// <returns></returns>
            public SizeF Add_StrXCenter(GDIDataModel m) 
            {
                var size=GetSizeF(m);
                m.X -= size.Width / 2;
    
                Models.Add(m);
    
                return size;
            }
    
            /// <summary>
            /// 仅获取待添加对象的占距,不添加到列表
            /// </summary>
            /// <param name="m"></param>
            /// <returns></returns>
            public SizeF GetSizeF(GDIDataModel m) 
            {
                if (graphics != null && !string.IsNullOrWhiteSpace(m.S))
                {
                    if (m.LimitW > 0)
                    {
                        
                        m.Size_Str = graphics.MeasureString(m.S, m.font, (int)m.LimitW);
                    }
                    else
                    {
                        m.Size_Str = graphics.MeasureString(m.S, m.font);
                    }
                }
                return m.Size_Str;
            }
    
            /// <summary>
            /// 绘制,使用计算的y坐标
            /// </summary>
            /// <param name="graphics"></param>
            public void DrawString_ComputeY()
            {
                if (Models == null || !Models.Any() || graphics == null)
                {
                    return;
                }
                //按行排序
                Models = Models.OrderBy(x => x.Row).ToList();
    
                foreach (var row in Models.Select(x => x.Row).Distinct().ToList())
                {
    
                    var thisRow = Models.Where(x => x.Row == row).ToList();
                    foreach (var m in thisRow)
                    {
                        //全局的缩放
                        m.SetRatio(ratio);
    
                        //绘制当前
                        m.DrawString(graphics, y);
    
                        //计算高
                        if (!string.IsNullOrWhiteSpace(m.S))
                        {
                            float h = m.Size_Str.Height;
                            if (m.DistanceH < m.Size_Str.Height)
                            {
                                m.DistanceH = m.Size_Str.Height  + m.RowSpace;
                            }
                        }
                    }
                    float thisMaxH = thisRow.Max(x => x.DistanceH);//当前行高最大值
    
                    //y轴偏移
                    y += thisMaxH;
                }
    
    
            }
        }
    
        /// <summary>
        /// GDI将要绘制的对象
        /// </summary>
        public class GDIDataModel
        {
            #region 属性
            /// <summary>
            /// 行下标
            /// </summary>
            public int Row;
    
            /// <summary>
            /// 内容限定宽。
            /// </summary>
            public float LimitW;
    
            /// <summary>
            /// 占高,文本可以按字体和限宽计算出来。
            /// </summary>
            public float DistanceH;
            
            //参数
            public Pen pen; //画笔
            public Font font;//字体
            public Brush brush;//图形
    
            /// <summary>
            /// 字符内容
            /// </summary>
            public string S;
    
            /// <summary>
            /// 绘制起点坐标
            /// </summary>
            public float X;
    
            /// <summary>
            /// 坐标y通常是计算的
            /// </summary>
            private float Y;
    
            /// <summary>
            /// 矩形宽
            /// </summary>
            public float Width;
    
            /// <summary>
            /// 矩形高
            /// </summary>
            public float Height;
    
            //public RectangleF layoutRectangle;
    
            /// <summary>
            /// 文本布局
            /// </summary>
            public StringFormat Format;
    
            /// <summary>
            /// 行间隔,文本的当行高度变为内容高度加行间隔
            /// </summary>
            public float RowSpace = 0;
    
            /// <summary>
            /// 参数类型,绘制类型,即Graphics绘制调用的方法
            /// </summary>
            public EnumDrawType Type;
    
            /// <summary>
            /// 为文本内容时,计算所占大小保存到此,由外部Graphics计算,所以此类中不使用本字段。
            /// </summary>
            public SizeF Size_Str { get; set; }
    
            #endregion
    
            private GDIDataModel() { }
    
            /// <summary>
            /// 坐标
            /// </summary>
            /// <param name="row">行下标</param>
            /// <param name="limitW">内容限定宽,字符且有限定宽时,绘制时自动转矩形框</param>
            /// <param name="s">字符内容</param>
            /// <param name="font"></param>
            /// <param name="brush"></param>
            /// <param name="x">绘制起点坐标</param>
            /// <param name="y">坐标y通常是计算的</param>
            /// <param name="rowSpace">行间隔,当行高度变为内容高度加行间隔</param>
            public GDIDataModel(int row, float limitW, string s, Font font, Brush brush, float x, float y
                , float rowSpace = 0)
            {
                this.Row = row;
                this.LimitW = limitW;
                this.S = s;
                this.font = font;
                this.brush = brush;
                this.X = x;
                this.Y = y;
                this.RowSpace = rowSpace;
                Type = EnumDrawType.坐标;
            }
    
            /// <summary>
            /// 坐标_文本布局
            /// </summary>
            /// <param name="row"></param>
            /// <param name="w"></param>
            /// <param name="s"></param>
            /// <param name="font"></param>
            /// <param name="brush"></param>
            /// <param name="x"></param>
            /// <param name="y"></param>
            /// <param name="format"></param>
            /// <param name="rowSpace"></param>
            public GDIDataModel(int row, float limitW, string s, Font font, Brush brush, float x, float y, StringFormat format
                , float rowSpace = 0)
            {
                this.Row = row;
                this.LimitW = limitW;
                this.S = s;
                this.font = font;
                this.brush = brush;
                this.X = x;
                this.Y = y;
                this.Format = format;
                this.RowSpace = rowSpace;
                Type = EnumDrawType.坐标_文本布局;
            }
    
            /// <summary>
            ////// </summary>
            /// <param name="row"></param>
            /// <param name="w"></param>
            /// <param name="s"></param>
            /// <param name="font"></param>
            /// <param name="brush"></param>
            /// <param name="point"></param>
            /// <param name="rowSpace"></param>
            public GDIDataModel(int row, float limitW, string s, Font font, Brush brush, PointF point
                , float rowSpace = 0)
            {
                this.Row = row;
                this.LimitW = limitW;
                this.S = s;
                this.font = font;
                this.brush = brush;
                this.X = point.X;
                this.Y = point.Y;
                this.RowSpace = rowSpace;
                Type = EnumDrawType.点;
            }
    
            /// <summary>
            /// 点_文本布局
            /// </summary>
            /// <param name="row"></param>
            /// <param name="w"></param>
            /// <param name="s"></param>
            /// <param name="font"></param>
            /// <param name="brush"></param>
            /// <param name="point"></param>
            /// <param name="format"></param>
            /// <param name="rowSpace"></param>
            public GDIDataModel(int row, float limitW, string s, Font font, Brush brush, PointF point, StringFormat format
                , float rowSpace = 0)
            {
                this.Row = row;
                this.LimitW = limitW;
                this.S = s;
                this.font = font;
                this.brush = brush;
                this.X = point.X;
                this.Y = point.Y;
                this.Format = format;
                this.RowSpace = rowSpace;
                Type = EnumDrawType.点_文本布局;
            }
    
            /// <summary>
            /// 矩形范围
            /// </summary>
            /// <param name="row"></param>
            /// <param name="w"></param>
            /// <param name="s"></param>
            /// <param name="font"></param>
            /// <param name="brush"></param>
            /// <param name="layoutRectangle"></param>
            /// <param name="rowSpace"></param>
            public GDIDataModel(int row, float limitW, string s, Font font, Brush brush, RectangleF layoutRectangle
                , float rowSpace = 0)
            {
                this.Row = row;
                this.LimitW = limitW;
                this.S = s;
                this.font = font;
                this.brush = brush;
                this.X = layoutRectangle.X;
                this.Y = layoutRectangle.Y;
                this.Width = layoutRectangle.Width;
                this.Height = layoutRectangle.Height;
                this.RowSpace = rowSpace;
                Type = EnumDrawType.矩形范围;
            }
    
            /// <summary>
            /// 矩形范围_文本布局
            /// </summary>
            /// <param name="row"></param>
            /// <param name="w"></param>
            /// <param name="s"></param>
            /// <param name="font"></param>
            /// <param name="brush"></param>
            /// <param name="layoutRectangle"></param>
            /// <param name="format"></param>
            /// <param name="rowSpace"></param>
            public GDIDataModel(int row, float limitW, string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format
                , float rowSpace = 0)
            {
                this.Row = row;
                this.LimitW = limitW ;
                this.S = s;
                this.font = font;
                this.brush = brush;
                this.X = layoutRectangle.X;
                this.Y = layoutRectangle.Y;
                this.Width = layoutRectangle.Width;
                this.Height = layoutRectangle.Height;
                this.Format = format;
                this.RowSpace = rowSpace;
                Type = EnumDrawType.矩形范围_文本布局;
            }
    
            /// <summary>
            /// 画笔_两点,必须是小坐标到大坐标
            /// </summary>
            /// <param name="pen"></param>
            /// <param name="x1"></param>
            /// <param name="y1"></param>
            /// <param name="x2"></param>
            /// <param name="y2"></param>
            public GDIDataModel(int row, Pen pen, float x1, float y1, float x2, float y2
                , float rowSpace = 0)
            {
                this.Row = row;
                this.pen = pen;
                this.X = x1;
                this.Width = Math.Abs(x2 - x1);
                this.Y = y1;
                this.Height = Math.Abs(y2 - y1);
                this.DistanceH = this.Height;
                Type = EnumDrawType.画笔_两点;
            }
    
            /// <summary>
            /// 空白占高
            /// </summary>
            /// <param name="row"></param>
            /// <param name="height"></param>
            public GDIDataModel(int row, float height)
            {
                this.Row = row;
                this.DistanceH = height;
    
                this.Type = EnumDrawType.空白占高;
            }
    
            /// <summary>
            /// 设置缩放
            /// </summary>
            /// <param name="ratio"></param>
            public void SetRatio(float ratio)
            {
                //修改所有位置参数
                X *= ratio;
                Width *= ratio;
    
                Y *= ratio;
                Height *= ratio;
            }
    
            /// <summary>
            /// 按位置属性绘制
            /// </summary>
            /// <param name="graphics"></param>
            /// <param name="newY">计算的y坐标,覆盖属性内的y坐标</param>
            public void DrawString(Graphics graphics, float? newY = null)
            {
                if (newY.HasValue) 
                {
                    this.Y = newY.Value;
                }
    
                //限定宽的,改为矩形
                if (LimitW > 0 && !string.IsNullOrWhiteSpace(S)) 
                {
                    Width = LimitW;
                    Height = this.Size_Str.Height;
                    if (this.Format == null)
                    {
                        this.Type = EnumDrawType.矩形范围;
                    }
                    else 
                    {
                        this.Type = EnumDrawType.矩形范围_文本布局;
                    }
                }
    
                //绘制当前
                switch (this.Type)
                {
                    case EnumDrawType.坐标: graphics.DrawString(this.S, this.font, this.brush, this.X, this.Y); break;
                    case EnumDrawType.坐标_文本布局: graphics.DrawString(this.S, this.font, this.brush, this.X, this.Y, this.Format); break;
                    case EnumDrawType.点: graphics.DrawString(this.S, this.font, this.brush, new PointF(this.X, this.Y)); break;
                    case EnumDrawType.点_文本布局: graphics.DrawString(this.S, this.font, this.brush, new PointF(this.X, this.Y), this.Format); break;
                    case EnumDrawType.矩形范围: graphics.DrawString(this.S, this.font, this.brush, new RectangleF(this.X, this.Y, this.Width, this.Height)); break;
                    case EnumDrawType.矩形范围_文本布局: graphics.DrawString(this.S, this.font, this.brush, new RectangleF(this.X, this.Y, this.Width, this.Height), this.Format); break;
                    case EnumDrawType.画笔_两点: graphics.DrawLine(this.pen, this.X, this.Y, this.X + this.Width, this.Y + this.Height); break;
                    case EnumDrawType.空白占高: break;
                    default:
                        break;
                }
            }
        }
    
        public enum EnumDrawType
        {
            点 = 0,
            点_文本布局 = 1,
            坐标 = 2,
            坐标_文本布局 = 3,
            矩形范围 = 4,
            矩形范围_文本布局 = 5,
            画笔_两点 = 6,
            空白占高 = 7,
        }
    }
    View Code

    示例 GDIHelperDemo

    using CommonUtil.QRCodeManage;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Drawing.Text;
    using System.IO;
    using System.Linq;
    
    namespace CommonUtil.GraphicsDrawString
    {
        public class GDIHelperDemo
        {
            /// <summary>
            /// 生成报告图片执行
            /// </summary>
            /// <param name="data"></param>
            private void CreateReportImg_Contagion_Execute(CreateReportImgDataMode_Contagion cn, CreateReportImgDataMode_Contagion en, int languageReport = 1, bool isCover = false)
            {
                if (languageReport == 1)
                {
                    //不覆盖
                    if (!isCover)
                    {
                        int existsCount = 0;
                        foreach (var item in cn.FilePathList)
                        {
                            if (File.Exists(item))
                            {
                                existsCount++;
                            }
                        }
                        if (existsCount == cn.FilePathList.Count)
                        {
                            return;
                        }
                    }
    
                    //目录判断
                    foreach (var dire in cn.DirectoryList)
                    {
                        if (!Directory.Exists(dire))
                        {
                            Directory.CreateDirectory(dire);
                        }
                    }
    
                    //只要到生成这步就是覆盖
                    foreach (var filePath in cn.FilePathList)
                    {
                        if (File.Exists(filePath))
                        {
                            File.Delete(filePath);
                        }
                    }
    
                    //Html解码
                    //cn.TestDescription = cn.TestDescription.Select(x => System.Web.HttpUtility.HtmlDecode(x)).ToList();
                    cn.Explain = System.Web.HttpUtility.HtmlDecode(cn.Explain);
    
                    string baseDirectory = System.AppDomain.CurrentDomain.BaseDirectory;
                    string path = baseDirectory + "fonts/Alibaba-PuHuiTi-Regular.ttf";
                    //读取字体文件             
                    PrivateFontCollection pfc = new PrivateFontCollection();
                    pfc.AddFontFile(path);
                    FontFamily fontFamily = pfc.Families[0];
    
                    //绘画参数
                    float ratio = cn.Ratio;//全局缩放
                    float startX = 96;//初始位置x
                    float startY = 192;//初始位置y
                    int nowRow = 0;//当前行
                    float rowSpace = 0;//行间距
                    float rowOneH = 0;//大体文本的行高,用来计算留白高度
    
                    Font FontTitle = new Font(fontFamily, 16 * ratio, FontStyle.Bold, GraphicsUnit.Point);//宠物信息列名
                    Font FontContent = new Font(fontFamily, 16 * ratio, FontStyle.Bold, GraphicsUnit.Point);//宠物信息内容
    
                    Image back = Image.FromFile(cn.BackGroundPath, true);
                    try
                    {
                        using (Bitmap bitmap = new Bitmap(back))
                        {
                            using (Graphics graphics = Graphics.FromImage(bitmap))
                            {
                                GDIHelper g = new GDIHelper(startY, ratio, graphics);
                                float W = bitmap.Width;
                                float H = bitmap.Height;
    
                                //画笔
                                Pen pen = new Pen(Brushes.DimGray, 1);
                                pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid; //实线
    
                                //顶部横线
                                SizeF size = g.Add(new GDIDataModel(nowRow, pen, startX, 0, W - startX, 0));
                                nowRow++;
    
                                #region 基本信息,每行格式为  列名:值     第二列:值
                                //基本信息,每行格式为  列名:值     第二列:值
                                float cellX = W / 2;//列2的x坐标
                                size = g.Add(new GDIDataModel(nowRow, 0, "检测项目:", FontTitle, Brushes.Black, startX, 0, rowSpace));
    
                                rowOneH = size.Height;
    
                                size = g.Add(new GDIDataModel(nowRow, 0, cn.ProductName, FontTitle, Brushes.Black, startX + size.Width, 0, rowSpace));
    
                                //基本信息_第二列
                                size = g.Add(new GDIDataModel(nowRow, 0, "收样日期:", FontTitle, Brushes.Black, cellX, 0, rowSpace));
                                size = g.Add(new GDIDataModel(nowRow, 0, cn.SampleDeliveryTime, FontTitle, Brushes.Black, cellX + size.Width, 0, rowSpace));
                                nowRow++;//换行
    
                                size = g.Add(new GDIDataModel(nowRow, 0, "报告编号:", FontTitle, Brushes.Black, startX, 0, rowSpace));
                                size = g.Add(new GDIDataModel(nowRow, 0, cn.ReportNumber, FontTitle, Brushes.Black, startX + size.Width, 0, rowSpace));
                                size = g.Add(new GDIDataModel(nowRow, 0, "报告日期:", FontTitle, Brushes.Black, cellX, 0, rowSpace));
                                size = g.Add(new GDIDataModel(nowRow, 0, cn.ReportTime, FontTitle, Brushes.Black, cellX + size.Width, 0, rowSpace));
                                nowRow++;//换行
    
                                //...
                                #endregion
    
                                //留白
                                size = g.Add(new GDIDataModel(nowRow, rowOneH * 2));
                                nowRow++;
    
                                #region 结果内容,格式 列1   列2  列3
                                float resultCellW = (W - startX * 2) / 3;//列内容每列占总内容的三分之一 
                                float centerX = W / 2; //列2居中
                                float resultCellX3 = startX + resultCellW * 2;//列3的x在三分之二
    
    
                                size = g.Add(new GDIDataModel(nowRow, 0, "报告内容", FontTitle, Brushes.Black, startX, 0, rowSpace));
                                nowRow++;
    
                                //横线
                                size = g.Add(new GDIDataModel(nowRow, pen, startX, 0, W - startX, 0));
                                nowRow++;
    
                                //标题
                                size = g.Add(new GDIDataModel(nowRow, resultCellW, "项目名称", FontTitle, Brushes.Black, startX, 0, rowSpace));
    
                                //列2居中用Add_StrXCenter
                                size = g.Add_StrXCenter(new GDIDataModel(nowRow, resultCellW, "检测结果(Ct值)", FontTitle, Brushes.Black, centerX, 0, rowSpace));
    
                                //列3的x在三分之二
                                size = g.Add(new GDIDataModel(nowRow, resultCellW, "结果判定", FontTitle, Brushes.Black, resultCellX3, 0, rowSpace));
                                nowRow++;
    
                                size = g.Add(new GDIDataModel(nowRow, pen, startX, 0, W - startX, 0));
                                nowRow++;
    
                                foreach (var item in cn.TestResult)
                                {
                                    size = g.Add(new GDIDataModel(nowRow, resultCellW, item[0], FontTitle, Brushes.Black, startX, 0, rowSpace));
                                    size = g.Add_StrXCenter(new GDIDataModel(nowRow, resultCellW, item[1], FontTitle, Brushes.Black, centerX, 0, rowSpace));
                                    size = g.Add(new GDIDataModel(nowRow, resultCellW, item[2], FontTitle, Brushes.Black, resultCellX3, 0, rowSpace));
                                    nowRow++;
                                }
                                #endregion
    
                                //留白
                                size = g.Add(new GDIDataModel(nowRow, rowOneH * 2));
                                nowRow++;
    
                                #region 结果说明,格式  (缩进2)列1标题:列2详情
                                size = g.Add(new GDIDataModel(nowRow, 0, "结果说明", FontTitle, Brushes.Black, startX, 0, rowSpace));
                                nowRow++;
    
                                float resultDeX = startX + (size.Width / 2);//结果说明标题列缩进两个字符
                                int resultOldRow = nowRow;//结果说明第一行
                                float resultMaxW = 0;//结果说明标题列最大宽度
    
                                //结果说明标题列
                                foreach (var item in cn.ResultDescriptionList)
                                {
                                    size = g.Add(new GDIDataModel(nowRow, 0, item[0] + "", FontTitle, Brushes.Black, resultDeX, 0, rowSpace));
                                    if (resultMaxW < size.Width)
                                    {
                                        resultMaxW = size.Width;
                                    }
                                    nowRow++;
                                }
    
                                //结果说明内容列
                                nowRow = resultOldRow;//回到结果说明第一行
                                float resultDeX2 = resultDeX + resultMaxW;//结果说明内容列的x
                                float resultDeW = W - startX - resultDeX2;//结果说明内容列的限定宽
                                foreach (var item in cn.ResultDescriptionList)
                                {
                                    size = g.Add(new GDIDataModel(nowRow, resultDeW, item[1], FontTitle, Brushes.Black, resultDeX2, 0, rowSpace));
                                    nowRow++;
                                }
                                #endregion
    
                                //绘制文本
                                g.DrawString_ComputeY();
    
                                #region 检测与判读说明等等,显示在底部
                                float remarkY = (1000 * ratio);
                                int remarkW = (int)(W - startX * 2);
    
                                size = graphics.MeasureString("检测与判读说明", FontTitle);
                                graphics.DrawString("检测与判读说明", FontTitle, Brushes.Black, startX, remarkY);
                                remarkY += size.Height + rowSpace;
    
                                if (cn.TestDescription != null && cn.TestDescription.Any())
                                {
                                    foreach (var item in cn.TestDescription)
                                    {
                                        if (item != null && item.Length > 1)
                                        {
                                            //说明标题
                                            size = graphics.MeasureString(item[0], FontTitle);
                                            graphics.DrawString(item[0], FontTitle, Brushes.Black, startX, remarkY);
                                            var thisX = startX + size.Width;
    
                                            //说明内容
                                            size = graphics.MeasureString(item[1], FontTitle, remarkW);
                                            graphics.DrawString(item[1], FontTitle, Brushes.Black, new RectangleF(thisX, remarkY, remarkW, size.Height));
    
                                            remarkY += size.Height + rowSpace;
                                        }
                                    }
                                }
    
    
                                #endregion
    
                                //准备贴上二维码
                                string url = ConfigurationHelper.AppSetting("qrcodeurl") + "?" + cn.ReportNumber;
                                var qrcodeImage = QRCodeHelper.CreateQRCode(url);
                                Rectangle fromR = new Rectangle(0, 0, qrcodeImage.Width, qrcodeImage.Height);
    
                                //固定二维码的位置
                                int qrcodeWidth = (int)(150 * ratio),
                                    qrcodeHeight = (int)(150 * ratio);
                                Rectangle toR = new Rectangle((int)(155 * ratio), (int)(1210 * ratio), qrcodeWidth, qrcodeHeight);
    
                                //画图
                                graphics.DrawImage(qrcodeImage, toR, fromR, GraphicsUnit.Pixel);
                                qrcodeImage.Dispose();
                            }
    
                            //保存文件
                            bitmap.Save(cn.FilePath);
                        }
                    }
                    finally
                    {
                        back.Dispose();
                        fontFamily.Dispose();
                        pfc.Dispose();
                    }
                }
                else if (languageReport == 1)
                {
    
                }
            }
    
        }
    
        public class CreateReportImgDataMode_Contagion 
        {
            /// <summary>
            /// 背景图
            /// </summary>
            public string BackGroundPath { get; set; }
    
            /// <summary>
            /// 显示比例
            /// </summary>
            public float Ratio { get; set; }
    
            /// <summary>
            /// 报告保存路径
            /// </summary>
            public string FilePath { get; set; }
    
            /// <summary>
            /// 检测项目
            /// </summary>
            public string ProductName { get; set; }
    
            /// <summary>
            /// 是否致病描述
            /// </summary>
            public string IsPathogenic { get; set; }
    
            /// <summary>
            /// 治疗方式描述
            /// </summary>
            public string TreatmentMethod { get; set; }
    
            /// <summary>
            /// 项目说明
            /// </summary>
            public string Explain { get; set; }
    
            /// <summary>
            /// 收样日期
            /// </summary>
            public string SampleDeliveryTime { get; set; }
    
            /// <summary>
            /// 报告日期
            /// </summary>
            public string ReportTime { get; set; }
    
            /// <summary>
            /// 报告编号
            /// </summary>
            public string ReportNumber { get; set; }
    
            /// <summary>
            /// 样本类型
            /// </summary>
            public int SampleType { get; set; }
    
            /// <summary>
            /// 样本类型名称
            /// </summary>
            public string SampleTypeName { get; set; }
    
            /// <summary>
            /// 样本编号
            /// </summary>
            public string SampleNumber { get; set; }
    
            /// <summary>
            /// 检测结果,0项目名,1结果ct值,2结果判定
            /// </summary>
            public List<string[]> TestResult { get; set; }
    
            /// <summary>
            /// 宠物,0名称,1编号
            /// </summary>
            public List<string[]> Pets { get; set; }
    
            /// <summary>
            /// 所有结果说明,0结果名称,1描述
            /// </summary>
            public List<string[]> ResultDescriptionList { get; set; }
    
            /// <summary>
            /// 检测与判读说明
            /// </summary>
            public List<string[]> TestDescription { get; set; }
    
            /// <summary>
            /// 传染病套餐项目,要将一张报告放到多个检测下的文件路径
            /// </summary>
            public List<string> FilePathList { get; set; }
    
            /// <summary>
            /// 报告路径目录
            /// </summary>
            public List<string> DirectoryList { get; set; }
        }
    
    }
    View Code
  • 相关阅读:
    不懂不可耻,可耻的是每当遇到不懂的东西不是想办法去学去了解而是极力掩饰。
    在咱学校的论坛上看到的一句话,觉得……我们都在等待某个人,等到累了,就随便牵起某人的手,默默地走进礼...
    在Linux下用Virtualbox虚拟机安装Windows XP
    大学里的挂科是对考前三天不用功的惩罚.这是教算法的赵PZ讲的,窃以为很有道理。可是接下来的十一天里我...
    壮哥!才发现你博客里这么多好东西,慢慢欣赏了,哈哈~~~~~~~~~~
    哥们现在用的什么?ghs不是又被封了吗
    提取字符串中的数字并分别保存
    十一天八考之路
    WPF使ListBox支持手势多选功能
    动手实现扩展属性为对象动态添加获取数据(续)
  • 原文地址:https://www.cnblogs.com/lanofsky/p/15400936.html
Copyright © 2020-2023  润新知