/// <summary>
        /// Remove um objeto da persistencia
        /// </summary>
        /// <param name="codigo"></param>
        public RemoverObjetoResponse <T> RemoverObjeto <T>(RemoverObjetoRequest <T> parametros) where T : ICodigoEntidade
        {
            // Permite que o hook interfira no processamento
            if (this.EventoRemover != null)
            {
                // Cria eventargs para permitir que o hook crie sua resposta
                PersistenciaArquivoEventoEventArgs eventArgs =
                    new PersistenciaArquivoEventoEventArgs()
                {
                    MensagemRequest = parametros
                };

                // Faz a chamada do hook
                this.EventoRemover(this, eventArgs);

                // Se tem resposta, é a que deve ser retornada
                if (eventArgs.MensagemResponse != null)
                {
                    return(eventArgs.MensagemResponse as RemoverObjetoResponse <T>);
                }
            }

            // Remove da coleção
            _persistenciaHelper.Entidades.Remove(gerarChaveEntidade(typeof(T), parametros.CodigoObjeto));

            // Retorna
            return(new RemoverObjetoResponse <T>());
        }
        /// <summary>
        /// Salva um objeto na persistencia.
        /// Overload do método para trabalhar com mensagens
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="objeto"></param>
        public SalvarObjetoResponse <T> SalvarObjeto <T>(SalvarObjetoRequest <T> parametros) where T : ICodigoEntidade
        {
            // Permite que o hook interfira no processamento
            if (this.EventoSalvar != null)
            {
                // Cria eventargs para permitir que o hook crie sua resposta
                PersistenciaArquivoEventoEventArgs eventArgs =
                    new PersistenciaArquivoEventoEventArgs()
                {
                    MensagemRequest = parametros
                };

                // Faz a chamada do hook
                this.EventoSalvar(this, eventArgs);

                // Se tem resposta, é a que deve ser retornada
                if (eventArgs.MensagemResponse != null)
                {
                    return(eventArgs.MensagemResponse as SalvarObjetoResponse <T>);
                }
            }

            // Pega o código da entidade
            string codigoEntidade = ((ICodigoEntidade)parametros.Objeto).ReceberCodigo();

            // Serializa
            EntidadeInfo entidadeInfo = serializar <T>(parametros.Objeto);

            // Verifica se já existe para adicionar ou alterar
            string chave = gerarChaveEntidade(entidadeInfo);

            lock (_persistenciaHelper)
                if (_persistenciaHelper.Entidades.ContainsKey(chave))
                {
                    _persistenciaHelper.Entidades[chave] = entidadeInfo;
                }
                else
                {
                    _persistenciaHelper.Entidades.Add(chave, entidadeInfo);
                }

            // Retorna
            return
                (new SalvarObjetoResponse <T>()
            {
                Objeto = parametros.Objeto
            });
        }
        /// <summary>
        /// Recebe o objeto desejado
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="codigo"></param>
        /// <returns></returns>
        public ReceberObjetoResponse <T> ReceberObjeto <T>(ReceberObjetoRequest <T> parametros) where T : ICodigoEntidade
        {
            // Permite que o hook interfira no processamento
            if (this.EventoReceber != null)
            {
                // Cria eventargs para permitir que o hook crie sua resposta
                PersistenciaArquivoEventoEventArgs eventArgs =
                    new PersistenciaArquivoEventoEventArgs()
                {
                    MensagemRequest = parametros
                };

                // Faz a chamada do hook
                this.EventoReceber(this, eventArgs);

                // Se tem resposta, é a que deve ser retornada
                if (eventArgs.MensagemResponse != null)
                {
                    return(eventArgs.MensagemResponse as ReceberObjetoResponse <T>);
                }
            }

            // Verifica se existe e retorna
            string chave = gerarChaveEntidade(typeof(T), parametros.CodigoObjeto);

            if (_persistenciaHelper.Entidades.ContainsKey(chave))
            {
                return new ReceberObjetoResponse <T>()
                       {
                           Objeto = desserializar <T>(_persistenciaHelper.Entidades[chave])
                       }
            }
            ;
            else
            {
                return new ReceberObjetoResponse <T>()
                       {
                           Objeto = default(T)
                       }
            };
        }
        /// <summary>
        /// Lista os objetos do tipo informado que obedecem às condições.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="condicoes"></param>
        /// <returns></returns>
        public ConsultarObjetosResponse <T> ConsultarObjetos <T>(ConsultarObjetosRequest <T> parametros) where T : ICodigoEntidade
        {
            // Permite que o hook interfira no processamento
            if (this.EventoConsultar != null)
            {
                // Cria eventargs para permitir que o hook crie sua resposta
                PersistenciaArquivoEventoEventArgs eventArgs =
                    new PersistenciaArquivoEventoEventArgs()
                {
                    MensagemRequest = parametros
                };

                // Faz a chamada do hook
                this.EventoConsultar(this, eventArgs);

                // Se tem resposta, é a que deve ser retornada
                if (eventArgs.MensagemResponse != null)
                {
                    return(eventArgs.MensagemResponse as ConsultarObjetosResponse <T>);
                }
            }

            // Lista todas as entidades do tipo informado
            IEnumerable <EntidadeInfo> entidadesInfo =
                from e in _persistenciaHelper.Entidades
                where e.Value.TipoObjeto == typeof(T).FullName
                select e.Value;

            // Inicializa
            ConsultarObjetosResponse <T> retorno = new ConsultarObjetosResponse <T>();

            retorno.Resultado = desserializar <T>(entidadesInfo);

            // Faz os filtros
            foreach (CondicaoInfo condicao in parametros.Condicoes)
            {
                // Faz o filtro
                retorno.Resultado =
                    retorno.Resultado.Where <T>(
                        delegate(T obj)
                {
                    // Inicializa
                    bool retorno2 = false;

                    // Pega o valor da propriedade
                    PropertyInfo ppInfo = typeof(T).GetProperty(condicao.Propriedade);
                    Type tipoValor      = ppInfo.PropertyType;
                    object valor        = ppInfo.GetValue(obj, null);

                    // Testa a condicao
                    switch (condicao.TipoCondicao)
                    {
                    case CondicaoTipoEnum.Igual:
                        if (valor != null)
                        {
                            retorno2 = valor.Equals(condicao.Valores[0]);
                        }
                        else
                        {
                            retorno2 = valor == condicao.Valores[0];
                        }
                        break;

                    case CondicaoTipoEnum.Diferente:
                        if (valor != null)
                        {
                            retorno2 = !valor.Equals(condicao.Valores[0]);
                        }
                        else
                        {
                            retorno2 = !(valor == condicao.Valores[0]);
                        }
                        break;

                    case CondicaoTipoEnum.Maior:
                        if (valor != null)
                        {
                            retorno2 = ((IComparable)valor).CompareTo(Convert.ChangeType(condicao.Valores[0], tipoValor)) > 0;
                        }
                        break;

                    case CondicaoTipoEnum.MaiorIgual:
                        if (valor != null)
                        {
                            retorno2 = ((IComparable)valor).CompareTo(Convert.ChangeType(condicao.Valores[0], tipoValor)) >= 0;
                        }
                        break;

                    case CondicaoTipoEnum.Menor:
                        if (valor != null)
                        {
                            retorno2 = ((IComparable)valor).CompareTo(Convert.ChangeType(condicao.Valores[0], tipoValor)) < 0;
                        }
                        break;

                    case CondicaoTipoEnum.MenorIgual:
                        if (valor != null)
                        {
                            retorno2 = ((IComparable)valor).CompareTo(Convert.ChangeType(condicao.Valores[0], tipoValor)) <= 0;
                        }
                        break;
                    }

                    // Retorna
                    return(retorno2);
                }).ToList <T>();
            }

            // Retorna
            return(retorno);
        }