Réponses:
Vous ne pouvez pas modifier une valeur DateTime - elle est immuable. Cependant, vous pouvez modifier la variable pour avoir une nouvelle valeur. La façon la plus simple de le faire pour modifier uniquement l'heure est de créer un TimeSpan avec l'heure appropriée et d'utiliser la propriété DateTime.Date:
DateTime s = ...;
TimeSpan ts = new TimeSpan(10, 30, 0);
s = s.Date + ts;
s
sera désormais la même date, mais à 10h30.
Notez que DateTime
ne tient pas compte des transitions d'heure d'été, représentant l'heure grégorienne «naïve» dans les deux sens (voir la section Remarques dans la DateTime
documentation ). Les seules exceptions sont .Now
et .Today
: elles récupèrent l'heure système actuelle qui reflète ces événements lorsqu'ils se produisent.
C'est le genre de chose qui m'a motivé à démarrer le projet Noda Time , qui est maintenant prêt pour la production. Son ZonedDateTime
type est rendu "conscient" en le liant à une tz
entrée de base de données .
Add
fournissant un intervalle de temps nul? Votre expression est équivalente s.Date
, mais plus longue ...
DateTime
s, (un pour la date et un pour l'heure), vous pouvez le faire:var result = date.Date + time.TimeOfDay;
time
ne devrait pas l'être DateTime
. (J'utiliserais Noda Time bien sûr, mais ...)
D'accord, je plonge avec ma suggestion, une méthode d'extension:
public static DateTime ChangeTime(this DateTime dateTime, int hours, int minutes, int seconds, int milliseconds)
{
return new DateTime(
dateTime.Year,
dateTime.Month,
dateTime.Day,
hours,
minutes,
seconds,
milliseconds,
dateTime.Kind);
}
Appelez ensuite:
DateTime myDate = DateTime.Now.ChangeTime(10,10,10,0);
Il est important de noter que cette extension renvoie un nouvel objet date, vous ne pouvez donc pas le faire:
DateTime myDate = DateTime.Now;
myDate.ChangeTime(10,10,10,0);
Mais vous pouvez le faire:
DateTime myDate = DateTime.Now;
myDate = myDate.ChangeTime(10,10,10,0);
Datetime.Today.Add(time.TimeOfDay)
. En effet, en interne, le constructeur n'effectue aucune correction basée sur le calendrier, à l'exception de la comptabilisation d'une année bissextile pour la partie date. C'est à dire DateTime
une implémentation "naïve" en termes de datetime
module de Python .
s = s.Date.AddHours(x).AddMinutes(y).AddSeconds(z);
De cette façon, vous conservez votre date, tout en insérant une nouvelle partie heures, minutes et secondes à votre convenance.
.AddMilliseconds()
si nécessaire.
bon mot
var date = DateTime.Now.Date.Add(new TimeSpan(4, 30, 0));
ramènerait la date d'aujourd'hui avec une heure de 4:30:00, remplacer DateTime.Now par n'importe quel objet de date
DateTime est un type immuable, vous ne pouvez donc pas changer .
Cependant, vous pouvez créer une nouvelle instance DateTime basée sur votre instance précédente. Dans votre cas, il semble que vous ayez besoin de la propriété Date, et vous pouvez ensuite ajouter un TimeSpan qui représente l'heure de la journée.
Quelque chose comme ça:
var newDt = s.Date + TimeSpan.FromHours(2);
Si l'heure est déjà stockée dans un autre DateTime
objet, vous pouvez utiliser la Add
méthode.
DateTime dateToUse = DateTime.Now();
DateTime timeToUse = new DateTime(2012, 2, 4, 10, 15, 30); //10:15:30 AM
DateTime dateWithRightTime = dateToUse.Date.Add(timeToUse.TimeOfDay);
La TimeOfDay
propriété est un TimeSpan
objet et peut être transmise à la Add
méthode. Et puisque nous utilisons la Date
propriété de la dateToUse
variable, nous obtenons juste la date et ajoutons l'intervalle de temps.
Solution la plus simple:
DateTime s = //some Datetime that you want to change time for 8:36:44 ;
s = new DateTime(s.Year, s.Month, s.Day, 8, 36, 44);
Et si vous avez besoin d'un format de date et d'heure spécifique:
s = new DateTime(s.Year, s.Month, s.Day, 8, 36, 44).ToString("yyyy-MM-dd h:mm:ss");
Je suis arrivé à ce poste alors que je cherchais la même fonctionnalité, cela pourrait éventuellement faire ce que le gars voulait. Prenez la date d'origine et remplacez la partie heure
DateTime dayOpen = DateTime.Parse(processDay.ToShortDateString() + " 05:00 AM");
Étant donné qu'il DateTime
est immuable, une nouvelle instance doit être créée lorsqu'un composant de date doit être modifié. Malheureusement, il n'y a pas de fonctionnalité intégrée pour définir les composants individuels d'unDateTime
instance.
Utilisation des méthodes d'extension suivantes
public static DateTime SetPart(this DateTime dateTime, int? year, int? month, int? day, int? hour, int? minute, int? second)
{
return new DateTime(
year ?? dateTime.Year,
month ?? dateTime.Month,
day ?? dateTime.Day,
hour ?? dateTime.Hour,
minute ?? dateTime.Minute,
second ?? dateTime.Second
);
}
public static DateTime SetYear(this DateTime dateTime, int year)
{
return dateTime.SetPart(year, null, null, null, null, null);
}
public static DateTime SetMonth(this DateTime dateTime, int month)
{
return dateTime.SetPart(null, month, null, null, null, null);
}
public static DateTime SetDay(this DateTime dateTime, int day)
{
return dateTime.SetPart(null, null, day, null, null, null);
}
public static DateTime SetHour(this DateTime dateTime, int hour)
{
return dateTime.SetPart(null, null, null, hour, null, null);
}
public static DateTime SetMinute(this DateTime dateTime, int minute)
{
return dateTime.SetPart(null, null, null, null, minute, null);
}
public static DateTime SetSecond(this DateTime dateTime, int second)
{
return dateTime.SetPart(null, null, null, null, null, second);
}
vous pouvez définir des DateTime
composants individuels comme
var now = DateTime.Now;
now.SetSecond(0);
Si vous avez un DateTime comme 2014/02/05 18:19:51 et que vous voulez juste 2014/02/05, vous pouvez le faire:
_yourDateTime = new DateTime(_yourDateTime.Year, _yourDateTime.Month, _yourDateTime.Day)
L'ajout de .Date à votre date la définit à minuit (00:00).
MyDate.Date
Remarque Le SQL équivaval estCONVERT(DATETIME, CONVERT(DATE, @MyDate))
Ce qui rend cette méthode si bonne, c'est qu'elle est à la fois rapide à taper et facile à lire. Un bonus est qu'il n'y a pas de conversion à partir de chaînes.
C'est-à-dire pour régler la date d'aujourd'hui à 23h30, utilisez:
DateTime.Now.Date.AddHours(23).AddMinutes(30)
Vous pouvez bien sûr remplacer DateTime.Now ou MyDate par la date de votre choix.
En fait, vous ne pouvez pas changer l'heure une fois créée. Mais vous pouvez le créer facilement avec de nombreux constructeurs: https://docs.microsoft.com/en-us/dotnet/api/system.datetime.-ctor?view=netframework-4.7.2
Par exemple, si vous voulez créer une seconde de changement de DateTime, vous pouvez simplement faire ceci:
DateTime now = DateTime.Now;
DateTime secondschanged = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, yourseconds);
int year = 2012;
int month = 12;
int day = 24;
int hour = 0;
int min = 0;
int second = 23;
DateTime dt = new DateTime(year, month, day, hour, min, second);
Utilisez Date.Add
et ajoutez un New TimeSpan
avec la nouvelle heure que vous souhaitez ajouter
DateTime dt = DateTime.Now
dt.Date.Add(new TimeSpan(12,15,00))
Lorsque vous construisez votre DateTime
objet, utilisez un constructeur qui vous permet de spécifier l'heure:
var myDateTime = new DateTime(2000, 01, 01, 13, 37, 42); // 2000-01-01 13:37:42
Si vous avez déjà un DateTime
objet et souhaitez changer l'heure, vous pouvez ajouter des minutes, des heures ou des secondes à votre en DateTime
utilisant des méthodes simples:
var myDateTime = new DateTime(2000, 01, 01); // 2000-01-01 00:00:00
myDateTime = myDateTime.AddHours(13); // 2000-01-01 13:00:00
myDateTime = myDateTime.AddMinutes(37); // 2000-01-01 13:37:00
myDateTime = myDateTime.AddSecounds(42); // 2000-01-01 13:37:42
Remarquez comment nous devons «enregistrer» le résultat de chaque appel de méthode à la myDateTime
variable. En effet, le DateTime
est immuable et ses méthodes créent simplement de nouvelles instances avec les heures / minutes / secondes supplémentaires ajoutées.
Si vous devez ajouter à la fois des heures et des minutes (et / ou des secondes), vous pouvez simplifier le code en ajoutant un TimeSpan
à l'original à la DateTime
place:
var myDateTime = new DateTime(2000, 01, 01); // 2000-01-01 00:00:00
myDateTime += new TimeSpan(13, 37, 42); // 2000-01-01 13:37:42
Si vous souhaitez définir des heures / minutes / secondes absolues, plutôt que d'ajouter aux valeurs existantes, vous pouvez utiliser le DateTime
constructeur susmentionné et réutiliser les valeurs pour l'année / mois / jour antérieures:
myDateTime = new DateTime(myDateTime.Year, myDateTime.Month, myDateTime.Day,
20, 33, 19) // 2000-01-01 20:33:19
Voici une méthode que vous pourriez utiliser pour le faire pour vous, utilisez-la comme ceci
DateTime newDataTime = ChangeDateTimePart(oldDateTime, DateTimePart.Seconds, 0);
Voici la méthode, il y a probablement une meilleure façon, mais je viens de préparer ceci:
public enum DateTimePart { Years, Months, Days, Hours, Minutes, Seconds };
public DateTime ChangeDateTimePart(DateTime dt, DateTimePart part, int newValue)
{
return new DateTime(
part == DateTimePart.Years ? newValue : dt.Year,
part == DateTimePart.Months ? newValue : dt.Month,
part == DateTimePart.Days ? newValue : dt.Day,
part == DateTimePart.Hours ? newValue : dt.Hour,
part == DateTimePart.Minutes ? newValue : dt.Minute,
part == DateTimePart.Seconds ? newValue : dt.Second
);
}
Je viens de rencontrer ce message parce que j'avais un problème similaire où je voulais définir l'heure pour un objet Entity Framework dans MVC qui obtient la date à partir d'une vue (datepicker) de sorte que le composant heure est 00:00:00 mais j'ai besoin ce sera l'heure actuelle. Sur la base des réponses dans ce post, j'ai trouvé:
myEntity.FromDate += DateTime.Now.TimeOfDay;
//The fastest way to copy time
DateTime justDate = new DateTime(2011, 1, 1); // 1/1/2011 12:00:00AM the date you will be adding time to, time ticks = 0
DateTime timeSource = new DateTime(1999, 2, 4, 10, 15, 30); // 2/4/1999 10:15:30AM - time tick = x
justDate = new DateTime(justDate.Date.Ticks + timeSource.TimeOfDay.Ticks);
Console.WriteLine(justDate); // 1/1/2011 10:15:30AM
Console.Read();
Vous pouvez attribuer une valeur initiale à une nouvelle DateTime
valeur de différentes manières:
Méthode d'extension DateTime
public static DateTime ChangeTime(this DateTime dateTime, int hours, int minutes, int seconds = default, int milliseconds = default)
{
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, hours, minutes, seconds, milliseconds, dateTime.Kind);
}
puis en utilisant ChangeTime
:
DateTime datetime = DateTime.Now; //Your DateTime
datetime = datetime.ChangeTime(12, 20, 10);
en utilisant les méthodes Add
DateTime datetime = DateTime.Now; //Your DateTime
datetime = datetime.Date.AddHours(12).AddMinutes(20).AddSeconds(10);
en utilisant le Timespan
DateTime datetime = DateTime.Now; //Your DateTime
datetime = datetime.Date.Add(new TimeSpan(12, 20, 10));
en utilisant la valeur initiale
DateTime datetime = DateTime.Now;
datetime = new DateTime(datetime.Year, datetime.Month, datetime.Day, 12, 20, 10);
Quel est le problème avec la méthode DateTime.AddSeconds où vous pouvez ajouter ou soustraire des secondes?
DateTime s;
//s = datevalue
s = s.AddMilliseconds(10);
s = s.AddMinutes(10);
s = s.AddSeconds(10);
s = s.AddHours(10);
vous pouvez ajouter des valeurs + ve / -ve dans le paramètre.
s.Add(new TimeSpan(1, 1, 1));
Cela ne résout-il pas vos problèmes ??
Dateime dt = DateTime.Now;
dt = dt.AddSeconds(10);
Using an extencion to DateTime:
public enum eTimeFragment
{
hours,
minutes,
seconds,
milliseconds
}
public static DateTime ClearTimeFrom(this DateTime dateToClear, eTimeFragment etf)
{
DateTime dtRet = dateToClear;
switch (etf)
{
case eTimeFragment.hours:
dtRet = dateToClear.Date;
break;
case eTimeFragment.minutes:
dtRet = dateToClear.AddMinutes(dateToClear.Minute * -1);
dtRet = dtRet.ClearTimeFrom(eTimeFragment.seconds);
break;
case eTimeFragment.seconds:
dtRet = dateToClear.AddSeconds(dateToClear.Second * -1);
dtRet = dtRet.ClearTimeFrom(eTimeFragment.milliseconds);
break;
case eTimeFragment.milliseconds:
dtRet = dateToClear.AddMilliseconds(dateToClear.Millisecond * -1);
break;
}
return dtRet;
}
Utilisez comme ceci:
Console.WriteLine (DateTime.Now.ClearTimeFrom (eTimeFragment.hours))
cela doit retourner: 2016-06-06 00: 00: 00.000
La meilleure solution est:
currdate.AddMilliseconds(currdate.Millisecond * -1).AddSeconds(currdate.Second * -1).AddMinutes(currdate.Minute * -1).AddHours(currdate.Hour * -1);
voici une façon ghetto, mais ça marche :)
DateTime dt = DateTime.Now; //get a DateTime variable for the example
string newSecondsValue = "00";
dt = Convert.ToDateTime(dt.ToString("MM/dd/yyyy hh:mm:" + newSecondsValue));
dt.AddSeconds(0-dt.Seconds).AddSeconds(newSecondsValue)
mais je ne le recommanderais pas.