La requête paramétrée ... attend le paramètre '@unités", qui n'a pas été fourni

Je suis de cette exception:

De la requête paramétrée '(@Nom de type nvarchar(8),@type nvarchar(8),@unités de type nvarchar(4000),@rang attend le paramètre '@unités", qui n'a pas été fourni.

Mon code pour l'insertion est:

public int insertType(string name, string type, string units = "N\\A", string range = "N\\A", string scale = "N\\A", string description = "N\\A", Guid guid = new Guid())
{
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        connection.Open();
        SqlCommand command = new SqlCommand();
        command.CommandText = "INSERT INTO Type(name, type, units, range, scale, description, guid) OUTPUT INSERTED.ID VALUES (@Name, @type, @units, @range, @scale, @description, @guid) ";
        command.Connection = connection;
        command.Parameters.AddWithValue("@Name", name);
        command.Parameters.AddWithValue("@type", type);
        command.Parameters.AddWithValue("@units", units);
        command.Parameters.AddWithValue("@range", range);
        command.Parameters.AddWithValue("@scale", scale);
        command.Parameters.AddWithValue("@description", description);
        command.Parameters.AddWithValue("@guid", guid);
        return (int)command.ExecuteScalar();
    }
}

L'exception a été une surprise parce que je suis en utilisant le AddWithValue fonction et de faire assurer, j'ai ajouté un paramètre par défaut pour la fonction.

RÉSOLU:

Le problème est que certains paramètres, où les Cordes à vide (qui remplace la valeur par défaut)

C'est le code de travail:

public int insertType(string name, string type, string units = "N\\A", string range = "N\\A", string scale = "N\\A", string description = "N\\A", Guid guid = new Guid())
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand command = new SqlCommand();
command.CommandText = "INSERT INTO Type(name, type, units, range, scale, description, guid) OUTPUT INSERTED.ID VALUES (@Name, @type, @units, @range, @scale, @description, @guid) ";
command.Connection = connection;
command.Parameters.AddWithValue("@Name", name);
command.Parameters.AddWithValue("@type", type);
if (String.IsNullOrEmpty(units))
{
command.Parameters.AddWithValue("@units", DBNull.Value); 
}
else
command.Parameters.AddWithValue("@units", units);
if (String.IsNullOrEmpty(range))
{
command.Parameters.AddWithValue("@range", DBNull.Value);
}
else
command.Parameters.AddWithValue("@range", range);
if (String.IsNullOrEmpty(scale))
{
command.Parameters.AddWithValue("@scale", DBNull.Value);
}
else
command.Parameters.AddWithValue("@scale", scale);
if (String.IsNullOrEmpty(description))
{
command.Parameters.AddWithValue("@description", DBNull.Value);
}
else
command.Parameters.AddWithValue("@description", description);
command.Parameters.AddWithValue("@guid", guid);
return (int)command.ExecuteScalar();
}
}

Vous avez oublié de mettre le @ que le premier caractère de chaque nom de paramètre.
Pourquoi le message d'erreur se plaindre @units plutôt que @Name, qui apparaît en premier?
Je suppose qu'il n'ont pas à chercher dans l'ordre où ils sont fournis.
Je suis choqué parce qu'encore personne n'a répondu à cette question. Par la voie, 2 upvotes?
J'ai ajouté le @ et encore même exception
Souhaitez-vous mettre à jour votre question avec votre code mis à jour, s'il vous plaît?
Oui, mis à jour...
Ahh, command.Parameters.AddWithValue("Name", @name) devrait être command.Parameters.AddWithValue("@Name", name) etc.
lol ok je vais vérifier que l'
Eh bien, toujours pas de travail. J'ai mis à jour mon code dans le message
pouvez-vous montrer ici script pour la création [Type] table?
Quelle est la valeur de units juste avant le "insertion"? Ne peut pas être null puisque vous spécifiez une valeur par défaut. Juste curieux de savoir si en quelque sorte l'une des valeurs de paramètre est à l'origine d'une étrange question.
Je soupçonne AddWithValue est de deviner quelque chose de mal. Essayez d'utiliser le SqlParameter Constructeur (String, SqlDbType, Int32).
ghost - je l'ai créé à partir de l'éditeur, ce que vous aimeriez savoir à propos de la table? @GrantWinney je pense qu'il peut être vide, alors que je suis de la vérification, nous allons supposer qu'il est, comment puis-je régler ce problème?
oui, ils sont tous vide (toutes les le avec par défaut)
double possible de La requête paramétrée attend le paramètre qui n'a pas été fourni

InformationsquelleAutor Yogevnn | 2014-05-03

c#exception sql-server

76

Essayez ce code:
```
SqlParameter unitsParam = command.Parameters.AddWithValue("@units", units);
if (units == null)
{
unitsParam.Value = DBNull.Value;
}
```
Et vous devez vérifier tous les autres paramètres à valeur null. Si null, vous devez passer DBNull.Value valeur.
- Je ne pense pas qu'il pourrait être nulle parce que l'OP a le paramètre comme ceci string units = "N\\A"
- Il pouvait le faire, parce que vous pouvez appeler la méthode comme ceci insertType(null, null, null, null, null, null);
- Problème résolu! Je vais éditer mon message avec la solution. Merci à vous tous!
- Apparemment ce n'est pas la façon dont il fonctionne. Le paramètre doit être omis dans le code appelant plutôt que de créer de null. Nommé et Arguments Optionnels
- Les valeurs par défaut ne fonctionne pas comme ça. Ils ne s'appliquent que lorsque vous ne passez pas tout (si vous omettez l'argument au total). Si vous passer quoi que ce soit, même null, alors que vous passez est ce que le destinataire de l'appel ne voit.
- Une façon plus simple d'écrire c'est command.Parameters.AddWithValue("@units", (object)units ?? DBNull.Value).
- htfepb @Denis peut vous aider moi je suis aller pour l'obtention de la liste des utilisateurs à l'aide de la SP dans le SqlQuery<Entité> mais cette fois, je suis d'erreur alors pouvez-vous s'il vous plaît aider pour que moi aussi je peux dire?
InformationsquelleAutor Denis

Ici un moyen à l'aide de l'null-coalescence de l'opérateur:

cmd.Parameters.AddWithValue("@units", units ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@range", range ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@scale", scale ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@description", description ?? (object)DBNull.Value);

Ou pour les plus strictes de vérification de type:

cmd.Parameters.Add("@units", SqlDbType.Int).Value = units ?? (object)DBNull.Value;
cmd.Parameters.Add("@range", SqlDbType.Int).Value = range ?? (object)DBNull.Value;
cmd.Parameters.Add("@scale", SqlDbType.Int).Value = scale ?? (object)DBNull.Value;
cmd.Parameters.Add("@description", SqlDbType.VarChar).Value = description ?? (object)DBNull.Value;

L'opérateur a également enchaîné:

int?[] a = { null, null, 1 };
Console.WriteLine(a[0] ?? a[1] ?? a[2]);

InformationsquelleAutor Will

command.Parameters.AddWithValue("@Name", (name == null ? "" : name));

InformationsquelleAutor سعد الضبي

Cette classe d'extension a été utile pour moi une couple de fois jusqu'à présent, pour ces questions:

public static class DbValueExtensions
{
//Used to convert values coming from the db
public static T As<T>(this object source)
{
return source == null || source == DBNull.Value
? default(T)
: (T)source;
}
//Used to convert values going to the db
public static object AsDbValue(this object source)
{
return source ?? DBNull.Value;
}
}

Vous utilisez normalement dans les deux scénarios. Tout d'abord, lors de la création de paramètres pour votre requête:

var parameters = new Dictionary<string, object>
{
{ "@username", username.AsDbValue() },
{ "@password", password.AsDbValue() },
{ "@birthDate", birthDate.AsDbValue() },
};

ou lors de l'analyse du SqlReader valeurs:

while (reader.Read())
{
yield return new UserInfo(
reader["username"].As<string>(),
reader["birthDate"].As<DateTime>(),
reader["graduationDate"].As<DateTime?>(),
reader["nickname"].As<string>()
);
}

InformationsquelleAutor Mladen B.

C'est une méthode pour être réutilisé avec plusieurs paramètres:

public void NullorEmptyParameter(QC.SqlCommand command, string at, string value)
{
if (String.IsNullOrEmpty(value))
{
command.Parameters.AddWithValue(at, DBNull.Value);
}
else
command.Parameters.AddWithValue(at, value);
}

Et puis vous pouvez la réutiliser pour autant de commandes et de paramètres:

NullorEmptyParameter(command, "@Idea_ID", Idea_ID);
NullorEmptyParameter(command, "@Opportunities_or_Idea", Opportunities_or_Idea);

InformationsquelleAutor locnguyen

Vous devez vous connecter pour publier un commentaire.