Come rimuovere la parte dell'ora della data in C # solo nell'oggetto DateTime?

Devo rimuovere la parte dell'ora della data o probabilmente avere la data nel seguente formato nella objectforma non nella forma di string.

06/26/2009 00:00:00:000

Non riesco a utilizzare alcun stringmetodo di conversione poiché ho bisogno della data nel objectmodulo.

Ho provato prima a convertire il DateTimein a string, rimuovere la data specifica dell'ora da esso, ma si aggiunge 12:00:00 AMnon appena lo riconvertire DateTime objectnuovamente.

Usa la proprietà Date :

var dateAndTime = DateTime.Now;
var date = dateAndTime.Date;

La datevariabile conterrà la data, la parte temporale sarà 00:00:00.

È possibile utilizzare le stringhe di formato per assegnare alla stringa di output il formato desiderato.

DateTime dateAndTime = DateTime.Now;
Console.WriteLine(dateAndTime.ToString("dd/MM/yyyy")); // Will give you smth like 25/05/2011

Ulteriori informazioni sulle stringhe personalizzate di formato di data e ora .

Utilizzare il metodo ToShortDateString. Vedere la documentazione http://msdn.microsoft.com/en-us/library/system.datetime.toshortdatestring.aspx

var dateTimeNow = DateTime.Now; // Return 00/00/0000 00:00:00
var dateOnlyString = dateTimeNow.ToShortDateString(); //Return 00/00/0000

Dai un'occhiata alla proprietà DateTime.Date .

Ottiene il componente data di questa istanza.

La Dateproprietà restituirà la data a mezzanotte.

Un'opzione potrebbe essere quella di ottenere i singoli valori (giorno / mese / anno) separatamente e memorizzarli nel tipo desiderato.

var dateAndTime = DateTime.Now; 
int year = dateAndTime.Year;
int month = dateAndTime.Month;
int day = dateAndTime.Day;

string.Format("{0}/{1}/{2}", month, day, year);

Nessuna delle risposte sopra ha risolto il mio problema con Winforms.

il modo più semplice per raggiungere SOLO la data è la semplice funzione in Datetime:

DateTime dt = DateTime.now;
String BirthDate = dt.ToShortDateString();

Avrai solo la data nella stringa di compleanno.

Prova a creare la tua struttura per questo. L'oggetto DateTime avrà la data e l'ora entrambe

Non puoi. Un DateTime in .NET ha sempre un orario, il cui valore predefinito è 00: 00: 00: 000. La proprietà Date di un DateTime è anche un DateTime (!), Con un tempo predefinito anche su 00: 00: 00: 000.

Questa è una carenza di .NET Framework e si potrebbe sostenere che DateTime in .NET viola il principio di responsabilità singola .

DateTime.Date

var newDate = DateTime.Now; //newDate.Date property is date portion of DateTime

Ecco un altro metodo che utilizzaString.Format

    DateTime todaysDate = DateTime.UtcNow;

    string dateString = String.Format("{0:dd/MM/yyyy}", todaysDate);

    Console.WriteLine("Date with Time: "+ todaysDate.ToString());

    Console.WriteLine("Date Only : " + dateString);

Produzione:

Date with Time: 9/4/2016 11:42:16 AM

Date Only : 04/09/2016

Questo funziona anche se la data e l'ora sono archiviate nel database.

Per ulteriori informazioni sulla formattazione di data e ora, controlla questi link:

Riferimento 1

Riferimento 2

La speranza aiuta.

Questo modo di ottenere solo la data senza tempo

DateTime date = DateTime.Now;
string Strdateonly = date.ToString("d");

Uscita = 16/05/2015

Ho scritto una DateOnlystruttura. Questo utilizza un DateTime sotto la pelle ma nessuna parte del tempo viene esposta pubblicamente:

using System;

public struct DateOnly : IComparable, IFormattable, IComparable<DateOnly>, IEquatable<DateOnly>
{

    private DateTime _dateValue;

    public int CompareTo(object obj)
    {
        if (obj == null)
        {
            return 1;
        }

        DateOnly otherDateOnly = (DateOnly)obj;
        if (otherDateOnly != null)
        {
            return ToDateTime().CompareTo(otherDateOnly.ToDateTime());
        }
        else
        {
            throw new ArgumentException("Object is not a DateOnly");
        }
    }

    int IComparable<DateOnly>.CompareTo(DateOnly other)
    {
        return this.CompareToOfT(other);
    }
    public int CompareToOfT(DateOnly other)
    {
        // If other is not a valid object reference, this instance is greater.
        if (other == new DateOnly())
        {
            return 1;
        }
        return this.ToDateTime().CompareTo(other.ToDateTime());
    }

    bool IEquatable<DateOnly>.Equals(DateOnly other)
    {
        return this.EqualsOfT(other);
    }
    public bool EqualsOfT(DateOnly other)
    {
        if (other == new DateOnly())
        {
            return false;
        }

        if (this.Year == other.Year && this.Month == other.Month && this.Day == other.Day)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public static DateOnly Now()
    {
        return new DateOnly(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
    }

    public static bool TryParse(string s, ref DateOnly result)
    {
        DateTime dateValue = default(DateTime);
        if (DateTime.TryParse(s, out dateValue))
        {
            result = new DateOnly(dateValue.Year, dateValue.Month, dateValue.Day);
            return true;
        }
        else
        {
            return false;
        }
    }

    public static DateOnly Parse(string s)
    {
        DateTime dateValue = default(DateTime);
        dateValue = DateTime.Parse(s);
        return new DateOnly(dateValue.Year, dateValue.Month, dateValue.Day);
    }

    public static DateOnly ParseExact(string s, string format)
    {
        CultureInfo provider = CultureInfo.InvariantCulture;
        DateTime dateValue = default(DateTime);
        dateValue = DateTime.ParseExact(s, format, provider);
        return new DateOnly(dateValue.Year, dateValue.Month, dateValue.Day);
    }

    public DateOnly(int yearValue, int monthValue, int dayValue) : this()
    {
        Year = yearValue;
        Month = monthValue;
        Day = dayValue;
    }

    public DateOnly AddDays(double value)
    {
        DateTime d = new DateTime(this.Year, this.Month, this.Day);
        d = d.AddDays(value);
        return new DateOnly(d.Year, d.Month, d.Day);
    }

    public DateOnly AddMonths(int months)
    {
        DateTime d = new DateTime(this.Year, this.Month, this.Day);
        d = d.AddMonths(months);
        return new DateOnly(d.Year, d.Month, d.Day);
    }

    public DateOnly AddYears(int years)
    {
        DateTime d = new DateTime(this.Year, this.Month, this.Day);
        d = d.AddYears(years);
        return new DateOnly(d.Year, d.Month, d.Day);
    }

    public DayOfWeek DayOfWeek
    {
        get
        {
            return _dateValue.DayOfWeek;
        }
    }

    public DateTime ToDateTime()
    {
        return _dateValue;
    }

    public int Year
    {
        get
        {
            return _dateValue.Year;
        }
        set
        {
            _dateValue = new DateTime(value, Month, Day);
        }
    }

    public int Month
    {
        get
        {
            return _dateValue.Month;
        }
        set
        {
            _dateValue = new DateTime(Year, value, Day);
        }
    }

    public int Day
    {
        get
        {
            return _dateValue.Day;
        }
        set
        {
            _dateValue = new DateTime(Year, Month, value);
        }
    }

    public static bool operator == (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() == aDateOnly2.ToDateTime());
    }

    public static bool operator != (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() != aDateOnly2.ToDateTime());
    }

    public static bool operator > (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() > aDateOnly2.ToDateTime());
    }

    public static bool operator < (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() < aDateOnly2.ToDateTime());
    }

    public static bool operator >= (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() >= aDateOnly2.ToDateTime());
    }

    public static bool operator <= (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() <= aDateOnly2.ToDateTime());
    }

    public static TimeSpan operator - (DateOnly aDateOnly1, DateOnly aDateOnly2)
    {
        return (aDateOnly1.ToDateTime() - aDateOnly2.ToDateTime());
    }


    public override string ToString()
    {
        return _dateValue.ToShortDateString();
    }

    public string ToString(string format)
    {
        return _dateValue.ToString(format);
    }

    public string ToString(string fmt, IFormatProvider provider)
    {
        return string.Format("{0:" + fmt + "}", _dateValue);
    }

    public string ToShortDateString()
    {
        return _dateValue.ToShortDateString();
    }

    public string ToDbFormat()
    {
        return string.Format("{0:yyyy-MM-dd}", _dateValue);
    }
}

Questo è convertito da VB.NET, quindi mi scuso se alcune conversioni non sono al 100%

Utilizzare date.ToShortDateString () per ottenere la data senza il componente orario

var date = DateTime.Now
var shortDate = date.ToShortDateString() //will give you 16/01/2019

usa date.ToString () per personalizzare il formato della data

var date = DateTime.Now
var shortDate = date.ToString('dd-MMM-yyyy') //will give you 16-Jan-2019

Sono sorpreso che nessuno abbia menzionato DateTime.Today

var date = DateTime.Today;
// {7/1/2014 12:00:00 AM}

Vedi MSDN

Puoi provarlo per la sola data dal datetime

String.Format("{0:d/M/YYYY}",dt);

Dove dt è il DateTime

Mi sono imbattuto in questo post quando ho cercato di risolvere il Q originale.

Sto usando Asp.Net e dopo alcune ricerche che ho trovato quando si è vincolanti al valore della data nel codice dietro, è possibile eliminare il tempo in modo che non venga visualizzato sullo schermo.

C #:

DateTime Today = DateTime.Now;

aspx:

<%: this.Today.ToShortDateString() %>

uso

DateTime.Now.ToString("dd-MM-yyyy");

Se lo stai convertendo in stringa, puoi farlo facilmente in questo modo.

Prendo la data come oggetto DateTime.

date.ToString("d");

Questo ti darà solo la data.

string dt = myCalender.SelectedDate.ToString();
string date = dt.Remove(10);
displayDate.Content = date;

Se prendi la data dal calendario, con questo abbiamo anche tempo. Che non è richiesto in ogni momento. Usando questo possiamo rimuovere l'ora dalla data.

nella mia esperienza nessuna di queste soluzioni ha funzionato, forse perché volevo rimuovere l'ora dalla data estratta dal database, ma il codice qui sotto ha funzionato bene:

var date = target_date.Value.ToString("dd/MM/yyyy"); 

Dichiarare la variabile come una stringa.

esempio :

public string dateOfBirth ;

quindi assegnare un valore come:

dateOfBirth = ((DateTime)(datetimevaluefromDB)).ToShortDateString();

So che questo è un vecchio post con molte risposte, ma non ho visto questo modo di rimuovere la porzione di tempo. Supponiamo di avere una DateTimevariabile chiamata myDate, con la data con la parte temporale. Puoi creare un nuovo DateTimeoggetto da esso, senza la parte temporale, usando questo costruttore:

public DateTime(int year, int month, int day);

Come questo:

myDate = new DateTime(myDate.Year, myDate.Month, myDate.Day);

In questo modo crei un nuovo DateTimeoggetto basato su quello vecchio, con 00:00:00 come parte temporale.

Crea uno struct che contenga solo le proprietà che desideri. Quindi un metodo di estensione per ottenere facilmente quella struttura da un'istanza di DateTime.

public struct DateOnly
{
    public int Day { get; set; }
    public int Month { get; set; }
    public int Year { get; set; }
}

public static class DateOnlyExtensions
{
    public static DateOnly GetDateOnly(this DateTime dt)
    {
        return new DateOnly
        {
            Day = dt.Day,
            Month = dt.Month,
            Year = dt.Year
        };
    }
}

uso

DateTime dt = DateTime.Now;
DateOnly result = dt.GetDateOnly();

Per ottenere solo la parte della data usa il metodo ToString (),

esempio: DateTime.Now.Date.ToString ("gg / MM / aaaa")

Nota: il mm nel formato gg / MM / aaaa deve essere in maiuscolo

Utilizzare .Data di un oggetto DateTime ignorerà la parte dell'ora.

Ecco il codice:

DateTime dateA = DateTime.Now;
DateTime dateB = DateTime.Now.AddHours(1).AddMinutes(10).AddSeconds(14);
Console.WriteLine("Date A: {0}",dateA.ToString("o"));
Console.WriteLine("Date B: {0}", dateB.ToString("o"));
Console.WriteLine(String.Format("Comparing objects A==B? {0}", dateA.Equals(dateB)));
Console.WriteLine(String.Format("Comparing ONLY Date property A==B? {0}", dateA.Date.Equals(dateB.Date)));
Console.ReadLine();

Produzione:

>Date A: 2014-09-04T07:53:14.6404013+02:00
>Date B: 2014-09-04T09:03:28.6414014+02:00
>Comparing objects A==B? False
>Comparing ONLY Date property A==B? True

Usa un po 'di RegEx:

Regex.Match(Date.Now.ToString(), @"^.*?(?= )");

Produce una data nel formato: gg / mm / aaaa

Per l'utilizzo tramite datalist, ripetitore .. nella pagina aspx: <% # Eval ("YourDateString"). ToString (). Rimuovi (10)%>

static void Main(string[] args)
{
    string dateStrings =  "2014-09-01T03:00:00+00:00" ;

    DateTime convertedDate = DateTime.Parse(dateStrings);
    Console.WriteLine("  {0} ----------------- {1}",

    convertedDate,DateTime.Parse(convertedDate.ToString()).ToString("dd/MM/yyyy"));

    Console.Read();
}

Questo potrebbe essere semplicemente fatto in questo modo:

var dateOnly = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day)

Questo codice offre una visione chiara della scrittura Datee Timeseparatamente

string time = DateTime.Now.Hour.ToString("00") + ":" + DateTime.Now.Minute.ToString("00") + ":" + DateTime.Now.Second.ToString("00");
        string date = DateTime.Now.ToString("M-dd-yyyy");
        MessageBox.Show(date + "\n" + time);

Spero che sia di aiuto.