Quelle devrait être la valeur par défaut dans un paramètre optionnel DateTime?
Normalement, si j'ai un type nullable pour un paramètre facultatif, je mettrais null comme valeur par défaut. De cette façon, je sais que si la valeur est null, l'appelant ne veut spécifier Aucune valeur pour celui-ci.
public void Foo(string text, string text2= null);
Si ce paramètre est normalement un entier positif, je peux utiliser un nombre négatif
public void Foo(string text, int index=-1);
Que diriez-vous de DateTime? Il n'est pas nullable, et (pour autant que je sache) il n'a pas un nombre sans signification qui ne peut pas non plus être une vraie entrée (comme -1 pour un entier positif). Ou est-il? Que feriez-vous dans cette situation?
Je sais aussi que je peux utiliser le type nullable DateTime, mais cela signifie que l'appelant de la méthode devra également utiliser Nullable plutôt que de simplement passer commodément un DateTime.
10 réponses
Vous pouvez rendre les types de valeur nullable en utilisant l'opérateur ? en C#:
DateTime? myDate = null;
À partir de là, vous pouvez rendre le paramètre facultatif:
void Foo(DateTime? myDate = null)
{
}
Pour en savoir plus sur les Types Nullable.
Ce n'est pas la seule façon de peler le chat cependant, vous pouvez utiliser default(DateTime), mais vous ne pouvez pas utiliser DateTime.MinValue, MaxValue, ou Now dans les paramètres optionnels car ils ne sont pas des constantes de compilation.
Bien sûr, vous n'avez pas besoin d'utiliser des paramètres optionnels, vous pouvez utiliser des méthodes surchargées si vous souhaitez utiliser Min, Max ou Now.
void Foo()
{
Foo(DateTime.MinValue);
}
void Foo(DateTime d)
{
}
Si vous voulez aller overkill (enfin, peut - être pas overkill, beaucoup de raisons valables pour le faire), alors vous pouvez définir un nouveau type de date qui comprend quand il a une valeur:
class SmarterDateTime
{
public bool IsSet { get; set; }
// Wrapper around DateTime etc excluded.
}
En ce qui concerne ce qui devrait être la valeur par défaut, Vous pouvez choisir de faire en sorte que n'importe quelle date représente une valeur par défaut si vous le souhaitez, mais pour des choses comme les paramètres facultatifs, vous aurez des limites.
Personnellement, j'ai tendance à utiliser DateTime.MinValue.
A la question "qu'est-ce qui peut être une valeur par défaut pour un DateTime", la réponse doit être: vous ne pouvez utiliser que default(DateTime). Ceci parce que la valeur par défaut doit être const et que DateTime.MinValue et DateTime.MaxValue ne sont que static readonly, mais notez que
default(DateTime) == DateTime.MinValue
Jusqu'au Kind.
Si vous le souhaitez, vous pouvez implémenter une surcharge avec un paramètre de moins (le DateTime) et à partir de cette surcharge appeler la méthode "main" en passant la valeur que vous préférez.
Mais comme écrit par d'autres, le problème est que vous avez mal écrit prémisse.
N, DateTime (comme presque tous les ValueTypes. Presque toutes car Nullable<Nullable<int>> est illégal, même si Nullable<T> est un ValueType) est nullable. Nullable<DateTime> ou DateTime? (même chose)
Même int sont nullables, vous savez? int? :-)
Vérifiez le paramètre par défaut dateTime, sa valeur serait 1/1/0001 12:00:00 AM,
private void M(Int32 x = 9, String s = “A”, DateTimedt = default(DateTime), Guidguid = new Guid()) {
Console.WriteLine(“x={0}, s={1}, dt={2}, guid={3}”, x, s, dt, guid);
}
Si vous utilisez le Nullable, les appelants de votre fonction peuvent simplement lui passer un DateTime régulier, donc ils ne remarqueront rien:) il y a des opérateurs implicites qui le feront pour vous
Si vous souhaitez définir une valeur par défaut dans votre fonction, vous pouvez faire:
public void Foo(DateTime? value = null)
{
if ( value == null )
{
value = ... // default
}
}
Extrait De Code
public DateTime method1()
{
if (condition)
return new DateTime(2007, 5, 30, 11, 32, 00);
else
return default(DateTime);
}
L'instruction default initialise un type de valeur à sa valeur par défaut. Dans le cas d'un datetime, cette valeur est également exposée en tant que propriété statique appelée DateTime.MinValue. Si vous utilisez C # 1.0, l'instruction " default (DateTime) "serait équivalente à" DateTime.MinValue". Vous pouvez utiliser cette valeur spéciale comme une sorte de valeur" marqueur", ce qui signifie que si elle est renvoyée, elle indique une date-heure invalide.
Si vous utilisez à nouveau C # 2.0, Il est également possible d'utiliser ce qui est appelé un type nullable, et renvoie effectivement NULL, comme indiqué dans l'exemple suivant
Extrait De Code
public DateTime? method2()
{
if (condition)
return new DateTime(2007, 5, 30, 11, 32, 00);
else
return null;
}
// This is the best way to null out the DateTime.
//
DateTime dateTime2 = DateTime.MinValue;
Vous pouvez envisager d'utiliser la valeur DateTime.MinValue et d'utiliser la surcharge.
Dépend de votre cas d'utilisation.
Tout ce qui ne correspondra pas aux données réelles fonctionnera, mais cela dépend de votre utilisation de celui-ci (donc d'une certaine manière -1 pour les entiers, puisque c'est un entier parfaitement bon seulement pour votre utilisation de celui-ci).
Si vous envoyez une date minimale (intéressée par tous les foo qui sont plus tard), toute date antérieure à la date raisonnable la plus ancienne fera l'affaire, et le code comme .Where(f -> f.When > myDate) fonctionnera sans même avoir à chercher ce spécial cas.
De même avec les dates maximales en sens inverse (toute date qui serait après la dernière date raisonnable).
Sinon, évitez simplement l'utilisation des valeurs par défaut, et surchargez à la place.