Quelques petits trucs :

au lieu de faire une fonction :
public string[] LireFichier(string parametre)
une fonction :
public bool EssaiLireFichier(string parametre,out string valeur)
serait plus propre.

le paramêtre out permet de créer un paramêtre de sortie, lu'tilisation de la fonction devient plus simple :

string valeurdemonparam;
string monparam = "MonParam";
if(EssaiLireFichier(monparam, out valeurdemonparam))
{
//ici valeurdemonparam correctement récupéré
Debug.WriteLine(string.Format("[{0}] vaut [{1}]", monparam, valeurdemonparam));
}
else
{
//ici valeurdemonparam non récupéré
Debug.WriteLine(string.Format("Impossible de lire [{0}]", monparam));
}

pour codé une telle fonction voilà le principe :

public bool EssaiLireFichier(string parametre,out string valeur)
{
//ici quand on as pus lire
valeur = valeurlu;
return true;

//ici quand on as pas pus lire
valeur = string.Empty;
return false;
}

Ensuite, à propos de la "fausse constante" :
string RCNL = Environment.NewLine;
tu peux écrire :
string readonly RCNL = Environment.NewLine;

ca empecheras toute modification ultérieur de la valeur qui devient une pseudo constante.

Attention toutefois :
  truc readonly trucconstant = new truc();
empêchera de faire
trucconstant = new truc();
mais pas
trucconstant.machin = new machin();

Il n'a actuellement aucun commentaire, je considère cette source comme non terminer tant que je n'aurais pas réussi à régler le problème de TemplateBinding, si vous avez idée de se qui pose problème, n'hésité pas à m'en faire part!

Il y'as 2 projet, Malkuth.Controls qui contient les contrôles Surface et SurfaceItem, l'autre projet est une petite application pour montrer l'utilisation et la facilité a intégré des éléments très divers dans les SurfaceItem.

Voilà un exemple complet avec implémantation du IDatareader :
http://www.csharpfr.com/codes/BULKINSERT-CSHARP_49377.aspx

Le cross aplly est effectivement trés pratique mais je doute vraiment que les performances soient au rendez vous.

sur 10 000 000 de lignes traitée la charge de travail deviens vraiment colosale et je crois que chaque partie d'un produit doit être utilisé pour ce qu'il sait le mieux faire, et pour moi C# est bien plus performant en transformation linéaire de donnée que SQL Serveur.

Sle projet avais été pure SQL pourquoi pas (enfin je pense que TheOnlyMaX à une solution plus performante) mais étant donnée qu'il nous présente un code C# j'en conclu qu'il a donc du C# dans son projet donc autant l'utiliser là ou il est mieux indiquer...

@TheOnlyMaX : serait'il possible que tu me passe un de tes fichiers d'importation type? (un Fake bien entendu) avec la table dans laquelle les données sont placé au final(déclaration SQL) afin de consolidé mon code pour un cas réaliste? pour infos je suis à un temps de 11 sec de traitement pour lecture/néttoyage/vérification métier sur un fichier de 10 000 000 de ligne et 3 colones (reste a traiter le bulkinsert en lui même) et ce code est trés loin d'un code optimisé.

Alors en fait, si tu baisse la valeur, c'est aussi baisser l'intêret du bulkcopy (aprés on peu tester différentes valeurs et en trouver une correct dans ton cas de maniére empirique).

Ensuite, ce code peux êtres déployé sur une autre serveur donc on déplace le probléme de charge mémoire/Travaille vers une machine qui n'auras pas la même importance dans le process glabal (voir dédier).

enfin, comme je le disait dans le dernier commentaire la fonction de transfert au serveur accept les interface IDatareader, celle ci représente un flux de lecture de donnée en avant uniquement, elle n'as donc pas besion de "Buffériser" les données, en gros pour expilquer l'interface:

une fonction ReadNext qui avannce d'une ligne le flux.
des fonction GetInt32(int col)/GetString(int col)/... qui lise la donnée de la [col] dans la ligne courante.
plusieur fonctions qui permette de gérés les métadonnée(nom de colone,type des colones etc.

En utilisant les fonction précédante et en les encapsulant dans une classe implémantant cette interface, on peu arrivé a ne jamais avoir plus d'une ligne de donné en mémoire.

Attention, en disant cela jetiens a présisé que je ne connait pas le fonctionnement interne de l'objet SqlBulkCopy, a t'il un buffer interne? a voir... un point important aussi, il faut bien pensé paramettré le Timeout car si l'opération est longue celui ci est vite dépassé et mettre une valeur trop longue peux complétement bugé le tout.

Enfin l'objet SqlBulkCopy posséde plusieur constructeur simpathique dont notement un constructeur permetant de spécifier une transaction et les option de Bulk (déclanchement des triggers,gestion des NULL/AutoIncrément etc, ce qui le rend particuliérement complet.

Un dernier point intérréssant de cette technique est sa souplesse il est trés facile d'introduire plusieurs couches de travaille intermédiare et de faire un code trés modulaire. ex :

Ajout d'un process de validation Métier:

public IEnumerable<donnéestructurées> ValidationMetier IEnumerable<donnéestructurées> donnéesavérifier)
        {
            foreach (donnéestructurées lignepropre in donnéesavérifier)
            {
                if (lignepropre.col_age < 10
                || lignepropre.col_age > 20
                || string.IsNullOrEmpty(lignepropre.col_nom))
                    // si ca va pas on reprend le traitement a la ligne suivante
                    continue;

                //Si tout va bien on envoie la ligne propre et on continue ;)
                yield return lignepropre;
            }
        }

Ce qui permet maintenant de faire :

Insererligne(ValidationMetier(nettoyerlignes(lireLignes("monfic.csv"))));

Maintenant, admettons que le fichier de départ est maintenant un XML :

public IEnumerable<donnéestructurées> LireDonnéesXML(string fichierxml)
{
....
yield return ...;
....
}

On peut mtn faire :
Insererligne(ValidationMetier(LireDonnéesXML("monfic.xml")))



La ca devient trés simpa car on a pu reprendre facilement le code commun sans ce prendre la tête et en gardant une compatibilité avec l'ancien code qui peut toujours servir si les deux type de fichier sont utilisé...

Enfin cette maniére de faire permet trés facilemet de test chaque fonction hors context et de valider son process:

public IEnumerable<string> fauxlecteur()
{
    yield return "Tom;10;";
    yield return "Rom;20";
    yield return "Tiemh";
}
public void VérificationNetoyage(IEnumerable<donnéestructurées> données)
{
    IEnumerator<donnéestructurées> enum = données.GetEnumerator();

    if(!enum.MoveNext()) throw new Exception();
    if(enum.Current.col_nom!= "Tom") throw new Exception();
    if(enum.Current.col_age!= 10) throw new Exception();

    if(!enum.MoveNext()) throw new Exception();
    if(enum.Current.col_nom!= "Rom") throw new Exception();
    if(enum.Current.col_age!= 20) throw new Exception();

    if(enum.MoveNext()) throw new Exception();
}

maintenant si on fais : VérificationNetoyage(nettoyerlignes(fauxlecteur())); et qu'on obtient une exception alors le nétoyage ne fonctionne pas comme on l'attendrais!


Vu que ca à l'air de plaire, je vais trouvé un peux de temps se weekend pour faire une source d'exemple complette.

en fait on remarque que le WriteToServeur peut aussi utilisé une interface IDataReader en paramêtre, donc pour allez un peu plus loin le mieux serais d'encapsuler les 2 fonctions dans une classe implémentant IDataReader ce qui évite de se retrouver a gérer un buffer en DataTable (j'ai horreur de ces objets DataRow/DataTable etc...) et la on aurais vraiment un programm entiérement "A la Volé" mais bon cette interface est un peu longue a implémenter pour un commentaire...peut être un code prochain.

oups, aprés la boucle foreach dans Insererligne il manque :

                        if((nblignes%100000)!=0)
                            cpy.WriteToServer(donnéespretes);

Lecture/ nétoyage à la volé ca veut dire en gros tu lis une ligne du fichier, tu la notoie aussitôt et tu la transmet au serveur.

donc, lire une à une les ligne d'un fichier texte ca donne un truc du genre :

        public IEnumerable<string> lireLignes(string cheminfichier)
        {
            string ligne;
            using (TextReader txtstrm = File.OpenText(cheminfichier))
                while ((ligne = txtstrm.ReadLine()) != null)
                    yield return ligne;
        }

ensuite on doit les néttoyé on va séparé ca en 2 phases : l'extraction des données puis leur vérification pour des d'optimisation certain les 2 étape peuvent être plus ou moins mélé, au passage on crée une petite structure légére pour conservé les donnée nétoyé (et typé d'ailleurs...)


        public struct donnéestructurées
        {
            public string col_nom;
            public int col_age;
        }


        public IEnumerable<donnéestructurées> nettoyerlignes(IEnumerable<string> lignesbrute)
        {
            foreach (string ligne in lignesbrute)
            {
                donnéestructurées lignepropre = new donnéestructurées();

                //extraction des données
                string[] donnesintermediaire = ligne.Split(';');
                if (donnesintermediaire.Length != 2) continue;// si ca va pas on reprend le traitement a la ligne suivante
                lignepropre.col_nom = donnesintermediaire[0];
                int.TryParse(donnesintermediaire[1],out lignepropre.col_age);

                //Vérification de la bonne conformitée des données
                if (lignepropre.col_age < 10
                || lignepropre.col_age > 20
                || string.IsNullOrEmpty(lignepropre.col_nom))
                    // si ca va pas on reprend le traitement a la ligne suivante
                    continue;

                //Si tout va bien on envoie la ligne propre et on continue ;)
                yield return lignepropre;
            }
        }

maintenant, on a donc moyen des récupéré des donnée propres juste en faisant:

nettoyerlignes(lireLignes("monfic.csv"));

(je ne sais pas ta connaissance éxacte de C# mais si tu fais une exécution pas à pas de ce code tu véras que contrairement au aparance, il lit une ligne, la nétoi, lit la suivante, la nétoi etc, si ce mécanisme t'est inconnue renseigne toi sur le mot clef yield, si connais déjà tout ca, oublie mon commentaire ;) )


alors maintenant on as des donnée propre, il faut les envoyés au serveur, solution un, une suite d'insert, a oublier dans ton cas on est bien d'accord, Solution 2, envoyé les donnée sous forme XML trés bien pour un volume moyen mais pas assez rapide pour 10millions de lignes ^^ solution 3 le Bulk insert (ouai on est d'accord ^^) et pour le bulkinsert y'a une classe pas mal foutu en .NET : System.Data.SqlClient.SqlBulkCopy

ca permet d'accéder a la plupart des fonctionnalité  de Bulkinsert directement depuis le code(donc sans avoir besiion de réécrire les données dans un fichier.

voici un exemple


        public void Insererligne(IEnumerable<donnéestructurées> données)
        {
            using(SqlConnection con = new SqlConnection("maconnexion"))
            {
                using (SqlBulkCopy cpy = new SqlBulkCopy(con))
                {
                    cpy.BulkCopyTimeout = 100000;
                    cpy.BatchSize = 100000;
                    cpy.DestinationTableName = "matablefinal";
                    cpy.ColumnMappings.Add("col_nom", "Nom");
                    cpy.ColumnMappings.Add("col_age", "Age");

                    DataTable donnéespretes = new DataTable();

                    DataColumn cNom = new DataColumn("col_nom", typeof(string));
                    donnéespretes.Columns.Add(cNom);

                    DataColumn cAge = new DataColumn("col_age", typeof(int));
                    donnéespretes.Columns.Add(cAge);
                    int nblignes = 0;
                    foreach (donnéestructurées donné in données)
                    {
                        DataRow row = donnéespretes.NewRow();
                        row[cNom] = donné.col_nom;
                        row[cAge] = donné.col_nom;
                        donnéespretes.Rows.Add(row);

                        if((nblignes%100000)==0)
                            cpy.WriteToServer(donnéespretes);
                    }
                }
            }
        }

donc maintenant tu fais : Insererligne(nettoyerlignes(lireLignes("monfic.csv")));
et ca roule.

Le code es pas optimiser pour 2 sous mais même en l'état il doit être bien plus performant.

Je rejoins tmcuh, je pense que la método n'est pas optimal(mais on as pas forcerment toute les infos...)

a lors actuel tu fais :
BulkInsert d'un CSV en table intermédiaire
Nettoyage/insertion final

Clairement SQL n'est pas le meilleur choix pour le nétoyage(qq bench pourrons facilement le prouver).

je pense que tu aurais plutot du utilisé la métho suivante :
Lecture/Nétoyage du CSV (netoyage a la volée)
bulkinsert dans la table final.

tu dispose de la classe [System.Data.SqlClient.SqlBulkCopy] qui permet de commander facilement l'insertion Bulk directement depuis C#.

D'abord ca me semble plus logique et surtout, Ca permet de déporter la charge de nettoyage sur une machine différente (voir plusieurs...)

Je vais essayer de me dégager un peu de temps se weekend pour mettre un peu a jour cette source et prendre en compte tes ajout, concernant l'encodage, je ne suis convaincu ni par le UTF8 ni par le et moins encore par le default qui risque d'être génant lors d'échange avec des system reposant sur d'autre encodage (unix/linux notament), en fait je pense rajouter un propriéter encoding sur le constructeur se qui me déchargeras de toute "responsabilitée" et rendra le code plus maléable :p

je vais aussi supprimer les Encoding.GetBytes(...) qui oblige a maintenir en mémoire des tableau d'octets volumineux l'utilisation de TextWriter seras a la fois plus eficace plus simple et finalement plus compréhensible.