C# 计算两个时间年份月份日期差 DateTime

已于 2024-05-31 11:07:51 修改
阅读量8k 收藏 5
点赞数
分类专栏： .Net技术 文章标签： c# java 算法
于 2018-02-26 13:44:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KingCruel/article/details/79376261
版权

格式化日期：2026-06-06
当月第一天：2026-06-01
当月最后一天：2026-06-30
获取日期的开始时间（第一秒）：2026-06-06 00:00:00
获取日期的结束时间（最后一秒）：2026-06-06 23:59:59
时间差：6年6个月6天6小时6分钟6秒
时间对象与时间戳相互转换

1、DateTimeExtensions.cs

using System.Text;
using System.Text.RegularExpressions;

namespace Trial.Common.Extensions
{
    public static class DateTimeExtensions
    {
        /// <summary>
        /// 格式化日期时间
        /// </summary>
        /// <param name="dateTime1">日期时间</param>
        /// <param name="dateMode">显示模式</param>
        /// <returns>0-9种模式的日期</returns>
        public static string FormatDate(DateTime dateTime1, string dateMode)
        {
            switch (dateMode)
            {
                case "0":
                    return dateTime1.ToString("yyyy-MM-dd");
                case "1":
                    return dateTime1.ToString("yyyy-MM-dd HH:mm:ss");
                case "2":
                    return dateTime1.ToString("yyyy/MM/dd");
                case "3":
                    return dateTime1.ToString("yyyy年MM月dd日");
                case "4":
                    return dateTime1.ToString("MM-dd");
                case "5":
                    return dateTime1.ToString("MM/dd");
                case "6":
                    return dateTime1.ToString("MM月dd日");
                case "7":
                    return dateTime1.ToString("yyyy-MM");
                case "8":
                    return dateTime1.ToString("yyyy/MM");
                case "9":
                    return dateTime1.ToString("yyyy年MM月");
                default:
                    return dateTime1.ToString();
            }
        }

        /// <summary>
        /// 时间差【推荐】
        /// </summary>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <param name="fullTime">是否显示全部</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static string DateDiff(DateTime startTime, DateTime endTime, bool fullTime = true)
        {
            if (startTime < endTime)
            {
                var t = new
                {
                    bm = startTime.Month,
                    em = endTime.Month,
                    bd = startTime.Day,
                    ed = endTime.Day
                };
                int diffMonth = (endTime.Year - startTime.Year) * 12 + (t.em - t.bm),//相差月
                    diffYear = diffMonth / 12;//相差年

                int[] d = new int[3] { 0, 0, 0 };
                if (diffYear > 0)
                {
                    if (t.em == t.bm && t.ed < t.bd)
                    {
                        d[0] = diffYear - 1;
                    }
                    else d[0] = diffYear;
                }

                if (t.ed >= t.bd)
                {
                    d[1] = diffMonth % 12;
                    d[2] = t.ed - t.bd;
                }
                else//结束日 小于 开始日
                {
                    int dm = diffMonth - 1;
                    d[1] = dm % 12;
                    TimeSpan ts = endTime - startTime.AddMonths(dm);
                    d[2] = ts.Days;
                }
                StringBuilder sb = new StringBuilder();

                if (d.Sum() > 0 || fullTime)
                {
                    #region 如果是0不显示
                    //if (d[0] > 0) sb.Append($"{d[0]}年");
                    //if (d[1] > 0) sb.Append($"{d[1]}个月");
                    //if (d[2] > 0) sb.Append($"{d[2]}天");

                    //int[] time = new int[2] { 0, 0 };
                    //TimeSpan sj = e - b;
                    //time[0] = sj.Hours;
                    //time[1] = sj.Minutes % 60;
                    //if (time[0] > 0) sb.Append($"{time[0]}小时");
                    //if (time[1] > 0) sb.Append($"{time[1]}分钟");

                    //if (time.Sum() <= 0) sb.Append($"{sj.Seconds}秒");
                    #endregion

                    #region 如果是0也显示
                    sb.Append($"{d[0]}年");
                    sb.Append($"{d[1]}个月");
                    sb.Append($"{d[2]}天");

                    int[] time = new int[2] { 0, 0 };
                    TimeSpan sj = endTime - startTime;
                    time[0] = sj.Hours;
                    time[1] = sj.Minutes % 60;
                    sb.Append($"{time[0]}小时");
                    sb.Append($"{time[1]}分钟");

                    sb.Append($"{sj.Seconds}秒");
                    #endregion
                }
                else
                {
                    int[] time = new int[2] { 0, 0 };
                    TimeSpan sj = endTime - startTime;
                    time[0] = sj.Hours;
                    time[1] = sj.Minutes % 60;
                    if (time[0] > 0) sb.Append($"{time[0]}小时");
                    if (time[1] > 0) sb.Append($"{time[1]}分钟");

                    if (time.Sum() <= 0) sb.Append($"{sj.Seconds}秒");
                }
                return sb.ToString();
            }
            else throw new Exception("开始日期必须小于结束日期");
        }

        /// <summary>
        /// 获得两个日期的间隔
        /// </summary>
        /// <param name="DateTime1">日期一。</param>
        /// <param name="DateTime2">日期二。</param>
        /// <returns>日期间隔TimeSpan。</returns>
        public static TimeSpan DateDiff2(DateTime DateTime1, DateTime DateTime2)
        {
            TimeSpan ts1 = new TimeSpan(DateTime1.Ticks);
            TimeSpan ts2 = new TimeSpan(DateTime2.Ticks);
            TimeSpan ts = ts1.Subtract(ts2).Duration();
            return ts;
        }

        /// <summary>
        /// 当月第一天
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static DateTime GetFirstDayOfMonth(this DateTime date)
        {
            DateTime dtFrom = date;
            dtFrom = dtFrom.AddDays(-(dtFrom.Day - 1));
            return dtFrom;
        }

        /// <summary>
        /// 当月最后一天
        /// full date
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static DateTime GetLastDayOfMonth(this DateTime date)
        {
            DateTime dtTo = date;
            dtTo = dtTo.AddMonths(1);
            dtTo = dtTo.AddDays(-(dtTo.Day));
            return dtTo;
        }

        /// <summary>
        /// 获取日期的开始时间（第一秒）
        /// </summary>
        /// <returns></returns>
        public static DateTime GetStartOfDay(this DateTime date, int dateMode)
        {
            DateTime startDate = Convert.ToDateTime("2024-6-6 06:06:06");
            DateTime startTime = DateTime.Now;
            if (dateMode == 1)
            {
                DateTime dt = DateTime.Today;
                string start = dt.ToString();
            }
            else if (dateMode == 2)
            {
                DateTime start1 = startDate.Date;
                string startTimeString = start1.ToString();

                /// 动态参数
                startTime = date.Date;
                string startString = startTime.ToString();
            }
            else if (dateMode == 3)
            {
                DateTime start1 = startDate.Date.AddTicks(1);

                /// 动态参数
                startTime = date.Date.AddTicks(1);
            }
            else if (dateMode == 4)
            {
                DateTime dateTime = Convert.ToDateTime(startDate.ToString("yyyy-MM-dd 00:00:00"));

                /// 动态参数
                startTime = Convert.ToDateTime(date.ToString("yyyy-MM-dd 00:00:00"));
            }
            else if (dateMode == 5)
            {
                DateTime start1 = Convert.ToDateTime(startDate.ToString("D").ToString());

                /// 动态参数
                startTime = Convert.ToDateTime(date.ToString("D").ToString());
            }
            else if (dateMode == 6)
            {
                startTime = new DateTime(date.Year, date.Month, date.Day, 0, 0, 0);
            }
            return startTime;
        }

        /// <summary>
        /// 获取日期的结束时间（最后一秒）
        /// </summary>
        /// <param name="date"></param>
        /// <param name="dateMode"></param>
        /// <returns></returns>
        public static DateTime GetEndOfDay(this DateTime date, int dateMode)
        {
            DateTime startDate = Convert.ToDateTime("2024-6-6 06:06:06");
            DateTime endTime = DateTime.Now;

            if (dateMode == 1)
            {
                var endDateTime = startDate.Date.AddDays(1).AddMilliseconds(-1);

                /// 动态参数
                endTime = date.Date.AddDays(1).AddMilliseconds(-1);
            }
            else if (dateMode == 2)
            {
                var startDateTime = Convert.ToDateTime(startDate.ToString("yyyy-MM-dd 00:00:00"));
                var endDateTime = startDateTime.AddDays(1).AddMilliseconds(-1);

                /// 动态参数
                var startTime = Convert.ToDateTime(date.ToString("yyyy-MM-dd 00:00:00"));
                endTime = startTime.AddDays(1).AddMilliseconds(-1);
            }
            else if (dateMode == 3)
            {
                DateTime endDateTime = Convert.ToDateTime(startDate.AddDays(1).ToString("D").ToString()).AddSeconds(-1);

                /// 动态参数
                endTime = Convert.ToDateTime(date.AddDays(1).ToString("D").ToString()).AddSeconds(-1);
            }
            else if (dateMode == 4)
            {
                endTime = new DateTime(date.Year, date.Month, date.Day, 23, 59, 59);
            }
            return endTime;
        }

        #region 时间对象与时间戳相互转换

        /// <summary>
        /// 将 DateTime 转换为 Unix 时间戳
        /// </summary>
        /// <param name="dateTime">需要转换的时间</param>
        /// <returns>Unix 时间戳</returns>
        public static long DateTimeToUnixTime(this DateTime dateTime)
        {
            return (long)(dateTime - TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1, 0, 0, 0), TimeZoneInfo.Local)).TotalSeconds;
        }

        /// <summary>
        /// 将 Unix 时间戳转换为 DateTime
        /// </summary>
        /// <param name="timestamp">Unix 时间戳</param>
        /// <returns>需要转换的时间</returns>
        public static DateTime UnixTimeToDateTime(this long timestamp)
        {
            if (timestamp < 0)
                throw new ArgumentOutOfRangeException("timestamp is out of range");

            return TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1, 0, 0, 0), TimeZoneInfo.Local).AddSeconds(timestamp);
        }

        #endregion

        #region 判断是否为日期，时间，日期+时间

        /// <summary>
        /// 判断是否为日期
        /// </summary>
        /// <param name="obj">Object</param>
        /// <returns>bool</returns>
        public static bool IsDate(Object obj)
        {
            var result = false;

            if (obj != null)
            {
                result = Regex.IsMatch(obj.ToString(), @"^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-9]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$");
            }

            return result;
        }

        /// <summary>
        /// 判断是否为时间
        /// </summary>
        /// <param name="obj">Object对象</param>
        /// <returns>bool</returns>
        public static bool IsTime(Object obj)
        {
            var result = false;

            if (obj != null)
            {
                result = Regex.IsMatch(obj.ToString(), @"^((20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d)$");
            }

            return result;
        }

        /// <summary>
        /// 判断是否为日期+时间
        /// </summary>
        /// <param name="obj">Object对象</param>
        /// <returns>bool</returns>
        public static bool IsDateTime(Object obj)
        {
            var result = false;

            if (obj != null)
            {
                result = Regex.IsMatch(obj.ToString(), @"^(((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-)) (20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d)$ ");
            }

            return result;
        }
        #endregion

    }
}

*、DateTimeUtil.cs

namespace Trial.Common
{
    /// <summary>
    /// Admin.NET 开源项目
    /// </summary>
    public class DateTimeUtil
    {
        /// <summary>
        /// 获取开始时间
        /// </summary>
        /// <param name="dateTime"></param>
        /// <param name="days"></param>
        /// <returns></returns>
        public static DateTime GetBeginTime(DateTime? dateTime, int days = 0)
        {
            if (dateTime == DateTime.MinValue || dateTime == null)
                return DateTime.Now.AddDays(days);

            return dateTime ?? DateTime.Now;
        }

        /// <summary>
        ///  时间戳转本地时间-时间戳精确到秒
        /// </summary>
        public static DateTime ToLocalTimeDateBySeconds(long unix)
        {
            return DateTimeOffset.FromUnixTimeSeconds(unix).ToLocalTime().DateTime;
        }

        /// <summary>
        ///  时间转时间戳Unix-时间戳精确到秒
        /// </summary>
        public static long ToUnixTimestampBySeconds(DateTime dt)
        {
            return new DateTimeOffset(dt).ToUnixTimeSeconds();
        }

        /// <summary>
        ///  时间戳转本地时间-时间戳精确到毫秒
        /// </summary>
        public static DateTime ToLocalTimeDateByMilliseconds(long unix)
        {
            return DateTimeOffset.FromUnixTimeMilliseconds(unix).ToLocalTime().DateTime;
        }

        /// <summary>
        ///  时间转时间戳Unix-时间戳精确到毫秒
        /// </summary>
        public static long ToUnixTimestampByMilliseconds(DateTime dt)
        {
            return new DateTimeOffset(dt).ToUnixTimeMilliseconds();
        }

        /// <summary>
        /// 毫秒转天时分秒
        /// </summary>
        /// <param name="ms"></param>
        /// <returns></returns>
        public static string FormatTime(long ms)
        {
            int ss = 1000;
            int mi = ss * 60;
            int hh = mi * 60;
            int dd = hh * 24;

            long day = ms / dd;
            long hour = (ms - day * dd) / hh;
            long minute = (ms - day * dd - hour * hh) / mi;
            long second = (ms - day * dd - hour * hh - minute * mi) / ss;
            long milliSecond = ms - day * dd - hour * hh - minute * mi - second * ss;

            string sDay = day < 10 ? "0" + day : "" + day; //天
            string sHour = hour < 10 ? "0" + hour : "" + hour;//小时
            string sMinute = minute < 10 ? "0" + minute : "" + minute;//分钟
            string sSecond = second < 10 ? "0" + second : "" + second;//秒
            string sMilliSecond = milliSecond < 10 ? "0" + milliSecond : "" + milliSecond;//毫秒
            sMilliSecond = milliSecond < 100 ? "0" + sMilliSecond : "" + sMilliSecond;

            return string.Format("{0} 天 {1} 小时 {2} 分 {3} 秒", sDay, sHour, sMinute, sSecond);
        }

        /// <summary>
        /// 获取unix时间戳
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static long GetUnixTimeStamp(DateTime dt)
        {
            return ((DateTimeOffset)dt).ToUnixTimeMilliseconds();
        }

        /// <summary>
        /// 获取日期天的最小时间
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static DateTime GetDayMinDate(DateTime dt)
        {
            return new DateTime(dt.Year, dt.Month, dt.Day, 0, 0, 0);
        }

        /// <summary>
        /// 获取日期天的最大时间
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>

        public static DateTime GetDayMaxDate(DateTime dt)
        {
            return new DateTime(dt.Year, dt.Month, dt.Day, 23, 59, 59);
        }

        /// <summary>
        /// 获取日期天的最大时间
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string FormatDateTime(DateTime? dt)
        {
            if (dt == null) return string.Empty;

            if (dt.Value.Year == DateTime.Now.Year)
                return dt.Value.ToString("MM-dd HH:mm");
            else
                return dt.Value.ToString("yyyy-MM-dd HH:mm");
        }

        /// <summary>
        /// 获取今天日期范围00:00:00 - 23:59:59
        /// </summary>
        /// <returns></returns>
        public static List<DateTime> GetTodayTimeList(DateTime time)
        {
            return new List<DateTime>
            {
                Convert.ToDateTime(time.ToString("D").ToString()),
                Convert.ToDateTime(time.AddDays(1).ToString("D").ToString()).AddSeconds(-1)
            };
        }

        /// <summary>
        /// 获取星期几
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string GetWeekByDate(DateTime dt)
        {
            var day = new[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
            return day[Convert.ToInt32(dt.DayOfWeek.ToString("d"))];
        }

        /// <summary>
        /// 获取这个月的第几周
        /// </summary>
        /// <param name="daytime"></param>
        /// <returns></returns>
        public static int GetWeekNumInMonth(DateTime daytime)
        {
            int dayInMonth = daytime.Day;
            // 本月第一天
            DateTime firstDay = daytime.AddDays(1 - daytime.Day);
            // 本月第一天是周几
            int weekday = firstDay.DayOfWeek == 0 ? 7 : (int)firstDay.DayOfWeek;
            // 本月第一周有几天
            int firstWeekEndDay = 7 - (weekday - 1);
            // 当前日期和第一周之差
            int diffday = dayInMonth - firstWeekEndDay;
            diffday = diffday > 0 ? diffday : 1;
            // 当前是第几周，若整除7就减一天
            return (diffday % 7 == 0 ? diffday / 7 - 1 : diffday / 7) + 1 + (dayInMonth > firstWeekEndDay ? 1 : 0);
        }
    }
}

*

        /// <summary>
        /// 计算两个时间年份月份差
        /// </summary>
        /// <returns></returns>
        public static int GetUsedMonth1()
        {
            try
            {
                DateTime currentDate = DateTime.Now;
                DateTime dynamicTime = Convert.ToDateTime("2017-9-5");
                int year = currentDate.Year - dynamicTime.Year; //相差的年份  
                int month = (currentDate.Year - dynamicTime.Year) * 12 + (currentDate.Month - dynamicTime.Month); //相差的月份
                int month1 = currentDate.Year * 12 + currentDate.Month - dynamicTime.Year * 12 - dynamicTime.Month; //相差的月份

                TimeSpan used = DateTime.Now - dynamicTime;
                double totalDays = used.TotalDays; //相差总天数

                return Convert.ToInt32(month);
            }
            catch (Exception)
            {
                return 0;
            }
        }

*、DateTimeController.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using MongoDB.Driver.Linq;
using Trial.Contract;

namespace Trial.WebAPI.Controllers
{
    [ApiController]
    [Route("api/DateTime/[action]")]
    public class DateTimeController : ControllerBase
    {
        public DateTimeController() { }

        /// <summary>
        /// 获取日期的开始时间（第一秒）
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult GetStartOfDay([FromBody] DateTime data)
        {
            DateTime d1 = Common.Extensions.DateTimeExtensions.GetStartOfDay(data, 1);
            DateTime d2 = Common.Extensions.DateTimeExtensions.GetStartOfDay(data, 2);
            DateTime d3 = Common.Extensions.DateTimeExtensions.GetStartOfDay(data, 3);
            DateTime d4 = Common.Extensions.DateTimeExtensions.GetStartOfDay(data, 4);
            DateTime d5 = Common.Extensions.DateTimeExtensions.GetStartOfDay(data, 5);

            return Ok(new
            {
                d1 = d1,
                d2 = d2,
                d3 = d3,
                d4 = d4,
                d5 = d5,
            });
        }

        /// <summary>
        /// 获取日期的结束时间（最后一秒）
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult GetEndOfDay([FromBody] DateTime data)
        {
            DateTime d1 = Common.Extensions.DateTimeExtensions.GetEndOfDay(data, 1);
            DateTime d2 = Common.Extensions.DateTimeExtensions.GetEndOfDay(data, 2);
            DateTime d3 = Common.Extensions.DateTimeExtensions.GetEndOfDay(data, 3);

            return Ok(new
            {
                d1 = d1,
                d2 = d2,
                d3 = d3,
            });
        }

        [HttpPost]
        public IActionResult GetDateDiff([FromBody] DateDiffInput input)
        {
            var d1 = Common.Extensions.DateTimeExtensions.DateDiff(input.StartTime, input.EndTime, input.FullTime);
            return Ok(new
            {
                d1 = d1,
            });
        }
    }
}

*
*
*

KingCruel
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
计算C＃中两个日期之间的月份差
cunchi8090的博客
07-19 4808
There are a lot of written methos of getting the difference between two dates, but I couldn't find the one I needed. I need to have a real difference like 3.7...
C#实现两个时间相减的方法
01-20
本文实例讲述了C#实现两个时间相减的方法。分享给大家供大家参考。具体实现方法如下： 代码如下:using System;  using System.Collections.Generic;  using System.Linq;  using System.Text;    namespace ...
C#计算两个时间差(精确到年月周日)
golden_stone_fish的博客
07-26 626
class Program { static void Main(string[] args) { DateTime date1 = new DateTime(2020,7,9); DateTime date2 = new DateTime(2022,7,2); TimeInterval(date1,date2); } private static void.
C#计算两个时间年份月份差
weixin_34067102的博客
10-26 736
C#计算两个时间年份月份差 DateTime dt1 = Convert.ToDateTime("2008-8-8"); DateTime dt2 = System.DateTime.Now; int Year = dt2.Year - dt1.Year; int Month = (dt2.Year - dt1.Year) * 12 + (dt2.Month - dt1.Month); ...
C# 计算DataTime的4种时间差的方法(相差天数、相差小时、相差分钟、相差秒)
最新发布
wangjunlei的专栏
06-04 535
【代码】C# 计算DataTime的4种时间差的方法(相差天数、相差小时、相差分钟、相差秒)
C#计算两个时间年份月份差&计算两个日期的时间间隔
weixin_44543121的博客
10-16 1731
static public DateTime ToDate(this object data) { if (data == null) return DateTime.MinValue; DateTime result; return DateTime.TryParse(data.ToString(), out result) ? result : DateTime.MinValue; .
C#计算两个日期返回年份、月份
u010894245的博客
01-20 555
C#计算两个日期返回年份、月份
C# 计算两个日期之间的月份数（差值）
热门推荐
研究、探索、分享与成长
02-14 1万+
var months = ((DateTime.Now.Year - baseDate.Year) * 12) + DateTime.Now.Month - baseDate.Month; （当前日期年份 - 目标日期年份 * 12）+ 当前日期月份 - 目标日期月份 一年 12 个月是固定的，所以年份差乘以 12 得出的月份加上目标日期与当前日期的差值既两个日期之间的月份总数。    ...
C#计算两个时间差（年月日时分秒）
beautifull001的博客
09-22 3002
由于业务需求，在系统中计算任务需要花费多少时间，并按开始时间和结束时间来计算，可以得到多少年、多少个月、多少天，如果是同一天就需要得到多少小时、多少分钟、多少秒 public string term(DateTime b, DateTime e) { if (b < e) { var t = new { bm = b.Month,
C# 计算两个时间的年月日物理时间差。。（修改后的）
12-27
总结，计算两个日期之间的年月日物理时间差涉及到C#的基础类型`DateTime`和`TimeSpan`，以及对日期和时间间隔的理解。通过适当的计算和处理，我们可以准确地得到两个日期之间的年、月、日差异。对于实际应用，还需要...
深入理解C# DateTime日期格式化
08-31
在C#编程语言中，`DateTime`是一个核心的类型，用于表示日期和时间的组合。它提供了丰富的功能，包括将日期和时间转换为字符串，以便于显示和处理。本文将深入探讨`DateTime`类型的日期格式化，特别是通过`ToString...
计算两个日期间的年月日差
12-04
在C#中，我们可以使用DateTime结构的`Subtract`方法来获取两个日期之间的时间间隔，这将返回一个TimeSpan对象。TimeSpan对象包含了间隔的天数，但并不直接提供年和月的差值。这是因为年和月的长度并不固定，所以直接...
C# 计算传入的时间距离今天的时间差
08-29
总结起来，这个`GetCriminalYX`方法提供了一种计算两个日期之间时间差的方法，可以方便地获取传入日期距离今天的年、月和日的差值。在实际应用中，这种方法可以广泛应用于日历应用、数据分析、时间间隔计算等各种...
C#日期时间格式化小结
09-05
这个方法接受两个参数，第一个参数`format`是一个字符串，用于定义日期时间的输出格式，第二个参数`IFormatProvider`则通常用于指定特定的文化信息，例如日期和时间的分隔符、数字格式等。在示例代码中，使用了`...
C#获取上个月第一天和最后一天日期的方法
09-04
总结起来，获取上个月第一天和最后一天的日期在C#中主要有两种方法：一种是根据当前月份判断并计算，另一种是通过日期的加减操作。这两种方法在实际开发中都非常实用，可以根据具体情况选择使用。希望这篇文章对你...
C#时间格式化(Datetime)用法详解
10-27
C#中的DateTime类型是处理日期和时间的核心类，它提供了丰富的功能来操作和格式化日期。DateTime.ToString()方法是用于将DateTime对象转换为字符串的重要工具，它可以接受一个格式字符串作为参数，通过这个字符串来...
C#如何获取系统日期时间
03-16
对于更复杂的日期和时间操作，如计算两个日期之间的差值或获取指定日期的某一部分（如年份、月份），C#提供了丰富的`DateTime`类方法，如`AddDays()`, `AddHours()`, `Year`, `Month`, `Day`等。 总的来说，C#提供...
C# 获取两个时间段，重复的时间区间
06-13
你可以使用C#中的DateTime和TimeSpan类来获取两个时间段之间的重复时间区间。以下是一个示例代码： ```csharp DateTime start1 = new DateTime(2022, 1, 1, 10, 0, 0); DateTime end1 = new DateTime(2022, 1, 1, 12, 0, 0); DateTime start2 = new DateTime(2022, 1, 1, 11, 0, 0); DateTime end2 = new DateTime(2022, 1, 1, 13, 0, 0); TimeSpan overlap = TimeSpan.Zero; if (start1 < end2 && end1 > start2) { DateTime overlapStart = (start1 > start2) ? start1 : start2; DateTime overlapEnd = (end1 < end2) ? end1 : end2; overlap = overlapEnd - overlapStart; } Console.WriteLine("重复时间区间为：" + overlap); ``` 在上面的示例代码中，我们假设有两个时间段：第一个时间段从2022年1月1日10:00:00开始，到12:00:00结束；第二个时间段从2022年1月1日11:00:00开始，到13:00:00结束。 我们首先判断这两个时间段是否有重叠，如果有，就计算重叠的起始时间和结束时间，然后计算它们之间的时间差，即为重复的时间区间。最后将结果输出即可。 注意：上述代码只考虑了两个时间段的情况，如果需要处理多个时间段之间的重复时间区间，需要使用更复杂的算法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值