C# DateTime.ToUnixTime方法代码示例

        public GroupsHistoryResponseModel GetChannelHistory(string slackApiToken, string channel, DateTime startTime, DateTime endTime, int count)
        {
            var responseString = "https://slack.com/api/channels.history"
                .PostUrlEncodedAsync(
                    new
                    {
                        token = slackApiToken,
                        channel,
                        latest = endTime.ToUnixTime(),
                        oldest = startTime.ToUnixTime(),
                        count
                    })
                .ReceiveString()
                .Result;

            var serializer = new JsonSerializer<GroupsHistoryResponseModel>();
            var response = serializer.DeserializeFromString(responseString);

            if (!response.ok)
            {
                throw new SlackApiException(response.error);
            }

            return response;
        }

        /// <summary>
        /// Gets a secure signed url for downloading through Amazon CloudFront
        /// </summary>
        /// <param name="resourceUrl">URL to the resource</param>
        /// <param name="expires">Expiry date for the download link</param>
        /// <param name="keyXml">Private key XML (Use OpenSSLKey to convert from pem format)</param>
        /// <param name="keypairId">Key Pair Id of the key from AWS Security Credentials page</param>
        /// <returns></returns>
        public static string GetSecureUrl(string resourceUrl, DateTime expires, string keyXml, string keypairId)
        {
            if (string.IsNullOrEmpty(resourceUrl))
            {
                throw new ArgumentNullException("resourceUrl");
            }

            if (string.IsNullOrEmpty(keyXml))
            {
                throw new ArgumentNullException("keyXml");
            }

            if (string.IsNullOrEmpty(keypairId))
            {
                throw new ArgumentNullException("keypairId");
            }

            if (expires < DateTime.Now)
            {
                throw new ArgumentException("Expiry date cannot be before current time.");
            }

            var unixExpiry = expires.ToUnixTime();
            var policy = BuildCannedPolicy(resourceUrl, unixExpiry);
            var rsa = GetRsaProvider(keyXml);
            var rsaSignature = rsa.SignData(Encoding.UTF8.GetBytes(policy), new SHA1CryptoServiceProvider());
            var signature = EncodeSignature(rsaSignature);

            return string.Format(
                            "{0}?Expires={1}&Signature={2}&Key-Pair-Id={3}",
                            resourceUrl,
                            unixExpiry,
                            signature,
                            keypairId);
        }

        /// <summary>
        /// Gets all authorization codes that matches the specified redirect uri and expires after the
        /// specified date. Called when authenticating an authorization code.
        /// </summary>
        /// <param name="redirectUri">The redirect uri.</param>
        /// <param name="expires">The expire date.</param>
        /// <returns>The authorization codes.</returns>
        public async Task<IEnumerable<IAuthorizationCode>> GetAuthorizationCodes(string redirectUri, DateTime expires)
        {
            var db = this.GetDatabase();

            var min = expires.ToUnixTime();
            var codes = new List<IAuthorizationCode>();

            var keys = db.SortedSetRangeByScore(this.Configuration.AuthorizationCodePrefix, min, DateTimeMax);

            foreach (var key in keys)
            {
                var hashedId = key.ToString().Substring(this.Configuration.AuthorizationCodePrefix.Length + 1);
                var id = Encoding.UTF8.GetString(Convert.FromBase64String(hashedId));

                if (id.Contains(redirectUri))
                {
                    var hashEntries = await db.HashGetAllAsync(key.ToString());

                    if (hashEntries.Any())
                    {
                        var code = new RedisAuthorizationCode(hashEntries) { Id = hashedId };

                        codes.Add(code);
                    }
                }
            }

            return codes;
        }

        public UserExtended GetCurrentChanged(DateTime since)
        {
            var url = string.Format(ApiRoutes.User.CurrentSinceUrl, since.ToUnixTime());

            var obj = ToggleSrv.Get(url).GetData<UserExtended>();

            return obj;
        }

		public void ToUnixTimeTest()
		{

			DateTime dt = new DateTime(1970, 1, 1);
			var unixTime = dt.ToUnixTime();
			Assert.AreEqual(unixTime, (long)0);


		}

        public async System.Threading.Tasks.Task<UserExtended> GetCurrentChanged(DateTime since)
        {
            var url = string.Format(ApiRoutes.User.CurrentSinceUrl, since.ToUnixTime());

            var response = await ToggleSrv.Get(url);
            var obj = response.GetData<UserExtended>();

            return obj;
        }

        public void ToUnixTime()
        {
            /*
             "The Unix epoch is the time 00:00:00 UTC on 1 January 1970 (or 1970-01-01T00:00:00Z ISO 8601)."
             * See:
             * https://en.wikipedia.org/wiki/Unix_time#Encoding_time_as_a_number
             */
            var unixStart = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
            long expected = 0;
            var actual = unixStart.ToUnixTime();
            Assert.AreEqual(expected, actual);

            // First second
            var test1 = new DateTime(1970, 1, 1, 0, 0, 1, DateTimeKind.Utc);
            expected = 1;
            actual = test1.ToUnixTime();
            Assert.AreEqual(expected, actual);

            // -1
            var test11 = new DateTime(1969, 12, 31, 23, 59, 59, DateTimeKind.Utc);
            expected = -1;
            actual = test11.ToUnixTime();
            Assert.AreEqual(expected, actual);

            /*
             * "At 01:46:40 UTC on 9 September 2001, the Unix billennium (Unix time number 1,000,000,000) was celebrated."
             */
            var test2 = new DateTime(2001, 9, 9, 1, 46, 40, DateTimeKind.Utc);
            expected = 1000000000;
            actual = test2.ToUnixTime();
            Assert.AreEqual(expected, actual);

            /*
             * "At 23:31:30 UTC on 13 February 2009, the decimal representation of Unix time reached 1,234,567,890 seconds (like the number row on a keyboard)."
             */
            var test3 = new DateTime(2009, 2, 13, 23, 31, 30, DateTimeKind.Utc);
            expected = 1234567890;
            actual = test3.ToUnixTime();
            Assert.AreEqual(expected, actual);

            /*
             * "At 06:28:15 UTC on Sun, 7 February 2106, the Unix time will reach 0xFFFFFFFF or 4,294,967,295 seconds which, for systems that hold the time on 32 bit unsigned numbers, is the maximum attainable"
             */
            var test4 = new DateTime(2106, 2, 7, 06, 28, 15, DateTimeKind.Utc);
            expected = 0xFFFFFFFF;
            actual = test4.ToUnixTime();
            Assert.AreEqual(expected, actual);

            /*
             * "At 16:53:20 UTC on 13 May 2014, the Unix time value 1,400,000,000 seconds was celebrated over the Web"
             */
            var test5 = new DateTime(2014, 5, 13, 16, 53, 20, DateTimeKind.Utc);
            expected = 1400000000;
            actual = test5.ToUnixTime();
            Assert.AreEqual(expected, actual);
        }

        public string CreateSignature(long userId, long appId, string appSecret, DateTime now)
        {
            var bytes = BitConverter.GetBytes(userId)
                .Concat(BitConverter.GetBytes(appId))
                .Concat(BitConverter.GetBytes(now.ToUnixTime()))
                .Concat(Encoding.UTF8.GetBytes(appSecret))
                .ToArray();

            return _hashAlgorithm.ComputeHash(bytes).ToHexString().ToLower();
        }

        public void Serialize_UTC_Date()
        {
            var d = new DateTime(2001, 01, 01);

            d.ToJson().Print();
            "\"\\/Date(978325200000-0000)\\/\"".Print();
            d.ToUnixTime().ToString().Print();
            d.ToUnixTimeMs().ToString().Print();

            Assert.That(d.ToJson(), Is.EqualTo("\"\\/Date(978325200000-0000)\\/\""));
        }

		public PlaintextMessage(string path, int value, DateTime timestamp)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}

			Path = path;
			Value = value;
			Timestamp = timestamp.ToUnixTime();
		}

        public void ToUnixTime_ThenCorrectUnixTimeReturned()
        {
            // arrange
            const Int64 Expected = 1396137600;
            DateTime dateTime = new DateTime(2014, 03, 30, 0, 0, 0, 0);

            // act
            Int64 unixTime = dateTime.ToUnixTime();

            // assert
            unixTime.ShouldBeEquivalentTo(Expected);
        }

        public IEnumerable<ScheduledGame> GetScheduledLeagueGames(DateTime dateMin = default(DateTime), DateTime dateMax = default(DateTime))
        {
            var request = new RestRequest(RequestPaths.Dota2.League.ScheduledLeagueGames);

            var defaultDateTime = default(DateTime);
            if (dateMin != defaultDateTime)
                request.AddQueryParameter("date_min", dateMin.ToUnixTime());
            if (dateMax != defaultDateTime)
                request.AddQueryParameter("date_max", dateMax.ToUnixTime());

            var response = Execute<ScheduledLeagueGamesResponseWrapper>(request);
            return Mapper.Map<List<ScheduledGame>>(response.Games);
        }

        public void DateTimeToUnixTime_Works()
        {
            // UTC time
            var utcDateTime = new DateTime(2013, 9, 26, 22, 21, 11, DateTimeKind.Utc);
            Assert.That(utcDateTime.ToUnixTime(), Is.EqualTo(1380234071L));

            // Local time
            var localDateTime = TimeZoneInfo.ConvertTimeFromUtc(utcDateTime, TimeZoneInfo.Local);
            Assert.That(localDateTime.ToUnixTime(), Is.EqualTo(1380234071L));

            // Min value
            Assert.That(DateTime.MinValue.ToUnixTime(), Is.EqualTo(-62135596800L));
        }

 public static DynamicProfileBadge CreateFromCommentCount(string userName, int commentCount, DateTime newestCommentTime)
 {
     if (string.IsNullOrWhiteSpace(userName))
         throw new ArgumentNullException(nameof(userName));
     foreach (var ccn in CommentCountNames.OrderByDescending(kvp => kvp.Key))
     {
         if (commentCount > ccn.Key)
         {
             var template = BadgeTemplates[DynamicBadgeType.Comments];
             var description = string.Format(template.Description ?? string.Empty, ccn.Key);
             var link = $"{ClientConstants.UserUrlPrefix}/{userName}/comments/before/{newestCommentTime.ToUnixTime()}";
             return new DynamicProfileBadge(template.Image, description, link, newestCommentTime, template.Name, ccn.Value);
         }
     }
     return null;
 }

        public Event[] GetInRange(DateTime from, DateTime to, int[] hostids, TypeOfEvent typeOfEvent = TypeOfEvent.Trigger, TypeOfObjectRelatedEvent relatedEvent = TypeOfObjectRelatedEvent.Trigger)
        {
            if (from == null || to == null)
                throw new ArgumentNullException();

            var response = _event.Get(new Get
            {
                time_from = from.ToUnixTime(),
                time_till = to.ToUnixTime(),
                @object = relatedEvent,
                source = typeOfEvent,
                sortfield = new []{"eventid"},
                output = "extend",
                sortorder = new[] { "desc" }
            });
            return response;
        }