Quoi utiliser pour la Taille de l'argument dans la Base de données.AddOutParameter au moment de retourner une chaîne de caractères?

Je reçois une chaîne de caractères comme paramètre de sortie, et ont besoin de savoir quels réglages pour la Taille de l'argument dans l'appel à AddOutParameter.

Je sais que je pourrais simplement utiliser un grand nombre, comme int.MaxValue, mais souhaitez connaître les meilleures pratiques.

Dans SQL Server, la colonne est en fait un type uniqueidentifier. L'instruction T-SQL exécutée insère un enregistrement, puis définit quelques variables de sortie à l'IDENTIFIANT et au GUID de la nouvelle enregistrements insérés. C'est le code que j'utilise, mais avec les noms de variable changé.

database.AddOutParameter(cmd, "@someInt", DbType.Int32, 0);
database.AddOutParameter(cmd, "@someString", DbType.String, 0);

database.ExecuteNonQuery(cmd);

someInt = (int)database.GetParameterValue(cmd, "@someInt");
someString = database.GetParameterValue(cmd, "@someString").ToString();

Lorsqu'il est exécuté, j'obtiens l'erreur suivante...

Système.InvalidOperationException: String[2]: la Taille de la propriété a une défaillance de la taille de 0.

Il est donc évident pour moi que vous ne pouvez pas simplement utiliser une taille de 0 avec un paramètre de sortie de chaîne. Vous pouvez le faire avec un Int32 paramètre de sortie, mais je suppose que la chaîne a besoin d'une taille valide. Alors, quelle est la meilleure pratique pour le réglage de la taille? Peut-il seulement être d'une taille énorme, sans affecter les performances à tous? Je peux juste régler int.MaxValue ou quelque chose? Est-il une constante peut être utilisée ici; (ne pas voir n'importe quelle Chaîne.MaxValue - vous pouvez sans doute dire que je suis nouveau sur C#, Java).

Devrais-je savoir ce que la taille maximale d'une colonne de type uniqueidentifier est et de définir la taille? Mais si je fais la même chose pour une colonne de type VARCHAR ou NVARCHAR?

Je souhaite que le cadre serait juste de le faire pour moi; je ne veux pas de spécifier une taille pour toutes les chaînes que je reçois en tant que sortie. N'importe qui ont des suggestions de meilleure pratique?

J'ai lu les messages ci-dessous, ainsi que la documentation MSDN, mais il n'y a pas vraiment de bonnes pratiques, de répondre à ce que j'ai trouvé encore.

AddOutParameter - non-magiques nombre moyen de trouver la longueur de DBType.Int32

Lire VARBINARY(MAX) à partir de SQL Server, C#

Dans SQL Server, la colonne est en fait un type uniqueidentifier ensuite, pourquoi ne pas simplement utiliser DbType.Guid au lieu d'un DbType.Chaîne
Bon commentaire. Je ne savais pas qu'il était un DbType.Guid. Je cherchais DbType.UniqueIdentifier ou quelque chose comme ça, et doivent avoir regardé à droite après le type de Guid. Mes yeux doivent être en train de vieillir. Merci un milliard de dollars! Je l'ai essayé et je peux définir la taille à 0 lors de l'utilisation de DbType.Guid et il n'y a aucune exception d'exécution. Pourtant si, je voudrais savoir si j'ai été d'obtenir des données à partir d'une colonne de type VARCHAR ou NVARCHAR, quelle est la meilleure pratique pour le réglage de la taille?
avec Varchar et NVarchar j'ai l'habitude de le faire correspondre quelle que soit la source de colonne ou de la variable taille est. Ses quand le Type n'est pas la carte qui est une douleur. Par exemple, si l'on n'avait pas le DbType.Guid. Je pense que j'ai eu un problème avec la lecture de SQL Server Guid dans Access 95
N'est-ce pas la taille de l'argument censé être en octets? Donc, si j'ai un NVARCHAR(50) de la colonne qui pourrait détenir des caractères multi-octets, n'ai-je pas de définir la taille est supérieure à 50? Et savez-vous si il n'y a aucune différence de performances (ou problème causé par) la définition de la taille juste d'être significativement plus élevé que vous seriez jamais besoin, comme à l'int.MaxValue?

OriginalL'auteur Jim | 2012-06-01

.net c#database enterprise-library sql-server

Comme nous l'avons découvert que vous utilisez le mauvais type pour un UniqueIdentifer. Vous devez utiliser DbType.Guid au lieu d'une chaîne de caractères, mais vous avez soulevé d'autres questions dans les commentaires que je ne pouvais pas répondre dans un commentaire et je n'étais pas sûr si j'avais besoin de tester.

Ils sont

Ce qui devrait vous définissez la taille de la chaîne de paramètres de sortie de la?
Importe-t-il si il est de type Nvarchar ou varchar?
Ce qui se passe si vous en faites trop grand ou trop petit?

J'ai commencé par utiliser SqlCommandBuilder.DeriveParameters pour trouver ce que ADO.NET et SQL Server pense qu'il devrait être, puis exécuté la Procédure Stockée pour voir ce que nos valeurs de retour ont été.

Sql Type     | DbType                | Size | Returned string.Length()
----------------------------------------------------------------
Varchar(10)  | AnsiString            | 10   | 9
Char(10)     | AnsiStringFixedLength | 10   | 10
Nvarchar(10  | String                | 10   | 9
Varchar(max) | AnsiString            | -1   | 20,480 
NVarchar(max)| String                | -1   | 20,480

Comme prévu, la dérivée de tailles correspondait à la longueur de champ sur tous les types de caractères, sauf pour le max et le retour des valeurs et de la durée prévue. Cependant, l'examen du max types et DbTypes nous avons eu quelques nouvelles questions pour aller avec nos trois premiers.

Qu'est-ce qui AnsiString type et si nous avons choisi DbType.Chaîne au lieu-t-il sur la sortie, si nous gardons la même taille? Réponse: Non, il n'est pas, sans doute parce que .NET chaînes unicode
Ne l'augmentation de la Paramater.Size d'influer sur la non-valeurs max? Réponse: Oui, mais seulement char(10). Il augmente la taille de la sortie par l'ajout d'espaces vides.
Ne la diminution de la Paramater.Size d'influer sur la non-valeurs max? Oui, il tronque les valeurs de retour
Est d'une taille de -1 magie? Réponse: Oui si vous définissez la taille de -1, il sera de retour les valeurs comme si vous l'aviez définir correctement

Code De Test .NET 4.0 SQL Server 2008

Code SQL

CREATE PROCEDURE SomeOutput( 
@tenVC varchar(10)  output,
@tenC char(10) output,
@tenNVC nvarchar(10) output,
@maxVC varchar(max) output,
@maxNVC nvarchar(max) output,
@Indentifier uniqueidentifier output)
AS 


SELECT @tenC = '123456789',
       @tenVC = '123456789',
       @tenNVC = '123456789',
       @Indentifier = NEWID(),
       @maxVC = '',
       @maxNVC = ''



SELECT 
       @maxVC = @maxVC + '1234567890',
       @maxNVC = @maxNVC + '1234567890'
FROM
        master..spt_values 
WHERE
      type= 'P'

De Code C#

static void Main(string[] args)
{
using (SqlConnection cnn = new SqlConnection("Server=.;Database=Test;Trusted_Connection=True;"))
{
SqlCommand cmd = new SqlCommand("SomeOutput", cnn);
cmd.CommandType = CommandType.StoredProcedure;
cnn.Open();
SqlCommandBuilder.DeriveParameters(cmd);
Printparams(cmd.Parameters, "Derived");
foreach (SqlParameter param in cmd.Parameters)
{
//By default output parameters are InputOutput
//This will cause problems if the value is both null
if (param.Direction == ParameterDirection.InputOutput )
param.Direction = ParameterDirection.Output;
}
cmd.ExecuteNonQuery();
Printparams(cmd.Parameters ,"Executed");
cmd.Parameters["@tenVC"].DbType = DbType.String;
cmd.Parameters["@tenNVC"].DbType = DbType.AnsiString;
cmd.ExecuteNonQuery();
Printparams(cmd.Parameters, "DbType change");
foreach (SqlParameter param in cmd.Parameters)
{
if (param.DbType != DbType.Int32
&& param.DbType != DbType.Guid
&& param.Size != -1)
{
param.Size = param.Size * 2;
}
}
cmd.ExecuteNonQuery();
Printparams(cmd.Parameters, "Mangeled sizes up");
foreach (SqlParameter param in cmd.Parameters)
{
if (param.DbType != DbType.Int32 
&& param.DbType != DbType.Guid
&& param.Size != -1)
{
param.Size = param.Size / 4;
}
}
cmd.ExecuteNonQuery();
Printparams(cmd.Parameters, "Mangeled sizes down");
cmd.Parameters["@maxVC"].Size = Int32.MaxValue;
cmd.Parameters["@maxNVC"].Size = Int32.MaxValue;
cmd.ExecuteNonQuery();
Printparams(cmd.Parameters, "Fixed max sizes");
foreach (SqlParameter param in cmd.Parameters)
{
if (param.DbType != DbType.Int32
&& param.DbType != DbType.Guid)
{
param.Size = -1;
}
}
cmd.ExecuteNonQuery();
Printparams(cmd.Parameters, "is negative one magic");
}
}

Sorties

Derived
@RETURN_VALUE : Int32 : 0 : ReturnValue : 0 :
@tenVC : AnsiString : 10 : InputOutput : 0 :
@tenC : AnsiStringFixedLength : 10 : InputOutput : 0 :
@tenNVC : String : 10 : InputOutput : 0 :
@maxVC : AnsiString : -1 : InputOutput : 0 :
@maxNVC : String : -1 : InputOutput : 0 :
@Indentifier : Guid : 0 : InputOutput : 0 :
Executed
@RETURN_VALUE : Int32 : 0 : ReturnValue : 1 : 0
@tenVC : AnsiString : 10 : Output : 9 : 123456789
@tenC : AnsiStringFixedLength : 10 : Output : 10 : 123456789
@tenNVC : String : 10 : Output : 9 : 123456789
@maxVC : AnsiString : -1 : Output : 20480 : 123456789012345678901234567
@maxNVC : String : -1 : Output : 20480 : 123456789012345678901234567
@Indentifier : Guid : 0 : Output : 36 : eccc3632-4d38-44e8-9edf-031
DbType change
@RETURN_VALUE : Int32 : 0 : ReturnValue : 1 : 0
@tenVC : String : 10 : Output : 9 : 123456789
@tenC : AnsiStringFixedLength : 10 : Output : 10 : 123456789
@tenNVC : AnsiString : 10 : Output : 9 : 123456789
@maxVC : AnsiString : -1 : Output : 20480 : 123456789012345678901234567
@maxNVC : String : -1 : Output : 20480 : 123456789012345678901234567
@Indentifier : Guid : 0 : Output : 36 : 94cb0039-8587-4357-88fb-25c
Mangeled sizes up
@RETURN_VALUE : Int32 : 0 : ReturnValue : 1 : 0
@tenVC : String : 20 : Output : 9 : 123456789
@tenC : AnsiStringFixedLength : 20 : Output : 20 : 123456789
@tenNVC : AnsiString : 20 : Output : 9 : 123456789
@maxVC : AnsiString : -1 : Output : 20480 : 123456789012345678901234567
@maxNVC : String : -1 : Output : 20480 : 123456789012345678901234567
@Indentifier : Guid : 0 : Output : 36 : 4de88f14-9963-4a78-b09b-bb6
Mangeled sizes down
@RETURN_VALUE : Int32 : 0 : ReturnValue : 1 : 0
@tenVC : String : 5 : Output : 5 : 12345
@tenC : AnsiStringFixedLength : 5 : Output : 5 : 12345
@tenNVC : AnsiString : 5 : Output : 5 : 12345
@maxVC : AnsiString : -1 : Output : 20480 : 123456789012345678901234567
@maxNVC : String : -1 : Output : 20480 : 123456789012345678901234567
@Indentifier : Guid : 0 : Output : 36 : 5e973e72-14e5-4b75-9cff-e88
Fixed max sizes
@RETURN_VALUE : Int32 : 0 : ReturnValue : 1 : 0
@tenVC : String : 5 : Output : 5 : 12345
@tenC : AnsiStringFixedLength : 5 : Output : 5 : 12345
@tenNVC : AnsiString : 5 : Output : 5 : 12345
@maxVC : AnsiString : 2147483647 : Output : 20480 : 123456789012345678901234567
@maxNVC : String : 2147483647 : Output : 20480 : 123456789012345678901234567
@Indentifier : Guid : 0 : Output : 36 : 6cab2b41-d4ba-42d2-a93a-e59
is negative one magic
@RETURN_VALUE : Int32 : 0 : ReturnValue : 1 : 0
@tenVC : String : -1 : Output : 9 : 123456789
@tenC : AnsiString : -1 : Output : 10 : 123456789
@tenNVC : AnsiString : -1 : Output : 9 : 123456789
@maxVC : AnsiString : -1 : Output : 20480 : 123456789012345678901234567
@maxNVC : String : -1 : Output : 20480 : 123456789012345678901234567
@Indentifier : Guid : 0 : Output : 36 : 0d69ed57-fab7-49c8-b03a-d75

OriginalL'auteur Conrad Frix

Vous devez vous connecter pour publier un commentaire.