public void Inserir(uint código, DbFoto miniatura)
 {
     hashMiniaturas[código] = miniatura;
     if ((DateTime.Now - últimoSalvamento).TotalSeconds > intervaloSegundosSalvamento)
     {
         lock (this)
         {
             if ((DateTime.Now - últimoSalvamento).TotalSeconds > intervaloSegundosSalvamento)
                 Salvar();
         }
     }
 }
 /// <summary>
 /// Libera a foto da memória.
 /// </summary>
 public void LiberarÍcone()
 {
     if (icone != null)
     {
         lock (this)
         {
             icone.Dispose();
             icone = null;
         }
     }
 }
		public void Dispose()
		{
            if (icone != null)
            {
                icone.Dispose();
                icone = null;
            }
		}
        private void Carregar()
        {
            hashMercadoriaMiniatura = new Dictionary<string, uint>(StringComparer.Ordinal);

            IDbConnection conexão;
            IDataReader leitor = null;

            conexão = Conexão;

            lock (conexão)
            {
                Usuários.UsuárioAtual.GerenciadorConexões.RemoverConexão(conexão);

                using (IDbCommand cmd = conexão.CreateCommand())
                {
                    cmd.CommandText = "SELECT mercadoria, codigo FROM foto";

                    using (leitor = cmd.ExecuteReader())
                    {

                        try
                        {
                            while (leitor.Read())
                            {
                                string referência = leitor.GetString(0);
                                uint códigoFoto;

                                códigoFoto = (uint)leitor.GetInt32(1);
                                string chave = GerarChave(referência);

                                hashMercadoriaMiniatura[chave] = códigoFoto;
                            }

                        }
                        finally
                        {
                            if (leitor != null)
                                leitor.Close();

                            Usuários.UsuárioAtual.GerenciadorConexões.AdicionarConexão(conexão);
                        }
                    }
                }
            }

            // Agora carrega as miniaturas do XML

            if (!System.IO.File.Exists(arquivoXml))
                return;

            XmlTextReader objXmlTextReader = new XmlTextReader(arquivoXml);

            uint códigoMiniatura = 0;
            byte[] miniatura;
            miniaturasSalvas = 0;

            string sName = "";

            try
            {
                while (objXmlTextReader.Read())
                {
                    switch (objXmlTextReader.NodeType)
                    {
                        case XmlNodeType.Element:
                            sName = objXmlTextReader.Name;
                            break;
                        case XmlNodeType.Text:
                            switch (sName)
                            {
                                case "Código":
                                    códigoMiniatura = uint.Parse(objXmlTextReader.Value);
                                    break;
                                case "Miniatura":
                                    miniatura = codificador.GetBytes(objXmlTextReader.Value);

                                    DbFoto entidade = new DbFoto(miniatura);
                                    hashMiniaturas.Add(códigoMiniatura, entidade);
                                    miniaturasSalvas++;
                                    break;
                            }
                            break;
                    }
                }
            }
            catch (Exception)
            {
                // Erro no arquivo de miniaturas.
                try
                {
                    System.IO.File.Delete(arquivoXml);
                }
                catch (Exception)
                {
                }
            } 
            finally
            {
                if (objXmlTextReader != null)
                    objXmlTextReader.Close();
            }
            
            Console.WriteLine(miniaturasSalvas.ToString() + " miniaturas carregadas!");
        }
        /// <summary>
        /// Dado o código, retorna a foto.
        /// Método padrão para obtenção de miniaturas via cache.
        /// Obtem várias miniaturas de uma só vez, seja da cache seja do banco de dados.
        /// </summary>
        /// <param name="?"></param>
        public void ObterMiniaturas(Dictionary<uint, Foto> fotos)
        {
            IDbConnection conexão;
            IDataReader leitor = null;

            StringBuilder comando = new StringBuilder("SELECT codigo, foto from foto where codigo IN (");
            int contadorObtençãoFoto = 0;

            foreach (uint código in fotos.Keys)
            {
                if (!hashMiniaturas.ContainsKey(código))
                {
                    // Realizar consulta no banco
                    if (contadorObtençãoFoto > 0)
                        comando.Append(", ");

                    comando.Append(código.ToString());
                    contadorObtençãoFoto++;
                }
            }
            comando.Append(")");

            if (contadorObtençãoFoto > 0)
            {
                // Necessário realizar consulta no banco
                conexão = Conexão;

                lock (conexão)
                {
                    Usuários.UsuárioAtual.GerenciadorConexões.RemoverConexão(conexão);


                    using (IDbCommand cmd = conexão.CreateCommand())
                    {
                        cmd.CommandText = comando.ToString();

                        using (leitor = cmd.ExecuteReader())
                        {

                            try
                            {
                                while (leitor.Read())
                                {
                                    uint código = (uint)leitor.GetInt32(0);
                                    Foto entidade = fotos[código];

                                    DbFoto foto = new DbFoto((byte[])leitor.GetValue(1));

                                    if (foto.Imagem != null)
                                    {
                                        double proporção = foto.Imagem.Width / (double)foto.Imagem.Height;
                                        int width, height;

                                        if (foto.Imagem.Width > foto.Imagem.Height)
                                        {
                                            width = Foto.tamanhoMaiorLadoMiniatura;
                                            height = Convert.ToInt32(Foto.tamanhoMaiorLadoMiniatura / proporção);
                                        }
                                        else
                                        {
                                            width = Convert.ToInt32(proporção * Foto.tamanhoMaiorLadoMiniatura);
                                            height = Foto.tamanhoMaiorLadoMiniatura;
                                        }

                                        Inserir(entidade.Código, foto.Imagem.GetThumbnailImage(width, height, null, IntPtr.Zero));
                                    }
                                }
                            }
                            finally
                            {
                                if (leitor != null)
                                    leitor.Close();

                                Usuários.UsuárioAtual.GerenciadorConexões.AdicionarConexão(conexão);
                            }
                        }
                    }
                }
            }

            Console.WriteLine("Obtenção em batch de " + fotos.Count.ToString() + ". Foi necessário SQL p/ " + contadorObtençãoFoto.ToString() + " fotos.");
        }