Caique Dourado

Métodos para tratamento de Textos, Edição de Imagens, Conversão, Formatação, Comparação de Valores.

Download
Atualizador.Util
Atualizador.Util.Textos
Atualizador.Util.Imagem

using System;
using System.IO;
using System.IO.Compression;
using System.Web;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Data;

namespace Atualizador.Util
{

    public static class Textos
    {

        #region Trata Textos para correta exibição no Site

        //Trata Texto subistuindo os BBCode
        public static String trataTexto(object valor)
        {
            return trataTexto(valor, false, true, 0);
        }

        //Trata Texto subistuindo os BBCode e removendo o HTML
        public static String trataTexto(object valor, int numCaracteres)
        {
            return trataTexto(valor, true, true, numCaracteres);
        }

        //Trata Texto subistuindo os BBCode e/ou removendo o HTML
        public static String trataTexto(object valor, bool removerHtml)
        {
            return trataTexto(valor, removerHtml, true, 0);
        }

        //Trata Texto subistuindo os BBCode e/ou removendo o HTML e retornando uma quantidade determinada de caracteres
        public static String trataTexto(object valor, bool removerHtml, int numCaracteres)
        {
            return trataTexto(valor, removerHtml, true, numCaracteres);
        }

        //Trata Texto substituindo ou não os BBCode, removendo ou não o HTML, e retornando uma quantidade determinada de caracteres
        public static String trataTexto(object valor, bool removerHtml, bool substituirTagsEspeciais, int numCaracteres)
        {
            String texto = Atualizador.Framework.Util.Util.converteString(valor);

            //Substitui BBCode (Obrigatoriamente se foi setada a remoção do HTML)
            if ((substituirTagsEspeciais == true) || (removerHtml == true))
                texto = BBCode(texto);

            //Remove HTML
            if (removerHtml)
                texto = removeHTML(texto);

            //Corta o Texto
            if (numCaracteres != 0)
                texto = cortarString(texto, numCaracteres);

            //Retorna texto removendo espaços antes e após
            return texto.Trim();

        }

        //Trata Texto substituindo ou não os BBCode, removendo ou não o HTML, e retornando uma quantidade determinada de caracteres
        public static String trataQuebraLinha(object valor, bool substituirTagsEspeciais, int numCaracteres)
        {
            String texto = Atualizador.Framework.Util.Util.converteString(valor);

            //Substitui BBCode (Obrigatoriamente se foi setada a remoção do HTML)
            if (substituirTagsEspeciais == true)
                texto = BBCode(texto);

            texto = texto.Replace("", String.Empty);
            texto = texto.Replace("", String.Empty);
            texto = texto.Replace("", String.Empty);
            texto = texto.Replace("", String.Empty);

            texto = texto.Replace("<em>", String.Empty);
            texto = texto.Replace("</em>", String.Empty);
            texto = texto.Replace("<em>", String.Empty);
            texto = texto.Replace("</em>", String.Empty);

            texto = texto.Replace("<em>", String.Empty);
            texto = texto.Replace("</em>", String.Empty);

            texto = texto.Replace("<em>", String.Empty);
            texto = texto.Replace("</em>", String.Empty);

            //Corta o Texto
            if (numCaracteres != 0)
                texto = cortarString(texto, numCaracteres);

            //Retorna texto removendo espaços antes e após
            return texto.Trim();

        }
        #endregion

        #region Corta uma parte do Texto

        //Corta uma parte da String
        public static string cortarString(String texto, int limite)
        {
            string output = texto;

            if (output.Length > limite &amp;amp;amp;&amp;amp;amp; limite > 0)
            {

                output = output.Substring(0, limite);

                if (texto.Substring(output.Length, 1) != " ")
                {
                    int LastSpace = output.LastIndexOf(" ");

                    if (LastSpace != -1)
                        output = output.Substring(0, LastSpace);
                }

                output += "...";
            }
            return output;
        }
        #endregion

        #region Converte BBCode
        public static string BBCode(string texto)
        {

            ////Define regex
            Regex regExp;

            ////Regex for URL tag without anchor
            regExp = new Regex(@"\[url\]([^\]]+)\[\/url\]");
            texto = regExp.Replace(texto, "<a href="\">$1</a>");

            ////Regex for URL tag without anchor
            regExp = new Regex(@"\[URL\]([^\]]+)\[\/URL\]");
            texto = regExp.Replace(texto, "<a href="\">$1</a>");

            ////Regex for URL with anchor
            regExp = new Regex(@"\[url=([^\]]+)\]([^\]]+)\[\/url\]");
            texto = regExp.Replace(texto, "<a href="\">$2</a>");

            ////Regex for URL with anchor
            regExp = new Regex(@"\[URL=([^\]]+)\]([^\]]+)\[\/URL\]");
            texto = regExp.Replace(texto, "<a href="\">$2</a>");

            ////Image regex
            regExp = new Regex(@"\[img\]([^\]]+)\[\/img\]");
            texto = regExp.Replace(texto, "<img src="\" alt="" />");

            ////Image regex
            regExp = new Regex(@"\[IMG\]([^\]]+)\[\/IMG\]");
            texto = regExp.Replace(texto, "<img src="\" alt="" />");

            ////Bold text
            regExp = new Regex(@"\[b\](.+?)\[\/b\]");
            texto = regExp.Replace(texto, "<strong>$1</strong>");

            ////Bold text
            regExp = new Regex(@"\[B\](.+?)\[\/B\]");
            texto = regExp.Replace(texto, "<strong>$1</strong>");

            ////Italic text
            regExp = new Regex(@"\[i\](.+?)\[\/i\]");
            texto = regExp.Replace(texto, "<em>$1</em>");

            ////Italic text
            regExp = new Regex(@"\[I\](.+?)\[\/I\]");
            texto = regExp.Replace(texto, "<em>$1</em>");

            ////Underline text
            regExp = new Regex(@"\[u\](.+?)\[\/u\]");
            texto = regExp.Replace(texto, "<span style="text-decoration: underline;">$1</span>");

            ////Underline text
            regExp = new Regex(@"\[U\](.+?)\[\/U\]");
            texto = regExp.Replace(texto, "<span style="text-decoration: underline;">$1</span>");

            ////Font size
            regExp = new Regex(@"\[size=([^\]]+)\]([^\]]+)\[\/size\]");
            texto = regExp.Replace(texto, "<span style="\">$2</span>");

            ////Font size
            regExp = new Regex(@"\[SIZE=([^\]]+)\]([^\]]+)\[\/SIZE\]");
            texto = regExp.Replace(texto, "<span style="\">$2</span>");

            ////Font color
            regExp = new Regex(@"\[color=([^\]]+)\]([^\]]+)\[\/color\]");
            texto = regExp.Replace(texto, "<span style="\">$2</span>");

            ////Font color
            regExp = new Regex(@"\[COLOR=([^\]]+)\]([^\]]+)\[\/COLOR\]");
            texto = regExp.Replace(texto, "<span style="\">$2</span>");

            ///BR
            texto = texto.Replace("[br]", "");
            texto = texto.Replace("[BR]", "");

            return texto;
        }
        #endregion

        #region Remove HTML
        public static String removeHTML(string texto)
        {
            String retorno = String.Empty;
            Regex regex = new Regex("<!--?(.*)-->", RegexOptions.IgnoreCase | RegexOptions.Multiline);
            retorno = regex.Replace(texto, string.Empty);
            return retorno;
        }
        #endregion

        #region Remove Acentos
        ///
        /// Remove Acentos de uma String, substituindo-as pelas letrar sem acento e eliminando os caracteres especiais
        ///
        ///
Texto para remoção dos acentos
        public static String removeAcentos(String texto)
        {
            string comAcentos = "^`|'³²²¹,.:;!@#$%¨&amp;amp;amp;*()-?=+{}><~/][°ªº§£¢¬ÄÅÁÂÀÃäáâàãÉÊËÈéêëèÍÎÏÌíîïìÖÓÔÒÕöóôòõÜÚÛüúûùÇç ";
            string semAcentos = "-----------------------------------------AAAAAAaaaaaEEEEeeeeIIIiiiiiOOOOOoooooUUUuuuuCc_";

            for (int i = 0; i < comAcentos.Length; i++)
                texto = texto.Replace(comAcentos[i].ToString(), semAcentos[i].ToString()).Trim();

            return texto.Replace("-", String.Empty);
        }
        #endregion

        #region Substitui Quebras de Linha para exibição na página
        public static String substituiQuebrasLinha(object valor)
        {
            String texto = Atualizador.Framework.Util.Util.converteString(valor);
            return substituiQuebrasLinha(texto);
        }

        public static String substituiQuebrasLinha(String texto)
        {
            texto = texto.Replace(System.Environment.NewLine, "");
            return texto;
        }

        #endregion

        #region Converte a primeira letra para Maiúscula
        public static string primeiraLetraMaiuscula(string s)
        {
            StringBuilder sb = new StringBuilder(s);
            sb[0] = Char.ToUpper(sb[0]);
            return sb.ToString();
        }
        #endregion
    }
}

using System;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;

namespace Atualizador.Util
{
    public static class Imagem
    {
        #region "Cortar Imagem"
        ///
        /// Corta uma área da imagem
        ///
        ///
Arquivo de Origem
        ///
Arquivo de Destino
        ///
Distância a partir da esquerda para recortar a imagem
        ///
Distância a partir do topo para recortar a imagem
        ///
Largura da área para recortar a imagem
        ///
Altura da área para recortar a imagem
        public static void redimensionarImagem(String imagem_origem, String imagem_destino, int posicaoCorteX, int posicaoCorteY, int larguraCorte, int alturaCorte)
        {

            //Corta uma área da imagem
            Bitmap BitmapOriginal = new Bitmap(imagem_origem);
            Bitmap BitmaCortado = new Bitmap(larguraCorte, alturaCorte);

            Graphics Imagem = Graphics.FromImage(BitmaCortado);
            Imagem.CompositingQuality = CompositingQuality.HighQuality;
            Imagem.SmoothingMode = SmoothingMode.HighQuality;
            Imagem.PixelOffsetMode = PixelOffsetMode.HighQuality;
            Imagem.InterpolationMode = InterpolationMode.HighQualityBicubic;
            Imagem.DrawImage(BitmapOriginal, new Rectangle(0, 0, BitmaCortado.Width, BitmaCortado.Height), posicaoCorteX, posicaoCorteY, BitmaCortado.Width, BitmaCortado.Height, GraphicsUnit.Pixel);

            BitmaCortado.Save(imagem_destino, BitmaCortado.RawFormat);

            Imagem.Dispose();
            BitmaCortado.Dispose();
            BitmapOriginal.Dispose();

        }
        #endregion

        #region "Redimensionar Imagem"
        ///
        /// Corte e Redimensiona a imagem fornecendo largura e altura finais
        ///
        ///
Arquivo de Origem
        ///
Arquivo de Destino
        ///
Distância a partir da esquerda para recortar a imagem
        ///
Distância a partir do topo para recortar a imagem
        ///
Largura da área para recortar a imagem
        ///
Altura da área para recortar a imagem
        ///
Largura da imagem para redimensionamento
        ///
Altura final da imagem para redimensionamento
        public static void redimensionarImagem(String imagem_origem, String imagem_destino, int posicaoCorteX, int posicaoCorteY, int larguraCorte, int alturaCorte, int larguraFinal, int alturaFinal)
        {
            //Corta e redimensiona uma área da imagem

            Bitmap BitmapOriginal = new Bitmap(imagem_origem);
            Bitmap BitmapCortado = new Bitmap(larguraCorte, alturaCorte);
            Graphics GraficoCortado = Graphics.FromImage(BitmapCortado);
            GraficoCortado.DrawImage(BitmapOriginal, new Rectangle(0, 0, BitmapCortado.Width, BitmapCortado.Height), posicaoCorteX, posicaoCorteY, BitmapCortado.Width, BitmapCortado.Height, GraphicsUnit.Pixel);

            Size NovoTamanho = new Size(larguraFinal, alturaFinal);
            System.Drawing.Image gdi = new Bitmap(NovoTamanho.Width, NovoTamanho.Height);

            Graphics BitmapZoom = Graphics.FromImage(gdi);
            BitmapZoom.InterpolationMode = InterpolationMode.HighQualityBicubic;
            BitmapZoom.CompositingQuality = CompositingQuality.HighQuality;
            BitmapZoom.SmoothingMode = SmoothingMode.HighQuality;
            BitmapZoom.PixelOffsetMode = PixelOffsetMode.HighQuality;
            BitmapZoom.InterpolationMode = InterpolationMode.HighQualityBicubic;
            BitmapZoom.DrawImage(BitmapCortado, new Rectangle(new Point(0, 0), NovoTamanho), new Rectangle(new Point(0, 0), BitmapCortado.Size), GraphicsUnit.Pixel);
            BitmapZoom.Dispose();

            gdi.Save(imagem_destino);

            GraficoCortado.Dispose();
            BitmapCortado.Dispose();
            BitmapOriginal.Dispose();

        }
        #endregion

        #region "Zoom Imagem"
        ///
Arquivo de Origem
        ///
Arquivo de Destino
        ///
Largura final da imagem
        ///
Altura final da imagem
        public static bool zoomImagem(String imagem_origem, String imagem_destino, int w_novo, int h_novo)
        {
            bool acao_ok = false;

            //Redimensiona uma área da imagem

            try
            {
                System.Drawing.Image BitmapOriginal = System.Drawing.Image.FromFile(imagem_origem);
                Size NovoTamanho = new Size(w_novo, h_novo);

                System.Drawing.Image gdi = new Bitmap(NovoTamanho.Width, NovoTamanho.Height);

                Graphics BitmapZoom = Graphics.FromImage(gdi);
                BitmapZoom.InterpolationMode = InterpolationMode.HighQualityBicubic;
                BitmapZoom.CompositingQuality = CompositingQuality.HighQuality;
                BitmapZoom.SmoothingMode = SmoothingMode.HighQuality;
                BitmapZoom.PixelOffsetMode = PixelOffsetMode.HighQuality;
                BitmapZoom.InterpolationMode = InterpolationMode.HighQualityBicubic;
                BitmapZoom.DrawImage(BitmapOriginal, new Rectangle(new Point(0, 0), NovoTamanho), new Rectangle(new Point(0, 0), BitmapOriginal.Size), GraphicsUnit.Pixel);
                BitmapZoom.Dispose();

                gdi.Save(imagem_destino, gdi.RawFormat);

                acao_ok = true;

            }
            catch { }

            return acao_ok;
        }
        #endregion

        #region "Retorna dimensão imagem"
        ///
Caminho do Arquivo
        public static Dimensao retornaTamanho(string nomeArquivo)
        {
            //Pega imagem
            System.Drawing.Image imagemEnviada = System.Drawing.Image.FromFile(nomeArquivo);

            //Determina largura e altura
            Dimensao dimensao = new Dimensao();
            dimensao.Largura = imagemEnviada.PhysicalDimension.Width;
            dimensao.Altura = imagemEnviada.PhysicalDimension.Height;

            return dimensao;
        }

        #endregion

        #region Retorna Proporção
        ///
Caminho do Arquivo
        ///
Largura Máxima
        ///
Altura Máxima
        ///
Largura
        ///
Altura
        public static Dimensao retornaProporcao(string nomeArquivo, float maxLarg, float maxAlt, float largura, float altura)
        {
            System.Drawing.Image OriImg = System.Drawing.Image.FromFile(nomeArquivo);
            Dimensao dimensao = new Dimensao();
            if (OriImg.Width > OriImg.Width)
            {
                //Padrão Paisagem
                if (OriImg.Width > maxLarg)
                {
                    dimensao.Largura = maxLarg;
                    dimensao.Altura = Convert.ToInt32(OriImg.Height * dimensao.Largura / OriImg.Width);
                }
                else
                {
                    dimensao.Largura = OriImg.Width;
                    dimensao.Altura = OriImg.Height;
                }
            }
            else
            {
                //Padrão Retrato
                if (OriImg.Height > maxAlt)
                {
                    dimensao.Altura = maxAlt;
                    dimensao.Largura = Convert.ToInt32(OriImg.Width * dimensao.Largura / OriImg.Height);
                }
                else
                {
                    dimensao.Largura = OriImg.Width;
                    dimensao.Altura = OriImg.Height;
                }

            }

            return dimensao;
        }
        #endregion

        #region Corta e Redimensiona Imagem
        ///
        /// Corta uma área da imagem
        ///
        ///
Arquivo de Origem
        ///
Arquivo de Destino
        ///
Distância a partir da esquerda para recortar a imagem
        ///
Distância a partir do topo para recortar a imagem
        ///
Largura da área para recortar a imagem
        ///
Altura da área para recortar a imagem
        ///
Largura da imagem final
        ///
Altura da imagem final
        public static void cortaRedimensionaImagem(String imagem_origem, String imagem_destino, int posicaoCorteX, int posicaoCorteY, int larguraCorte, int alturaCorte,int novaLargura, int novaAltura)
        {

            //Corta uma área da imagem
            Bitmap BitmapOriginal = new Bitmap(imagem_origem);
            Bitmap BitmaCortado = new Bitmap(larguraCorte, alturaCorte);

            Graphics Imagem = Graphics.FromImage(BitmaCortado);
            Imagem.CompositingQuality = CompositingQuality.HighQuality;
            Imagem.SmoothingMode = SmoothingMode.HighQuality;
            Imagem.PixelOffsetMode = PixelOffsetMode.HighQuality;
            Imagem.InterpolationMode = InterpolationMode.HighQualityBicubic;
            Imagem.DrawImage(BitmapOriginal, new Rectangle(0, 0, BitmaCortado.Width, BitmaCortado.Height), posicaoCorteX, posicaoCorteY, BitmaCortado.Width, BitmaCortado.Height, GraphicsUnit.Pixel);

            /////////////////////////////////
            Size NovoTamanho = new Size(novaLargura, novaAltura);

            System.Drawing.Image gdi = new Bitmap(NovoTamanho.Width, NovoTamanho.Height);

            Graphics BitmapZoom = Graphics.FromImage(gdi);
            BitmapZoom.InterpolationMode = InterpolationMode.HighQualityBicubic;
            BitmapZoom.CompositingQuality = CompositingQuality.HighQuality;
            BitmapZoom.SmoothingMode = SmoothingMode.HighQuality;
            BitmapZoom.PixelOffsetMode = PixelOffsetMode.HighQuality;
            BitmapZoom.InterpolationMode = InterpolationMode.HighQualityBicubic;
            BitmapZoom.DrawImage(BitmaCortado, new Rectangle(new Point(0, 0), NovoTamanho), new Rectangle(new Point(0, 0), BitmaCortado.Size), GraphicsUnit.Pixel);
            BitmapZoom.Dispose();

            gdi.Save(imagem_destino, gdi.RawFormat);

            /////////////////////////

            Imagem.Dispose();
            gdi.Dispose();
            BitmaCortado.Dispose();
            BitmapOriginal.Dispose();

        }
        #endregion

    }

    public class Dimensao
    {
        float altura;
        float largura;

        #region Altura
        public float Altura
        {
            get { return altura; }
            set { altura = value; }
        }
        #endregion

        #region Largura
        public float Largura
        {
            get { return largura; }
            set { largura = value; }
        }
        #endregion
    }
}

using System;
using System.IO;
using System.IO.Compression;
using System.Web;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Data;

namespace Atualizador
{
    public static class Util
    {

        #region "Normaliza as aspas da String"
        ///
        /// Remove as aspas e a barra invertida de uma String
        ///
        ///
String para Remoção
        public static string aspasSQL(string str)
        {
            String retorno = str;

            retorno = retorno.Replace("'", "''");

            return retorno;
        }

        ///
        /// Remove as aspas e a barra invertida de um Objeto
        ///
        ///
Objeto para Remoção
        public static string aspasSQL(object ostr)
        {
            String retorno = ostr.ToString();

            retorno = retorno.Replace("'", "''");

            return retorno;
        }
        #endregion

        #region "Normaliza as aspas da String"
        ///
        /// Substitui as aspas de uma String
        ///
        ///
String para Remoção
        public static string aspasJavaScript(string str)
        {
            String retorno = str;

            retorno = retorno.Replace("'", "\\'");

            return retorno;
        }
        #endregion

        #region Conversões

        public static int converteInteiro(object valor)
        {
            int retorno;

            try
            {
                retorno = int.Parse(valor.ToString());
            }
            catch
            {
                retorno = 0;
            }

            return retorno;
        }

        public static long converteNumero(object valor)
        {
            long retorno;

            try
            {
                retorno = long.Parse(valor.ToString());
            }
            catch
            {
                retorno = 0;
            }

            return retorno;
        }

        public static short converteShort(object valor)
        {
            short retorno;

            try
            {
                retorno = short.Parse(valor.ToString());
            }
            catch
            {
                retorno = 0;
            }

            return retorno;
        }

        public static String converteString(object valor)
        {
                return (valor != null) ? valor.ToString() : String.Empty;
        }

        public static float converteFloat(object valor)
        {
            float retorno;

            try
            {
                retorno = float.Parse(valor.ToString());
            }
            catch
            {
                retorno = 0;
            }

            return retorno;
        }

        public static bool converteBool(object valor)
        {
            bool retorno;

            try
            {
                if ((valor.ToString().ToLower() == "0") || (valor.ToString().ToLower() == "false") || (valor.ToString().ToLower() == String.Empty))
                    retorno = false;
                else
                    retorno = true;
            }
            catch
            {
                retorno = false;
            }

            return retorno;
        }

        public static decimal converteDecimal(object valor)
        {
            decimal retorno;

            try
            {
                retorno = decimal.Parse(valor.ToString());
            }
            catch
            {
                retorno = 0;
            }

            return retorno;
        }

        public static string converteDataToString(DateTime data)
        {
            string strAno = data.Year.ToString();
            string strMes = data.Month.ToString();
            string strDia = data.Day.ToString();

            if (Int16.Parse(strMes) <= 9)
                strMes = "0" + strMes;
            if (Int16.Parse(strDia) <= 9)
                strDia = "0" + strDia;

            string strData = strAno + strMes + strDia;
            return strData;
        }

        public static DateTime convertStringToData(string strData)
        {
            string strAno = strData.Substring(0, 4);
            string strMes = strData.Substring(4, 2);
            string strDia = strData.Substring(6, 2);
            return DateTime.Parse(strDia + "/" + strMes + "/" + strAno);
        }

        public static DateTime converteData(object valor)
        {
            return converteData(converteString(valor));
        }

        public static DateTime converteData(string valor)
        {
            return DateTime.Parse(valor);
        }

        #endregion

        #region Formata Data / Hora

        public static String formataData(object valor)
        {
            String dataStr = Atualizador.Framework.Util.Util.formataStringData(valor.ToString());
            DateTime data = Atualizador.Framework.Util.Util.converteData(dataStr);

            String nomeMes = String.Format("{0:MMMM}", data).Substring(0, 3).ToUpper();
            return String.Format("{0} de {1}", data.Day, nomeMes);
        }

        #endregion

        #region Formata Valor Boleano

        ///
        /// Formata o valor booleano (True/False) para (Sim/Não)
        ///
        ///
Data
        public static string formataBoolString(bool valor)
        {
            if (valor)
                return "Sim";
            else
                return "Não";
        }

        #endregion

        #region Retorna Mensagem de boas vindas
        public static String mensagemBoasVindas(DateTime horario)
        {
            if (horario.Hour <= 12)
                return "Bom Dia";
            else if ((horario.Hour > 12) &amp;amp;amp;&amp;amp;amp; (horario.Hour < 18))
                return "Boa Tarde";
            else
                return "Boa Noite";
        }
        #endregion

        #region Extrai Números
        public static String extraiNumeros(string valor)
        {
            return string.Join(null, System.Text.RegularExpressions.Regex.Split(valor, "[^\\d]"));
        }
        #endregion

        #region Converte Data para o formato Juliano
        public static long converteDataParaJuliano(DateTime dt)
        {
            int m = dt.Month;
            int d = dt.Day;
            int y = dt.Year;

            if (m < 3)
            {
                m = m + 12;
                y = y - 1;
            }
            long jd = d + (153 * m - 457) / 5 + 365 * y + (y / 4) - (y / 100) + (y / 400) + 1721119;
            return jd;
        }
        #endregion

        #region Número de dias entre duas Datas
        public static int numeroDiasEntreDatas(DateTime dataInicial, DateTime dataFinal)
        {
            int ano = 0;
            int dias = 0;

            TimeSpan ts = new TimeSpan();
            ts = dataFinal.Subtract(dataInicial);
            ano = (ts.Days / 365);

            dias = dataFinal.Subtract(dataInicial.AddYears(ano)).Days;

            return dias;
        }
        #endregion

        #region Traduz valor Boolean para Português (Sim / Não)
        public static String traduzValorBoolean(object str)
        {
            bool valor = converteBool(str);
            return (valor) ? "Sim" : "Não";
        }
        #endregion

        /* Validações */

        #region "Valida Número"
        ///
        /// Verifica se o valor do objeto é um número
        ///
        ///
Objeto para verificação
        public static bool IsNumeric(Object objValue)
        {
            bool _Valid = false;

            try
            {
                double y = Convert.ToDouble(objValue);
                _Valid = true;
                return _Valid;
            }
            catch
            {
                _Valid = false;
            }

            try
            {
                int x = Convert.ToInt32(objValue);
                _Valid = true;
                return _Valid;
            }
            catch
            {
                _Valid = false;
            }

            return _Valid;
        }
        #endregion

        #region "Valida Data"
        ///
        /// Verifica se uma String é uma Data
        ///
        ///
String para verificação
        public static bool IsDateTime(String sDateTime)
        {
            bool bIsDateTime = false;

            try
            {
                System.DateTime.Parse(sDateTime);
                bIsDateTime = true;
            }
            catch
            {
                bIsDateTime = false;
            }

            return bIsDateTime;
        }
        #endregion

        #region Valida E-mail
        public static bool validaEmail(string inputEmail)
        {

            string strRegex = @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}" +
                  @"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" +
                  @".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$";
            Regex re = new Regex(strRegex);
            if (re.IsMatch(inputEmail))
                return (true);
            else
                return (false);
        }
        #endregion

        #region Valida CEP
        public static bool validaCEP(string valor)
        {
            valor = valor.Replace("-",String.Empty);

            String cep = Atualizador.Framework.Util.Util.extraiNumeros(valor);

            return (cep.Length == 8);
        }
        #endregion

        #region Valida CPF
        public static bool validaCPF(string cpf)
        {
            int[] multiplicador1 = new int[9] { 10, 9, 8, 7, 6, 5, 4, 3, 2 };
            int[] multiplicador2 = new int[10] { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
            string tempCpf;
            string digito;
            int soma;
            int resto;

            cpf = cpf.Trim();
            cpf = cpf.Replace(".", "").Replace("-", "");

            if (cpf.Length != 11)
                return false;

            tempCpf = cpf.Substring(0, 9);
            soma = 0;
            for (int i = 0; i < 9; i++)
                soma += int.Parse(tempCpf[i].ToString()) * multiplicador1[i];

            resto = soma % 11;
            if (resto < 2)
                resto = 0;
            else
                resto = 11 - resto;

            digito = resto.ToString();

            tempCpf = tempCpf + digito;

            soma = 0;
            for (int i = 0; i < 10; i++)
                soma += int.Parse(tempCpf[i].ToString()) * multiplicador2[i];

            resto = soma % 11;
            if (resto < 2)
                resto = 0;
            else
                resto = 11 - resto;

            digito = digito + resto.ToString();

            return cpf.EndsWith(digito);
        }
        #endregion

        #region Valida CNPJ
        public static bool ValidaCnpj(string cnpj)
        {
            int[] multiplicador1 = new int[12] { 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
            int[] multiplicador2 = new int[13] { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
            int soma;
            int resto;
            string digito;
            string tempCnpj;

            cnpj = cnpj.Trim();
            cnpj = cnpj.Replace(".", "").Replace("-", "").Replace("/", "");

            if (cnpj.Length != 14)
                return false;

            tempCnpj = cnpj.Substring(0, 12);

            soma = 0;
            for (int i = 0; i < 12; i++)
                soma += int.Parse(tempCnpj[i].ToString()) * multiplicador1[i];

            resto = (soma % 11);
            if (resto < 2)
                resto = 0;
            else
                resto = 11 - resto;

            digito = resto.ToString();

            tempCnpj = tempCnpj + digito;
            soma = 0;
            for (int i = 0; i < 13; i++)
                soma += int.Parse(tempCnpj[i].ToString()) * multiplicador2[i];

            resto = (soma % 11);
            if (resto < 2)
                resto = 0;
            else
                resto = 11 - resto;

            digito = digito + resto.ToString();

            return cnpj.EndsWith(digito);
        }
        #endregion

        #region "Arredonda Número"
        ///
        /// Arredonda o valor de um Número, aproximando-o para mais (2,3 -> 3)
        ///
        ///
Valor a ser arredondado
        public static int arredondaNum(double valor)
        {
            return (int)Math.Ceiling(valor);
        }

        public static int arredondaNum(decimal valor)
        {
            return (int)Math.Ceiling(valor);
        }
        #endregion

        /* Formata Moeda */

        #region Formata Moeda
        public static String formataMoeda(object valor)
        {
            return String.Format("{0:c}", valor);
        }
        #endregion

        #region "Formata telefone xxxx-xxxx"
        ///
        /// Formata telefone xxxx-xxxx
        ///
        ///
Numero
        public static string formataTelefone(Object numero)
        {
            string num = converteString(numero);
            string n = "";

            for (int i = 0; i < num.Length; i++)
            {
                n += num.Substring(i, 1);
                if (i == 3)
                    n += "-";
            }

            return n;
        }
        #endregion

        #region "Formata telefone (xx)xxxx-xxxx"
        ///
        /// Formata telefone (xx)xxxx-xxxx
        ///
        ///
Numero
        public static string formataTelefoneDDD(Object numero)
        {
            string num = converteString(numero);
            string n = "";

            for (int i = 0; i < num.Length; i++)
            {
                if (i == 0)
                    n += "(";

                n += num.Substring(i, 1);

                if (i == 1)
                    n += ")";

                if (i == 5)
                    n += "-";
            }

            return n;
        }
        #endregion

        #region "Formata Cep xxxxx-xxx"
        ///
        /// Formata Cep xxxxx-xxx
        ///
        ///
CEP
        public static string formataCep(Object cep)
        {
            string num = converteString(cep).Replace("-", String.Empty);
            string n = "";

            for (int i = 0; i < num.Length; i++)
            {
                n += num.Substring(i, 1);
                if (i == 4)
                    n += "-";
            }

            return n;
        }
        #endregion

        /* Query Strings */

        #region "Pega parâmetro da URL (String)"
        ///
        /// Retorna o valor, sem espaços em branco, de uma QueryString informando seu nome como parâmetro
        ///
        ///
Nome da QueryString
        public static String parametroStr(String nome)
        {

            if (System.Web.HttpContext.Current.Request.QueryString[nome] != null)
                return System.Web.HttpContext.Current.Request.QueryString[nome].ToString();
                //return System.Web.HttpContext.Current.Server.UrlDecode(System.Web.HttpContext.Current.Request.QueryString[nome].ToString());
            else
                return String.Empty;

        }
        #endregion

        #region "Pega parâmetro da URL (Número)"
        ///
        /// Retorna o valor númerico de uma QueryString  passando seu nome como parâmetro. Se a qusery string não for um número válido é retornado '0'
        ///
        ///
Nome da QueryString
        public static int parametroNum(String nome)
        {
            Int32 numRetorno;
            Int32.TryParse(System.Web.HttpContext.Current.Request.QueryString[nome], out numRetorno);
            return numRetorno;
        }
        #endregion

        /* Arquivos */

        #region "Gera nome para o arquivo"
        ///
        /// Gera um nome de arquivo único
        ///
        ///
Nome do arquivo original para capturar a extensão original do arquivo
        public static String geraNomeArquivo(String arquivo)
        {
            return String.Format("{0}{1}", Guid.NewGuid().ToString().Replace("-", String.Empty), System.IO.Path.GetExtension(arquivo));
        }

        ///
        /// Gera um nome incremental de arquivo
        ///
        ///
Nome do arquivo original para capturar a extensão original do arquivo
        ///
Diretório de armazenamento
        public static String geraNomeArquivoIncremental(String nomeArquivo, String diretorioArquivos)
        {
            //Inclui '/' final
            if (!diretorioArquivos.EndsWith("/"))
                diretorioArquivos = String.Concat(diretorioArquivos, "/");

            if (!System.IO.File.Exists(diretorioArquivos + nomeArquivo))
            {
                //Se não existe um arquivo com o mesmo nome
                return nomeArquivo;
            }
            else
            {
                #region Se já existe um arquivo com o mesmo nome

                //Nome final do Arquivo
                String novoNome = nomeArquivo;

                //Contador
                int numIncremento = 1;

                String arquivo, extensao = String.Empty;

                while (System.IO.File.Exists(diretorioArquivos + novoNome))
                {
                    //Resgata nome e extensão do arquivo
                    extensao = System.IO.Path.GetExtension(novoNome);
                    arquivo = nomeArquivo.Replace(extensao, String.Empty);

                    //Gera novo nome
                    novoNome = String.Format("{0}({1}){2}", arquivo, numIncremento, extensao);

                    //Incrementa o Contador
                    numIncremento += 1;
                }

                return novoNome;

                #endregion
            }

        }
        #endregion

        /* HTMLControls */

        #region Adiciona Classe
        public static void adicionaClasse(HtmlControl controle, String classe)
        {
            adicionaClasse(controle, classe, true);

        }

        public static void adicionaClasse(HtmlControl controle, String classe, bool verificaSeJaExiste)
        {
            bool jaExiste = false;

            //Verifica se o elemento já possui a classe
            if (verificaSeJaExiste)
            {
                jaExiste = existeClasse(controle, classe);
            }

            //Se a classe ainda não foi adicionada ao elemento
            if (jaExiste == false)
            {
                if (classe == String.Empty)
                {
                    //Se o elemento não possui classes
                    controle.Attributes["class"] = classe;
                }
                else
                {
                    //Se o elemento possui outras classes
                    controle.Attributes["class"] = String.Concat(controle.Attributes["class"], " ", classe);
                }
            }

        }
        #endregion

        #region Remove Classe
        public static void removerClasse(HtmlControl controle, String classe)
        {
            String classesElemento = controle.Attributes["class"];

            //Remove a Classe
            classesElemento = classesElemento.Replace(classe, String.Empty);

            controle.Attributes["class"] = classesElemento;
        }
        #endregion

        #region Verifica se Classe já existe
        public static bool existeClasse(HtmlControl controle, String classe)
        {
            bool jaExiste = false;

            String classesElemento = controle.Attributes["class"];

            //Separa as Classes do Elemento
            String[] listaClassesElemento = controle.Attributes["class"].Split(' ');

            //Verifica se o elemento já possui a Classe
            foreach (String itemClasse in listaClassesElemento)
            {
                if (itemClasse.Trim() == classe)
                {
                    jaExiste = true;
                    break;
                }
            }

            return jaExiste;
        }
        #endregion

    }
}