Set System Time Zone from .NET
I don't know if this is what you are looking for, but there is some information on how to use the Win32 functions to get and set the timezone information at
http://www.pinvoke.net/default.aspx/kernel32/GetTimeZoneInformation.html
The main part of the following sample code is taken from this site. I just added a few more lines to actually call the GetTimeZone() method and fixed a small error in the access modifier of the SystemTime struct to make the sample work.
Hope this helps...
using System;
using System.Runtime.InteropServices;
namespace Stackoverflow
{
class TimeZoneFunctionality
{
/// <summary>
/// [Win32 API call]
/// The GetTimeZoneInformation function retrieves the current time-zone parameters.
/// These parameters control the translations between Coordinated Universal Time (UTC)
/// and local time.
/// </summary>
/// <param name="lpTimeZoneInformation">[out] Pointer to a TIME_ZONE_INFORMATION structure to receive the current time-zone parameters.</param>
/// <returns>
/// If the function succeeds, the return value is one of the following values.
/// <list type="table">
/// <listheader>
/// <term>Return code/value</term>
/// <description>Description</description>
/// </listheader>
/// <item>
/// <term>TIME_ZONE_ID_UNKNOWN == 0</term>
/// <description>
/// The system cannot determine the current time zone. This error is also returned if you call the SetTimeZoneInformation function and supply the bias values but no transition dates.
/// This value is returned if daylight saving time is not used in the current time zone, because there are no transition dates.
/// </description>
/// </item>
/// <item>
/// <term>TIME_ZONE_ID_STANDARD == 1</term>
/// <description>
/// The system is operating in the range covered by the StandardDate member of the TIME_ZONE_INFORMATION structure.
/// </description>
/// </item>
/// <item>
/// <term>TIME_ZONE_ID_DAYLIGHT == 2</term>
/// <description>
/// The system is operating in the range covered by the DaylightDate member of the TIME_ZONE_INFORMATION structure.
/// </description>
/// </item>
/// </list>
/// If the function fails, the return value is TIME_ZONE_ID_INVALID. To get extended error information, call GetLastError.
/// </returns>
[DllImport( "kernel32.dll", CharSet = CharSet.Auto )]
private static extern int GetTimeZoneInformation( out TimeZoneInformation lpTimeZoneInformation );
/// <summary>
/// [Win32 API call]
/// The SetTimeZoneInformation function sets the current time-zone parameters.
/// These parameters control translations from Coordinated Universal Time (UTC)
/// to local time.
/// </summary>
/// <param name="lpTimeZoneInformation">[in] Pointer to a TIME_ZONE_INFORMATION structure that contains the time-zone parameters to set.</param>
/// <returns>
/// If the function succeeds, the return value is nonzero.
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
/// </returns>
[DllImport( "kernel32.dll", CharSet = CharSet.Auto )]
private static extern bool SetTimeZoneInformation( [In] ref TimeZoneInformation lpTimeZoneInformation );
/// <summary>
/// The SystemTime structure represents a date and time using individual members
/// for the month, day, year, weekday, hour, minute, second, and millisecond.
/// </summary>
[StructLayoutAttribute( LayoutKind.Sequential )]
public struct SystemTime
{
public short year;
public short month;
public short dayOfWeek;
public short day;
public short hour;
public short minute;
public short second;
public short milliseconds;
}
/// <summary>
/// The TimeZoneInformation structure specifies information specific to the time zone.
/// </summary>
[StructLayout( LayoutKind.Sequential, CharSet = CharSet.Unicode )]
public struct TimeZoneInformation
{
/// <summary>
/// Current bias for local time translation on this computer, in minutes. The bias is the difference, in minutes, between Coordinated Universal Time (UTC) and local time. All translations between UTC and local time are based on the following formula:
/// <para>UTC = local time + bias</para>
/// <para>This member is required.</para>
/// </summary>
public int bias;
/// <summary>
/// Pointer to a null-terminated string associated with standard time. For example, "EST" could indicate Eastern Standard Time. The string will be returned unchanged by the GetTimeZoneInformation function. This string can be empty.
/// </summary>
[MarshalAs( UnmanagedType.ByValTStr, SizeConst = 32 )]
public string standardName;
/// <summary>
/// A SystemTime structure that contains a date and local time when the transition from daylight saving time to standard time occurs on this operating system. If the time zone does not support daylight saving time or if the caller needs to disable daylight saving time, the wMonth member in the SystemTime structure must be zero. If this date is specified, the DaylightDate value in the TimeZoneInformation structure must also be specified. Otherwise, the system assumes the time zone data is invalid and no changes will be applied.
/// <para>To select the correct day in the month, set the wYear member to zero, the wHour and wMinute members to the transition time, the wDayOfWeek member to the appropriate weekday, and the wDay member to indicate the occurence of the day of the week within the month (first through fifth).</para>
/// <para>Using this notation, specify the 2:00a.m. on the first Sunday in April as follows: wHour = 2, wMonth = 4, wDayOfWeek = 0, wDay = 1. Specify 2:00a.m. on the last Thursday in October as follows: wHour = 2, wMonth = 10, wDayOfWeek = 4, wDay = 5.</para>
/// </summary>
public SystemTime standardDate;
/// <summary>
/// Bias value to be used during local time translations that occur during standard time. This member is ignored if a value for the StandardDate member is not supplied.
/// <para>This value is added to the value of the Bias member to form the bias used during standard time. In most time zones, the value of this member is zero.</para>
/// </summary>
public int standardBias;
/// <summary>
/// Pointer to a null-terminated string associated with daylight saving time. For example, "PDT" could indicate Pacific Daylight Time. The string will be returned unchanged by the GetTimeZoneInformation function. This string can be empty.
/// </summary>
[MarshalAs( UnmanagedType.ByValTStr, SizeConst = 32 )]
public string daylightName;
/// <summary>
/// A SystemTime structure that contains a date and local time when the transition from standard time to daylight saving time occurs on this operating system. If the time zone does not support daylight saving time or if the caller needs to disable daylight saving time, the wMonth member in the SystemTime structure must be zero. If this date is specified, the StandardDate value in the TimeZoneInformation structure must also be specified. Otherwise, the system assumes the time zone data is invalid and no changes will be applied.
/// <para>To select the correct day in the month, set the wYear member to zero, the wHour and wMinute members to the transition time, the wDayOfWeek member to the appropriate weekday, and the wDay member to indicate the occurence of the day of the week within the month (first through fifth).</para>
/// </summary>
public SystemTime daylightDate;
/// <summary>
/// Bias value to be used during local time translations that occur during daylight saving time. This member is ignored if a value for the DaylightDate member is not supplied.
/// <para>This value is added to the value of the Bias member to form the bias used during daylight saving time. In most time zones, the value of this member is –60.</para>
/// </summary>
public int daylightBias;
}
/// <summary>
/// Sets new time-zone information for the local system.
/// </summary>
/// <param name="tzi">Struct containing the time-zone parameters to set.</param>
public static void SetTimeZone( TimeZoneInformation tzi )
{
// set local system timezone
SetTimeZoneInformation( ref tzi );
}
/// <summary>
/// Gets current timezone information for the local system.
/// </summary>
/// <returns>Struct containing the current time-zone parameters.</returns>
public static TimeZoneInformation GetTimeZone()
{
// create struct instance
TimeZoneInformation tzi;
// retrieve timezone info
int currentTimeZone = GetTimeZoneInformation( out tzi );
return tzi;
}
/// <summary>
/// Oversimplyfied method to test the GetTimeZone functionality
/// </summary>
/// <param name="args">the usual stuff</param>
static void Main( string[] args )
{
TimeZoneInformation timeZoneInformation = GetTimeZone();
return;
}
}
}
Before setting the time zone information you will need to ensure that the process has the appropriate privileges. As noted on the MSDN page for SetTimeZoneInformation:
An application must have the SE_TIME_ZONE_NAME privilege for this
function to succeed. This privilege is disabled by default.
Here is some sample code to enable this privilege:
public class AdjustTokenPrivilegesFunctionality
{
[StructLayout(LayoutKind.Sequential)]
private struct LUID
{
public uint LowPart;
public int HighPart;
}
[StructLayout(LayoutKind.Sequential)]
private struct LUID_AND_ATTRIBUTES
{
public LUID Luid;
public UInt32 Attributes;
}
private struct TOKEN_PRIVILEGES
{
public UInt32 PrivilegeCount;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public LUID_AND_ATTRIBUTES[] Privileges;
}
public const string SE_TIME_ZONE_NAME = "SeTimeZonePrivilege";
public const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
public const int TOKEN_QUERY = 0x00000008;
public const int SE_PRIVILEGE_ENABLED = 0x00000002;
[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool AdjustTokenPrivileges(IntPtr TokenHandle, bool DisableAllPrivileges, ref TOKEN_PRIVILEGES NewState, UInt32 Zero, IntPtr Null1, IntPtr Null2);
[DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
private static extern int OpenProcessToken(int ProcessHandle, int DesiredAccess, out IntPtr tokenhandle);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
private static extern int GetCurrentProcess();
[DllImport("advapi32.dll", CharSet = CharSet.Auto)]
private static extern int LookupPrivilegeValue(string lpsystemname, string lpname, [MarshalAs(UnmanagedType.Struct)] ref LUID lpLuid);
static void EnableSetTimeZonePrivileges()
{
// We must add the set timezone privilege to the process token or SetTimeZoneInformation will fail
IntPtr token;
int retval = OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, out token);
Assert.IsTrue(retval != 0, String.Format("OpenProcessToken failed. GetLastError: {0}", Marshal.GetLastWin32Error()));
LUID luid = new LUID();
retval = LookupPrivilegeValue(null, SE_TIME_ZONE_NAME, ref luid);
Assert.IsTrue(retval != 0, String.Format("LookupPrivilegeValue failed. GetLastError: {0}", Marshal.GetLastWin32Error()));
TOKEN_PRIVILEGES tokenPrivs = new TOKEN_PRIVILEGES();
tokenPrivs.PrivilegeCount = 1;
tokenPrivs.Privileges = new LUID_AND_ATTRIBUTES[1];
tokenPrivs.Privileges[0].Luid = luid;
tokenPrivs.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
Assert.IsTrue(AdjustTokenPrivileges(token, false, ref tokenPrivs, 0, IntPtr.Zero, IntPtr.Zero), String.Format("AdjustTokenPrivileges failed. GetLastError: {0}", Marshal.GetLastWin32Error()));
}
}
How to change default timezone c#
DateTime utcTime = DateTime.UtcNow;
string zoneID = CurrentUserSession.TimeZoneID // Here you get the current login user session and their TimeZone which you configured in database at the time of user creation. or if you want to get client pc time zone then you have to use javascript and get client pc Timezone
TimeZoneInfo myZone = TimeZoneInfo.FindSystemTimeZoneById(zoneID);
DateTime custDateTime = TimeZoneInfo.ConvertTimeFromUtc(utcTime, myZone);
How to set a time zone (or a Kind) of a DateTime value?
While the DateTime.Kind property does not have a setter, the static method DateTime.SpecifyKind creates a DateTime instance with a specified value for Kind.
Altenatively there are several DateTime constructor overloads that take a DateTimeKind parameter
How to change time zone for an asp.net application
Sorry there is no way in .NET to change the time zone globally.
The only way you have is to change the timezone of your server or rewrite all of your code.
The best practice is to not rely on the system time zone at all (never use DateTime.Now).
You should handle all date as Utc dates and then convert to a specific zone when displaying them to users.
Even if you manage to handle timezones in your ASP.NET application, there are still timezones on SQL Server, for example GETTIME funtion. If your application is entirely written in UTC, your SQL server function will work as well.
How do I get local time in another timezone in dot net core
The IANA time zone ID for Sweden is "Europe/Stockholm" (for use on Linux, OSX, and other non-Windows platforms). The Windows time zone ID for Sweden is "W. Europe Standard Time".
Thus, you can do the following:
// Determine the time zone ID for Sweden
string timeZoneId = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
? "W. Europe Standard Time"
: "Europe/Stockholm";
// Get a TimeZoneInfo object for that time zone
TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
// Convert the current UTC time to the time in Sweden
DateTimeOffset currentTimeInSweden = TimeZoneInfo.ConvertTime(DateTimeOffset.UtcNow, tzi);
If desired, you can simplify this by using my TimeZoneConverter library, which allows you to use either id on any platform.
TimeZoneInfo tzi = TZConvert.GetTimeZoneInfo("Europe/Stockholm");
DateTimeOffset currentTimeInSweden = TimeZoneInfo.ConvertTime(DateTimeOffset.UtcNow, tzi);
If running on .NET 6 or newer, and you have ICU globalization support enabled, you no longer need to use my library. .NET will automatically convert from one format to the other if needed. So you can just do:
TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById("Europe/Stockholm");
DateTimeOffset currentTimeInSweden = TimeZoneInfo.ConvertTime(DateTimeOffset.UtcNow, tzi);
Also note that the time zone where the code is running is not relevant, nor should it be. The daylight savings rules of Sweden are the only that are relevant, not those of the time zone where the code might be running in.
Lastly, note that the computer's clock must be set correctly if you expect to get a valid result. Always synchronize your computer's clock to the Internet by using NTP or your OS's "Set date and time automatically" feature.
Application does not see system time zone changes until restarted
Take a look at the documentation for that property:
http://msdn.microsoft.com/en-us/library/system.timezone.currenttimezone(v=vs.110).aspx
Local time zone data is cached after CurrentTimeZone is first used to retrieve time zone information. If the system's local time zone subsequently changes, the CurrentTimeZone property does not reflect this change. If you need to handle time zone changes while your application is running, use the TimeZoneInfo class and call its TimeZoneInfo.ClearCachedData method.
TimeZoneInfo local = TimeZoneInfo.Local;
TimeZoneInfo.ClearCachedData();
local = TimeZoneInfo.Local; //updated local time zone info
Related Topics
Linq to Xml - Update/Alter the Nodes of an Xml Document
How to Use C# 8 with Visual Studio 2017
C# Datetimes: Conversion for Different Time Zones
Use Linq to Generate Direct Update Without Select
How to Change Pixel Color of an Image in C#.Net
In C# Why Can't a Conditional Operator Implicitly Cast to a Nullable Type
Get the Decimal Part from a Double
How to Translate a List<String> into a SQLparameter for a SQL in Statement
C#: How to Add Subitems in Listview
Authentication with Old Password No Longer Supported, Use 4.1 Style Passwords
Cannot Deserialize JSON Array into Type - JSON.Net
Print HTML Document from Windows Service Without Print Dialog
The Operation Cannot Be Completed Because the Dbcontext Has Been Disposed Using MVC 4
Should Idisposable.Dispose() Be Made Safe to Call Multiple Times
Alternative to Findmimefromdata Method in Urlmon.Dll One Which Has More Mime Types