当前位置：移动技术网 > IT编程>开发语言>.net > C#用GDI+解析Json文件绘制Chart

C#用GDI+解析Json文件绘制Chart

2018年08月17日 | 移动技术网IT编程 | 我要评论

大灾建,福州人才市场,网上赚钱论坛

using system.collections.generic;
namespace chart
{
    public class program
    {
        static void main(string[] args)
        {
            chart chart = new chart();
            charttype charttype = charttype.histogram;
            string path = @"..\..\json.json";
            datasource datasource = new jsondatasource();
            list<composition> compositions = datasource.getdatalist(path);
            chart.compositions.addrange(compositions);
            chart.draw(charttype);
            chart.save();
        }
    }
}

program.cs

using system;
using system.collections.generic;
using system.diagnostics;
using system.drawing;
namespace chart
{
    public class chart
    {
        private bitmap bmp = new bitmap(600, 600);
        list<composition> composition = new list<composition>();
        public list<composition> compositions { get { return composition; } }
        private float width;

        private float width
        {
            get
            {
                int sum = 0;
                foreach (var composition in compositions)
                {
                    sum += composition.datapoints.count + 1;
                }
                width = (float)420 / sum;
                return width;
            }
        }

        public void draw(charttype charttype)
        {
            series series;

            switch (charttype)
            {
                case charttype.linechart:
                    series = new lineseries();
                    break;

                case charttype.histogram:
                    series = new histogramseries();
                    break;

                case charttype.piechart:
                    series = new pieseries();
                    break;

                default:
                    throw new argumentoutofrangeexception("nonexistent charttype!");
            }

            foreach (var composition in compositions)
            {
                series.legend.add(composition.name);
            }

            platform platform = new windows(bmp);

            series.draw(width, platform, compositions);
        }

        public void save()
        {
            bmp.save(@"..\..\1.bmp");
            process.start(@"..\..\1.bmp");
        }
    }
}

chart.cs

using system.collections;
using system.collections.generic;
using system.drawing;
namespace chart
{
    public abstract class series
    {
        arraylist legend = new arraylist();
        public arraylist legend { get { return legend; } set { } }

        protected pointf pointformlarge;
        protected pointf pointformsmall;

        private void drawchart(platform g)
        {
            g.fillrectangle(g.wbrush, 20, 20, 580, 500);
        }

        protected abstract void drawcore(float width, platform g, list<composition> compositions);

        public void draw(float width, platform g, list<composition> compositions)
        {
            pointformlarge = new pointf(width * compositions.count + width, 0);
            pointformsmall = new pointf(width, 0);
            drawchart(g);
            drawcore(width, g, compositions);
        }
    }
}

series.cs

using system.collections.generic;
using system.drawing;
using system;
namespace chart
{
    public class histogramseries : series
    {

        private void drawaxes(platform g)
        {
            g.drawline(g.rpen, new point(100, 40), new point(100, 420));
            g.drawline(g.rpen, new point(100, 40), new point(90, 50));
            g.drawline(g.rpen, new point(100, 40), new point(110, 50));
            g.drawline(g.rpen, new point(100, 420), new point(570, 420));
            g.drawline(g.rpen, new point(570, 420), new point(560, 410));
            g.drawline(g.rpen, new point(570, 420), new point(560, 430));

            g.drawstring("月考成绩", g.largefont, g.bbrush, new rectanglef(300, 30, 170, 50));
            g.drawstring("科目", g.largefont, g.bbrush, new rectanglef(530, 450, 100, 40));
            g.drawstring("成绩", g.largefont, g.bbrush, new rectanglef(40, 30, 40, 40));

            for (int i = 0; i < 5; i++)
            {
                g.drawline(g.blackpen, new point(100, 60 + 72 * i), new point(570, 60 + 72 * i));
            }
        }

        private void drawlegend(platform g)
        {
            int legendwidth = 250 / (legend.count - 1);
            int stringx = 50;
            int legendx = stringx + 60;
            int k = 0;
            foreach (string legend in legend)
            {
                switch (k)
                {
                    case 0:
                        g.brush = brushes.blue;
                        break;
                    case 1:
                        g.brush = brushes.red;
                        break;
                    case 2:
                        g.brush = brushes.yellow;
                        break;
                    case 3:
                        g.brush = brushes.green;
                        break;
                }
                g.drawstring(legend, g.largefont, brushes.blue, stringx, 480);
                rectangle rect = new rectangle(legendx, 480, legendwidth * 2 / 3, 20);
                g.fillrectangle(g.brush, rect);

                stringx += 550 / legend.count;
                legendx = stringx + 60;
                k++;
            }
        }



        protected override void drawcore(float width, platform g, list<composition> compositions)
        {
            drawaxes(g);
            drawlegend(g);
            foreach (var datapoint in compositions[0].datapoints)
            {
                g.drawstring(datapoint.xvalue, g.largefont, g.bbrush, 120, 430);
                g.translatetransform(pointformlarge.x, pointformlarge.y);
            }
            g.resettransform();

            int yvaluemax = 0;
            foreach (var composition in compositions)
            {
                if (yvaluemax <= composition.max)
                {
                    yvaluemax = composition.max;
                }
            }

            g.yratioscale = 370 / yvaluemax;


            for (int i = 0; i <= 5; i++)
            {
                g.drawstring(math.ceiling(360/5/ g.yratioscale*(5-i)).tostring(), g.largefont, g.blackbrush, new rectanglef(80, 50 + 72 * i, 50, 50));
            }




            void drawrectangle(float x, float y, float width, float height, composition composition)
            {
                rectangle rect = new rectangle((int)x, (int)y, (int)width, (int)height);
                g.fillrectangle(composition.brushcolor, rect);
            }
            int j = 1;
            foreach (var composition in compositions)
            {
                compositions[0].brushcolor = brushes.blue;
                compositions[1].brushcolor = brushes.red;
                compositions[2].brushcolor = brushes.yellow;
                foreach (var datapoint in composition.datapoints)
                {
                    drawrectangle(120, 420 - datapoint.yvalue * g.yratioscale, width, datapoint.yvalue * g.yratioscale, composition);
                    g.drawstring(datapoint.yvalue.tostring(), g.smallfont, brushes.red, 120, 420 - datapoint.yvalue * g.yratioscale - 15);
                    g.translatetransform(pointformlarge.x, pointformlarge.y);
                }
                g.resettransform();
                for (int i = 0; i < j; i++)
                {
                    g.translatetransform(pointformsmall.x, pointformsmall.y);
                }
                j++;
            }
            g.resettransform();
        }
    }
}

histogram.cs

using system.drawing;
namespace chart
{
    public abstract class platform
    {
        public abstract void fillrectangle(brush b, int x, int y, int width, int height);
        public abstract void drawline(pen pen, point pt1, point pt2);
        public abstract void drawstring(string s, font font, brush brush, rectanglef layoutrectangle);
        public abstract void drawstring(string s, font font, brush brush, float x, float y);
        public abstract void fillrectangle(brush brush, rectangle rect);
        public abstract void translatetransform(float dx, float dy);
        public abstract void resettransform();

        private brush wbrush = brushes.white;
        private brush bbrush = brushes.blue ;
        private brush blackbrush = brushes.black; 
        private brush brush ;
        pen rpen = new pen(color.red, 3);
        pen blackpen = new pen(color .black ,1);
        font largefont = new font("黑体", 12);
        font smallfont = new font("黑体", 8);
        private float yratioscale;

        public brush wbrush { get => wbrush; set => wbrush = value; }
        public pen rpen { get => rpen; set => rpen = value; }
        public font largefont { get => largefont; set => largefont = value; }
        public font smallfont { get => smallfont; set => smallfont = value; }
        public brush bbrush { get => bbrush; set => bbrush = value; }
        internal float yratioscale { get => yratioscale; set => yratioscale = value; }
        public brush brush { get => brush; set => brush = value; }
        public pen blackpen { get => blackpen; set => blackpen = value; }
        public brush blackbrush { get => blackbrush; set => blackbrush = value; }
    }
}

platform.cs

using system.drawing;

namespace chart
{
    public class windows : platform 
    {
        private readonly graphics graphics;

        public windows(bitmap bmp)
        {
            graphics = graphics.fromimage(bmp);
        }

        public override void fillrectangle(brush b, int x, int y, int width, int height)
        {
            graphics.fillrectangle(b, x, y, width, height);
        }
        public override void drawline(pen pen, point pt1, point pt2)
        {
            graphics.drawline(pen, pt1, pt2);
        }
        public override void drawstring(string s, font font, brush brush, rectanglef layoutrectangle)
        {
            graphics.drawstring(s, font, brush, layoutrectangle);
        }
        public override void drawstring(string s, font font, brush brush, float x, float y)
        {
            graphics.drawstring(s, font, brush, x, y);
        }
        public override void fillrectangle(brush brush, rectangle rect)
        {
            graphics.fillrectangle(brush, rect);
        }
        public override void translatetransform(float dx, float dy)
        {
            graphics.translatetransform(dx, dy);
        }
        public override void resettransform()
        {
            graphics.resettransform();
        }
    }
}

windows.cs

using system.collections.generic;
using system.drawing;
namespace chart
{
    public class composition
    {
        private list<datapoint> datapoints;
        private string name;
        private brush brushcolor;
        private int max;         

        public list<datapoint> datapoints { get => datapoints; set => datapoints = value; }
        public string name { get => name; set => name = value; }
        public brush brushcolor { get => brushcolor; set => brushcolor = value; }
        
        public int max              //linq中提供的计算list最大值的方法是集合中的元素即为可比较的数值类型，datapoint不是，所以这里的方法自定义
        {
            get
            {
                foreach (var datapoint in datapoints)
                {
                    if (datapoint.yvalue >= max)
                    {
                        max = datapoint.yvalue;
                    }
                }
                return max;
            }
        }
    }
}

composition.cs

namespace chart
{
    public class datapoint
    {
        private string xvalue;
        private int yvalue;

        public int yvalue { get => yvalue; set => yvalue = value; }
        public string xvalue { get => xvalue; set => xvalue = value; }
    }
}

datapoint

using system.collections.generic;
using system.io;
namespace chart
{
    public abstract class datasource
    {
        protected abstract list<composition> getdatalistcore(string path);  

        public list<composition> getdatalist(string path)
        {
            if (!file.exists(path))
            {
                throw new filenotfoundexception(path);
            }
            return getdatalistcore(path);
        }
    }
}

datasource.cs

using newtonsoft.json;
using system.collections.generic;
using system.io;
namespace chart
{
    public class jsondatasource : datasource
    {
        protected override list<composition> getdatalistcore(string path)
        {
          return  jsonconvert.deserializeobject<list<composition>>(file.readalltext(path));            
        }
    }
}

jsondatasource.cs

[
  {
    "name": "molly",
    "datapoints": [
      {
        "xvalue": "english",
        "yvalue": 2
      },
      {
        "xvalue": "chinese",
        "yvalue": 6
      },
      {
        "xvalue": "math",
        "yvalue": 7
      },
      {
        "xvalue": "art",
        "yvalue": 7
      }
    ]
  },
  {
    "name": "bob",
    "datapoints": [
      {
        "xvalue": "english",
        "yvalue": 9
      },
      {
        "xvalue": "math",
        "yvalue": 12
      },
      {
        "xvalue": "art",
        "yvalue": 3
      },
      {
        "xvalue": "chinese",
        "yvalue": 3
      }
    ]
  },
  {
    "name": "angela",
    "datapoints": [
      {
        "xvalue": "english",
        "yvalue": 5
      },
      {
        "xvalue": "math",
        "yvalue": 13
      },
      {
        "xvalue": "art",
        "yvalue": 9
      },
      {
        "xvalue": "chinese",
        "yvalue": 6
      }
    ]
  }

]

json.json

以下附上这个程序设计的uml类图

https://www.processon.com/view/link/5b4dbd93e4b00b08ad2085d7

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！点击进行留言回复

详解.NET Core 3.0 里新的JSON API

为什么需要新的 json api ？json.net 大家都用过，老版本的 asp.net core 也依赖于 json.net 。然而这个依赖就会引起一些版... [阅读全文]
Net Core Web Api项目与在NginX下发布的方法

前言本文将介绍net core的一些基础知识和如何nginx下发布net core的webapi项目。测试环境操作系统：windows 10 开发工具：v... [阅读全文]
浅谈ASP.NET Core 中jwt授权认证的流程原理

1，快速实现授权验证什么是 jwt ？为什么要用 jwt ？jwt 的组成？这些百度可以直接找到，这里不再赘述。实际上，只需要知道 jwt 认证模式是使用一段 ... [阅读全文]
.Net Core 实现图片验证码的实现示例

记录自己的学习，参考了网上各位大佬的技术，往往在登录的时候需要使用到验证码来进行简单的一个校验，这边使用在.net core上进行生成图片二维码思路很简单=》 ... [阅读全文]
asp.net core3.1 引用的元包dll版本兼容性问题解决方案

自从.netcore 3.1出来后，大家都想立马升级到最新版本。我也是如此，微软也对.netcore 3.1 的官方组件不断升级，几乎每隔几天就会有部分元包可以... [阅读全文]
IdentityServer4实现.Net Core API接口权限认证(快速入门)

什么是identityserver4官方解释：identityserver4是基于asp.net core实现的认证和授权框架，是对openid connect... [阅读全文]
从ASP.NET Core3.1迁移到5.0的方法

3月中旬，微软官方已经发布了dotnet 5的第一个预览版：5.0.0-preview.1。dotnet core经过前几个版本的发展和沉淀，到3.1已经基本趋... [阅读全文]
.NET Core中创建和使用NuGet包的示例代码

在.net core的项目中，如果我们要在项目中引用其它dll文件，不建议直接在项目引用中添加dll文件（虽然在.net core项目中也可以这么做），建议是去... [阅读全文]
ASP.NET Core MVC通过IViewLocationExpander扩展视图搜索路径的实现

iviewlocationexpander api expandviewlocations razor视图路径，视图引擎会搜索该路径. populateva... [阅读全文]
ASP.NET Core中的Controller使用示例

asp.net core出现之前我们实现的controller，mvc都继承自controller基类，webapi的话继承自apicontroller。现在a... [阅读全文]

网友评论


验证码：

C#用GDI+解析Json文件绘制Chart

2018年08月17日 | 移动技术网IT编程 | 我要评论

您可能感兴趣的文章:

相关文章:

网友评论