Hej!

Har ett objekt med egenskapen slutdatum.
När jag sparar detta objekt så finns inte alltid ett slutdatum.

Hur får jag egenskapen datetime att vara ingenting när jag skall spara.

Har försök att inte sätta egenskapen datetime i mitt objekt men då blit datetime 0000-00-00.

Men jag vill inte att detta datetime inte skall ha något värde alls i databasen.

Hur göra?

Skall jag sätta egenskapen datetime till string istället?

Sätt värdet till null (System.DBNull.Value).

Jo det kan ja ju göra men bara värdet i databasen. Sätter jag min egenskap i objektet som är av typen datetime så blir det ju ett felmeddelande.

Fungerar det inte att sätta den till null?

/Johan

Värdedatatyper kan fn inte vara null i .NET (kommer i 2.0). Jag kan inte se någon annan lösning att på ett eller annat sätt ha en kompleterande flagga som talar om huruvida datumet skall betraktas som null eller ej.

Okej, tack för svaren

Det du kan göra är att välja ett datum som betyder att datumet är tomt. Det finns två lämpliga värden för detta, nämligen System.DateTime.MinValue och System.DateTime.MaxValue.

Sannolikheten att du skulle behöva använda just det datum som System.DateTime.MinValue representerar är ganska liten. Från hjälpen :
<info>
<b>Remarks</b>
The value of this constant is equivalent to 00:00:00.0000000, January 1, 0001.
</info>
När du vill "nulla" ett datum skriver du alltså :
<code>
Dim MyDate As System.DateTime=System.DateTime.MinValue
</code>
och när du vill kolla om ett datum är "null" så skriver du :
<code>
If MyDate=System.DateTime.MinValue then
...
End If
' or
If MyDate.Equals(System.DateTime.MinValue) then
...
End If
</code>

Alternativet är ju annars som Anders skrev, att vänta på .Net 2.0 och nullable types :-(

Vill bara påpeka att man redan nu att skapa egna "nullable types". Nu är det ju inte riktigt samma sak som en äkta datetime, men om du är intresserad så kanske följande kod kan vara till hjälp:

    /// <summary>
    /// A nullable alternative to the corresponding intrinsic value type.
    /// </summary>
    [Serializable]
    public struct NullableDateTime
    {
        private DateTime _value;
        private bool _isNotNull;

        /// <summary>
        /// Creates an instance based on the given value.
        /// </summary>
        /// <param name="value">The value to give the new instance.</param>
        public NullableDateTime(DateTime value)
        {
            _value = value;
            _isNotNull = true;
        }

        /// <summary>
        /// Returns the the underlying value of the type.
        /// </summary>
        public DateTime Value
        {
            get { return _value; }
            set { _value = value; }
        }

        /// <summary>
        /// Is true if the no value has been set.
        /// </summary>
        public bool IsNull
        {
            get { return !_isNotNull; }
            set { _isNotNull = !value; }
        }

        /// <summary>
        /// Operator to allow implicit cast from the nullable type to a the intrinsic type.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static implicit operator DateTime(NullableDateTime value) 
        {
            return value.Value;
        }

        /// <summary>
        /// Operator to allow implicit cast from an intrinsic type to the nullable type.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static implicit operator NullableDateTime(DateTime value) 
        {
            return new NullableDateTime(value);
        }

        /// <summary>
        /// Returns a String that represents the current type.
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return this.IsNull ? "" : _value.ToString();
        }

        /// <summary>
        /// Determines whether the current instance is equal to the given object.
        /// </summary>
        /// <param name="obj">The object to compare with the current instance.</param>
        /// <returns>True if both are null or if both are of same type and has the same value.</returns>
        public override bool Equals(object obj)
        {
            if (this.IsNull || obj == null)
            {
                return this.IsNull && obj == null;
            }
            else if (obj is DateTime || obj is NullableDateTime)
            {
                return DateTime.Equals(this.Value, (DateTime) obj);
            }
            else 
            {
                return false;
            }
        }

        /// <summary>
        /// Returns a hash code for the current instance.
        /// </summary>
        /// <returns>The hash code of the underlying value object.</returns>
        public override int GetHashCode()
        {
            return Value.GetHashCode();
        }

        /// <summary>
        /// Allows comparison between two instances of the nullable type.
        /// </summary>
        /// <param name="leftValue">Left value.</param>
        /// <param name="rightValue">Right value.</param>
        /// <returns>True if equal, false if not.</returns>
        public static bool operator ==(NullableDateTime leftValue, NullableDateTime rightValue) 
        {
            return leftValue.Equals(rightValue);
        }

        /// <summary>
        /// Allows comparison between two instances of the nullable type.
        /// </summary>
        /// <param name="leftValue">Left value.</param>
        /// <param name="rightValue">Right value.</param>
        /// <returns>False if equal, true if not.</returns>
        public static bool operator !=(NullableDateTime leftValue, NullableDateTime rightValue) 
        {
            return !leftValue.Equals(rightValue);
        }
    }

Nice, den strukturen skulle man kunna ha användning för ibland.

En av de implicita typkonverteringarna kommer ju dock att smälla på ett "object reference not set"-exception (vad det nu heter) om value är Null så bättre hade kanske varit att ändra :
<code>
public static implicit operator DateTime(NullableDateTime value)
{
return value.Value;
}
</code>
till :
<code>
public static implicit operator DateTime(NullableDateTime value)
{
if (value==null) throw new ArgumentNullException();

return value.Value;
}
</code>

Den snutten hamnar hur som helst i bra-att-ha-högen...

Hmm... Hur gör man för att hamna i det läget du beskriver, dvs att argumentet value är null i DateTime-operatorn?