¿Cómo eliminar la porción de tiempo de la fecha en C # solo en el objeto DateTime?

Necesito eliminar la parte de tiempo de la fecha o probablemente tenga la fecha en el siguiente formato en objectforma no en forma de string.

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

No puedo usar ningún stringmétodo de conversión, ya que necesito la fecha en el objectformulario.

Primero intenté convertir el DateTimea a string, eliminar la fecha específica de tiempo, pero se agrega 12:00:00 AMtan pronto como lo convierto de DateTime objectnuevo.

Use la propiedad Fecha :

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

La datevariable contendrá la fecha, la parte del tiempo será 00:00:00.

Puede usar cadenas de formato para darle a la cadena de salida el formato que desee.

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

Lea más sobre cadenas de formato de fecha y hora personalizadas .

Use el método ToShortDateString. Consulte la documentación 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

Eche un vistazo a la propiedad DateTime.Date .

Obtiene el componente de fecha de esta instancia.

El Dateestablecimiento devolverá la fecha a medianoche.

Una opción podría ser obtener los valores individuales (día / mes / año) por separado y almacenarlos en el tipo que desee.

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

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

Ninguna de las respuestas anteriores resolvió mi problema en winforms.

La forma más fácil de alcanzar SOLO la fecha es la función simple en Fecha y hora:

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

Solo tendrá fecha en la cadena de cumpleaños.

Intenta hacer tu propia Estructura para eso. El objeto DateTime tendrá fecha y hora tanto

No puedes Un DateTime en .NET siempre tiene un tiempo, por defecto a 00: 00: 00: 000. La propiedad Date de DateTime también es DateTime (!), Por lo que también tiene un tiempo predeterminado de 00: 00: 00: 000.

Esta es una escasez en .NET Framework, y se podría argumentar que DateTime en .NET viola el Principio de responsabilidad única .

DateTime.Date

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

Aquí hay otro método usandoString.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);

Salida:

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

Date Only : 04/09/2016

Esto también funciona si la fecha y hora se almacena en la base de datos.

Para obtener más formato de fecha y hora, consulte estos enlaces:

Referencia 1

Referencia 2

La esperanza ayuda.

Esta forma de obtener solo una fecha sin tiempo

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

Salida = 16/05/2015

Escribí una DateOnlyestructura. Esto usa un DateTime debajo de la piel pero no hay partes de tiempo que estén expuestas públicamente:

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);
    }
}

Esto se convierte desde VB.NET, así que disculpas si algunas conversiones no son 100%

Use date.ToShortDateString () para obtener la fecha sin el componente de hora

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

use date.ToString () para personalizar el formato de la fecha

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

Me sorprende que nadie haya mencionado DateTime.Today

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

Ver MSDN

Puede probar esto para la única fecha desde la fecha y hora

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

Donde dt es el DateTime

Encontré esta publicación al intentar resolver la Q original.

Estoy usando Asp.Net y después de algunas investigaciones que encontré cuando está vinculando el valor de la fecha en el código detrás, puede eliminar el tiempo para que no se muestre en la pantalla.

C#:

DateTime Today = DateTime.Now;

aspx:

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

utilizar

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

Si lo está convirtiendo en cadena, puede hacerlo fácilmente de esta manera.

Estoy tomando fecha como su objeto DateTime.

date.ToString("d");

Esto solo le dará la fecha.

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

Si toma la fecha del calendario, con esto también tenemos tiempo. Lo cual no se requiere todo el tiempo. Con esto podemos eliminar el tiempo de la fecha.

en mi experiencia, ninguna de las soluciones mencionadas funcionó, tal vez porque quería eliminar el tiempo de la fecha extraída de la base de datos, pero el siguiente código funcionó bien:

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

Declara la variable como una cadena.

ejemplo:

public string dateOfBirth ;

luego asigne un valor como:

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

Sé que esta es una publicación antigua con muchas respuestas, pero no he visto esta forma de eliminar la porción de tiempo. Suponga que tiene una DateTimevariable llamada myDate, con la fecha con parte de tiempo. Puede crear un nuevo DateTimeobjeto a partir de él, sin la parte de tiempo, utilizando este constructor:

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

Me gusta esto:

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

De esta manera, crea un nuevo DateTimeobjeto basado en el anterior, con 00:00:00 como parte del tiempo.

Cree una estructura que contenga solo las propiedades que desee. Luego, un método de extensión para obtener fácilmente esa estructura de una instancia de 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();

Para obtener solo la parte de la fecha, use el método ToString (),

ejemplo: DateTime.Now.Date.ToString ("dd / MM / aaaa")

Nota: El mm en el formato dd / MM / aaaa debe estar en mayúscula

El uso .Date de un objeto DateTime ignorará la porción de tiempo.

Aquí está el código:

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();

Salida:

>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

Use un poco de RegEx:

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

Produce una fecha en el formato: dd / mm / aaaa

Para usar por datalist, repetidor .. en la página aspx: <% # Eval ("YourDateString"). ToString (). Remove (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();
}

Esto podría hacerse simplemente de esta manera:

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

Este código le brinda una visión clara de la escritura Date, así como por Timeseparado

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);

Espero que esto ayude.