Ｃ#　时段计费算法

最新推荐文章于 2023-07-06 15:02:28 发布
最新推荐文章于 2023-07-06 15:02:28 发布
阅读量3.2k 收藏 8
点赞数
文章标签： 时段计费 停车计费 时段消费
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wysdong/article/details/85321864
版权

留点什么？希望别人有用……
一天分成多个时间段，各个时段不同的费用，以前在小软件上有做个类似的，但现在发觉之前的方法还是有点小问题了，
而今无聊之余，重新整理思绪，算是做了些优化吧

源码：https://download.csdn.net/download/wysdong/10883293 （源码加上去，就不能删！~，所有源码的类CalcM，还是用文章后面的吧）

 

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

namespace CLib
{
    public class CalcM
    {

  public CalcM()
        {

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="_FreeMinute">免费停车 分钟</param>
        /// <param name="_iMinTime">最低消费时间长</param>
        /// <param name="_oneDayMaxCost">一天最高的费用</param>
        /// <param name="_timelist">时间段&每小时费用  _timelist.Add("00:00&08:00&4");//起始时间&结束时间&费率</param>
        /// <param name="_idayType">一整天计费方式：0=汇总各个时段费用（时段长*单价）；1=用“idayMoney一整天的费用”来计算;2=重新计算，按firstHour内多少钱，后面各个小时多少钱</param>
        /// <param name="_idayMoney">一整天的费用</param>
        /// <param name="_iFirstType">0=前N分钟不计费，1=最低扣费时间长</param>
        /// <param name="_firstHour">超过免费时间后，firstHour小时内FirstCash元</param>
        /// <param name="_firstCash">超过免费时间后，firstHour小时内FirstCash元</param>
        /// <param name="_iAfter24H">第二天（过晚上24点后），计费方式：0＝重新计费，1=汇总各时段费用</param>
        public CalcM(int _FreeMinute, int _iMinTime, decimal _oneDayMaxCost, System.Collections.ArrayList _timelist,
            int _idayType, decimal _idayMoney, int _iFirstType, int _firstHour, int _firstCash, int _iAfter24H)
        {
            this.FreeMinute = _FreeMinute;
            this.iMinTime = _iMinTime;
            this.OneDayMaxCost = _oneDayMaxCost;
            this.timelist = _timelist;
            this.idayType = _idayType;
            this.idayMoney = _idayMoney;
            this.iFirstType = _iFirstType;
            this.firstHour = _firstHour;
            this.firstCash = _firstCash;
            this.iAfter24H = _iAfter24H;
        }


        #region 计费参数

        /// <summary>
        /// 免费停车 分钟
        /// </summary>
        private int _FreeMinute = 30;
        /// <summary>
        /// 最低消费时间长
        /// </summary>
        private int _iMinTime = 30;
        /// <summary>
        /// 一天最高的费用
        /// </summary>
        private decimal _oneDayMaxCost = 99999990;
        /// <summary>
        ///  时间段&每小时费用  _timelist.Add("00:00&08:00&4");//起始时间&结束时间&费率
        ///   _timelist.Add("00:00&08:00&4");
        ///   _timelist.Add("08:00&16:00&5");
        ///   _timelist.Add("16:00&23:59&6");
        /// </summary>
        private System.Collections.ArrayList _timelist = new ArrayList();
        /// <summary>
        /// 一整天计费方式：0=汇总各个时段费用（时段长*单价）；1=用“idayMoney一整天的费用”来计算;2=重新计算，按firstHour内多少钱，后面各个小时多少钱
        /// </summary>
        private int _idayType = 0;
        /// <summary>
        /// 一整天的费用
        /// </summary>
        private decimal _idayMoney = 60;
        /// <summary>
        ///  0=前N分钟不计费，1=最低扣费时间长
        /// </summary>
        private int _iFirstType = 0;
        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        private int _firstHour = 3;
        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        private int _firstCash = 10;
        /// <summary>
        /// 第二天（过晚上24点后），计费方式：0＝重新计费，1=汇总各时段费用
        /// </summary>
        private int _iAfter24H = 0;

        /// <summary>
        /// 免费停车 分钟
        /// </summary>
        public int FreeMinute
        {
            get
            {
                return _FreeMinute;
            }
            set
            {
                _FreeMinute = value;
            }
        }


        /// <summary>
        /// 单天最高的费用
        /// </summary>
        public decimal OneDayMaxCost
        {
            get
            {
                return _oneDayMaxCost;
            }

            set
            {
                _oneDayMaxCost = value;
            }
        }

        /// <summary>
        /// 时间段&每小时费用  _timelist.Add("00:00&08:00&4");
        /// </summary>
        public ArrayList timelist
        {
            get
            {
                if (_timelist.Count < 1)
                {
                    _timelist.Add("00:00&08:00&4");
                    _timelist.Add("08:00&16:00&5");
                    _timelist.Add("16:00&23:59&6");
                }
                return _timelist;
            }
            set
            {
                _timelist = value;
            }
        }

        /// <summary>
        /// 一整天计费方式：0=汇总各个时段费用（时段长*单价）；1=用“idayMoney一整天的费用”来计算;2=重新计算，按firstHour内多少钱，后面各个小时多少钱
        /// </summary>
        public int idayType
        {
            get
            {
                return _idayType;
            }

            set
            {
                _idayType = value;
            }
        }

        /// <summary>
        /// 一整天的费用
        /// </summary>
        public decimal idayMoney
        {
            get
            {
                return _idayMoney;
            }
            set
            {
                _idayMoney = value;
            }
        }

        /// <summary>
        /// 最低消费时间长
        /// </summary>
        public int iMinTime
        {
            get
            {
                return _iMinTime;
            }

            set
            {
                _iMinTime = value;
            }
        }
        /// <summary>
        /// 0=前N分钟不计费，1=最低扣费时间长
        /// </summary>
        public int iFirstType
        {
            get
            {
                return _iFirstType;
            }

            set
            {
                _iFirstType = value;
            }
        }

        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        public int firstHour
        {
            get
            {
                return _firstHour;
            }

            set
            {
                _firstHour = value;
            }
        }

        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        public int firstCash
        {
            get
            {
                return _firstCash;
            }

            set
            {
                _firstCash = value;
            }
        }
        /// <summary>
        /// 第二天（过晚上24点后），计费方式：0＝重新计费，1=汇总各时段费用
        /// </summary>
        public int iAfter24H
        {
            get
            {
                return _iAfter24H;
            }

            set
            {
                _iAfter24H = value;
            }
        }


        #endregion

        #region 计算费用
        int iDayIndex = 1;
        /// <summary>
        /// 计算费用
        /// </summary>
        /// <param name="ST">起始时间</param>
        /// <param name="OT">停止时间</param>
        /// <returns></returns>
        public string CalcStopCash(DateTime ST, DateTime OT)
        {
            backdata rt = new backdata();
            rt.result = "OK";
            rt.errcode = "0";
            rt.errmsg = "";
            rt.paycash = 0;
            rt.iHour = 0;
            decimal _CalcM = 0;
            string result = "";
            string errmsg = "";
            ArrayList alist = new ArrayList();
            iDayIndex = 1;
            string StopTimeInfo = "";
            try
            {

                #region 
                if (decimal.Parse(ST.ToString("yyMMddHHmm")) >= decimal.Parse(OT.ToString("yyMMddHHmm")))
                {
                    rt.result = "FAIL";
                    rt.errcode = "-1";
                    rt.errmsg = "停车的起始时间>=截止时间，无法计算。";
                    result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                    return result;
                }
                TimeSpan ts = OT.Subtract(ST);
                rt.iHour = decimal.Parse(ts.TotalHours.ToString("f2"));
                if (ts.Days > 0)
                {
                    StopTimeInfo += ts.Days.ToString() + "天";
                }
                if (ts.Hours > 0)
                {
                    StopTimeInfo += ts.Hours.ToString() + "小时";
                }
                if (ts.Minutes > 0)
                {
                    StopTimeInfo += ts.Minutes.ToString() + "分钟";
                }
                #endregion
                DateTime _ST = ST;
                DateTime _OT = OT;
                while (decimal.Parse(_ST.ToString("yyMMdd")) <= decimal.Parse(_OT.ToString("yyMMdd")))
                {
                    decimal OneDayCash = 0;//计算某一天的费用
                    if (ST.ToString("yyMMdd") == OT.ToString("yyMMdd"))
                    {
                        OneDayCash = CalcOneDayCast(ST, OT, ref alist, true);
                        if (OneDayCash == -100)
                        {
                            rt.result = "FAIL";
                            rt.errcode = "-2";
                            rt.errmsg = "计费出错：" + ExceptionInfo;
                            result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                            return result;
                        }
                        _CalcM += OneDayCash;
                    }
                    else
                    {
                        #region
                        if (_ST.ToString("yyMMdd") == ST.ToString("yyMMdd"))
                        {
                            #region 起始一天

                            DateTime _temDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd 23:59:59"));
                            OneDayCash = CalcOneDayCast(ST, _temDT, ref alist, true);
                            if (OneDayCash == -100)
                            {
                                rt.result = "FAIL";
                                rt.errcode = "-3";
                                rt.errmsg = "计费出错：" + ExceptionInfo;
                                result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                                return result;
                            }
                            _CalcM += OneDayCash;


                            #endregion
                        }
                        else if (_ST.ToString("yyMMdd") == OT.ToString("yyMMdd"))
                        {

                            #region 最后一天
                            DateTime _temDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd 00:00:00"));
                            OneDayCash = CalcOneDayCast(_temDT, OT, ref alist, false);
                            if (OneDayCash == -100)
                            {
                                rt.result = "FAIL";
                                rt.errcode = "-4";
                                rt.errmsg = "计费出错：" + ExceptionInfo;
                                result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                                return result;
                            }
                            _CalcM += OneDayCash;

                            #endregion
                        }
                        else
                        {
                            #region  一整天

                            if (idayType == 2)
                            {
                                //errmsg = "超过1天，按收费标准重新计费:";
                                //重新按计费标准计费
                                DateTime tem_beg = DateTime.Parse(_ST.ToString("yyyy-MM-dd 00:00:00"));
                                DateTime tem_end = DateTime.Parse(_ST.ToString("yyyy-MM-dd 23:59:00"));
                                OneDayCash = CalcOneDayCast(tem_beg, tem_end, ref alist, false);
                                if (OneDayCash == -100)
                                {
                                    rt.result = "FAIL";
                                    rt.errcode = "-5";
                                    rt.errmsg = "计费出错：" + ExceptionInfo;
                                    result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                                    return result;
                                }
                            }
                            else
                            {
                                OneDayCash = idayMoney;
                                if (OneDayCash > OneDayMaxCost)
                                {
                                    OneDayCash = OneDayMaxCost;
                                    errmsg = "------>:" + iDayIndex.ToString() + "、" + _ST.ToString("yyyyMMdd") + "单天超过最高收费标准" + OneDayMaxCost.ToString("f2") + "，按最高标准收费。:<-----";
                                    alist.Add(errmsg);
                                }
                                else
                                {
                                    errmsg = "------>:" + iDayIndex.ToString() + "、" + _ST.ToString("yyyyMMdd") + "一整天的费用为" + idayMoney.ToString() + " :<-----";
                                    alist.Add(errmsg);
                                }
                                iDayIndex++;

                            }
                            _CalcM += OneDayCash;


                            #endregion
                        }
                        #endregion
                    }

                    _ST = _ST.AddDays(1);
                }


            }
            catch (Exception ex)
            {
                rt.result = "FAIL";
                rt.errcode = "-6";
                rt.errmsg = "计费出错：" + ex.Message;
            }

            rt.paycash = _CalcM;
            alist.Add("{  " + ST.ToString("yyyy-MM-dd HH:mm:00") + "   " + OT.ToString("yyyy-MM-dd HH:mm:00") + "  共停车  " + StopTimeInfo + "，合计费用：" + _CalcM.ToString("f2") + "  }");
            rt.alist = alist;
            result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
            return result;
        }
        #endregion

        #region 计算一天内时段的费用
        /// <summary>
        /// 出错信息
        /// </summary>
        string ExceptionInfo = "";
        /// <summary>
        /// 计算一天内时段的费用
        /// </summary>
        /// <param name="_ST"></param>
        /// <param name="_OT"></param>
        /// <param name="_Cash"></param>
        /// <param name="alist"></param>
        /// <returns></returns>
        private decimal CalcOneDayCast(DateTime _ST, DateTime _OT, ref ArrayList alist, bool boFirstDay)
        {
            try
            {
                ExceptionInfo = "";

                #region 
                string errmsg = "";
                decimal OneDayValue = 0;

                _OT = DateTime.Parse(_ST.ToString("yyyy-MM-dd ") + _OT.ToString("HH:mm:00"));
                TimeSpan ts = _OT.Subtract(_ST);
                alist.Add("------>:" + iDayIndex.ToString() + "、" + _ST.ToString("yyyy-MM-dd HH:mm:00") + "    " + _OT.ToString("yyyy-MM-dd HH:mm:00"));
                bool boReturn = false;
                if (boFirstDay || iAfter24H == 0)
                {
                    //第一天或都重新计费
                    if (ts.TotalMinutes < FreeMinute)
                    {
                        alist.Add(ts.TotalMinutes.ToString() + "小于" + FreeMinute.ToString() + "不收费。");
                        boReturn = true;
                        //return OneDayValue;
                    }
                    else if (ts.TotalMinutes <= firstHour * 60)
                    {
                        OneDayValue += firstCash;
                        alist.Add("超过" + FreeMinute.ToString() + "分钟,在" + firstHour.ToString() + "小时内" + firstCash.ToString() + "元");
                        boReturn = true;
                        // return OneDayValue;
                    }
                    else
                    {
                        _ST = _ST.AddHours(firstHour);
                        OneDayValue += firstCash;
                        alist.Add("超过" + FreeMinute.ToString() + "分钟,在" + firstHour.ToString() + "小时内" + firstCash.ToString() + "元");
                    }
                }
                if (!boReturn)
                {
                    #region 停车时间在同一天内
                    decimal _H_Start = decimal.Parse(_ST.ToString("HHmm"));
                    decimal _H_End = decimal.Parse(_OT.ToString("HHmm"));
                    alist.Add(_ST.ToString("HH:mm") + "  VS  " + _OT.ToString("HH:mm"));
                    //TimeSpan ts = _OT.Subtract(_ST);
                    //消费在一天内
                    for (int i = 0; i < timelist.Count; i++)
                    {
                        #region
                        // _timelist.Add("00:00&08:00&4");
                        string[] spt = timelist[i].ToString().Split(new char[] { '&' });
                        DateTime _StartDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd") + " " + spt[0]);
                        DateTime _EndDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd") + " " + spt[1]);
                        decimal _C_Start = decimal.Parse(spt[0].Replace(":", "").Trim());
                        decimal _C_End = decimal.Parse(spt[1].Replace(":", "").Trim());

                        decimal _SpCash = decimal.Parse(spt[2]);
                        //_H_Start06:00;   _C_Start:8:00;  _H_End:10:00;  _C_End:12:00
                        if (_H_Start <= _C_Start && _H_End >= _C_Start && _H_End <= _C_End)
                        {
                            //消费起始时间小于时段起始时间，消费截止时间在时段内
                            ts = _OT.Subtract(_StartDT);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _StartDT.ToString("HH:mm") + " " + _OT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        else if (_C_Start >= _H_Start && _C_Start <= _H_End)// (_H_Start >= _C_Start && _H_End<= _C_End)
                        {
                            //整个时段内在消费
                            ts = _EndDT.Subtract(_StartDT);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        else if (_H_Start >= _C_Start && _H_End <= _C_End)
                        {
                            //消费在时段内
                            ts = _OT.Subtract(_ST);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _ST.ToString("HH:mm") + " " + _OT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        else if (_H_Start >= _C_Start && _H_Start <= _C_End &&
                            _H_End >= _C_Start && _H_End >= _C_End)
                        {
                            //消费起始时间在时段内，消费截止时间大于结束时间
                            ts = _EndDT.Subtract(_ST);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _ST.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        #endregion
                    }
                    #endregion
                }
                if (OneDayValue > OneDayMaxCost)
                {
                    errmsg = _ST.ToString("yyyy-MM-dd") + "单天费用" + OneDayValue.ToString("f2") + "超过最高收费标准" + OneDayMaxCost.ToString("f2") + "，按最高标准收费。:<-----";
                    OneDayValue = OneDayMaxCost;
                    alist.Add(errmsg);
                }
                else
                {
                    alist.Add(_ST.ToString("yyyy-MM-dd") + "当天合计费用：" + OneDayValue.ToString("f2") + " :<-----");
                }

                iDayIndex++;

                return OneDayValue;
                #endregion
            }
            catch (Exception ex)
            {
                ExceptionInfo = ex.Message;
                return -100;
            }
        }
        #endregion

    }

    /// <summary>
    /// 返回信息
    /// </summary>
    public class backdata
    {
        #region 返回信息
        /// <summary>
        /// 返回结果:OK/FAIL
        /// </summary>
        public string result
        {
            get;
            set;
        }

        /// <summary>
        /// 错误码
        /// </summary>
        public string errcode
        {
            get;
            set;
        }
        /// <summary>
        /// 错误信息
        /// </summary>
        public string errmsg
        {
            get;
            set;
        }
        /// <summary>
        /// 合计费用
        /// </summary>
        public decimal paycash
        {
            get;
            set;
        }
        /// <summary>
        /// 消费时长
        /// </summary>
        public decimal iHour
        {
            get;
            set;
        }

        /// <summary>
        /// 时段消费明细
        /// </summary>
        public ArrayList alist
        {
            get;
            set;
        }
        #endregion
    }
}

努力，别失业
关注
c#不同时间段、不同费率计算费用
zhouwen5288的专栏
04-21 744
c语言地铁收费程序,地铁收费系统C语言2
weixin_36362326的博客
05-18 1260
#include "stdio.h"#include "string.h"#include "stdlib.h"#include "api.h"#include "SubwayCharge.h"#include "SubwayList.h"HistoryInfoNode *g_historyInfoNodeHead =NULL;CardStat_EN g_CardStatusInfo[MAX_CA...
C#停车场收费系统(winform项目)
12-20
C#语言，winform程序，SQLServer数据库（可自行更改），压缩包内包含数据库文件，主要的模块有添加停车、车辆出库、停车收费、收费查询、管理等界面
停车场计费算法 php,时段计费算法，一般用于停车计费
weixin_35801828的博客
04-04 1064
【实例简介】Ｃ#winFrom实现按不同时间不同费用，计算时段内的消费金额，一般用于停车场管理计费算法　https://blog.csdn.net/wysdong/article/details/85321864　对应的源码【实例截图】【核心代码】8b73ff6a-841d-47a9-8bf7-0cc001ad2257└── NCTest├── CLib│ ├── bin│ │ └──...
C#邮包计费
weixin_30463341的博客
12-25 240
using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.F...
时段计费算法，一般用于停车计费
12-28
Ｃ#winFrom实现按不同时间不同费用，计算时段内的消费金额，一般用于停车场管理计费算法　https://blog.csdn.net/wysdong/article/details/85321864　对应的源码
用电计费系统 用电的困扰
10-12
2. **计费算法模块**：根据各地电价和用电时段设定，计算每个用户应缴纳的费用。例如，高峰时段和低峰时段的电价可能不同，系统需要能够灵活处理这些规则。 3. **用户管理模块**：登记用户信息，分配用户账号，允许...
时间段收费设置及计算
12-22
在C#中，利用`DateTime`和`TimeSpan`的强大功能，以及自定义的数据结构和算法，可以实现灵活且准确的计费逻辑。对于更复杂的业务需求，还可以引入数据库存储费率信息，使用线程安全的方式来处理并发计费请求，以及...
停车场管理系统
06-10
综上所述，停车场管理系统是一个涵盖软件设计、数据结构、算法以及系统集成等多个方面的综合项目，使用C#和控制台界面可以构建出一个基础但实用的解决方案。通过不断的优化和扩展，可以使其满足不同规模和需求的停车...
c#做的一个停车收费系统
12-16
对进入停车场的汽车进行车位安排和计时计费
基于C#的网吧计费系统（Web＋数据库实例）
04-27
包括业务界面，用户界面，上机，下机功能，换机，注册会员，会员充值，新增计算以及其与数据库的连接和界面，是个很不错的代码
球场分时段计费算法
u013685199的博客
08-20 1417
球场分时段计费算法    1.输入数据   开始结束时间 2.变量（时间段，单价，初始价，封顶价） 3.思路 ：（1）.传入开始结束时间，提取必要的对比信息（开始结束小时，时间戳，经过时长）。（2.）根据时间创建1-2的数组。（2.循环时间数组，调用不同时间段的计价方法） 不废话，直接贴贴代码          public $stime = "2018-08-04 23:41:00"...
C#物联网工程技术停车场收费系统
最新发布
2301_77330829的博客
07-06 183
会将预约信息发送给云端服务器进行处理，当用户到达停车场时，系统会通过RFID识别车辆信息，自动将预约的车位开启。基于物联网技术的智能停车场系统，可以提高停车场的管理效率，优化用户的停车体验，有效解决城市停车难问题。4.智能导航:系统通过移动客户端提供智能导航功能，为用户提供最快、最近的停车位信息，有效减少用户寻找停车位的时间。1.物联网传感器:选用低功耗、小型化的无线传感器，通过Zigbee协议进行通信，实现多节点接入、低功耗、高效通信的。到广泛应用，为城市交通的发展提供有力的支持和保障。
物联网工程关键技术----C#停车场收费系统
2301_77897522的博客
07-05 199
i++) //遍历字符串数组，把每个字符串转换成字节类型赋值给每个字节变量。
C#物联网工程关键技术停车场收费系统
m0_68011227的博客
07-03 337
设计一个停车场收费系统，要求车辆进入时刷卡登记，出场刷卡后计算时间，并显示扣费金额。C#物联网工程中停车场收费系统的实现可以涉及以下关键技术：设备连接与通信：使用物联网技术将停车场设备连接到系统中。可以使用传统的串口通信。车辆识别与管理：使用车牌识别技术或其他身份识别技术来识别车辆进入和离开停车场，记录车辆信息并管理停车位的分配。收费计算与管理：根据停车时间和费率规则计算车辆应付的停车费用。
c#时间的计算
hwj1107的专栏
06-04 481
这么久了，对于时间的加减，总是用着很复杂的方法，今天才发现原来时间类有自带的函数，哎，笨死了/DateTime t2 = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm"));            DateTime t2 =DateTime.Now;            DateTime t1 = t2.AddMinut
C# 时间计算
让梦想疯狂
02-03 1277
1、获取时间范围经过的周数 public static int GetWeekCount(DateTime startTime, DateTime endTime) { //开始时间是星期几 int startWeek = Convert.ToInt32(startTime.DayOfWeek); startWeek = (startWeek == 0 ? (7 - 1) : (startWeek -
C#加油站计费系统
zzzzzwwwwjjjj的博客
08-13 934
namespace WindowsFormsApplication11 { public partial class Form1 : Form { public Form1() { InitializeComponent(); System.Collections.ArrayList rooms = new System.Collections.ArrayList(); rooms.Ad.
应用于停车场的24小时计费算法
梦醒逃荒岛的博客
01-22 3532
停车场管理中，最普遍最简单的计费规则当属24小时计费，也就是在按停车小时数计费. 收费规则设置界面如下 24小时计费规则并不复杂，方法输入车辆进出时间startTime、endTime ```java public static BigDecimal chargin(HourChargingRule rule,LocalDateTime inTime,LocalDateTime endTime){ Duration between = Duration.between(inTim
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值