Case à cocher pour accepter les valeurs null boolean

Je l'ai eu à travailler avec

@Html.EditorFor(model => model.Foo) 

et ensuite faire un Booléen.cshtml dans mon EditorTemplates dossier et coller

@model bool?

@Html.CheckBox("", Model.GetValueOrDefault())

à l'intérieur.

J'ai bool? IsDisabled { get; set; } dans le Modèle. Inséré si en Vue.

<div class="inputClass" id="disabled">
    <div>
    @if(Model.IsDisabled==null)
    {
        Model.IsDisabled = false;
    }           
    @Html.CheckBoxFor(model => model.IsDisabled.Value)         
    </div>
</div> 

Compliquant une primitive avec des champs cachés de préciser si False ou Null n'est pas recommandé.

Case à cocher n'est pas ce que vous devriez être en utilisant -- il n'a en fait qu'un état: Vérifié. Sinon, il pourrait être n'importe quoi.

Lorsque votre champ de base de données est un boolean nullable (bool?), le UX devez utiliser de 3 Boutons Radio, où le premier bouton représente votre "Checked", le deuxième bouton représente "Non Vérifié" et le troisième bouton représente votre null, quelle que soit la sémantique de null. Vous pouvez utiliser un <select><option> la liste déroulante enregistrer l'immobilier, mais l'utilisateur doit cliquer deux fois et les choix ne sont pas presque aussi instantanément clair.

  1     0      null 
True  False  Not Set
Yes   No     Undecided
Male  Female Unknown
On    Off    Not Detected

La RadioButtonList, défini comme une extension nommée RadioButtonForSelectList, s'appuie sur les boutons pour vous, y compris la sélection, la valeur, et définit la <div class="RBxxxx"> de sorte que vous pouvez utiliser css pour faire de votre radio boutons aller à l'horizontale (display: inline-block), à la verticale, ou dans une table de la mode (display: inline-block; width:100px;)

Dans le modèle (je suis l'aide de la chaîne, chaîne pour la définition du dictionnaire comme un exemple pédagogique. Vous pouvez utiliser bool?, string)

public IEnumerable<SelectListItem> Sexsli { get; set; }
SexDict = new Dictionary<string, string>()
{
{ "M", "Male"},
{ "F", "Female" },
{ "U", "Undecided" },
};
//Convert the Dictionary Type into a SelectListItem Type
Sexsli = SexDict.Select(k =>
new SelectListItem
{
Selected = (k.Key == "U"),
Text = k.Value,
Value = k.Key.ToString()
});
<fieldset id="Gender">
<legend id="GenderLegend" title="Gender - Sex">I am a</legend>
@Html.RadioButtonForSelectList(m => m.Sexsli, Model.Sexsli, "Sex") 
@Html.ValidationMessageFor(m => m.Sexsli)
</fieldset>
public static class HtmlExtensions
{
public static MvcHtmlString RadioButtonForSelectList<TModel, TProperty>(
this HtmlHelper<TModel> htmlHelper,
Expression<Func<TModel, TProperty>> expression,
IEnumerable<SelectListItem> listOfValues,
String rbClassName = "Horizontal")
{
var metaData = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
var sb = new StringBuilder();
if (listOfValues != null)
{
//Create a radio button for each item in the list 
foreach (SelectListItem item in listOfValues)
{
//Generate an id to be given to the radio button field 
var id = string.Format("{0}_{1}", metaData.PropertyName, item.Value);
//Create and populate a radio button using the existing html helpers 
var label = htmlHelper.Label(id, HttpUtility.HtmlEncode(item.Text));
var radio = String.Empty;
if (item.Selected == true)
{
radio = htmlHelper.RadioButtonFor(expression, item.Value, new { id = id, @checked = "checked" }).ToHtmlString();
}
else
{
radio = htmlHelper.RadioButtonFor(expression, item.Value, new { id = id }).ToHtmlString();
}//Create the html string to return to client browser
//e.g. <input data-val="true" data-val-required="You must select an option" id="RB_1" name="RB" type="radio" value="1" /><label for="RB_1">Choice 1</label> 
sb.AppendFormat("<div class=\"RB{2}\">{0}{1}</div>", radio, label, rbClassName);
}
}
return MvcHtmlString.Create(sb.ToString());
}
}

Case seulement vous offrir 2 valeurs (vrai, faux). Boolean Nullable a 3 valeurs (true, false, null), donc il est impossible de le faire avec une case à cocher.

Une bonne option est d'utiliser une liste déroulante au lieu.

Modèle

public bool? myValue;
public List<SelectListItem> valueList;

Contrôleur

model.valueList = new List<SelectListItem>();
model.valueList.Add(new SelectListItem() { Text = "", Value = "" });
model.valueList.Add(new SelectListItem() { Text = "Yes", Value = "true" });
model.valueList.Add(new SelectListItem() { Text = "No", Value = "false" });

Vue

@Html.DropDownListFor(m => m.myValue, valueList)

Le plus propre de l'approche que je pouvais venir est de développer les extensions disponibles pour HtmlHelper tout en encore la réutilisation des fonctionnalités fournies par le framework.

public static MvcHtmlString CheckBoxFor<T>(this HtmlHelper<T> htmlHelper, Expression<Func<T, bool?>> expression, IDictionary<string, object> htmlAttributes) {
ModelMetadata modelMeta = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
bool? value = (modelMeta.Model as bool?);
string name = ExpressionHelper.GetExpressionText(expression);
return htmlHelper.CheckBox(name, value ?? false, htmlAttributes);
}

J'ai expérimenté avec la 'formation' de l'expression afin de permettre un droit de traverser le natif CheckBoxFor<Expression<Func<T, bool>>> mais je ne pense pas que c'est possible.

Seulement de vérifier la valeur null et retourne false pour elle:

@{ bool nullableValue = ((Model.nullableValue == null) || (Model.nullableValue == false)) ? false : true; }
@Html.CheckBoxFor(model => nullableValue)

Lors de la prise de EditorTemplate pour un modèle qui contient un nullable bool...

• Diviser le nullable bool en 2 booléens:

  //Foo is still a nullable boolean.
  public bool? Foo 
  {
  get 
  { 
  if (FooIsNull)
  return null;
  return FooCheckbox;  
  }
  set
  {
  FooIsNull   = (value == null);
  FooCheckbox = (value ?? false);
  }
  }
  //These contain the value of Foo. Public only so they are visible in Razor views.
  public bool FooIsNull { get; set; }
  public bool FooCheckbox { get; set; }

• Au sein de l'éditeur de modèle:

  @Html.HiddenFor(m => m.FooIsNull)
  @if (Model.FooIsNull)
  {
  //Null means "checkbox is hidden"
  @Html.HiddenFor(m => m.FooCheckbox)
  }
  else
  {
  @Html.CheckBoxFor(m => m.FooCheckbox)
  }

• N'publication de l'origine des biens Foo, parce que c'est maintenant calculé à partir de FooIsNull et FooCheckbox.

Les méthodes d'Extension:

        public static MvcHtmlString CheckBoxFor<TModel>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, bool?>> expression)
{
return htmlHelper.CheckBoxFor<TModel>(expression, null);
}
public static MvcHtmlString CheckBoxFor<TModel>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, bool?>> expression, object htmlAttributes)
{
ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
bool? isChecked = null;
if (metadata.Model != null)
{
bool modelChecked;
if (Boolean.TryParse(metadata.Model.ToString(), out modelChecked))
{
isChecked = modelChecked;
}
}
return htmlHelper.CheckBox(ExpressionHelper.GetExpressionText(expression), isChecked??false ,  htmlAttributes);
}

C'est une vieille question, et les réponses décrivent la plupart des solutions de rechange. Mais il y a une option simple, si vous avez bool? dans votre viewmodel, et vous ne se soucient pas null dans votre INTERFACE utilisateur:

@Html.CheckBoxFor(m => m.boolValue ?? false);