C# DateTimeOffset.ToString方法代码示例

 public string FormatStartDate(DateTimeOffset startDateTime)
 {
     var timeOfDay = startDateTime.TimeOfDay;
     return timeOfDay.Hours == 0
                 ? startDateTime.ToString(DateOnlyPattern)
                 : startDateTime.ToString(DateAndTimePattern);
 }

        /// <summary>
        /// 定义将时间点对象 <see cref="System.DateTimeOffset"/> 转换为字符串的方法。
        /// </summary>
        /// <param name="datetimeOffset"></param>
        /// <returns></returns>
        protected override string ToString(DateTimeOffset datetimeOffset)
        {
            if (datetimeOffset.HasDate())
                return datetimeOffset.HasTime() ? base.ToString(datetimeOffset) : datetimeOffset.ToString(this.Culture.DateTimeFormat.ShortDatePattern, this.Culture);
            else if (datetimeOffset.HasTime())
                return datetimeOffset.ToString(this.Culture.DateTimeFormat.ShortTimePattern, this.Culture);

            return base.ToString(datetimeOffset);
        }

 public HistoryEntry(string id, DateTimeOffset timestamp, string operatorName, string alarmStatus, string alarmState, string response)
 {
     Id = id;
     Timestamp = timestamp.ToString("G", CultureInfo.CurrentCulture);
     SortableTimestamp = timestamp.ToString("s", CultureInfo.InvariantCulture);
     OperatorName = operatorName;
     AlarmStatus = alarmStatus;
     AlarmState = alarmState;
     Response = response;
 }

 /// <summary>
 /// Creates an immutable message object
 /// </summary>
 /// <param name="id">Message id</param>
 /// <param name="description">Message description</param>
 /// <param name="partitionId">The GUID of the partition the message occurred on</param>
 /// <param name="partitionName">The name of the partition the message occurred on</param>
 /// <param name="isPublic">True if the message is public, otherwise false</param>
 /// <param name="messageDateTime">The Date and Time the message occurred.</param>
 public Message(Guid id, string description, Guid partitionId, string partitionName, bool isPublic, DateTimeOffset messageDateTime)
 {
     Id = id;
     Description = description;
     PartitionId = partitionId;
     PartitionName = partitionName;
     IsPublic = isPublic;
     MessageDateTime = messageDateTime;
     MessageDateString = MessageDateTime.ToString("d", CultureInfo.CurrentCulture);
     MessageTimeString = MessageDateTime.ToString("t", CultureInfo.CurrentCulture);
     MessageDateTimeString = MessageDateTime.ToString("G", CultureInfo.CurrentCulture);
     MessageDateTimeSortableString = MessageDateTime.ToString("s", CultureInfo.InvariantCulture);
     MessageUtcDateTime = (long) (MessageDateTime.UtcDateTime - new DateTime(1970,1,1,0,0,0,0,DateTimeKind.Utc)).TotalMilliseconds;
 }

 /// <summary>
 /// Creates an immutable Case object
 /// </summary>        
 /// <param name="id">Globally unique identifier for the case</param>
 /// <param name="title">Title of the case</param>
 /// <param name="createdBy">User who created the case</param>
 /// <param name="createdDateTime">Time and Date that the case was created</param>
 /// <param name="owner">User who owns the case</param>
 /// <param name="notes">The list of notes on the case</param>
 /// <param name="status">Status of the case</param>
 public Case(string id, string title, string createdBy, DateTimeOffset createdDateTime, string owner, IEnumerable<CaseNote> notes, CaseStatus status)
 {
     Id = id;
     Title = title;
     CreatedBy = createdBy;
     CreatedDateTime = createdDateTime;
     CreatedDateString = CreatedDateTime.ToString("d", CultureInfo.CurrentCulture);
     CreatedTimeString = CreatedDateTime.ToString("t", CultureInfo.CurrentCulture);
     CreatedDateTimeString = CreatedDateTime.ToString("g", CultureInfo.CurrentCulture);
     CreatedDateTimeSortableString = CreatedDateTime.ToString("s", CultureInfo.InvariantCulture);
     Owner = owner;
     Notes = notes.ToList();
     StatusEnum = status;
 }

        /// <summary>
        ///   Determines if the time is in the specified time period.
        /// </summary>
        /// <param name="now">
        ///   The time to compare.
        /// </param>
        /// <param name="inclusiveStart">The inclusive start time.</param>
        /// <param name="exclusiveEnd">The exclusive end time.</param>
        /// <returns>
        ///   <b>true</b> if <paramref name="now"/> within the specified period; otherwise <b>false</b>.
        /// </returns>
        /// <exception cref="ArgumentOutOfRangeException">
        ///   <paramref name="exclusiveEnd"/> must be greater than <paramref name="inclusiveStart"/>.
        /// </exception>
        /// <example>
        ///   <code title="Credit Card Check" source="SepiaExamples\TimeExample.cs" region="Credit Card Check" language="C#" />
        /// </example>
        public static bool Between(this DateTimeOffset now, DateTimeOffset inclusiveStart, DateTimeOffset exclusiveEnd)
        {
            if (exclusiveEnd <= inclusiveStart)
                throw new ArgumentOutOfRangeException("end", exclusiveEnd.ToString("o"), string.Format("The end must be greater than the start '{0:o}'.", inclusiveStart));

            return inclusiveStart <= now && now < exclusiveEnd;
        }

        internal void ProcessRequest(ResourceSession rpResourceSession, Session rpSession)
        {
            if (CurrentMode == CacheMode.Disabled)
                return;

            string rFilename;
            var rNoVerification = CheckFileInCache(rpResourceSession.Path, out rFilename);

            rpResourceSession.CacheFilename = rFilename;

            if (rNoVerification == null)
                return;

            if (!rNoVerification.Value)
            {
                var rTimestamp = new DateTimeOffset(File.GetLastWriteTime(rFilename));

                if (rpResourceSession.Path.OICContains("mainD2.swf") || rpResourceSession.Path.OICContains(".js") || !CheckFileVersionAndTimestamp(rpResourceSession, rTimestamp))
                {
                    rpSession.oRequest["If-Modified-Since"] = rTimestamp.ToString("R");
                    rpSession.bBufferResponse = true;

                    return;
                }
            }

            rpSession.utilCreateResponseAndBypassServer();
            LoadFile(rFilename, rpResourceSession, rpSession);
        }

        public void SerializationTests_DateTimeOffset()
        {
            // Local Kind
            DateTime inputLocalDateTime = DateTime.Now;
            DateTimeOffset inputLocal = new DateTimeOffset(inputLocalDateTime);

            DateTimeOffset outputLocal = SerializationManager.RoundTripSerializationForTesting(inputLocal);
            Assert.AreEqual(inputLocal, outputLocal, "Local time");
            Assert.AreEqual(
                inputLocal.ToString(CultureInfo.InvariantCulture),
                outputLocal.ToString(CultureInfo.InvariantCulture));
            Assert.AreEqual(inputLocal.DateTime.Kind, outputLocal.DateTime.Kind);

            // UTC Kind
            DateTime inputUtcDateTime = DateTime.UtcNow;
            DateTimeOffset inputUtc = new DateTimeOffset(inputUtcDateTime);

            DateTimeOffset outputUtc = SerializationManager.RoundTripSerializationForTesting(inputUtc);
            Assert.AreEqual(inputUtc, outputUtc, "UTC time");
            Assert.AreEqual(
                inputUtc.ToString(CultureInfo.InvariantCulture),
                outputUtc.ToString(CultureInfo.InvariantCulture));
            Assert.AreEqual(inputUtc.DateTime.Kind, outputUtc.DateTime.Kind);

            // Unspecified Kind
            DateTime inputUnspecifiedDateTime = new DateTime(0x08d27e2c0cc7dfb9);
            DateTimeOffset inputUnspecified = new DateTimeOffset(inputUnspecifiedDateTime);

            DateTimeOffset outputUnspecified = SerializationManager.RoundTripSerializationForTesting(inputUnspecified);
            Assert.AreEqual(inputUnspecified, outputUnspecified, "Unspecified time");
            Assert.AreEqual(
                inputUnspecified.ToString(CultureInfo.InvariantCulture),
                outputUnspecified.ToString(CultureInfo.InvariantCulture));
            Assert.AreEqual(inputUnspecified.DateTime.Kind, outputUnspecified.DateTime.Kind);
        }

        public void DateTimeOffsetScenarioShouldFail()
        {
            var date = new DateTimeOffset(new DateTime(2000, 6, 1), TimeSpan.Zero);
            var dateString = date.ToString();
            var exptected = new DateTimeOffset(new DateTime(2000, 6, 1, 1, 0, 1), TimeSpan.Zero);
            var expectedDate = exptected.ToString();
            Verify.ShouldFail(() =>
date.ShouldBe(exptected, TimeSpan.FromHours(1), "Some additional context"),

errorWithSource:
[email protected]"date
    should be within
01:00:00
    of
{expectedDate}
    but was
{dateString}

Additional Info:
    Some additional context",

errorWithoutSource:
[email protected]"{dateString}
    should be within
01:00:00
    of
{expectedDate}
    but was not

Additional Info:
    Some additional context");
        }

 public RepositoryInfo(Repository repository, DateTimeOffset commitDate, string hash)
 {
     ProjectName = repository.Name;
     ProjectId = repository.Id;
     Date = commitDate.ToString("yyyy-MM-dd");
     Hash = hash;
 }

 internal static string ToAtomString(DateTimeOffset dateTime)
 {
     if (dateTime.Offset == zeroOffset)
     {
         return dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
     }
     return dateTime.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture);
 }

 private string AsString(DateTimeOffset dateTime)
 {
     if (dateTime.Offset == zeroOffset)
     {
         return dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
     }
     return dateTime.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture);
 }

        private string PrintNetworkUsage(NetworkUsage networkUsage, DateTimeOffset startTime)
        {
            string result = "Usage from " + startTime.ToString() + " to " + (startTime + networkUsage.ConnectionDuration).ToString() +
                "\n\tBytes sent: " + networkUsage.BytesSent +
                "\n\tBytes received: " + networkUsage.BytesReceived + "\n";

            return result;
        }

        public static void ConvertTo_WithContext()
        {
            DateTimeFormatInfo formatInfo = (DateTimeFormatInfo)CultureInfo.CurrentCulture.GetFormat(typeof(DateTimeFormatInfo));
            string formatWithTime = formatInfo.ShortDatePattern + " " + formatInfo.ShortTimePattern + " zzz";
            string format = formatInfo.ShortDatePattern + " zzz";
            DateTimeOffset testDateAndTime = new DateTimeOffset(new DateTime(1998, 12, 5, 22, 30, 30));

            ConvertTo_WithContext(new object[5, 3]
                {
                    { DateTimeOffsetConverterTests.s_testOffset, DateTimeOffsetConverterTests.s_testOffset.ToString(format, CultureInfo.CurrentCulture), null },
                    { testDateAndTime, testDateAndTime.ToString(formatWithTime, CultureInfo.CurrentCulture), null },
                    { DateTimeOffset.MinValue, string.Empty, null },
                    { DateTimeOffsetConverterTests.s_testOffset, DateTimeOffsetConverterTests.s_testOffset.ToString("yyyy-MM-dd zzz", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture },
                    { testDateAndTime, testDateAndTime.ToString(CultureInfo.InvariantCulture), CultureInfo.InvariantCulture }
                },
                DateTimeOffsetConverterTests.s_converter);
        }

        private string PrintNetworkUsage(AttributedNetworkUsage networkUsage, DateTimeOffset startTime, DateTimeOffset endTime)
        {
            string result = "Usage by " + networkUsage.AttributionName +
                "\n\tFrom: " + startTime.ToString() + " to " + endTime.ToString() +
                "\n\tBytes sent: " + networkUsage.BytesSent +
                "\n\tBytes received: " + networkUsage.BytesReceived + "\n";

            return result;
        }