/// <summary>
 /// 	Sets the time on the specified DateTime value using the specified time zone.
 /// </summary>
 /// <param name = "datetimeOff">The base date.</param>
 /// <param name = "timespan">The TimeSpan to be applied.</param>
 /// <param name = "localTimeZone">The local time zone.</param>
 /// <returns>/// The DateTimeOffset including the new time value/// </returns>
 public static DateTimeOffset SetTime(this DateTimeOffset datetimeOff, TimeSpan timespan,
                                      TimeZoneInfo localTimeZone)
 {
     var localDate = datetimeOff.ToLocalDateTime(localTimeZone);
     localDate.SetTime(timespan);
     return localDate.ToDateTimeOffset(localTimeZone);
 }

 public Reglage(ReglageViewModel rvm){
     Id = rvm.IdReglage;
     Duree = new TimeSpan(rvm.Duree, 0, 0, 0);
     Lumiere = Math.Round(rvm.Lumiere, 2);
     TemperatureInterieur = Math.Round(rvm.TemperatureInterieur, 2);
     Humidite = Math.Round(rvm.Humidite, 2);
 }

 private void RetrieveFileData(HttpContext context, string filePath, string container)
 {
     MediaFileModel resultModel = new MediaFileModel();
     // only send request to imageprocessor if querystring exists; can exclude other parameters if needed
     if (context.Request.RawUrl.Contains("?"))
     {
         resultModel = MediaHelper.GetMediaFile(filePath, container, context.Request.RawUrl);
     }
     else
     {
         resultModel = MediaHelper.GetMediaFile(filePath, container);
     }
     if (resultModel.RedirectToAzureStorage)
     {
         context.Response.Redirect(filePath.Replace($"/{container}", $"{ConfigurationManager.AppSettings["BlobStorage"]}/{container}"), true);
     }
     var myTimeSpan = new TimeSpan(7, 0, 0, 0);
     context.Response.Cache.SetCacheability(HttpCacheability.Public);
     context.Response.Cache.SetValidUntilExpires(true);
     context.Response.Cache.SetMaxAge(myTimeSpan);
     context.Response.Cache.SetLastModified(resultModel.LastModifiedDate);
     context.Response.Cache.SetETag(resultModel.ETag.Replace("\\\"", ""));
     context.Response.AddHeader("Content-MD5", resultModel.ContentMd5);
     context.Response.ContentType = resultModel.ContentType;
     // replicate properties returned by blob storage
     context.Response.AddHeader("Server", "Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0");
     context.Response.AddHeader("x-ms-request-id", Guid.NewGuid().ToString());
     context.Response.AddHeader("x-ms-version", "2009-09-19");
     context.Response.AddHeader("x-ms-lease-status", "unlocked");
     context.Response.AddHeader("x-ms-blob-type", "BlockBlob");
     context.Response.OutputStream.Write(resultModel.ImageData, 0, resultModel.ImageData.Length);
     context.Response.AddHeader("Content-Length", resultModel.ImageData.Length.ToString());
     context.Response.Flush();
     context.Response.End();
 }

 /// <summary>
 /// Datetime转Json时间，datetime - 1970.1.1
 /// </summary>
 /// <param name="dt"></param>
 /// <returns></returns>
 public static int UnixTicks(DateTime dt)
 {
     DateTime d1 = new DateTime(1970, 1, 1);
     DateTime d2 = dt.ToUniversalTime();
     TimeSpan ts = new TimeSpan(d2.Ticks - d1.Ticks);
     return (int)ts.TotalSeconds;
 }

 public void StartCountdown(int hours, int minutes, int seconds, Action callback)
 {
     countFrom = new TimeSpan(hours, minutes, seconds);
     stopWatch = new Stopwatch();
     cb = callback;
     stopWatch.Start();
 }

        /// <summary>
        ///   Calculates the position of this vessel at some future universal timestamp,
        ///   taking into account all currently predicted SOI transition patches, and also
        ///   assuming that all the planned maneuver nodes will actually be executed precisely
        ///   as planned.  Note that this cannot "see" into the future any farther than the
        ///   KSP orbit patches setting allows for.
        /// </summary>
        /// <param name="timeStamp">The time to predict for.  Although the intention is to
        ///   predict for a future time, it could be used to predict for a past time.</param>
        /// <returns>The position as a user-readable Vector in Shared.Vessel-origin raw rotation coordinates.</returns>
        override public Vector GetPositionAtUT(TimeSpan timeStamp)
        {
            string blockingTech;
            if (!Career.CanMakeNodes(out blockingTech))
                throw new KOSLowTechException("use POSITIONAT on a vessel", blockingTech);

            double desiredUT = timeStamp.ToUnixStyleTime();

            Orbit patch = GetOrbitAtUT(desiredUT);
            Vector3d pos = patch.getPositionAtUT(desiredUT);

            // This is an ugly workaround to fix what is probably a bug in KSP's API:
            // If looking at a future orbit patch around a child body of the current body, then
            // the various get{Thingy}AtUT() methods return numbers calculated incorrectly as
            // if the child body was going to remain stationary where it is now, rather than
            // taking into account where it will be later when the intercept happens.
            // This corrects for that case:
            if (Utils.BodyOrbitsBody(patch.referenceBody, Vessel.orbit.referenceBody))
            {
                Vector3d futureSOIPosNow = patch.referenceBody.position;
                Vector3d futureSOIPosLater = patch.referenceBody.getPositionAtUT(desiredUT);
                Vector3d offset = futureSOIPosLater - futureSOIPosNow;
                pos = pos + offset;
            }

            return new Vector(pos - Shared.Vessel.findWorldCenterOfMass()); // Convert to ship-centered frame.
        }

		public RetryConditionHeaderValue (TimeSpan delta)
		{
			if (delta.TotalSeconds > uint.MaxValue)
				throw new ArgumentOutOfRangeException ("delta");

			Delta = delta;
		}

        public bool EnterAsync(TimeSpan timeout, FastAsyncCallback callback, object state)
        {
            Fx.Assert(callback != null, "must have a non-null call back for async purposes");

            AsyncWaitHandle waiter = null;

            lock (this.ThisLock)
            {
                if (this.aborted)
                {
                    throw Fx.Exception.AsError(CreateObjectAbortedException());
                }

                if (this.count < this.maxCount)
                {
                    this.count++;
                    return true;
                }

                waiter = new AsyncWaitHandle();
                this.Waiters.Enqueue(waiter);
            }

            return waiter.WaitAsync(EnteredAsyncCallback, new EnterAsyncData(this, waiter, callback, state), timeout);
        }

 public bool TryAcquire(TimeSpan timeout)
 {
     long tm = (long)timeout.TotalMilliseconds;
     if (tm < -1 || tm > (long)Int32.MaxValue)
         throw new ArgumentOutOfRangeException("timeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
     return TryAcquire((int)tm);
 }

    public bool NegTest1()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("NegTest1: ArgumentOutOfRangeException should be thrown when The parameters specify a TimeSpan value less than MinValue");

        try
        {
            TimeSpan ts = new TimeSpan(Int32.MinValue, Int32.MinValue, Int32.MinValue, Int32.MinValue, Int32.MinValue);

            TestLibrary.TestFramework.LogError("101.1", "ArgumentOutOfRangeException is not thrown when The parameters specify a TimeSpan value less than MinValue");
            retVal = false;
        }
        catch (ArgumentOutOfRangeException)
        {
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("101.0", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

 public static string NormalizeTimpstamp0(long timpStamp)
 {
     long unixTime = timpStamp * 10000000L;
     TimeSpan toNow = new TimeSpan(unixTime);
     DateTime dt = dtStart.Add(toNow);
     return dt.ToString("yyyy-MM-dd");
 }

 // Default constructor. If a derived class does not invoke a base-
 // class constructor explicitly, the default constructor is called
 // implicitly.
 public WorkItem()
 {
     ID = 0;
             Title = "Default title";
             Description = "Default description.";
             jobLength = new TimeSpan();
 }

        private void SetTimerCountDownText(TimeSpan timeLeft)
        {
            var minutes = timeLeft.Minutes.ToString();
            var seconds = (timeLeft.Seconds < 10) ? "0" + timeLeft.Seconds : timeLeft.Seconds.ToString();

            txtTimerCountDown.Text = minutes + ":" + seconds;
        }

    static void Main(string[] args)
    {
        Console.Title = "Date and time after 6 hours and 30 minutes";

        Thread.CurrentThread.CurrentCulture = new CultureInfo("bg-BG");
        
        Console.ForegroundColor = ConsoleColor.Green;
        Console.Write("Enter a date and time: ");
        string dateAndTime = Console.ReadLine();

        try
        {
            DateTime date = DateTime.ParseExact(dateAndTime, "dd.MM.yyyy HH:mm:ss", CultureInfo.InvariantCulture);

            TimeSpan after = new TimeSpan(6, 30, 0);
            date = date.Add(after);

            Console.ForegroundColor = ConsoleColor.Magenta;
            Console.WriteLine("\nThe date after 6 hours and 30 minutes is: {0} {1:dd.MM.yyyy hh:mm:ss}", date.ToString("dddd"), date);
        }
        catch (FormatException)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("\nYou have entered a wrong date or time!!!");
        }
        finally
        {
            Console.WriteLine();
            Console.ResetColor();
        }
    }

    public bool PosTest1()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest1: Call Duration on a TimeSpan instance whose value is 0");

        try
        {
            TimeSpan expected = new TimeSpan(0);
            TimeSpan actual = expected.Duration();

            if (actual.Ticks != expected.Ticks)
            {
                TestLibrary.TestFramework.LogError("001.1", "Calling Duration on a TimeSpan instance whose value is 0");
                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual.Ticks = " + actual.Ticks + ", expected.Ticks = " + expected.Ticks);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

        public OpenCollectionAsyncResult(TimeSpan timeout, AsyncCallback otherCallback, object state, IList<ICommunicationObject> collection)
            : base(otherCallback, state)
        {
            _timeoutHelper = new TimeoutHelper(timeout);
            _completedSynchronously = true;

            _count = collection.Count;
            if (_count == 0)
            {
                Complete(true);
                return;
            }

            for (int index = 0; index < collection.Count; index++)
            {
                // Throw exception if there was a failure calling EndOpen in the callback (skips remaining items)
                if (_exception != null)
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(_exception);
                CallbackState callbackState = new CallbackState(this, collection[index]);
                IAsyncResult result = collection[index].BeginOpen(_timeoutHelper.RemainingTime(), s_nestedCallback, callbackState);
                if (result.CompletedSynchronously)
                {
                    collection[index].EndOpen(result);
                    Decrement(true);
                }
            }
        }

    public bool PosTest2()
    {
        bool retVal = true;
        long randValue = 0;

        TestLibrary.TestFramework.BeginScenario("PosTest2: Call Duration on a TimeSpan instance whose value is a positive value");

        try
        {
            do
            {
                randValue = TestLibrary.Generator.GetInt64(-55);
            } while (randValue == 0);
            if (randValue < 0) randValue *= -1;

            TimeSpan expected = new TimeSpan(randValue);
            TimeSpan actual = expected.Duration();

            if (actual.Ticks != expected.Ticks)
            {
                TestLibrary.TestFramework.LogError("002.1", "Calling Duration on a TimeSpan instance whose value is a positive value");
                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] actual.Ticks = " + actual.Ticks + ", expected.Ticks = " + expected.Ticks + ", randValue = " + randValue);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLE] randValue = " + randValue);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    private SceneManager()
    {
        mUpdateCallback = new EditorApplication.CallbackFunction(EditorUpdate);
        if (EditorApplication.update == null)
        {
            EditorApplication.update += mUpdateCallback;
        }
        else if (!EditorApplication.update.Equals(mUpdateCallback))
        {
            EditorApplication.update += mUpdateCallback;
        }

        mRefreshThreshold = new TimeSpan(0, 0, 0, SECONDS_TO_WAIT, 0);

        // We force a config.xml read operation before the SceneManager is used
        // to avoid inconsistencies on Unity startup.
        mDoDeserialization = true;

        // Make sure that the scene is initialized whenever a new instance of
        // the SceneManager is created.
        mSceneInitialized = false;

        // Unity does not allow to store global editor settings in a comfortable
        // way so we store them in a file.
        ReadProperties();
    }

 public Task<HttpListenerWebSocketContext> AcceptWebSocketAsync(string subProtocol,
     int receiveBufferSize,
     TimeSpan keepAliveInterval,
     ArraySegment<byte> internalBuffer)
 {
     throw new PlatformNotSupportedException();
 }

        public UserLoginSession(string sessionID, long id, TimeSpan sessionTimeout)
        {
            SessionID = sessionID;
            Id = id;

            SessionTimeout = sessionTimeout;
        }