/// <summary>
        /// Comando usato per aggiornare il contenuto di un file sul server.
        /// </summary>
        /// <exception>ServerExeption con un codice corrispondente all'errore riscontrato</exception>
        public override bool esegui()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(nome_comando).Append(Environment.NewLine).
            Append(nome_file).Append(Environment.NewLine).
            Append(path).Append(Environment.NewLine).
            Append(t_modifica.Ticks).Append(Environment.NewLine).
            Append(sha_contenuto).Append(Environment.NewLine).
            Append(dim).Append(Environment.NewLine).
            Append(Environment.NewLine);
            sendData(sb.ToString());
            //control_stream_writer.Write(sb.ToString());
            //control_stream_writer.Flush();
            string response       = null;
            var    respEnumerator = getResponses().GetEnumerator();

            if (!respEnumerator.MoveNext() || respEnumerator.Current == null)
            {
                Monitor.Exit(sharedLock);
                return(false);
            }
            response = respEnumerator.Current;
            respEnumerator.MoveNext();
            try {
                data_stream = CollegamentoDati.getCollegamentoDati(response);
            }
            catch
            {
                error_message = Properties.Messaggi.collegamentoDati;
                error_code    = ServerErrorCode.CollegamentoDatiNonDisponibile;
                Connected     = false;
                Monitor.Exit(sharedLock);
                return(false);
            }

            byte[] buffer = new byte[1024];
            int    size   = 1024;

            try
            {
                while ((size = file.Read(buffer, 0, size)) != 0)
                {
                    data_stream.Write(buffer, 0, size);
                    data_stream.Flush();
                }
                data_stream.Close();
                file.Close();
            }
            catch
            {
                error_message = Properties.Messaggi.erroreConnessioneServer;
                error_code    = ServerErrorCode.ConnessioneInterrotta;
                Monitor.Exit(sharedLock);
                return(false);
            }
            //Leggo la risposta (se tutto è andato bene o c'è stato un errore)
            Monitor.Exit(sharedLock);
            if (!respEnumerator.MoveNext())
            {
                return(false);
            }
            response = respEnumerator.Current;
            if (response == null)
            {
                return(false);
            }
            return(true);
        }
        /// <summary>
        /// Carica la versione richiesta del file all'utente che lo richiede.
        /// </summary>
        /// <param name="s"></param>
        /// <param name="dati">
        ///     [0]: nome_file
        ///     [1]: path relativo
        ///     [2]: timestamp versione (in Ticks)
        /// </param>
        /// <returns>
        /// OK intermedio
        /// token
        /// dimensione file
        /// sha contenuto
        /// </returns>
        public override bool esegui()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(nome_comando).Append(Environment.NewLine).
            Append(nome_file).Append(Environment.NewLine).
            Append(path).Append(Environment.NewLine).
            Append(t_creazione.Ticks).Append(Environment.NewLine).
            Append(Environment.NewLine);
            sendData(sb.ToString());
            //control_stream_writer.Write(sb.ToString());
            //control_stream_writer.Flush();
            string response       = null;
            var    respEnumerator = getResponses().GetEnumerator();

            respEnumerator.MoveNext();
            response = respEnumerator.Current;
            if (response == null)
            {
                Monitor.Exit(sharedLock);
                return(false);
            }
            try
            {
                string token = response;
                if (!respEnumerator.MoveNext() || respEnumerator.Current == null)
                {
                    Monitor.Exit(sharedLock);
                    return(false);
                }
                this.dim = Int32.Parse(respEnumerator.Current);
                if (!respEnumerator.MoveNext() || respEnumerator.Current == null)
                {
                    Monitor.Exit(sharedLock);
                    return(false);
                }
                this.sha_contenuto = respEnumerator.Current;
                data_stream        = CollegamentoDati.getCollegamentoDati(token);
                respEnumerator.MoveNext();
            }
            catch
            {
                Monitor.Exit(sharedLock);
                error_message = Properties.Messaggi.collegamentoDati;
                error_code    = ServerErrorCode.CollegamentoDatiNonDisponibile;
                Connected     = false;
                return(false);
            }
            byte[] buffer   = new byte[1024];
            int    size     = 1024;
            int    tot_read = 0;

            try
            {
                while ((size = data_stream.Read(buffer, 0, size)) != 0)
                {
                    //Scrivo su un file temporaneo. Se tutto va bene sostituisco quello presente
                    //nella cartella dell'utente
                    tot_read += size;
                    tmp_file.Write(buffer, 0, size);
                    tmp_file.Flush();
                }
            }
            catch
            {
                Monitor.Exit(sharedLock);
                error_message = Properties.Messaggi.erroreConnessioneServer;
                error_code    = ServerErrorCode.ConnessioneInterrotta;
                Connected     = false;
                return(false);
            }
            finally
            {
                tmp_file.Close();
                data_stream.Close();
            }

            if (tot_read != this.dim)
            {
                error_message = Properties.Messaggi.datiInconsistenti;
                error_code    = ServerErrorCode.DatiInconsistenti;
                Monitor.Exit(sharedLock);
                return(false);
            }
            SHA256 sha_obj = SHA256Managed.Create();

            byte[] hash_val;
            tmp_file = File.Open(tmp_path, FileMode.Open);
            hash_val = sha_obj.ComputeHash(tmp_file);
            tmp_file.Close();
            StringBuilder hex = new StringBuilder(hash_val.Length * 2);

            foreach (byte b in hash_val)
            {
                hex.AppendFormat("{0:x2}", b);
            }
            string sha_reale = hex.ToString();

            if (sha_reale != sha_contenuto.Trim())
            {
                error_message = Properties.Messaggi.datiInconsistenti;
                error_code    = ServerErrorCode.DatiInconsistenti;
                Monitor.Exit(sharedLock);
                return(false);
            }

            if (!respEnumerator.MoveNext() || respEnumerator.Current == null)
            {
                Monitor.Exit(sharedLock);
                return(false);
            }

            while (respEnumerator.MoveNext())
            {
                ;
            }
            Monitor.Exit(sharedLock);
            FileUtenteList list = FileUtenteList.getInstance();

            //vado a vedere il flag di validità sul db
            //se è TRUE -> è una retrive di un file esistente
            //se è FALSE -> è una retrive di un file cancellato

            if (list.getValidity(this.nome_file, this.path) == true)
            {
                list[this.nome_file, this.path].aggiornaDatiPrec(this.dim, this.t_creazione, this.SHAContenuto);
            }
            else
            {
                FileUtente[] deleted = list.Deleted;
                foreach (FileUtente fu in deleted)
                {
                    if (fu.Nome == this.nome_file && fu.Path == this.path)
                    {
                        list.Ripristina(fu.Id);
                        fu.aggiornaDatiPrec(this.dim, this.t_creazione, this.SHAContenuto);
                        break;
                    }
                }
            }
            try
            {
                // Ensure that the target does not exist.
                if (File.Exists(path_completo))
                {
                    File.Delete(path_completo);
                }
                // Move the file.
                File.Move(tmp_path, path_completo);
            }
            catch (Exception e)
            {
                error_message = "Errore nel sostituire la versione precedente. " + e.Message;
                error_code    = ServerErrorCode.Unknown;
                return(false);
            }
            return(true);
        }