Problème de duplication de chaîne C#

Question

J'utilise VSTS 2008 + C# + .Net 3.0. J'ai deux cordes d'entrée, je pense qu'ils sont différents. Mais le code C# suivant pense qu'ils sont identiques et renvoie System.Data.ConstraintException, indique que le nom de colonne est contraint à être unique, mais que la valeur existe déjà. Des idées ce qui ne va pas?

Voici mon code et mes cordes d'entrée,

vue Hex de mes cordes d'entrée,

http://i30.tinypic.com/2anx2b.jpg

vue Bloc-notes de mes chaînes d'entrée,

http://i30.tinypic.com/2q03hn4.jpg

Mon code,

static void Main(string[] args) 
    { 
     string[] buf = new string[] { "2ch", "２ｃｈ" }; 

     DataTable bulkInserTable = new DataTable("BulkTable"); 
     DataColumn column = null; 
     DataRow row = null; 

     column = new DataColumn(); 
     column.DataType = System.Type.GetType("System.String"); 
     column.ColumnName = "Name"; 
     column.ReadOnly = true; 
     column.Unique = true; 
     bulkInserTable.Columns.Add(column); 

     foreach (string item in buf) 
     { 
      row = bulkInserTable.NewRow(); 
      row["Name"] = item; 
      bulkInserTable.Rows.Add(row); 
     } 
    } 

EDIT 1:

Ma confusion est, pourquoi C# Dictionnaire pense qu'ils sont différents, mais DataSet pense qu'ils sont de même. Toute solution pour rendre le comportement cohérent? Voici mon code pour prouver que C# Dictionary pense qu'ils sont différents, le tableau buf de retour est de deux éléments.

  Dictionary<string, bool> dic = new Dictionary<string, bool>(); 
      foreach (string s in buf) 
      { 
       dic[s] = true; 
      } 
      buf = new List<string>(dic.Keys).ToArray(); // we got two strings here, other than one, which proves Dictionary thinks the two strings are different. 

Answer 1

bien pour commencer, vous devez vous codez échantillon à:

foreach (string item in buf) 
{ 
    row = bulkInserTable.NewRow(); 
    row["Name"] = item; 
    bulkInserTable.Rows.Add(row); 
} 

Bien que présente encore la question au moins il est pour la vraie raison

La raison en est que, Lors de la création d'un tableau de données, les options de comparaison par défaut en vigueur sont les suivantes:

this._compareFlags = CompareOptions.IgnoreWidth 
        CompareOptions.IgnoreKanaType | 
        CompareOptions.IgnoreCase; 

Depuis le Ignorer la largeur:

Indique que la comparaison de chaînes doit ignorer la largeur du caractère. Par exemple, les caractères katakana japonais peuvent être écrits en pleine largeur ou en demi-largeur. Si cette valeur est sélectionnée, les caractères katakana écrits en pleine largeur sont considérés comme égaux aux mêmes caractères écrits en demi-largeur.

System.Globalization.CultureInfo.CurrentCulture.CompareInfo.Compare(
    "2ch", "２ｃｈ", System.Globalization.CompareOptions.IgnoreWidth); 

renvoie 0, soit identique

Je vous suggère fortement ne considèrent ces valeurs identiques ou causer la confusion la ligne si vous voulez vraiment changer:

//CaseSensitive property uses this under the hood 
internal bool SetCaseSensitiveValue(
    bool isCaseSensitive, bool userSet, bool resetIndexes) 
{ 
    if (!userSet && (
     this._caseSensitiveUserSet || (this._caseSensitive == isCaseSensitive))) 
    { 
     return false; 
    } 
    this._caseSensitive = isCaseSensitive; 
    if (isCaseSensitive) 
    { 
     this._compareFlags = CompareOptions.None; 
    } 
    else 
    { 
     this._compareFlags = CompareOptions.IgnoreWidth | 
          CompareOptions.IgnoreKanaType | 
          CompareOptions.IgnoreCase; 
    } 
    if (resetIndexes) 
    { 
     this.ResetIndexes(); 
     foreach (Constraint constraint in this.Constraints) 
     { 
      constraint.CheckConstraint(); 
     } 
    } 
    return true; 
} 

Ainsi, vous pouvez ignorer les cas et désactiver totalement les options de comparaison complexes.

Si vous voulez faire un dictionnaire avec le même comportement utiliser le comparateur suivant:

public class DataTableIgnoreCaseComparer : IEqualityComparer<string> 
{ 
    private readonly System.Globalization.CompareInfo ci = 
     System.Globalization.CultureInfo.CurrentCulture.CompareInfo; 
    private const System.Globalization.CompareOptions options = 
     CompareOptions.IgnoreCase | 
     CompareOptions.IgnoreKanaType | 
     CompareOptions.IgnoreWidth; 

    public DataTableIgnoreCaseComparer() {} 

    public bool Equals(string a, string b) 
    { 
     return ci.Compare(a, b, options) == 0; 
    } 

    public int GetHashCode(string s) 
    { 
     return ci.GetSortKey(s, options).GetHashCode(); 
    } 
} 

Answer 2

Où placez-vous la chaîne dans la rangée? Il me semble que vous créez des lignes vides et en insérant 2 d'entre eux?

Quelque chose comme ça?

 foreach (string item in buf) 
     { 
      row = bulkInserTable.NewRow(); 
      row["Name"] = item;//Set the data<------------ 
      bulkInserTable.Rows.Add(row); 
     } 

Answer 3

Il semble que le codage est différent sur la deuxième chaîne. Lors du débogage, la deuxième chaîne revient en tant que poubelle. Si je supprime la deuxième chaîne et entrez "2 c h" dans Visual Studio, cela fonctionne correctement.

Answer 4

Cela dépend de ce que vous entendez par "le même".

Les deux chaînes ont des valeurs Unicode différentes, mais je suppose que dans certaines règles de normalisation, elles seraient identiques. Juste pour que d'autres puissent le reproduire facilement sans problèmes de couper et coller, la deuxième chaîne est:

"\uff12\uff43\uff48" 

Ce sont les versions "full width" de « 2ch ». EDIT: Pour répondre à votre modification, il est clair que le DataSet utilise une autre idée d'égalité, tandis que si vous ne fournissez rien de spécifique, Dictionary utilisera des comparaisons ordinales (fournies par string lui-même).

EDIT: Je suis assez sûr que le problème est que le DataTable utilise CompareOptions.IgnoreWidth:

using System; 
using System.Data; 
using System.Globalization; 

class Test 
{ 
    static void Main() 
    { 
     string a = "2ch"; 
     string b = "\uff12\uff43\uff48"; 

     DataTable table = new DataTable();    
     CompareInfo ci = table.Locale.CompareInfo; 

     // Prints 0, i.e. equal 
     Console.WriteLine(ci.Compare(a, b, CompareOptions.IgnoreWidth)); 
    } 
} 

EDIT: Si vous définissez CaseSensitive propriété du DataTable à vrai, je pense qu'il se comportera de la Identique à Dictionary.