944 messaggi dal 11 febbraio 2013
Scusa il ritardo ma non sono stato a lavoro per una settimana...
ora provo

tuttavia mi sembra implicito che debbo creare una classe per ogni tabella...
mappare tutte le tabelle mi sembra in effetti la cosa piu OOP giusto ?

ti faccio sapere e grazie per il link che mi hai segnalato
944 messaggi dal 11 febbraio 2013
Hai ragione...sembra funzionare perfettamente
ovvero non ho problemi di caratteri non validi, non debbo gestire i separatori dei decimali e il file è piu leggero...solo ci mette piu tempo rispetto dataset.xmlwriter/reader.

Pero quando importo in tabella tronca i valori dei campi note (vedo solo un carattere nel campo) !!!

ho serializzato cosi:
String path = Server.MapPath("~/App_data/TABELLA.bin");
        if (File.Exists(path))
        {
            File.Delete(path);
        }

        String constr = ConfigurationManager.ConnectionStrings["ExportBackupConnectionString"].ConnectionString;
        using (SqlConnection conn = new SqlConnection(constr))
        {
            String select = "SELECT .... FROM TABELLA";
            using (SqlCommand comm = new SqlCommand(select, conn))
            {

                conn.Open();
                SqlDataReader reader = comm.ExecuteReader();
                BinaryFormatter formatter = new BinaryFormatter();
                while (reader.Read())
                {
                    TABELLA myTabella = new TABELLA();

                    myTabella.Anno = reader.GetInt16(0);
                    myTabella.xxx = reader.GetString(1);
                    myTabella.xxx = reader.GetString(2);
                    ...

                    using (FileStream stream = new FileStream(path, FileMode.Append, FileAccess.Write))
                    {
                        formatter.Serialize(stream, myTabella);
                    }
                }
            }
        }


e deserializzato cosi:

 long position = 0;
      
        String path = Server.MapPath("~/App_data/TABELLA.bin"); 
        
        BinaryFormatter formatter = new BinaryFormatter();

        TABELLA myTABELLA = null;
        using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
        {
            ConnectionImport impconn = new ConnectionImport();
            var openedConn = impconn.OpenConnection();

            while (position < stream.Length)
            {
            
                stream.Seek(position, SeekOrigin.Begin);
                myTABELLA = (TABELLA)formatter.Deserialize(stream);
                position = stream.Position;

                myTABELLA.Insert(openedConn, myTABELLA);
               
            }

            impconn.CloseDisposeConnection();
        }


ho creato una classe che rappresentasse la tabella e ho scritto un metodo insert:
public void Insert(SqlConnection ImportConn, TABELLA vTABELLA)
   {  
using (SqlCommand command = new SqlCommand("InsertTABELLA", ImportConn))
       {
           command.CommandType = System.Data.CommandType.StoredProcedure;

           command.Parameters.AddWithValue("@Anno", this.Anno); //smallint,
           command.Parameters.AddWithValue("@XXX", this.XXX);  //varchar,
      

           int numRec = command.ExecuteNonQuery();
   }
}


Che dici sbaglio qualcosa...si può rendere piu performante ?
grazie comunque infinite...non avevo provato la serializzazione binaria
Modificato da jjchuck il 15 marzo 2016 18.12 -
Modificato da jjchuck il 15 marzo 2016 18.41 -
11.886 messaggi dal 09 febbraio 2002
Contributi
Ciao, prego!
Metti un breakpoint sia nel punto in cui serializzi che deserializzi la classe e vedi se la proprietà Note ha il nome completo.
Se ti inserisce un solo carattere, vai anche a verificare se il campo varchar è abbastanza capiente nel db.

Per velocizzarlo un po', prova a serializzare liste di 10 o 100 oggetti alla volta.

ciao,
Moreno

Enjoy learning and just keep making
944 messaggi dal 11 febbraio 2013
nella classe della tabella ho dato il nome dei campi uguale a quello che hanno in tabella.
nella definizione tabella i campi hanno le dimensioni corrette infatti ho notato che anche i campi varchar(5) sono troncati.

Ho provato ha leggere il file binario con response.write e nel file i valori sono corretti ...quando importo invece no!

Anche nel metodo i valori passati come parametro per l'insert sono corretti...
tutti i campi varchar sono giusti...

non capisco cosa può mancare!
Modificato da jjchuck il 16 marzo 2016 10.33 -
944 messaggi dal 11 febbraio 2013
Niente ne ho provate diverse ma non capisco cosa manca...
magari ci fosse un SqlBulkCopy con file binari....
11.886 messaggi dal 09 febbraio 2002
Contributi
Non so, prova a debuggare la stored procedure in qualche modo.
Eseguendola da Sql Server Management Studio i dati vengono inseriti correttamente?

Eventualmente apri un altro thread nella sezione "Sql server" e posta il codice della SP.

Enjoy learning and just keep making
944 messaggi dal 11 febbraio 2013
Ho replicato il procedimento su una tabella di northwind e funziona perfettamente...
poi come mi hai detto della SP sono andato ad eseguirla e ho notato che la definizione dei parametri era sbagliata :

field1 varchar
field2 nchar...

per forza inseriva solo un carattere

grazie ancora

a presto e buon lavoro
944 messaggi dal 11 febbraio 2013
 int i = 0;
               while (reader.Read())
               {
                   for (; i <= 100; i++)
                   {
                      
                   Class myClass = new Class();

                   myClass.c1= reader.GetInt16(0);
                   myClass.c2= reader.GetString(1);
                   myClass.c3= reader.GetString(2);
                   myClass.c4= reader.GetString(3);
              
                   
                   
                   listClass.Add(myClass);
                               
                   }
                   i = 0;
               }
               reader.Close();

intendevi questo quando mi suggerivi di serializzare/deserializzare 100 oggetti alla volta?
Modificato da jjchuck il 20 marzo 2016 16.13 -

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.