Desenvolvedores.Net - TechBlog

Category Archives: C#

Embedded Javascript

0
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (2 votos, média: 5,00 de 5)
Loading...
5 de novembro de 2011

embedded-javascript

Introdução

Neste artigo irei ensinar uma técnica em asp.net para embutir javascript em uma página HTML como um recurso embutido (embedded resource), utilizando nossos próprios componentes.

Muitas vezes precisamos escrever nossos controles em asp, e quando vamos disponibilizar nossa biblioteca de controles nos deparamos com a necessidade de enviar todo o código que foi feito em javascript e nossos controles compilados  não são instalados corretamente, algum diretório da nossa estrutura é modificado pelo usuário, algum diretório não é criado, logo, nossos controles deixam de funcionar como gostaríamos por causa de uma instalação errada ou uma permissão de arquivo.

Um recurso interessante que vejo nos controles asp é a possibilidade de embutirmos todo o nosso código javascript dentro da DLL do controle, isso mesmo, compilar e embutir o nosso javascript e depois utilizar ele com um recurso não mais precisando fazer a criação de diretórios, ou distribuir nossos arquivos .js junto com nosso controle.

O que é Recurso Embutido (Embedded Resource)?

Recurso embutido é quando inserimos algum arquivo dentro de nossa aplicação e o mesmo é compilado e enviado junto com a aplicação dentro do mesmo arquivo, seja um .exe ou .DLL.

Exemplos práticos de arquivos embutidos são quando criamos aplicações Windows no Visual Studio, se repararmos quando colocamos uma imagem em um “form” é criado um arquivo com a extensão .resx, este arquivo é usado para embutir o recurso, no caso uma imagem.

Outro arquivo que o Visual Studio cria é o “Resources.resx” este arquivo é criado quando inserimos imagens, textos, áudio, qualquer arquivo que iremos usar como um recurso em nossa aplicação.

Em asp isso também é possível, neste arquivo irei ensinar como fazer com javascript, mas isso não quer dizer que é possível apenas com javascript, pode ser utilizado para css, imagens e até mesmo páginas inteiras. Mas o nosso foco é javascript.

O que veremos?

Iremos ver desde o modo mais simples de embutir um recurso:

Até o tratamento com o nosso próprio handler.

Iremos ver aqui também como registrar este recurso dentro da tag HEAD e não na tag BODY

Ok! Chega de lero-lero e vamos ao que interessa, se você chegou até aqui é porque já está habituado com o visual Studio. Vou assumir que você tem conhecimento em desenvolvimento web.

Iniciando

Para o nosso exemplo iremos criar dois projetos, uma aplicação web e uma aplicação de controle.

Passos:

  1. Abra o Visual Studio  e crie uma nova aplicação web (ASP.Net Web Application), a minha eu chamei de EmbeddingJavascript;
  2. Adicione um segundo novo projeto à sua solução, do tipo “ASP.Net Server Control” o meu eu chamei de EmbeddingJavascriptMyControl.
  3. No projeto “EmbeddingJavascriptMyControl” adicione um novo item do tipo “ASP.Net Server Control” e de o nome de “MyControl”

Agora já temos dois projetos em nossa solução veja se a sua está parecida com a minha:

Agora vamos à montagem dos códigos e configurações necessárias para fazer o nosso script embutido.

Abra sua classe “MyControl.cs” no método RenderContents iremos criar o nosso componente, um componente simples que irá pedir um texto qualquer com um botão para ser clicado.

Veja o código

protected override void RenderContents(HtmlTextWriter output)
{
string html = @"Digite algo:
				<input type='text' id='txtAlgo' />
				<input type='button' value='Clique aqui' onclick='CallAlert(txtAlgo.value);' />";

output.Write(html);
}

Reparem na linha cinco do código que temos um onclick=’CallAlert(txtNome.value);’ para não dar erro em nossa aplicação temos que definir o script e criar a função js CallAlert.

Então mãos a obra.

No projeto “EmbeddingJavascriptMyControl”  Adicione um novo item do tipo “JScript File” o meu eu chamei de “MyControl.js” nele iremos digitar o nosso código para a função CallAlert

/**
* Exibe uma mensagem de alerta
* @param m (string) mensagem a ser exibida
*/
function CallAlert(m)
{
    if(m=='')
        alert("Informe a mensagem a ser exibida");
    else
        alert(m);
} 

Feito isso voltaremos ao nosso projeto “EmbeddingJavascript”, siga os passos descritos para colocar o nosso componente na página Default.aspx

  1. Faça a referencia ao projeto “EmbeddingJavascriptMyControl”;
  2. Feito a referencia abra o arquivo Default.aspx, nele iremos colocar uma diretiva para que possamos ter o nosso controle na página.
<%@ Register Assembly="EmbeddingJavascriptMyControl" Namespace="EmbeddingJavascriptMyControl"
    TagPrefix="myctl" %>

Repare na propriedade TagPrefix, é por ela que iremos acessar os nossos controles criados no namespace que foi carregado pela propriedade Namespace, é uma atalho, para não ter que ficar digitando todo o namespace.
Dentro da tag body iremos declarar agora nosso controle MyControl, para isso temos que usar a tag “myctl”, veja a declaração:

<myctl:MyControl runat="server" ID="myControl" />

Código completo da página Default.aspx

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="EmbeddingJavascript._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ Register Assembly="EmbeddingJavascriptMyControl" Namespace="EmbeddingJavascriptMyControl"
    TagPrefix="myctl" %>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Acessando recursos embutidos</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <myctl:MyControl runat="server" ID="myControl" />
    </div>
    </form>
</body>
</html>

Ok! Vamos agora executar nossa aplicação e clicar no botão que será criado no navegador.

🙁 Puxa. Primeiro erro, “CallAlert não está definido”.

Obvio, ainda não o definimos. Vamos fazer algumas configurações para que o nosso arquivo javascript seja carregado de forma correta.

Voltaremos ao nosso projeto “EmbeddingJavascriptMyControl” selecione o arquivo “MyControl.js” botão direito, “Propriedades” ou “Properties” na janela que abriu, em “Build Action” marque “Embedded Resource

Agora vamos executar nossa aplicação e clicar no botão novamente… e … erro de novo, o mesmo erro  “CallAlert não está definido”. Isso acontece porque não basta marcar como “Embedded Resource”, ainda temos mais duas alterações a fazer para que nosso recurso funcione. Então vamos a elas.

Primeira Alteração

Abra o arquivo AssemblyInfo.cs e nele digite a seguinte linha

 [assembly: System.Web.UI.WebResource("EmbeddingJavascriptMyControl.MyControl.js", "application/x-javascript")]

Esta linha dirá ao Assembly onde está o recurso embutido, mas muita atenção aqui a dois pontos:

  • É case sensitive (Sensível ao Caso), diferencia MAIÚSCULAS de minúsculas;
  • Onde informamos “EmbeddingJavascriptMyControl.MyControl.js” temos que prestar atenção a nossa estrutura de diretório, se nossos arquivos .js irão ficar em um diretório chamado “Resource/js/arquivo.js” temos que informar o caminho completo do arquivo, assim:  “EmbeddingJavascriptMyControl.Resource.js.arquivo.js”

O arquivo AssemblyInfo.js fica em embaixo do nó “Properties” do nosso projeto “EmbeddingJavascriptMyControl”

Segunda Alteração

Voltaremos ao nosso projeto “EmbeddingJavascript”, abra o arquivo “Default.aspx”.

Antes da nossa declaração <myctl:MyControl… cole a seguinte linha

 <asp:ScriptManager ID="ScriptManager1" EnablePartialRendering="True" runat="server">
            <Scripts>
                <asp:ScriptReference Assembly="EmbeddingJavascriptMyControl" Name="EmbeddingJavascriptMyControl.MyControl.js" />
            </Scripts>
        </asp:ScriptManager>

O Código da página deve ter ficado parecido com este:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="EmbeddingJavascript._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ Register Assembly="EmbeddingJavascriptMyControl" Namespace="EmbeddingJavascriptMyControl"
    TagPrefix="myctl" %>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Acessando recursos embutidos</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:ScriptManager ID="ScriptManager1" EnablePartialRendering="True" runat="server">
            <Scripts>
                <asp:ScriptReference Assembly="EmbeddingJavascriptMyControl" Name="EmbeddingJavascriptMyControl.MyControl.js" />
            </Scripts>
        </asp:ScriptManager>
        <myctl:MyControl runat="server" ID="myControl" />
    </div>
    </form>
</body>
</html>

Agora podemos executar nossa aplicação e clicar no botão que tudo irá funcionar.

Abra o código fonte da página, vamos ver o que foi gerado.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head><title>
	Acessando recursos embutidos
</title></head>
<body>
    <form name="form1" method="post" action="default.aspx" id="form1">
<div>
<input type="hidden" name="__EVENTTARGET" id="__EVENTTARGET" value="" />
<input type="hidden" name="__EVENTARGUMENT" id="__EVENTARGUMENT" value="" />
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwULLTEyNjU1NTIyMDlkZBHjFb7Tj9qnQw+tUeeM3n2rSAIt" />
</div>

<script type="text/javascript">
//<![CDATA[
var theForm = document.forms['form1'];
if (!theForm) {
    theForm = document.form1;
}
function __doPostBack(eventTarget, eventArgument) {
    if (!theForm.onsubmit || (theForm.onsubmit() != false)) {
        theForm.__EVENTTARGET.value = eventTarget;
        theForm.__EVENTARGUMENT.value = eventArgument;
        theForm.submit();
    }
}
//]]>
</script>

<script src="/WebResource.axd?d=vJiRxykuUPDnEnitlfulpUyNW8r5H6f6ZTXVc0STOzayuJB5KQYvdOM6qDn1woYY3aHrZvYEH3kaqgMXLvHN0f1Rgw81&amp;t=634245118914809245" type="text/javascript"></script>

<script src="/ScriptResource.axd?d=pQSfU-Gluj5fWKvwHugAhrYCplBo6HWtAZk18MYQFen7LCnH5eACZQlY2hQFj_mG8wBOBn8gzXjwh__AP4GvZAYiRAXNVfqsrwJ_47pioSwJ0Nt50nZsPwYb_ImjAVVyDYqnF5Mrxws1Hb-eiA7hx6mpB7JzD1kjO5Z0nisDG9Htu64q0&amp;t=fffffffff9d85fa6" type="text/javascript"></script>
<script type="text/javascript">
//<![CDATA[
if (typeof(Sys) === 'undefined') throw new Error('A estrutura do cliente do ASP.NET Ajax falhou ao ser carregada.');
//]]>
</script>

<script src="/ScriptResource.axd?d=NjPhQE1Bg_p8r6kqRbkzTPoHZEUVZljs8n4CqKl-4K_SKhwe4jodATh4CnF0I6areXjIfo1RXiLf4npDOWzM3aFzuXVJ8J5aUvDNXTQM0aIaoAgK-1desXxMafETtHLNsh1PEt5-FelvmW-JH-0-0vJV7Y2ziFETXay4wFRNjRdh_c1F0&amp;t=fffffffff9d85fa6" type="text/javascript"></script>
<script src="/ScriptResource.axd?d=BZRoaxvjoo_kLM6d5_RbZyrPibF04d5B4H_E9ve7x6R9w7j4h8eSLh1dELDU0HnMVzRTtC11C31fvdqZm20-B7I3y0joB9f7DDGCZbLa5ydhKnkJqYlCPlFvCw83WLuQCOYPbAJ9hEEPRfOGyysCkjJ9Pal1xeF5TbJH3LC4OYpMqqSQ0&amp;t=ffffffffb915d82c" type="text/javascript"></script>
    <div>
        <script type="text/javascript">
//<![CDATA[
Sys.WebForms.PageRequestManager._initialize('ScriptManager1', document.getElementById('form1'));
Sys.WebForms.PageRequestManager.getInstance()._updateControls([], [], [], 90);
//]]>
</script>

        <span id="myControl">Digite algo:
                            <input type='text' id='txtAlgo' />
                            <input type='button' value='Clique aqui' onclick='CallAlert(txtAlgo.value);' /></span>
    </div>

<script type="text/javascript">
//<![CDATA[
Sys.Application.initialize();
//]]>
</script>
</form>
</body>
</html>

Podemos reparar que desta forma funciona, mas, não creio que atenda a nossa necessidade, alem de que é gerada muita coisa desnecessária em nossa página, vamos fazer uma análise de tudo que aconteceu na nossa página.

Veja quantas linhas de código foram geradas apenas para mostrar uma mensagem de alerta.

<script src="/WebResource.axd?d=vJiRxykuUPDnEnitlfulpUyNW8r5H6f6ZTXVc0STOzayuJB5KQYvdOM6qDn1woYY3aHrZvYEH3kaqgMXLvHN0f1Rgw81&amp;t=634245118914809245" type="text/javascript"></script>

<script src="/ScriptResource.axd?d=pQSfU-Gluj5fWKvwHugAhrYCplBo6HWtAZk18MYQFen7LCnH5eACZQlY2hQFj_mG8wBOBn8gzXjwh__AP4GvZAYiRAXNVfqsrwJ_47pioSwJ0Nt50nZsPwYb_ImjAVVyDYqnF5Mrxws1Hb-eiA7hx6mpB7JzD1kjO5Z0nisDG9Htu64q0&amp;t=fffffffff9d85fa6" type="text/javascript"></script>
<script type="text/javascript">
//<![CDATA[
if (typeof(Sys) === 'undefined') throw new Error('A estrutura do cliente do ASP.NET Ajax falhou ao ser carregada.');
//]]>
</script>

<script src="/ScriptResource.axd?d=NjPhQE1Bg_p8r6kqRbkzTPoHZEUVZljs8n4CqKl-4K_SKhwe4jodATh4CnF0I6areXjIfo1RXiLf4npDOWzM3aFzuXVJ8J5aUvDNXTQM0aIaoAgK-1desXxMafETtHLNsh1PEt5-FelvmW-JH-0-0vJV7Y2ziFETXay4wFRNjRdh_c1F0&amp;t=fffffffff9d85fa6" type="text/javascript"></script>
<script src="/ScriptResource.axd?d=BZRoaxvjoo_kLM6d5_RbZyrPibF04d5B4H_E9ve7x6R9w7j4h8eSLh1dELDU0HnMVzRTtC11C31fvdqZm20-B7I3y0joB9f7DDGCZbLa5ydhKnkJqYlCPlFvCw83WLuQCOYPbAJ9hEEPRfOGyysCkjJ9Pal1xeF5TbJH3LC4OYpMqqSQ0&amp;t=ffffffffb915d82c" type="text/javascript"></script>
    <div>
        <script type="text/javascript">
//<![CDATA[
Sys.WebForms.PageRequestManager._initialize('ScriptManager1', document.getElementById('form1'));
Sys.WebForms.PageRequestManager.getInstance()._updateControls([], [], [], 90);
//]]>
</script>

Imagine se tivéssemos muitos controles carregados na página, o tanto de código que seria carregado.
E se precisássemos chamar algum método antes da tag body para que nosso controle funcione perfeitamente?

Outro problema, é que o utilizador de nossos componentes teria que saber a estrutura de nossos recursos e teria que se lembrar de ficar colocando o Script Manager e configurá-lo de forma adequada em todas as páginas, caso contrário daria erros. Isso não é legal.

Mas como eu prometi, vamos resolver todos estes problemas com o uso de Handlers e Modules.

Então, vamos a segunda parte do artigo.


Usando Handlers e Modules com recursos embutidos

Antes de iniciar vamos descobrir para que servem e o que são os handlers e modules.

O que são handlers (manipuladores)?

Os handlers, ou manipuladores, normalmente processam as requisições e não têm interatividade com o usuário, como páginas ou controles, e normalmente são responsáveis por camadas lógicas dentro da aplicação.

Podemos utilizar um handler quando precisamos executar algo no servidor sem a necessidade de intervenção do usuário final.

Os handlers implementam a interface IHttpHandler, o HttpHandler é responsável por atender as requisições do browser e a interface IHttpHandler possui as assinaturas necessárias para que estas requisições sejam atendidas.

O que são modules (módulos)?

Os módulos HTTP são executados antes e depois do handler (manipulador) e nos fornece métodos para interagir com a requisição (HttpRequest). Os módulos devem implementar a interface System.Web.IHttpModule.

São normalmente sincronizados com os eventos da classe System.Web.IHttpModule (implementado dentro do Global.asax.cs ou. vb).

A seguir uma lista de eventos que devem ser considerados na implementação do módulo:

  • BeginRequest
  • AuthenticateRequest
  • AuthorizeRequest
  • ResolveRequestCache
  • AcquireRequestState
  • PreRequestHandlerExecute
  • PostRequestHandlerExecute
  • ReleaseRequestState
  • UpdateRequestCache
  • EndRequest
  • * PreSendRequestHeaders
  • * PreSendRequestContent
  • * error

Os eventos identificados por um asterisco (*) pode ocorrer a qualquer momento dentro da requisição, todos os outros estão listados em sua ordem de chamada.

Agora que sabemos com o que iremos trabalhar, vamos dar uma limpada na nossa página “Default.aspx” remova a tag do Script Manager, não iremos usar mais ela.  O código deverá ter ficado assim:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="EmbeddingJavascript._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ Register Assembly="EmbeddingJavascriptMyControl" Namespace="EmbeddingJavascriptMyControl"
    TagPrefix="myctl" %>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Acessando recursos embutidos</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <myctl:MyControl runat="server" ID="myControl" />
    </div>
    </form>
</body>
</html>

Voltaremos ao nosso projeto “EmbeddingJavascriptMyControl” , adicionaremos uma nova classe ao nosso projeto, a minha eu chamei de “ResourceHandler.cs”

Segue o código completo da classe:

 #region Using
using System;
using System.IO;
using System.Web;
using System.Web.UI;
using System.Text;
using System.Text.RegularExpressions;
using System.IO.Compression;
using System.Web.Caching;
using System.Net;
using System.Collections.Generic;
using System.Reflection;
#endregion

namespace EmbeddingJavascriptMyControl
{
    public class ResourceHandler : IHttpHandler
    {
        private const int DAYS_IN_CACHE = 30;
        public void ProcessRequest(HttpContext context)
        {
            string path = context.Request.QueryString["r"];
            path = "EmbeddingJavascriptMyControl." + path + ".js";
            string content = string.Empty;

            if (!string.IsNullOrEmpty(path))
            {
                if (context.Cache[path] == null)
                {
                    string[] scripts = path.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
                    foreach (string script in scripts)
                    {
                        content += RetrieveScript(script) + Environment.NewLine;
                    }

                    content = StripWhitespace(content);
                    context.Cache.Insert(path, content, null, Cache.NoAbsoluteExpiration, new TimeSpan(DAYS_IN_CACHE, 0, 0, 0));
                }
            }

            content = (string)context.Cache[path];
            if (!string.IsNullOrEmpty(content))
            {
                context.Response.Write(content);
                SetHeaders(content.GetHashCode(), context);
                Compress(context);
            }
        }

        /// <summary>
        /// carrega o script em memória e depois devolve ao objeto chamador
        /// </summary>
        /// <param name="resourceFullName">caminho completo do recurso</param>
        private static string RetrieveScript(string resourceFullName)
        {
            string script = null;
            //get from resource
            Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceFullName);

            if (stream != null)
            {
                using (StreamReader sr = new StreamReader(stream))
                {
                    script = sr.ReadToEnd();
                    sr.Close();
                }
            }

            return script;
        }

        /// <summary>
        /// limpa o arquivo javascrip e retorna
        /// </summary>
        /// <param name="body">script</param>
        private static string StripWhitespace(string body)
        {

            /*
             * aqui eu retorno o o script diretamente
             * facilita para a depuração.
             * mas você pode tratar, se estiver em modo debug, não limpa
             * compilou, limpa
             */

            //remove newLine e comentários com //
            string[] lines = body.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
            StringBuilder emptyLines = new StringBuilder();
            foreach (string line in lines)
            {
                string s = line.Trim();
                if (s.Length > 0 && !s.StartsWith("//"))
                {
                    if (s.Contains("//"))
                        s = s.Substring(0, s.IndexOf("//"));

                    emptyLines.AppendLine(s.Trim());
                }
            }

            body = emptyLines.ToString();

            // remove C styles comments
            body = Regex.Replace(body, "/\\*.*?\\*/", String.Empty, RegexOptions.Compiled | RegexOptions.Singleline);
            //// trim left
            body = Regex.Replace(body, "^\\s*", String.Empty, RegexOptions.Compiled | RegexOptions.Multiline);
            //// trim right
            body = Regex.Replace(body, "\\s*[\\r\\n]", "\r\n", RegexOptions.Compiled | RegexOptions.ECMAScript);
            // remove whitespace beside of left curly braced
            body = Regex.Replace(body, "\\s*{\\s*", "{", RegexOptions.Compiled | RegexOptions.ECMAScript);
            // remove whitespace beside of coma
            body = Regex.Replace(body, "\\s*,\\s*", ",", RegexOptions.Compiled | RegexOptions.ECMAScript);
            // remove whitespace beside of semicolon
            body = Regex.Replace(body, "\\s*;\\s*", ";", RegexOptions.Compiled | RegexOptions.ECMAScript);
            // remove newline after keywords
            //body = Regex.Replace(body, "\\r\\n(?<=\\b(abstract|boolean|break|byte|case|catch|char|class|const|continue|default|delete|do|double|else|extends|false|final|finally|float|for|function|goto|if|implements|import|in|instanceof|int|interface|long|native|new|null|package|private|protected|public|return|short|static|super|switch|synchronized|this|throw|throws|transient|true|try|typeof|var|void|while|with)\\r\\n)", " ", RegexOptions.Compiled | RegexOptions.ECMAScript);

            return body;
        }

        /// <summary>
        /// Isso fará com que o navegador e o servidor mantenham a saída
        /// em cache melhorando o desempenho.
        /// </summary>
        private static void SetHeaders(int hash, HttpContext context)
        {
            HttpCachePolicy cache = context.Response.Cache;
            DateTime modifiedDate = new DateTime(GetAssemblyTime(Assembly.GetExecutingAssembly())).ToUniversalTime();
            DateTime nowDate = DateTime.Now.ToUniversalTime().AddSeconds(-1);

            if (modifiedDate > nowDate)
            {
                modifiedDate = nowDate;
            }

            cache.SetLastModified(modifiedDate);
            cache.SetOmitVaryStar(true);
            cache.SetVaryByCustom("r");
            cache.SetExpires(DateTime.UtcNow.AddDays(365));
            cache.SetValidUntilExpires(true);
            cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
            cache.SetCacheability(HttpCacheability.Public);
            cache.SetLastModifiedFromFileDependencies();
            cache.SetMaxAge(new TimeSpan(DAYS_IN_CACHE, 0, 0, 0));
            cache.SetETag("\"" + hash.ToString() + "\"");

            context.Response.ContentType = "text/javascript";
            context.Response.Cache.VaryByHeaders["Accept-Encoding"] = true;
        }

        private static long GetAssemblyTime(Assembly assembly)
        {
            AssemblyName assemblyName = assembly.GetName();

            return File.GetLastWriteTime(new Uri(assemblyName.CodeBase).LocalPath).Ticks;
        }

        #region Compression

        private const string GZIP = "gzip";
        private const string DEFLATE = "deflate";

        private static void Compress(HttpContext context)
        {
            if (context.Request.UserAgent != null && context.Request.UserAgent.Contains("MSIE 6"))
                return;

            if (IsEncodingAccepted(GZIP))
            {
                context.Response.Filter = new GZipStream(context.Response.Filter, CompressionMode.Compress);
                SetEncoding(GZIP);
            }
            else if (IsEncodingAccepted(DEFLATE))
            {
                context.Response.Filter = new DeflateStream(context.Response.Filter, CompressionMode.Compress);
                SetEncoding(DEFLATE);
            }
        }

        /// <summary>
        /// Verifica os cabeçalhos da solicitação para ver se a
        /// codificação é aceita pelo cliente.
        /// </summary>
        private static bool IsEncodingAccepted(string encoding)
        {
            return HttpContext.Current.Request.Headers["Accept-encoding"] != null && HttpContext.Current.Request.Headers["Accept-encoding"].Contains(encoding);
        }

        /// <summary>
        /// Adiciona a codificação ao cabeçalho de resposta
        /// </summary>
        /// <param name="encoding"></param>
        private static void SetEncoding(string encoding)
        {
            HttpContext.Current.Response.AppendHeader("Content-encoding", encoding);
        }

        #endregion

        public bool IsReusable
        {
            get { return false; }
        }

    }

    public class ResourceModule : IHttpModule
    {

        #region IHttpModule Members

        void IHttpModule.Dispose()
        {

        }

        void IHttpModule.Init(HttpApplication context)
        {
            context.PostRequestHandlerExecute += new EventHandler(context_BeginRequest);
        }

        #endregion

        void context_BeginRequest(object sender, EventArgs e)
        {
            HttpApplication app = sender as HttpApplication;
            if (app.Context.CurrentHandler is Page && !app.Request.RawUrl.Contains("serviceframe"))
            {
                if (!app.Context.Request.Url.Scheme.Contains("https"))
                {
                    app.Response.Filter = new WebResourceFilter(app.Response.Filter);
                }
            }
        }

        #region Stream filter

        private class WebResourceFilter : Stream
        {

            public WebResourceFilter(Stream sink)
            {
                _sink = sink;
            }

            private Stream _sink;

            #region Properites

            public override bool CanRead
            {
                get { return true; }
            }

            public override bool CanSeek
            {
                get { return true; }
            }

            public override bool CanWrite
            {
                get { return true; }
            }

            public override void Flush()
            {
                _sink.Flush();
            }

            public override long Length
            {
                get { return 0; }
            }

            private long _position;
            public override long Position
            {
                get { return _position; }
                set { _position = value; }
            }

            #endregion

            #region Methods

            public override int Read(byte[] buffer, int offset, int count)
            {
                return _sink.Read(buffer, offset, count);
            }

            public override long Seek(long offset, SeekOrigin origin)
            {
                return _sink.Seek(offset, origin);
            }

            public override void SetLength(long value)
            {
                _sink.SetLength(value);
            }

            public override void Close()
            {
                _sink.Close();
            }

            public override void Write(byte[] buffer, int offset, int count)
            {
                byte[] data = new byte[count];
                Buffer.BlockCopy(buffer, offset, data, 0, count);
                string html = System.Text.Encoding.Default.GetString(buffer);
                int index = 0;
                List<string> list = new List<string>();

                Regex regex = new Regex("<script\\s*src=\"((?=[^\"]*(webresource.axd|scriptresource.axd))[^\"]*)\"\\s*type=\"text/javascript\"[^>]*>[^<]*(?:</script>)?", RegexOptions.IgnoreCase);
                foreach (Match match in regex.Matches(html))
                {
                    if (index == 0)
                        index = html.IndexOf(match.Value);

                    string relative = match.Groups[1].Value;
                    list.Add(relative);
                    html = html.Replace(match.Value, string.Empty);
                }

                if (index > 0)
                {
                    string script = "<script type=\"text/javascript\" src=\"js.axd?path={0}\"></script>";
                    string path = string.Empty;
                    foreach (string s in list)
                    {
                        path += HttpUtility.UrlEncode(s) + ",";
                    }

                    html = html.Insert(index, string.Format(script, path));
                }

                byte[] outdata = System.Text.Encoding.Default.GetBytes(html);
                _sink.Write(outdata, 0, outdata.GetLength(0));
            }

            #endregion

        }

        #endregion

    }
}

Adicione outra classe ao seu projeto, a minha eu chamei de “JavascriptManager” será responsável por adicionar a tag script nas páginas que usam o nosso controle.

Código da classe:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.UI.HtmlControls;
using System.Web.UI;

namespace EmbeddingJavascriptMyControl
{
    public static class JavascriptManager
    {
        /// <summary>
        /// Use este método para incluir um arquivo javascript na página
        /// </summary>
        /// <param name="_page">página que o arquivo deverá ser incluído</param>
        /// <param name="resourceName">caminho script</param>
        public static void IncludeResource(Page _page, string resourceName)
        {
            //aqui eu usei o nome EmbeddingJavascriptMyControl, mas você poderá usar o nome que quiser
            resourceName = "/EmbeddingJavascriptMyControl.axd?r=" + resourceName;

            HtmlGenericControl script = new HtmlGenericControl("script");
            script.Attributes.Add("type", "text/javascript");
            script.Attributes.Add("src", _page.ResolveClientUrl(resourceName));
            _page.Header.Controls.Add(script);
        }
    }
} 

Ufa! Já estamos quase lá. O bom disso é que só iremos ter o trabalho uma vez, e poderemos usar em todo o nosso projeto de componentes, podemos ter um ou cem componentes, sempre serão iguais e usarão os mesmos métodos.

Agora precisamos ajustar o nosso MyControl.cs para que ele faça a referência ao script que o controla.

Para isso, iremos sobrescrever o evento “OnInit”.

 protected override void OnInit(EventArgs e)
 {
 base.OnInit(e);

JavascriptManager.IncludeResource(Page,"MyControl");
 }

Você devará ter isso em todos os controles que você criar, eu tenho por hábito criar os controles e com os mesmos nomes dos arquivos.js, como eu fiz  com o MyControl.cs e MyControl.js, assim eu sei para que uso cada arquivo js, mesmo que fiquem em diretórios separados.

Feito isso, já podemos executar a nossa aplicação. Abra o código fonte da página e veja como ficou mais limpo. Economizamos algumas linhas e memória no navegador do cliente.

Percebam também que o nosso script foi registrado na tag head. Isso nos ajudará muito quando fizermos controles mais complexos e dinâmicos.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head><title>
	Acessando recursos embutidos
</title><script type="text/javascript" src="/EmbeddingJavascriptMyControl.axd?r=MyControl"></script></head>
<body>
    <form name="form1" method="post" action="default.aspx" id="form1">
<div>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwULLTEzNjgwMjk4NDBkZMpc3l1d4uAY38/msqun4petNKEJ" />
</div>

    <div>
        <span id="myControl">Digite algo:
                            <input type='text' id='txtAlgo' />
                            <input type='button' value='Clique aqui' onclick='CallAlert(txtAlgo.value);' /></span>
    </div>
    </form>
</body>
</html>

Certo. Mas se você clicar no botão … dará o mesmo erro de sempre. “CallAlert não está definido”. Isso irá acontecer porque o nosso script é referenciado pela nossa url

<script type=”text/javascript” src=”/EmbeddingJavascriptMyControl.axd?r=MyControl“></script>

Veja que definimos um url diferente para o src de nosso script, é aqui que iremos usar o nosso handler e o module que criamos. É ele, o handler, quem será responsável por tratar o script e carregar no navegador, mas precisamente no cache do navegador.

Então vamos lá colocar o handler e o módulo para funcionar.

Voltamos ao nosso  projeto “EmbeddingJavascript” abra o arquivo “Web.config” nele precisamos configurar os nossos handlers e modules

Localize dentro do Web.config a chave <httpHandlers> antes da tag de fechamento iremos colocar o nosso handler

A minha ficou assim:

<httpHandlers>
	<remove verb="*" path="*.asmx"/>
	<add verb="*" path="*.asmx" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
	<add path="*/EmbeddingJavascriptMyControl.axd" verb="*" type ="EmbeddingJavascriptMyControl.ResourceHandler"/>
</httpHandlers>

Lembra do src do javascript? “/EmbeddingJavascriptMyControl.axd” é aqui que informamos quem será o manipulador do nosso handler.

Agora segue a declaração do módulo dentro do arquivo web.config. Declare entre as tags <httpModules> </httpModules>

<httpModules>
	<add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
	<add name="EmbeddingJavascriptMyControlResourceModule" type="EmbeddingJavascriptMyControl.ResourceModule"/>
</httpModules>

Pronto. Agora pode executar a aplicação e clicar no botão. Se fez tudo correto. Vai funcionar. 🙂

Esta dica não serve apenas para javascript, com alguns ajustes no código do “ResourceHandler” você poderá usar para tratar imagens, css, e outros arquivos que forem necessários ao funcionamento do seu componente, mas nunca se esqueça de marcar como “Embedded Resource”.

A alteração que fizemos no web.config também podemos automatizá-la. Mas isso fica para um próximo artigo. Este já está muito extenso.

Segue o fonte do exemplo que eu usei no artigo [download id=”20″]


É isso ai pessoal 🙂
Até o próximo
? Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Introdução ao C# – Parte 3 – Enum e Casting

0
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (3 votos, média: 5,00 de 5)
Loading...
7 de outubro de 2011

C_thumb1

Pessoal

Segue abaixo mais um vídeo da nossa série sobre .NET Framework, C# e OOP (Programação Orientada a Objetos). E neste estamos dando sequencia a introdução a linguagem C#, tratando mais especificamente dos enumeradores (enum) e conversões entre tipos (casting).

YouTube responded to TubePress with an HTTP 410 - No longer available

Ler webservice com javascript

7
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (2 votos, média: 5,00 de 5)
Loading...
24 de setembro de 2011

Ola Pessoal.

Conversando com um amigo pelo messenger estávamos discutindo o consumo de um web service usando JavaScript, sem usar frameworks, apenas JavaScript  puro.

A solução que encontrei foi esta que descrevo abaixo.

Primeiro iremos criar o nosso web service, este web service irá calcular a idade e retornar

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Xml.Linq;

namespace WebService
{
    /// <summary>
    /// web service de exemplo
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [ToolboxItem(false)]
    public class ws : System.Web.Services.WebService
    {

        /// <summary>
        /// Calcula a idade e retorna
        /// </summary>
        /// <param name="dia">dia de nascimento</param>
        /// <param name="mes">mes de nascimento</param>
        /// <param name="ano">ano de nascimento</param>
        /// <returns>idade</returns>
        [WebMethod]
        public int CalcularIdade(int dia, int mes, int ano)
        {
            if (ano.ToString().Length != 4) throw new Exception("O Ano deve ter 4 dígitos");

            DateTime hoje = DateTime.Today;
            DateTime dtNasc = new DateTime(ano, mes, dia);

            int anos = hoje.Year - dtNasc.Year;

            if (hoje.Month > dtNasc.Month)
                return anos;
            else if (dtNasc.Month == hoje.Month)
            {
                if (hoje.Day >= dtNasc.Day)
                    return anos;
                else return --anos;
            }
            else --anos;

            return anos;
        }
    }
}

Criaremos agora a página que irá consumir nosso web service, é uma página simples que pede três dados, Dia, Mês e Ano de nascimento.

Preste atenção na linha marcada. Não esqueça que devemos informar nosso arquivo javascript.
Aqui chamei o meu de acessarWS.js.

<html>
<head runat="server">
    <title>Teste de Webservice</title>

    <script language="javascript" type="text/javascript" src="acessarWS.js"></script>

</head>
<body>
    <p>
        Preencha os dados e clique em calcular</p>
    <div>
        Dia:<br />
        <input type="text" id="txtDia" />
        <br />
        <br />
        Mes:<br />
        <input type="text" id="txtMes" />
        <br />
        <br />
        Ano:<br />
        <input type="text" id="txtAno" />
        <br />
        <br />
        <button type="submit" onclick="CallWs();">
            Calcular</button>
    </div>
    <hr />
    <p>
        Resposta do servidor</p>
    <div id="divResponse">
    </div>
</body>
</html>

Ok! Criamos o nosso web service e agora precisamos criar o nosso JavaScript que irá consumir o web service.

O meu eu dei o nome de acessarWS.js.

var ajax;

/**
 * Criar o objeto ajax que vai fazer a requisição
 */
function CreateAjaxObject() {
	if(window.XMLHttpRequest) {// Mozilla, Safari, Novos browsers...
		ajax = new XMLHttpRequest();
	} else if(window.ActiveXObject) {// IE antigo
		ajax = new ActiveXObject("Msxml2.XMLHTTP");
		if(!ajax) {
			ajax = new ActiveXObject("Microsoft.XMLHTTP");
		}
	}

	if(!ajax)// iniciou com sucesso
		alert("Seu navegador não possui suporte para esta aplicação!");
}

/*
 * Envia os dados para a URL informada
 *
 * @param url Arquivo que irá receber os dados
 * @param dados dados a serem enviados no formato querystring nome=valor&nome1=valor2
 * @param AjaxResponseFunction  variável to tipo function(string) para receber a resposta do ajax
 */
function SendData(url, dados, AjaxResponseFunction) {
	CreateAjaxObject();
	if(ajax) {
		ajax.onreadystatechange = function trataResposta() {
			if(ajax.readyState == 4) {
				AjaxResponseFunction(ajax.status, ajax.responseText);
			}
		};
		//definir o tipo de método
		ajax.open("POST", url, true);

		//definir o encode do conteúdo
		ajax.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");

		//tamanho dos dados enviados
		ajax.setRequestHeader('Content-length', dados.length);

		//enviar os dados
		ajax.send(dados);
	}
}

/**
 * Chama o webservice
 */
function CallWs() {
	/*
	    aqui passe os parâmetros do método.
	    no formato 'querystring'
	    ex:
	        nomeParam1=valor1&nomeParam2=valor2&nomeParamN=valorN

        Muita atenção aqui, pois deve ser informado aqui os nomes dos parâmetros
        que estão definidos no wsdl.
        Uma boa olhada, com atenção ao wsdl irá te mostrar os parâmetros,tipos e os nomes dos métodos
        disponíveis no método ou web service
	*/

	var dados = '';
	dados += 'ano=' + encodeURIComponent(txtAno.value);
	dados += '&mes=' + encodeURIComponent(txtMes.value);
	dados += '&dia=' + encodeURIComponent(txtDia.value);

	//aqui o caminho completo do webservice seguido do nome do método
	SendData("http://localhost/ws.asmx/CalcularIdade", dados, AjaxResponseFunction);
}

/**
 * tratar a resposta do servidor
 * @param status status da resposta
 * @response resposta do servidor
 */
function AjaxResponseFunction(status, response) {

    var divR = document.getElementById('divResponse');

    if(ajax.status != 200)
        divR.style.color = '#FF0000'; //vermelho
    else
        divR.style.color = '#0000FF';//azul

	//escrever na div de resposta
	divResponse.innerHTML = response;
}

Vamos dar uma olhada no WSDL que foi criado para o nosso web service.
Preste atenção nas linhas em destaque, elas mostraram o nome do nosso método e os parâmetros e tipos que devemos informar.

<?xml version="1.0" encoding="utf-8"?>
<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:tns="http://tempuri.org/" xmlns:s="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" targetNamespace="http://tempuri.org/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
  <wsdl:types>
    <s:schema elementFormDefault="qualified" targetNamespace="http://tempuri.org/">
      <s:element name="CalcularIdade">
        <s:complexType>
          <s:sequence>
            <s:element minOccurs="1" maxOccurs="1" name="dia" type="s:int" />
            <s:element minOccurs="1" maxOccurs="1" name="mes" type="s:int" />
            <s:element minOccurs="1" maxOccurs="1" name="ano" type="s:int" />
          </s:sequence>
        </s:complexType>
      </s:element>
      <s:element name="CalcularIdadeResponse">
        <s:complexType>
          <s:sequence>
            <s:element minOccurs="1" maxOccurs="1" name="CalcularIdadeResult" type="s:int" />
          </s:sequence>
        </s:complexType>
      </s:element>
    </s:schema>
  </wsdl:types>
  <wsdl:message name="CalcularIdadeSoapIn">
    <wsdl:part name="parameters" element="tns:CalcularIdade" />
  </wsdl:message>
  <wsdl:message name="CalcularIdadeSoapOut">
    <wsdl:part name="parameters" element="tns:CalcularIdadeResponse" />
  </wsdl:message>
  <wsdl:portType name="wsSoap">
    <wsdl:operation name="CalcularIdade">
      <wsdl:input message="tns:CalcularIdadeSoapIn" />
      <wsdl:output message="tns:CalcularIdadeSoapOut" />
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="wsSoap" type="tns:wsSoap">
    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="CalcularIdade">
      <soap:operation soapAction="http://tempuri.org/CalcularIdade" style="document" />
      <wsdl:input>
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:binding name="wsSoap12" type="tns:wsSoap">
    <soap12:binding transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="CalcularIdade">
      <soap12:operation soapAction="http://tempuri.org/CalcularIdade" style="document" />
      <wsdl:input>
        <soap12:body use="literal" />
      </wsdl:input>
      <wsdl:output>
        <soap12:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="ws">
    <wsdl:port name="wsSoap" binding="tns:wsSoap">
      <soap:address location="http://localhost:2695/ws.asmx" />
    </wsdl:port>
    <wsdl:port name="wsSoap12" binding="tns:wsSoap12">
      <soap12:address location="http://localhost:2695/ws.asmx" />
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Um site que possui uma boa coleção de web services gratuitos é http://www.webservicex.net vale a pena uma visita para testar esta dica.


É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Ler XSD e Validar XML

2
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (3 votos, média: 5,00 de 5)
Loading...
13 de agosto de 2011

Escrever este artigo surgiu da necessidade de um amigo através de uma conversa por Skype®.
A necessidade dele era ler o arquivo XSD e não apenas validar o XML contra o XSD.
Aproveitando o gancho, eu fiz as duas coisas. A leitura do XSD e a validação pelo XSD.

Se você não sabe o que é um XSD: http://pt.wikipedia.org/wiki/XML_Schema

Eu não vou ensinar aqui a criar o XSD, pois isso daria assunto para outro artigo. 🙂
Caso queiram aprender a criar o XSD: http://www.w3schools.com/schema/schema_intro.asp

Ok! Agora que já temos uma base e já sabemos do que se trata. Vamos ao que interessa.

Primeiramente iremos criar o nosso XSD de validação do XML.
Irei chamar de endereco.xsd

<?xml version="1.0" encoding="utf-8"?>
<xs:schema
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
	elementFormDefault="qualified"
	attributeFormDefault="unqualified"
>

	<!--definir os tipos primários do nosso xml-->
	<xs:simpleType name="TUF">
		<xs:annotation>
			<xs:documentation>Estado para usar no endereço</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="AC"/>
			<xs:enumeration value="AL"/>
			<xs:enumeration value="AM"/>
			<xs:enumeration value="AP"/>
			<xs:enumeration value="BA"/>
			<xs:enumeration value="CE"/>
			<xs:enumeration value="DF"/>
			<xs:enumeration value="ES"/>
			<xs:enumeration value="GO"/>
			<xs:enumeration value="MA"/>
			<xs:enumeration value="MG"/>
			<xs:enumeration value="MS"/>
			<xs:enumeration value="MT"/>
			<xs:enumeration value="PA"/>
			<xs:enumeration value="PB"/>
			<xs:enumeration value="PE"/>
			<xs:enumeration value="PI"/>
			<xs:enumeration value="PR"/>
			<xs:enumeration value="RJ"/>
			<xs:enumeration value="RN"/>
			<xs:enumeration value="RO"/>
			<xs:enumeration value="RR"/>
			<xs:enumeration value="RS"/>
			<xs:enumeration value="SC"/>
			<xs:enumeration value="SE"/>
			<xs:enumeration value="SP"/>
			<xs:enumeration value="TO"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:simpleType name="TCEP">
		<xs:annotation>
			<xs:documentation>Tipo CEP</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:pattern value="[0-9\-]{9}"/>
		</xs:restriction>
	</xs:simpleType>

	<!--definir a estrutura do xml-->
	<xs:element name="enderecos">
		<xs:complexType>
			<xs:sequence>
				<xs:element name ="endereco" maxOccurs="unbounded">
					<xs:complexType>
						<xs:sequence>
							<xs:element name="logradouro" type="xs:string"></xs:element>
							<xs:element name ="numero" type="xs:integer"></xs:element>
							<xs:element name="estado" type="TUF"></xs:element>
							<xs:element name="cep" type="TCEP"></xs:element>
							<xs:element name="bairro" type="xs:string"></xs:element>
							<xs:element name="cidade" type="xs:string"></xs:element>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
		</xs:complexType>
	</xs:element>
</xs:schema>

Ok! Criado o nosso xsd. Iremos criar mais dois arquivos endereco_erro.xml e endereco_ok.xml. Como os próprios nomes já dizem um com erro e um sem erro, para podermos testar nosso xsd.

endereco_erro.xml

<?xml version="1.0" encoding="utf-8" ?>
<enderecos>
	<endereco>
		<logradouro>rua nono NoNo no no </logradouro>
		<numero>123</numero>
		<estado>XX</estado>
		<cep>XXs111</cep>
		<bairro>NonnoNon</bairro>
		<cidade>Non on o nNOn</cidade>
	</endereco>
</enderecos>

endereco_ok.xml

<?xml version="1.0" encoding="utf-8" ?>
<enderecos>
	<endereco>
		<logradouro>rua nono NoNo no no </logradouro>
		<numero>123</numero>
		<estado>SP</estado>
		<cep>11111-111</cep>
		<bairro>NonnoNon</bairro>
		<cidade>Non on o nNOn</cidade>
	</endereco>
</enderecos>

Ok! Já temos os nossos xml’s e o nosso xsd. Agora precisamos do nosso aplicativo para ler o xsd e validar os xmls.

Para isso crie uma aplicação console no Visual Studio e cole o código abaixo na classe program.cs

Prestem atenção nas linhas em destaque. São nelas que iremos definir o nosso evento que irá capturar o erro do XML.

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Xml.Schema;

namespace XSD_XML
{
    class Program
    {
        static void Main(string[] args)
        {
            #region Ler o XSD

            WriteConsole("Lendo definição do arquivo XSD");
            //primeiro vamos ler nosso xsd. e ver suas definições
            XmlSchema schema = XmlSchema.Read(new XmlTextReader("xsd/endereco.xsd"), null);

            //lista os namespaces
            XmlQualifiedName[] namespaces = schema.Namespaces.ToArray();
            foreach (XmlQualifiedName item in namespaces)
                Console.WriteLine(string.Format("Nome: {0} Namespace: {1}", item.Name, item.Namespace));

            //lista os tipos
            string[] nomeTipo = null;

            foreach (object item in schema.Items)
            {
                nomeTipo = new string[3];

                if (item is XmlSchemaSimpleType)
                {
                    XmlSchemaSimpleType sType = item as XmlSchemaSimpleType;
                    nomeTipo[0] = sType.Name;
                    nomeTipo[1] = "SimpleType";

                    //lista as restrições deste tipo. Se houver
                    XmlSchemaSimpleTypeRestriction restriction = sType.Content as XmlSchemaSimpleTypeRestriction;
                    if (restriction != null)
                    {
                        foreach (XmlSchemaFacet facet in restriction.Facets)
                            nomeTipo[2] += facet.Value + ",";
                    }

                    Console.WriteLine(string.Format("Nome: {0} Tipo: {1} Restrição:{2} ", nomeTipo));
                }
                else if (item is XmlSchemaElement)
                {
                    //tipo elemento
                    XmlSchemaElement eType = item as XmlSchemaElement;
                    nomeTipo[0] = eType.Name;
                    nomeTipo[1] = eType.SchemaTypeName.Name;
                    nomeTipo[2] = "Não Tem";

                    Console.WriteLine(string.Format("Nome: {0} Tipo: {1} Restrição:{2} ", nomeTipo));

                    //le os itens deste elemento
                    WriteItens(eType);
                }
            }
            #endregion

            //criar o settings
            XmlReaderSettings settings = new XmlReaderSettings();

            /*
             * ATENÇÃO:
             * Aqui iremos definir o evento que será chamado se nosso xml tiver erros
             */

            settings.ValidationEventHandler += new ValidationEventHandler(validatingReader_ValidationEventHandler);
            settings.ValidationType = ValidationType.Schema;
            settings.Schemas.Add(schema);

            //abrir o xml com erro
            XmlReader validatingReader = XmlReader.Create("xml/endereco_erro.xml", settings);

            ////validar o xml
            WriteConsole("Validando o XML com erros");
            while (validatingReader.Read()) { };

            //xml sem erros
            validatingReader = XmlReader.Create("xml/endereco_ok.xml", settings);
            WriteConsole("Validando o XML sem erros");
            while (validatingReader.Read()) { };
            Console.ReadKey();
        }

        /// <summary>
        /// escreve os items de um elemento
        /// </summary>
        /// <param name="element">elemento xml</param>
        private static void WriteItens(XmlSchemaElement element)
        {
            System.Xml.Schema.XmlSchemaType type = element.SchemaType as System.Xml.Schema.XmlSchemaType;
            if (type == null) return;

            System.Xml.Schema.XmlSchemaComplexType complex = type as System.Xml.Schema.XmlSchemaComplexType;
            if (complex == null) return;

            System.Xml.Schema.XmlSchemaSequence sequence = complex.Particle as System.Xml.Schema.XmlSchemaSequence;
            if (sequence == null) return;

            WriteConsole("Linhas do tipo complexo", ConsoleColor.DarkMagenta);

            foreach (XmlSchemaElement item in sequence.Items)
            {
                Console.WriteLine(string.Format("Nome: {0}", item.Name));
            }
        }

        /// <summary>
        /// método de validação do XML. É aqui que iremos tratar o erro do nosso XML.
        /// </summary>
        /// <param name="sender">objeto que chamou o método</param>
        /// <param name="e">argumentos do evento</param>
        static void validatingReader_ValidationEventHandler(object sender, ValidationEventArgs e)
        {
            WriteConsole(e.Message, ConsoleColor.Red);
        }

        /// <summary>
        /// escreve uma linha no console
        /// </summary>
        /// <param name="message">mensagem</param>
        /// <param name="color">cor da mensagem</param>
        private static void WriteConsole(string message, ConsoleColor color)
        {
            Console.ForegroundColor = color;
            Console.WriteLine(message);
            Console.ResetColor();
        }

        /// <summary>
        /// Escreve uma linha no console. Cor padrão azul
        /// </summary>
        /// <param name="message">mensagem</param>
        private static void WriteConsole(string message)
        {
            WriteConsole(message, ConsoleColor.Blue);
        }

    }
}

Link para o download do projeto de exemplo. (formato .zip Visual Studio 2010) [download id=’16’]


É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Introdução ao C# – Parte 2

0
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (1 votos, média: 5,00 de 5)
Loading...
1 de agosto de 2011

C

Pessoal

Segue abaixo mais vídeo da série sobre .NET Framework, C# e OOP (Programação Orientada a Objetos) e neste estamos fazendo uma introdução a linguagem C#.

YouTube responded to TubePress with an HTTP 410 - No longer available

Introdução ao C# – Parte 1

2
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (4 votos, média: 5,00 de 5)
Loading...
28 de julho de 2011

C

Pessoal

Segue abaixo mais vídeo da série sobre .NET Framework, C# e OOP (Programação Orientada a Objetos) e neste estamos iniciando a introdução a linguagem C#.

YouTube responded to TubePress with an HTTP 410 - No longer available

 

Adicionar javascript na tag head

0
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (2 votos, média: 5,00 de 5)
Loading...
25 de julho de 2011

 Existem várias maneiras de se adicionar script dinamicamente em uma página html no lado servidor, aqui eu vou ensinar três delas.

A primeira e a mais simples é usando o ClientScriptManager que é uma classe para a manipulação de scripts do lado cliente

Vamos ao exemplo:

protected void Page_Load(object sender, EventArgs e)
{
	ClientScriptManager cs = Page.ClientScript;
	cs.RegisterClientScriptBlock(this.GetType(), "meuScript", "alert('Seja bem-vindo ao desenvolvedores.net');", true);
}

Este é o modo mais simples de se adicionar uma tag script. Vamos aos parâmetros.

No primeiro parâmetro informamos o tipo de objeto que iremos colocar o nosso script.

No segundo parâmetro informamos uma chave para identificar o nosso script.

No terceiro parâmetro informamos o nosso script.

No quarto parâmetro informamos que é para ser adicionado a tag <script>…</script>.

Usando esta técnica o script será adicionado no corpo do html, ou seja entre a tag <body>…</body>. Vejam o código gerado pelo asp

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head><title>
	Untitled Page
</title></head>
<body>
    <form name="form1" method="post" action="Default.aspx" id="form1">
<div>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwUJNzgzNDMwNTMzZGSCZayBSwoHn5bPS8BXxDJhk6Dhtg==" />
</div>

<script type="text/javascript">
//<![CDATA[
alert('Seja bem-vindo ao desenvolvedores.net');//]]>
</script>
    <div>
    </div>
    </form>
</body>
</html>

Ok! Interessante, e funciona. Mas em alguns casos eu preciso adicionar na tag <head>…</head>. Isto é interessante quando temos que declarar uma função que será executada por algum componente, ou quando queremos tratar algo antes do corpo da página ser montado. Então. Como devo proceder?

Neste caso temo que usar o objeto chamado HtmlGenericControl e definir seu tipo e atributos. Vamos ao exemplo:

protected void Page_Load(object sender, EventArgs e)
{
	HtmlGenericControl script = new HtmlGenericControl("script");
	script.Attributes.Add("type", "text/javascript");
	script.InnerHtml = "alert('Seja bem-vindo ao desenvolvedores.net');";
	this.Page.Header.Controls.Add(script);
}

Veja que definimos o tipo de objeto “script” e usamos o Attributes para definir a linguagem de script que vamos utilizar, e dentro da propriedade InnerHtml colocamos todo o código do nosso script.

Aqui o código gerado pela página, repare nas linhas em destaque que estão dentro da tag <head>…</head>.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head><title>
	Untitled Page
</title>
<script type="text/javascript">
alert('Seja bem-vindo ao desenvolvedores.net');
</script>
</head>
<body>
    <form name="form1" method="post" action="Default.aspx" id="form1">
<div>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwUJNzgzNDMwNTMzZGSCZayBSwoHn5bPS8BXxDJhk6Dhtg==" />
</div>
    <div>
    </div>
    </form>
</body>
</html>

Bom. Mas eu uso um arquivo .js para organizar meus scripts, tem como eu fazer isso usando um arquivo?

A resposta é sim, tem como. Usando a mesma técnica descrita acima. Podemos adicionar um .js à nossa página. Vamos ao exemplo:

protected void Page_Load(object sender, EventArgs e)
{
	HtmlGenericControl script = new HtmlGenericControl("script");
	script.Attributes.Add("type", "text/javascript");
	script.Attributes.Add("src", "Arquivo.js");
	this.Page.Header.Controls.Add(script);
}

Repare que tiramos o InnerHtml e colocamos mais um atributo, o src , é aqui que definimos o caminho para o nosso arquivo .js.

abaixo o código gerado pela página. Repare nas linhas em destaque

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head><title>
	Untitled Page
</title>
<script type="text/javascript" src="Arquivo.js">
</script>
</head>
<body>
    <form name="form1" method="post" action="Default.aspx" id="form1">
<div>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwUJNzgzNDMwNTMzZGSCZayBSwoHn5bPS8BXxDJhk6Dhtg==" />
</div>
    <div>
    </div>
    </form>
</body>
</html>

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Linq to Twitter

0
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (5 votos, média: 5,00 de 5)
Loading...
20 de julho de 2011

 Ola Pessoal. Hoje eu vou falar sobre uma biblioteca para recuperar os dados do twitter que é a LinqToTwitter.

Ela é fácil de trabalhar a documentação é boa e tem bastante exemplos de uso.

Então vamos lá. Mãos a obra.

Preparando o ambiente

Siga os passos abaixo na ordem descrita

Para que o twitter funcione de modo correto precisamos criar uma aplicação dentro do twitter. Este passo não é obrigatório caso você queira pegar apenas os tweets públicos, mas se desejar pegar de um usuário específico terá que usar os passos descritos abaixo.

  1.  Faça login na sua conta do twitter neste link https://dev.twitter.com/apps/new

  2. Uma página semelhante à esta deverá ter sido aberta para você: (Clique na miniatura para ver a

    imagem da tela.)
  3. Preencha os campos
    1. “Name” (Nome da  sua aplicação)
    2. “Description” (Descrição da sua aplicação)
    3. “WebSite” (Coloque a URL do seu site onde as pessoas irão acessar os tweets)
  4. Se você preencheu todos os dados corretamente uma página semelhante a esta será exibida. (Clique na miniatura para ver a imagem da página)

  5. Mantenha esta página aberta, pois iremos usar estas configurações.

Passos para criar o projeto

  1. Faça o download da dll Linq2Twitter. Link da versão que usamos no artigo http://linqtotwitter.codeplex.com/releases/view/69833.
  2. Descompacte o arquivo que você recebeu, lembre-se do diretório, você ira precisar dele 🙂
  3. Abra o Visual Studio e crie uma nova aplicação web
  4. Faça referencia à dll LinqToTwitter.dll, ela deverá estar no diretório onde você descompactou os arquivos no passo 2

Você não precisa ter uma conta no twitter para usar a DLL, só que neste caso você ira recuperar apenas os tweeters públicos

Código de exemplo para recuperar os tweets públicos:

<%@ Page Language="C#" AutoEventWireup="true" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ Import Namespace="System.Linq" %>
<%@ Import Namespace="System.Data" %>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Linq To Twitter</title>

    <script runat="server">
        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                var twitterCtx = new LinqToTwitter.TwitterContext();

                var publicTweets =
                    from tweet in twitterCtx.Status
                    where tweet.Type == LinqToTwitter.StatusType.Public
                    select tweet;

                System.Collections.Generic.List<object> data = new System.Collections.Generic.List<object>();

                publicTweets.ToList().ForEach(
                    tweet =>
                    {
                        data.Add(new { Nome = tweet.ScreenName, Mensagem = tweet.Text });
                    }
                    );

                grdTwitter.DataSource = data;
                grdTwitter.DataBind();

            }
            catch (Exception ex)
            {
                Context.Response.Write("Impossível conectar ao twitter<br/>" + ex.ToString());
            }
        }
    </script>

</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:GridView runat="server" ID="grdTwitter">
            <Columns>
            </Columns>
        </asp:GridView>
    </div>
    </form>
</body>
</html>

Ok! Agora queremos pegar um tweet de um determinado usuário. Como fazer?

Prestem bastante atenção aos comentários pelo código

<%@ Page Language="C#" AutoEventWireup="true" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ Import Namespace="System.Linq" %>
<%@ Import Namespace="System.Data" %>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Linq To Twitter</title>

    <script runat="server">
        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                //agora que temos uma aplicação cadastrada
                //temos que criar a autenticação ao twitter
                //primeiro criamos um objeto de autorização do tipo LinqToTwitter.SignInAuthorizer
                LinqToTwitter.SignInAuthorizer auth = new LinqToTwitter.SignInAuthorizer()
                {
                    //lembra daquele cadastro que fizemos no twitter?
                    //link:   https://dev.twitter.com/apps/new
                    //os dados que foram informados pelo twitter deverão ser informados aqui
                    //reparem que o mesmo nome da propriedade aqui é o mesmo nome da página do twitter.
                    //Não tem como errar.
                    Credentials = new LinqToTwitter.InMemoryCredentials()
                    {
                        ConsumerKey = "seu consumer key",
                        ConsumerSecret = "seu consumer secret",

                        //ATENÇÃO
                        //nesta propriedade informe o valor da página "Access token"
                        OAuthToken = "aqui vai o Access token",

                        //ATENÇÃO
                        //Nesta propriedade informe o valor da página "Access token secret"
                        AccessToken = "Aqui vai o Access token secret"
                    },

                    //estas podem manter como estão
                    UseCompression = true,
                    OAuthRequestTokenUrl = "https://api.twitter.com/oauth/request_token",
                    OAuthAccessTokenUrl = "https://api.twitter.com/oauth/access_token",
                    OAuthAuthorizeUrl = "https://api.twitter.com/oauth/authorize",
                };

                auth.Authorize();

                var twitterCtx = new LinqToTwitter.TwitterContext(auth);

                var publicTweets =
                    from tweet in twitterCtx.Status
                    where tweet.Type == LinqToTwitter.StatusType.User &&
                        tweet.ScreenName == "desenvolvedores"
                    select tweet;

                System.Collections.Generic.List<object> data = new System.Collections.Generic.List<object>();

                publicTweets.ToList().ForEach(
                    tweet =>
                    {
                        data.Add(new
                        {
                            Nome = tweet.ScreenName,
                            Mensagem = tweet.Text,
                            Site = tweet.User.URL,
                        });
                    });

                grdTwitter.DataSource = data;
                grdTwitter.DataBind();

            }
            catch (Exception ex)
            {
                Context.Response.Write("Impossível conectar ao twitter<br/>" + ex.ToString());
            }
        }
    </script>

</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:GridView runat="server" ID="grdTwitter">
            <Columns>
            </Columns>
        </asp:GridView>
    </div>
    </form>
</body>
</html>

Lembre-se: No twitter na tela que se configura o site você terá sempre que informar para qual site está liberado sua aplicação. Se não fizer isso, pode ser que não funcione quando você publicar sua aplicação.


É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

SharpSVN

1
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (3 votos, média: 5,00 de 5)
Loading...
17 de julho de 2011

Eu sempre usei o Subversion pra controlar as versões de meus códigos e no começo deste mês tive a necessidade de desenvolver uma aplicação que recuperasse as revisões do SVN e disponibilizasse em um site para controle dos gerentes de um dos projetos.

Como ferramenta eu optei por usar o SharpSVN, uma biblioteca escrita  para .NET. Apesar do esforço não encontrei muita coisa em português então resolvi dar uma estudada na documentação (http://docs.sharpsvn.net/current) e escrever este artigo.

Aqui eu vou mostrar uma conexão simples e como resolver o seguinte erro ao publicar o site  “SharpSvn.SvnFormatException: Can’t determine the user’s config path“.

Então vamos lá. Mãos a obra.

Primeiramente temos que preparar o nosso ambiente, para isso temos que baixar os arquivos do SharpSVN http://sharpsvn.open.collab.net/files/documents/180/4381/SSvn-1.6016.1637.zip

Extraia os arquivos.

Abra o Visual Studio e cria uma nova aplicação Web.

Faça referência a dll SharpSvn.dll.

Eu vou recuperar as versões de um projeto que nós do desenvolvedores.net apoiamos e que está no Sourceforge

Página oficial do projeto: http://uninfe.com.br

Página no Sourceforge: https://uninfe.svn.sourceforge.net/svnroot/uninfe

E como sempre, prestem atenção aos comentários do código. Eu coloco informações úteis no mesmo.

<%@ Page Language="C#" AutoEventWireup="true" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Exemplo SVN</title>

    <script runat="server" type="text/C#">
        protected void Page_Load(object sender, EventArgs e)
        {
            //definir o datasource do meu grid
            grdRevision.DataSource = LoadSvnRevision();

            //popular os dados no grid
            grdRevision.DataBind();
        }

        private System.Collections.Generic.List<object> LoadSvnRevision()
        {
            //inicar o cliente svm
            SharpSvn.SvnClient client = new SharpSvn.SvnClient();
            //aqui iniciamos o objeto que irá receber os dados de retorno do svn.
            //Obrigatoriamente tem que ser deste tipo System.Collections.ObjectModel.Collection<SharpSvn.SvnLogEventArgs>
            //pois o parâmetro é do tipo "out"
            System.Collections.ObjectModel.Collection<SharpSvn.SvnLogEventArgs> logItems = new System.Collections.ObjectModel.Collection<SharpSvn.SvnLogEventArgs>();

            //aqui chamamos o método responsável por trazer as revisões do SVN
            //no primeiro parâmetro informamos a url do repositório. (targetPath)
            //no segundo parâmetro informamos a nossa variável que irá receber o retorno
            client.GetLog(new Uri("https://uninfe.svn.sourceforge.net/svnroot/uninfe"), out logItems);

            //aqui eu crio uma variável que irá recuperar este retorno e converter
            //em uma lista de obejtos para ser usada dentro do meu grid
            System.Collections.Generic.List<object> data = new System.Collections.Generic.List<object>();

            foreach (var item in logItems) //aqui eu uso um array nomeado do tipo Key/Value
            {
                data.Add(new
                {
                    Id = item.Revision,
                    Autor = item.Author,
                    Data = item.Time,
                });
            }

            //descarrego cliente
            client.Dispose();

            //limpo da memória
            client = null;

            //retorno minha lista de dados
            return data;
        }
    </script>

</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:GridView runat="server" ID="grdRevision">
        </asp:GridView>
    </div>
    </form>
</body>
</html>

Assim temos uma aplicação básica que recupera os dados de um diretório publico. Mas, e se for em um diretório privado?

Basta acrescentar estas duas linhas ao seu código. Antes de chamar o método client.GetLog();

//Limpamos a autenticação antes de começar
client.Authentication.Clear();
//criamos uma autenticação de usuário usando o System.Net.NetworkCredential
client.Authentication.DefaultCredentials = new System.Net.NetworkCredential("Nome do usuário", "senha");

Uma outra dica que creio ser interessante passar é a opção de filtragem dos dados que iremos receber em nosso objeto de retorno. Do modo como foi feito no código de exemplo iremos recuperar todas as revisões, isso não é interessante em um projeto grande. Aqui vou ensinar a fazer o filtro por data.

//data de início do log que vamos buscar
//aqui informo +1 dia para que pegue também o dia atual
DateTime startDateTime = DateTime.Today.AddDays(1);

//iremos buscar 15 dias antes. Então informamos a segunda data
DateTime endDateTime = startDateTime.AddDays(-15);

//aqui iremos criar um "range" de datas para filtrar.
//para isso usamos o tipo SharpSvn.SvnRevisionRange
//o construtor do range aceita o tipo new SharpSvn.SvnRevision
//que por sua vez aceita vários tipos de filtros, um deles é o tipo data
//passamos então as datas de início e fim do range,
//de acordo com os parâmetros do contrutor do objeto SharpSvn.SvnRevisionRange
//primeiro e segundo parâmetro do construtor
SharpSvn.SvnRevisionRange range = new SharpSvn.SvnRevisionRange(new SharpSvn.SvnRevision(startDateTime), new SharpSvn.SvnRevision(endDateTime));

//criamos a nossa variável do tipo SharpSvn.SvnLogArgs para passar o nosso range de datas.
SharpSvn.SvnLogArgs args = new SharpSvn.SvnLogArgs(range);

//aqui chamamos o método responsável por trazer as revisões do SVN
//no primeiro parâmetro informamos a url do repositório. (targetPath)
//no segundo parâmetro passamos os argumentos de filtragem dos dados
//no terceiro parâmetro informamos a nossa variável que irá receber o retorno
client.GetLog(new Uri("https://uninfe.svn.sourceforge.net/svnroot/uninfe"), args, out logItems);

Preste atenção na linha em destaque, repare que modificamos o método client.GetLog() e passamos o parâmetro args que é o nosso filtro por data.

Vamos agora à um problema conhecido quando publicamos o nosso site.  “SharpSvn.SvnFormatException: Can’t determine the user’s config path“. Este erro não acontece no modo debug porque estamos executando nossa aplicação local e a nossa configuração de usuário já foi toda carregada. Mas quando publicamos podemos receber este erro, pois normalmente a aplicação web roda como um serviço no servidor e pode não ter toda a configuração de usuário carregada. Para isso temos que informar o caminho onde iremos salvar a configuração padrão do usuário. Podemos usar um caminho temporário ou um caminho fixo na sua aplicação. Fica a seu critério. Eu optei por executar eu um caminho temporário.

Para contornar este erro, iremos usar o método LoadConfiguration() que irá indicar onde iremos salvar o arquivo de configuração temporário.

client.LoadConfiguration(System.IO.Path.Combine(System.IO.Path.GetTempPath(), "Svn"), true);

Atenção: Este método deve ser chamado antes de client.GetLog();

Abaixo o código completo de nossa aplicação SVN

<%@ Page Language="C#" AutoEventWireup="true" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Exemplo SVN</title>

    <script runat="server" type="text/C#">
        protected void Page_Load(object sender, EventArgs e)
        {
            //definir o datasource do meu grid
            grdRevision.DataSource = LoadSvnRevision();

            //popular os dados no grid
            grdRevision.DataBind();
        }

        private System.Collections.Generic.List<object> LoadSvnRevision()
        {
            //inicar o cliente svm
            SharpSvn.SvnClient client = new SharpSvn.SvnClient();
            //aqui iniciamos o objeto que irá receber os dados de retorno do svn.
            //Obrigatoriamente tem que ser deste tipo System.Collections.ObjectModel.Collection<SharpSvn.SvnLogEventArgs>
            //pois o parâmetro é do tipo "out"
            System.Collections.ObjectModel.Collection<SharpSvn.SvnLogEventArgs> logItems = new System.Collections.ObjectModel.Collection<SharpSvn.SvnLogEventArgs>();

            //data de início do log que vamos buscar
            DateTime startDateTime = DateTime.Today.AddDays(1);

            //iremos buscar 15 dias antes. Então informamos a segunda data
            DateTime endDateTime = startDateTime.AddDays(-15);

            //aqui iremos criar um "range" de datas para filtrar.
            //para isso usamos o tipo SharpSvn.SvnRevisionRange
            //o construtor do range aceita o tipo new SharpSvn.SvnRevision que por sua vez aceita vários tipos de filtros, um deles é o tipo data
            //passamos então as datas de início e fim do range, de acordo com os parâmetros do contrutor do objeto SharpSvn.SvnRevisionRange
            SharpSvn.SvnRevisionRange range = new SharpSvn.SvnRevisionRange(new SharpSvn.SvnRevision(startDateTime), new SharpSvn.SvnRevision(endDateTime));

            //criamos a nossa variável do tipo SharpSvn.SvnLogArgs para passar o nosso range de datas.
            SharpSvn.SvnLogArgs args = new SharpSvn.SvnLogArgs(range);

            //aqui iremos dizer onde o arquivo de configuração do svn deverá ser salvo
            client.LoadConfiguration(System.IO.Path.Combine(System.IO.Path.GetTempPath(), "Svn"), true);

            //aqui chamamos o método responsável por trazer as revisões do SVN
            //no primeiro parâmetro informamos a url do repositório. (targetPath)
            //no segundo parâmetro passamos os argumentos de filtragem dos dados
            //no terceiro parâmetro informamos a nossa variável que irá receber o retorno
            client.GetLog(new Uri("https://uninfe.svn.sourceforge.net/svnroot/uninfe"), args, out logItems);

            //aqui eu crio uma variável que irá recuperar este retorno e converter
            //em uma lista de obejtos para ser usada dentro do meu grid
            System.Collections.Generic.List<object> data = new System.Collections.Generic.List<object>();

            foreach (var item in logItems) //aqui eu uso um array nomeado do tipo Key/Value
            {
                data.Add(new
                {
                    Id = item.Revision,
                    Autor = item.Author,
                    Data = item.Time,
                });
            }

            //descarrego cliente
            client.Dispose();

            //limpo da memória
            client = null;

            //retorno minha lista de dados
            return data;
        }
    </script>

</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:GridView runat="server" ID="grdRevision">
        </asp:GridView>
    </div>
    </form>
</body>
</html>

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s

Introdução ao Microsoft Visual Studio

2
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (2 votos, média: 5,00 de 5)
Loading...
7 de julho de 2011

vs2010_logo

Pessoal

Segue abaixo nosso segundo vídeo da série sobre .NET Framework, C# e OOP (Programação Orientada a Objetos) e neste estaremos tratando sobre a IDE do Microsoft Visual Studio (uma visão geral do seu funcionamento e recursos).

YouTube responded to TubePress with an HTTP 410 - No longer available

Introdução ao .Net Framework

0
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (Sem votação.)
Loading...
30 de junho de 2011

image_2

 

Segue abaixo o primeiro vídeo de uma série sobre .NET Framework, C# e OOP (Programação Orientada a Objetos) que estaremos publicando.

YouTube responded to TubePress with an HTTP 410 - No longer available

 

CSharp com SQLite

5
1 Estrela2 Estrelas3 Estrelas4 Estrelas5 Estrelas (4 votos, média: 4,00 de 5)
Loading...
2 de maio de 2011

Olá Pessoal.

Neste artigo eu vou falar sobre um banco de dados embarcado que eu acho muito prático de usar o nome dele é SQLite.

O que é o SQLite?

SQLite é uma biblioteca C que implementa um banco de dados SQL embutido. Programas que usam a biblioteca SQLite podem ter acesso ao banco de dados SQL sem executar um processo RDBMS separado.
SQLite não é uma biblioteca de cliente usada para conectar com um grande servidor de banco de dados. SQLite é o servidor.

A biblioteca SQLite lê e escreve diretamente para e do arquivo do banco de dados no disco.
O uso do SQLite é recomendado onde a simplicidade da administração, implementação e manutenção são mais importantes que incontáveis recursos que SGBDs mais voltados para aplicações complexas possivelmente implementam.

Entretanto situações onde a simplicidade é a melhor escolha são muito mais freqüentes do que pode-se imaginar.

Exemplos de uso do SQLite são:

  • Não restrito à sites (com menos de cem mil requisições por dia);
  • Dispositivos e sistemas embarcados;
  • Aplicações desktop;
  • Ferramentas estatísticas e de análise;
  • Aprendizado de banco de dados;
  • Implementação de novas extensões à SQL.

Não se recomenda o uso do SQLite para:

  • Sites com muitos acessos;
  • Grande quantidades de dados (talvez maior que algumas dúzias de gigabytes);
  • Sistemas com grande concorrência;
  • Aplicações cliente/servidor.

Algumas características do SQLite:

  • Software livre/domínio público e Multiplataforma;
  • Mecanismo de armazenamento seguro com transações ACID;
  • Não necessita de instalação, configuração ou administração;
  • Implementa a maioria do SQL92;
  • O Banco de Dados é guardado em um único arquivo;
  • Suporta bases de dados acima de 2 terabytes;
  • Sem dependências externas.

No artigo irei criar a base de dados e as tabelas “Programaticamente” (não achei uma palavra melhor para descrever isso.) mas se você quiser usar uma ferramenta recomendo o uso do SQLite Studio, é gratuita (http://sqlitestudio.one.pl/index.rvt)

Vou assumir que você já sabe o que é uma base de dados embarcada (embedded, embutido) e que tenha conhecimentos em C#.

Primeiramente temos que preparar o nosso ambiente. Para isso iremos fazer o download do provider para .NET. Descompacte o arquivo em uma pasta, iremos usar este caminho mais tarde.

Feito o download iremos criar um novo projeto do tipo windows form e chamar de SQLiteEmbedded.

Renomearemos o form1 para frmMain.

Vamos colocar seis botões em nosso form, segue os nomes e o texto para cada botão

Nome Botão Texto
btnCriarBase Criar Base
btnCriarTabelas Criar Tabelas
btnInsert Insert
btnUpdate Update
btnSelect Select
btnDelete Delete

Com estes botões iremos implementar as operações básicas, desde a criação da base de dados, criação das tabelas e a manipulação dos dados.

Iremos colocar agora um dataGridView e alguns campos de texto e data para montar o nosso form, não se preocupe com o form, ao final do artigo terá um link para download do projeto. Mas se quiser fazer o form.

A tela do meu form ficou assim:

Se quiser poupar trabalho, segue o código para colar no designer (frmMain.Designer.cs) troque o código que tem lá, por este.

namespace SQLiteEmbedded
{
    partial class frmMain
    {
        ///
        /// Required designer variable.
        ///
        private System.ComponentModel.IContainer components = null;

        ///
        /// Clean up any resources being used.
        ///
        /// <param name="disposing" />true if managed resources should be disposed; otherwise, false.
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        ///
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        ///
        private void InitializeComponent()
        {
            this.btnCriarBase = new System.Windows.Forms.Button();
            this.btnCriarTabelas = new System.Windows.Forms.Button();
            this.btnInsert = new System.Windows.Forms.Button();
            this.Update = new System.Windows.Forms.Button();
            this.btnDelete = new System.Windows.Forms.Button();
            this.dataGridView = new System.Windows.Forms.DataGridView();
            this.label1 = new System.Windows.Forms.Label();
            this.txtID = new System.Windows.Forms.TextBox();
            this.label2 = new System.Windows.Forms.Label();
            this.label3 = new System.Windows.Forms.Label();
            this.label4 = new System.Windows.Forms.Label();
            this.txtNome = new System.Windows.Forms.TextBox();
            this.txtTelefone = new System.Windows.Forms.TextBox();
            this.dtDataNascimento = new System.Windows.Forms.DateTimePicker();
            this.btnSelect = new System.Windows.Forms.Button();
            this.label5 = new System.Windows.Forms.Label();
            this.label6 = new System.Windows.Forms.Label();
            ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).BeginInit();
            this.SuspendLayout();
            //
            // btnCriarBase
            //
            this.btnCriarBase.Location = new System.Drawing.Point(12, 12);
            this.btnCriarBase.Name = "btnCriarBase";
            this.btnCriarBase.Size = new System.Drawing.Size(103, 23);
            this.btnCriarBase.TabIndex = 0;
            this.btnCriarBase.Text = "Criar Base";
            this.btnCriarBase.UseVisualStyleBackColor = true;
            this.btnCriarBase.Click += new System.EventHandler(this.btnCriarBase_Click);
            //
            // btnCriarTabelas
            //
            this.btnCriarTabelas.Location = new System.Drawing.Point(121, 12);
            this.btnCriarTabelas.Name = "btnCriarTabelas";
            this.btnCriarTabelas.Size = new System.Drawing.Size(103, 23);
            this.btnCriarTabelas.TabIndex = 1;
            this.btnCriarTabelas.Text = "Criar Tabelas";
            this.btnCriarTabelas.UseVisualStyleBackColor = true;
            this.btnCriarTabelas.Click += new System.EventHandler(this.btnCriarTabelas_Click);
            //
            // btnInsert
            //
            this.btnInsert.Location = new System.Drawing.Point(348, 51);
            this.btnInsert.Name = "btnInsert";
            this.btnInsert.Size = new System.Drawing.Size(75, 23);
            this.btnInsert.TabIndex = 2;
            this.btnInsert.Text = "Insert";
            this.btnInsert.UseVisualStyleBackColor = true;
            this.btnInsert.Click += new System.EventHandler(this.btnInsert_Click);
            //
            // Update
            //
            this.Update.Location = new System.Drawing.Point(348, 81);
            this.Update.Name = "Update";
            this.Update.Size = new System.Drawing.Size(75, 23);
            this.Update.TabIndex = 3;
            this.Update.Text = "Update";
            this.Update.UseVisualStyleBackColor = true;
            this.Update.Click += new System.EventHandler(this.Update_Click);
            //
            // btnDelete
            //
            this.btnDelete.Location = new System.Drawing.Point(348, 111);
            this.btnDelete.Name = "btnDelete";
            this.btnDelete.Size = new System.Drawing.Size(75, 23);
            this.btnDelete.TabIndex = 4;
            this.btnDelete.Text = "Delete";
            this.btnDelete.UseVisualStyleBackColor = true;
            this.btnDelete.Click += new System.EventHandler(this.btnDelete_Click);
            //
            // dataGridView
            //
            this.dataGridView.AllowUserToAddRows = false;
            this.dataGridView.AllowUserToDeleteRows = false;
            this.dataGridView.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
            this.dataGridView.Location = new System.Drawing.Point(12, 182);
            this.dataGridView.Name = "dataGridView";
            this.dataGridView.ReadOnly = true;
            this.dataGridView.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect;
            this.dataGridView.Size = new System.Drawing.Size(537, 267);
            this.dataGridView.TabIndex = 6;
            this.dataGridView.SelectionChanged += new System.EventHandler(this.dataGridView_SelectionChanged);
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(12, 51);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(21, 13);
            this.label1.TabIndex = 7;
            this.label1.Text = "ID:";
            //
            // txtID
            //
            this.txtID.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.txtID.Location = new System.Drawing.Point(96, 51);
            this.txtID.Name = "txtID";
            this.txtID.ReadOnly = true;
            this.txtID.Size = new System.Drawing.Size(100, 20);
            this.txtID.TabIndex = 8;
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(12, 81);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(38, 13);
            this.label2.TabIndex = 9;
            this.label2.Text = "Nome:";
            //
            // label3
            //
            this.label3.AutoSize = true;
            this.label3.Location = new System.Drawing.Point(12, 111);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(52, 13);
            this.label3.TabIndex = 10;
            this.label3.Text = "Telefone:";
            //
            // label4
            //
            this.label4.AutoSize = true;
            this.label4.Location = new System.Drawing.Point(12, 141);
            this.label4.Name = "label4";
            this.label4.Size = new System.Drawing.Size(70, 13);
            this.label4.TabIndex = 11;
            this.label4.Text = "Data Nascto:";
            //
            // txtNome
            //
            this.txtNome.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.txtNome.Location = new System.Drawing.Point(96, 81);
            this.txtNome.Name = "txtNome";
            this.txtNome.Size = new System.Drawing.Size(209, 20);
            this.txtNome.TabIndex = 12;
            //
            // txtTelefone
            //
            this.txtTelefone.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.txtTelefone.Location = new System.Drawing.Point(96, 111);
            this.txtTelefone.Name = "txtTelefone";
            this.txtTelefone.Size = new System.Drawing.Size(94, 20);
            this.txtTelefone.TabIndex = 13;
            //
            // dtDataNascimento
            //
            this.dtDataNascimento.CustomFormat = "dd/MM/yyyy";
            this.dtDataNascimento.Format = System.Windows.Forms.DateTimePickerFormat.Custom;
            this.dtDataNascimento.Location = new System.Drawing.Point(96, 141);
            this.dtDataNascimento.Name = "dtDataNascimento";
            this.dtDataNascimento.Size = new System.Drawing.Size(94, 20);
            this.dtDataNascimento.TabIndex = 14;
            //
            // btnSelect
            //
            this.btnSelect.Location = new System.Drawing.Point(348, 140);
            this.btnSelect.Name = "btnSelect";
            this.btnSelect.Size = new System.Drawing.Size(75, 23);
            this.btnSelect.TabIndex = 15;
            this.btnSelect.Text = "Select";
            this.btnSelect.UseVisualStyleBackColor = true;
            this.btnSelect.Click += new System.EventHandler(this.btnSelect_Click);
            //
            // label5
            //
            this.label5.AutoSize = true;
            this.label5.Location = new System.Drawing.Point(12, 35);
            this.label5.Name = "label5";
            this.label5.Size = new System.Drawing.Size(538, 13);
            this.label5.TabIndex = 16;
            this.label5.Text = "---------------------------------------------------------------------------------" +
                "--------------------------------------------------------------------------------" +
                "----------------";
            //
            // label6
            //
            this.label6.AutoSize = true;
            this.label6.Location = new System.Drawing.Point(12, 166);
            this.label6.Name = "label6";
            this.label6.Size = new System.Drawing.Size(538, 13);
            this.label6.TabIndex = 17;
            this.label6.Text = "---------------------------------------------------------------------------------" +
                "--------------------------------------------------------------------------------" +
                "----------------";
            //
            // frmMain
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(561, 461);
            this.Controls.Add(this.label6);
            this.Controls.Add(this.label5);
            this.Controls.Add(this.btnSelect);
            this.Controls.Add(this.dtDataNascimento);
            this.Controls.Add(this.txtTelefone);
            this.Controls.Add(this.txtNome);
            this.Controls.Add(this.label4);
            this.Controls.Add(this.label3);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.txtID);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.dataGridView);
            this.Controls.Add(this.btnDelete);
            this.Controls.Add(this.Update);
            this.Controls.Add(this.btnInsert);
            this.Controls.Add(this.btnCriarTabelas);
            this.Controls.Add(this.btnCriarBase);
            this.Name = "frmMain";
            this.Text = "SQLite Embededd";
            ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).EndInit();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Button btnCriarBase;
        private System.Windows.Forms.Button btnCriarTabelas;
        private System.Windows.Forms.Button btnInsert;
        private System.Windows.Forms.Button Update;
        private System.Windows.Forms.Button btnDelete;
        private System.Windows.Forms.DataGridView dataGridView;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox txtID;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.Label label4;
        private System.Windows.Forms.TextBox txtNome;
        private System.Windows.Forms.TextBox txtTelefone;
        private System.Windows.Forms.DateTimePicker dtDataNascimento;
        private System.Windows.Forms.Button btnSelect;
        private System.Windows.Forms.Label label5;
        private System.Windows.Forms.Label label6;
    }
}

Ok! Feito isso iremos agora programar o código para cada um de nossos botões.

Para isso faça a referência à DLL System.Data.SQLite.dll. Procure pelo arquivo que você descompactou, aquele que você fez o download.

Primeiro vamos criar a base de dados.

Para criar o arquivo de base de dados usamos o método estático System.Data.SQLite.SQLiteConnection.CreateFile.

Clique 2x no botão “Criar Base”.  Segue o código do evento clique.

 private void btnCriarBase_Click(object sender, EventArgs e)
        {
            try
            {
                string dbFile = "sqlLite.db"; //a extensão pode ser a que você quiser
                if (System.IO.File.Exists(dbFile)) System.IO.File.Delete(dbFile);
                System.Data.SQLite.SQLiteConnection.CreateFile(dbFile);
                MessageBox.Show(this, "Base de dados criada com sucesso.", "Aviso!", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, "Ocorreu um erro ao criar a base de dados.\n" +
                    ex.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

OK! Agora que criamos a base de dados precisamos criar as tabelas. O SQLite aceita os comando de criação de tabelas, CREATE TABLE, ALTER TABLE, DROP TABLE. Então vamos criar a nossa tabela.

Antes de criar as nossas tabelas precisamos conhecer as strings de conexões que podemos ter para o SQLite.

Se você não definiu nenhuma senha para sua base de dados, esta string é o suficiente.

Data Source=caminho completo do arquivo;Version=3;

Caso tenha definido uma senha, use esta string

Data Source=caminho completo do arquivo;Version=3;Password=senha;

Clique 2x no botão “Criar Tabelas”. Segue o código do evento clique.

 private void btnCriarTabelas_Click(object sender, EventArgs e)
        {
            try
            {
                SQLiteConnection conn = OpenConnection();

                //criamos um objeto Command;
                SQLiteCommand command = conn.CreateCommand();

                //definimos o script de criação de tabelas
                string createTable = @"CREATE TABLE Pessoa (
                        ID INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
                        Nome VARCHAR(100) NOT NULL,
                        Telefone VARCHAR (30)
                    )";

                command.CommandText = createTable;
                command.ExecuteNonQuery();

                //aqui iremos fazer um alter table apenas para mostrar que é possível
                string alterTable = "ALTER TABLE Pessoa ADD Column DataNascimento DATE";

                command.CommandText = alterTable;
                command.ExecuteNonQuery();

                MessageBox.Show(this, "Tabela criada com sucesso.", "Aviso!", MessageBoxButtons.OK, MessageBoxIcon.Error);

            }
            catch (Exception ex)
            {
                MessageBox.Show(this, "Ocorreu um erro ao criar a tabela na base de dados.\n" +
                    ex.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

Repare na linha em destaque o comando ID INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT aqui definimos que o campo ID será nossa chave primária do tipo inteiro e autoincremento. NO SQLite você não precisa definir a diretiva “AUTOINCREMENT“, pois por padrão toda chave primária do tipo inteiro é autoincremento. Mas, eu gosto de colocar.

Ok! Já criamos a nossa base de dados e já criamos a nossa tabela. Agora vamos manipular estes dados, para isso iremos codificar os botões btnInsert, btnUpdate, btnDelete e btnSelect.

Veja o código dos botões abaixo.

Botão btnInsert

private void btnInsert_Click(object sender, EventArgs e)
{
	if (!Validate(false)) return;

	SQLiteConnection conn = OpenConnection();
	SQLiteTransaction transaction = null;
	try
	{
		transaction = conn.BeginTransaction();
		SQLiteCommand command = conn.CreateCommand();
		string insertCommand = "INSERT INTO Pessoa (Nome, Telefone, DataNascimento) VALUES(?,?,?)";
		command.Parameters.Add("Nome", DbType.String).Value = txtNome.Text;
		command.Parameters.Add("Telefone", DbType.String).Value = txtTelefone.Text;
		command.Parameters.Add("DataNascimento", DbType.Date).Value = dtDataNascimento.Text;
		command.CommandText = insertCommand;
		command.ExecuteNonQuery();
		transaction.Commit();
		btnSelect.PerformClick();

	}
	catch (Exception ex)
	{
		if (transaction != null) transaction.Rollback();
		MessageBox.Show(this, "Ocorreu um erro ao inserir os dados na tabela.\n" +
						   ex.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);

	}
	finally { conn.Close(); }
}

Botão btnUpdate


private void Update_Click(object sender, EventArgs e)
{
	if (!Validate(true)) return;

	SQLiteConnection conn = OpenConnection();
	SQLiteTransaction transaction = null;
	try
	{
		transaction = conn.BeginTransaction();
		SQLiteCommand command = conn.CreateCommand();
		string updateCommand = "UPDATE Pessoa SET Nome = ?, Telefone = ?, DataNascimento =? WHERE ID = ?";
		command.Parameters.Add("Nome", DbType.String).Value = txtNome.Text;
		command.Parameters.Add("Telefone", DbType.String).Value = txtTelefone.Text;
		command.Parameters.Add("DataNascimento", DbType.Date).Value = dtDataNascimento.Text;
		command.Parameters.Add("ID", DbType.Int32).Value = txtID.Text;
		command.CommandText = updateCommand;
		command.ExecuteNonQuery();
		transaction.Commit();
		btnSelect.PerformClick();

	}
	catch (Exception ex)
	{
		if (transaction != null) transaction.Rollback();
		MessageBox.Show(this, "Ocorreu um erro ao inserir os dados na tabela.\n" +
						   ex.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);

	}
	finally { conn.Close(); }
}

Botão btnDelete

private void btnDelete_Click(object sender, EventArgs e)
{
	if (string.IsNullOrEmpty(txtID.Text) || Convert.ToInt32(txtID.Text) == 0)
	{
		MessageBox.Show(this, "Selecione um registro para excluir!", "Exluir!", MessageBoxButtons.OK, MessageBoxIcon.Information);
		return;
	}

	SQLiteConnection conn = OpenConnection();
	SQLiteTransaction transaction = null;
	try
	{
		transaction = conn.BeginTransaction();
		SQLiteCommand command = conn.CreateCommand();
		string deleteCommand = "DELETE FROM Pessoa WHERE ID = ?";
		command.Parameters.Add("ID", DbType.Int32).Value = txtID.Text;
		command.CommandText = deleteCommand;
		command.ExecuteNonQuery();
		transaction.Commit();
		btnSelect.PerformClick();
	}
	catch (Exception ex)
	{
		if (transaction != null) transaction.Rollback();
		MessageBox.Show(this, "Ocorreu um erro ao excluir os dados da tabela.\n" +
						   ex.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);

	}
	finally { conn.Close(); }
}

Botão btnSelect

private void btnSelect_Click(object sender, EventArgs e)
{
	try
	{
		RefreshGrid();
	}
	catch (Exception ex)
	{
		MessageBox.Show(this, "Ocorreu um erro ao selcionar os registros.\n" +
						   ex.Message, "Erro!", MessageBoxButtons.OK, MessageBoxIcon.Error);

	}
	finally { }
}

Precisaremos também de alguns métodos que irão nos auxiliar no decorrer do processo.

Preste atenção aos comentários de cada método.

#region Métodos Auxiliares
///
/// abre uma conexão e retorna
///
///
private SQLiteConnection OpenConnection()
{
	string dbFile = "sqlLite.db";
	//criamos a conexão com a base de dados
	SQLiteConnection conn = new SQLiteConnection("Data Source=" + dbFile + ";Version=3;");
	//abrimos a conexão
	conn.Open();
	return conn;
}

///
/// atualiza a grid com os dados da base.
///
private void RefreshGrid()
{
	SQLiteConnection conn = OpenConnection();
	SQLiteCommand command = conn.CreateCommand();
	command.CommandText = "SELECT ID, Nome, Telefone, DataNascimento AS 'Data Nascto' FROM Pessoa";
	SQLiteDataReader rs = command.ExecuteReader();
	BindDataGrid(dataGridView, rs);
	conn.Close();
}

///
/// cria os campos da grid e prepara para exibir os dados da base
///
/// <param name="_dataGrid" />datagridview que deverá ser preparada
/// <param name="_rs" />recordset com os dados que deverão ser populados na grid
private void BindDataGrid(DataGridView _dataGrid, SQLiteDataReader _rs)
{
	_dataGrid.Rows.Clear();
	_dataGrid.Columns.Clear();

	for (int i = 0; i < _rs.FieldCount; i++)
	{
		DataGridViewTextBoxColumn col = new DataGridViewTextBoxColumn();
		col.HeaderText = _rs.GetName(i);
		col.Visible = true;
		col.Name = "col" + i;
		col.Resizable = DataGridViewTriState.True;
		_dataGrid.Columns.Add(col);
	}

	while (_rs.Read())
	{
		object[] row = new object[_rs.FieldCount];

		for (int i = 0; i < _rs.FieldCount; i++)
		{
			row[i] = FormatValue(_rs.GetValue(i), _rs.GetDataTypeName(i));
		}

		_dataGrid.Rows.Add(row);
	}
}

///
/// Formata um valor para ser exibido na grid
///
/// <param name="fieldValue" />valor do campo
/// <param name="fieldType" />tipo do campo
///
private object FormatValue(object fieldValue, string fieldType)
{
	string ret = "";

	if (fieldType.ToUpper() == "DATE")//só nos interessa o campo data para exemplo
		ret = string.Format("{0:dd/MM/yyyy}", fieldValue);
	else
		ret = fieldValue.ToString();

	return ret;
}

///
/// valida os dados do formulário e retorna
///
/// <param name="update" />se true valida o ID
///
new private bool Validate(bool update)
{
	if (string.IsNullOrEmpty(txtNome.Text))
	{
		MessageBox.Show(this, "Nome é obrigatório!", "Campo Obrigatório!", MessageBoxButtons.OK, MessageBoxIcon.Information);
		return false;
	}

	if (string.IsNullOrEmpty(txtTelefone.Text))
	{
		MessageBox.Show(this, "Telefone é obrigatório!", "Campo Obrigatório!", MessageBoxButtons.OK, MessageBoxIcon.Information);
		return false;
	}

	if (update)
	{
		if (string.IsNullOrEmpty(txtID.Text) || Convert.ToInt32(txtID.Text) == 0)
		{
			MessageBox.Show(this, "Selecione um registro para continuar!", "Registro!", MessageBoxButtons.OK, MessageBoxIcon.Information);
			return false;
		}
	}

	return true;
}
#endregion

Com isso apresentei a vocês o SQLite, com este tutorial você aprendeu tudo que é preciso para fazer uma aplicação usando esta base de dados embarcada.

Para saber mais sobre o SQLite Provider acesse o link http://system.data.sqlite.org

Para saber mais sobre o SQLite acesse o link http://sqlite.org/docs.html

Para saber mais sobre as strings de conexão para SQLite acesse o link http://www.connectionstrings.com/sqlite

Se tiver alguma dúvida, utilize o nosso fórum de C# link http://techblog.desenvolvedores.net/bbpress/forum.php?id=2

Download para o projeto de exemplo [download id=”15″]


É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Nascido em Juruaia/MG em uma fazenda de criação de búfalos, e residindo na região Sul do Brasil. Trabalha com desenvolvimento de aplicações desde os 17 anos. Atualmente é Arquiteto Organizacional na Unimake Software. Para saber mais ... http://desenvolvedores.net/marcelo []'s
Page 3 of 4«1234»