Este artigo foi traduzido por máquina.

Cutting Edge

Vinculação de dados no ASP.NET AJAX 4.0

Dino Esposito

Baixar o código de exemplo

Pare combatendo ao redor o bush: AJAX não é possível apenas com um mecanismo JavaScript alta segurança que é executado dentro do navegador cliente e fornece a base para os recursos mais avançados e assíncronos. A biblioteca JavaScript atualmente incorporada no ASP.NET 3.5 Service Pack 1 é uma tentativa necessária, mas insuficiente, fornecer uma biblioteca. Uma plataforma ASP.NET AJAX mais poderosa é necessária e apenas ser introduzido como parte do AJAX ASP.NET 4.0.

Abstractly falando, um baseados em AJAX front-end é uma camada de apresentação que combina os sofisticados recursos de interface do usuário com a implementação de alguma lógica de aplicativo. A lógica do aplicativo é essencialmente o código por trás de todos os os diagramas de caso de uso que resultou das fases de análise e design. A lógica do aplicativo expressa o comportamento desejado do aplicativo e como um usuário é esperado a interação com todo o sistema.

O que torna um AJAX front-end bastante exclusivo, no mínimo quando comparado a uma Web clássico ou smart-client front-end, é a necessidade pressionando misturar elementos de uma experiência de usuário com ferramentas de programação de nível inferior. Como um front-end AJAX é executado dentro do navegador cliente, ele pode contar apenas em HTML para produzir a interface do usuário e somente em JavaScript para aprimorar os elementos visuais com efeitos especiais, arrastar-e-soltar, busca de dados assíncronos e atualizações parciais.

Para atender às expectativas, uma plataforma moderna e eficiente do AJAX deve fornecer os dois recursos principais. Primeiro, ele deve habilitar os desenvolvedores a chamadas assíncronas para uma fachada HTTP de módulos do servidor ad hoc. Em segundo lugar, ele deve permitem aos desenvolvedores incorporar qualquer dados brutos recebidos a página existente DOM (Document Object Model). Ambos os recursos, no entanto, seriam perder muita seu apelo inerente se implementada de forma que não é que fácil e eficiente.

No ASP.NET 3.5 Service Pack 1, os desenvolvedores encontrar uma API eficiente e confiável para se conectar forma assíncrona a uma camada de serviços da Web baseado em HTTP. ASP.NET AJAX 3.5 torna possível e fácil em geral, para poder fazer referência a um serviço da Web da página de cliente. Quando você faz isso, a estrutura também gera automaticamente uma classe de proxy do JavaScript que espelha o contrato de serviço. A estrutura existente do AJAX, tanto no servidor e cliente, funciona para proteger os desenvolvedores de todos os detalhes de serialização de dados. Da perspectiva do desenvolvedor JavaScript, um serviço Web remoto (ainda sujeito a diretiva de mesma origem conhecido) é como um objeto JavaScript local expor comportamento por meio de métodos.

ASP.NET 3.5 Service Pack 1 não oferece as virtudes mesmas que diz respeito à criação da interface do usuário. Ele torna muito fácil buscar dados brutos do servidor, mas ele não oferece grande parte no meio de uma interface poderosa para exibir esses dados não processados em uma interface de usuário. A principal deficiência do suporte AJAX do ASP.NET 3.5 Service Pack 1 é a falta de ferramentas eficientes para ligação de dados do lado do cliente e modelos HTML. Por que um mecanismo de renderização de modelo no lado do cliente e uma sintaxe de ligação de dados made-to-measure são os recursos mais interessantes que você encontrar na ASP.NET AJAX 4.0.

Neste artigo, examinarei pilares de desenvolvimento de AJAX do mundo real como tem suporte no ASP.NET AJAX 4.0. Ao fazer isso, me concentrarei principalmente na modelos do lado do cliente e vinculação de dados mas não ignorar outras novidades, como classes de proxy de serviços de dados ADO.NET e recursos de programação.

Pilares do desenvolvimento de AJAX do mundo real

Desenvolvimento de AJAX do mundo real é sobre como criar interfaces do usuário avançada pela Internet, e ele exige o aplicativo de novos padrões de design e emprego de novas ferramentas de programação.

Para um longo tempo, qualquer interface de usuário da Web representado um retrocesso todo em termos de uso e capacidade de resposta se comparado a qualquer interface de usuário da área de trabalho. Por um longo tempo, da Web desenvolvedores apenas ignorados (porque não estava relevante para seu trabalho) um número de padrões de interface do usuário e recursos de programação, inclusive busca previsão, cache, monitoramento de tarefas remotas, exibição contextual e drill-down, subviews, desativação da interface do usuário parcial e modalidade.

No desenvolvimento da Web clássico, a criação da interface do usuário inteiramente foi delegada para o lado do servidor e implementada com eficiência usando ligação de dados do lado do servidor e controles ad hoc. O advento do paradigma AJAX feitas nesse modo obsoleto e unappealing para aumentar o número de aplicativos.

Dados vinculando, porém, é muito eficiente um recurso para ignorar um modelo de programação AJAX. Além disso, orientação a objeto é difícil recusar quando a complexidade do código cresce além de um determinado limite. Ao mesmo tempo, um aplicativo da Web permanece uma combinação exclusiva muito de recursos ricos, downloads armazenáveis em cache e pegadas pequenas.

O caminho de desenvolvimento de AJAX do mundo real, bibliotecas JavaScript são a maneira acessível apenas para adicionar programação energia. Através de bibliotecas JavaScript, você fornecer a base de orientação a objeto em um idioma não OOP;oferecer widgets de interface do usuário avançados e disponíveis no mercadoe você pode oferecer ferramentas de programação para efetivamente código de ligação de dados totalmente no lado do cliente.

Sem um poderoso modelo para vinculação de dados do lado do cliente, você não pode ter uma plataforma poderosa para desenvolvimento de AJAX do mundo real.

Requisitos para ligação de dados do cliente

Há dois padrões fundamentais para implementar funcionalidades de ligação de dados. Uma é o padrão de mensagem HTML e o outro é o padrão de modelo do lado do navegador. O primeiro envolve Preparando um serviço remoto chamada para um componente que retorna prearranged marcação HTML para exibição. A última opção é tudo sobre como configurar maquinaria para baixar dados brutos e decidir sobre o cliente como processar check-out.

O padrão de mensagem HTML é semelhante a uma forma inteligente de processamento parcial, exceto que ela não envolve qualquer estado de exibição e pode ser configurada para ser uma operação autônoma não vinculada a outras operações postback ocorra no mesmo aplicativo. Em uma implementação do padrão de mensagem HTML, tudo o que ocorre no servidor;qualquer ligação de dados é essencialmente um formulário de dados de servidor clássicos envolvendo controles, como DataGrid e ListView e gerenciados contêineres de dados extraídos de ligação.

O padrão de mensagem HTML pode ser facilmente implementado com as ferramentas disponíveis no ASP.NET 3.5. Tudo o que ele requer o cliente é a ligação de retornada marcação para a página DOM. O trecho de código abaixo mostra o que realmente precisava de uma perspectiva de codificação:

grid.innerHTML = markup;

No exemplo, a grade indica o elemento HTML para conter a marcação — normalmente isso é uma marca DIV. A variável chamada marcação, por outro lado, indica qualquer parte do HTML obtido como uma resposta de uma chamada de método de serviço.

É preciso dizer que o serviço usado para implementar o padrão de mensagem HTML deve incorporar a lógica para recuperar ou calcular os dados para retornar mais qualquer lógica necessária para formatar os dados em HTML.

Em geral, uma solução baseada no padrão de mensagem HTML requer mais largura de banda conforme aumenta o tamanho médio de resposta para cada chamada de método remoto.

O modelo do lado do navegador padrão (BST) requer codificação mais no seu lado, mas também pode fornecer melhores resultados tanto em termos de flexibilidade e otimização de largura de banda. O padrão BST se baseia a idéia de que você coloque uma chamada remota para recuperar dados. Dados são descarregados no cliente em um formato que permite a manipulação com JavaScript. Finalmente, os dados são mesclados com DOM da página existente e produz qualquer interface complexa, que você precisa.

Muitas vezes, o poder do paradigma AJAX é representado por engano com a possibilidade de forma assíncrona atualizando pequenas partes da interface do usuário. Ele é uma coisa para obter um valor escalar de forma assíncrona (digamos, o saldo atual de uma conta bancária) e inserir que página DOM; em existenteé bastante outra coisa para atualizar uma matriz de dados que se altera com freqüência e requer uma infra-estrutura gridlike para exibir de forma assíncrona.

O servidor é simples com controles de servidor, como abaixo:

Collection<StockInfo> stocks = GetLatestQuotes(...);
DataGrid1.DataSource = stocks;
DataGrid1.DataBind();

Qual seria o equivalente a esse código para o cliente? A primeira parte pode ser facilmente mapeada para os recursos do ASP.NET 3.5. Tudo o que fazer é criar uma instância e use um proxy de cliente para um serviço remoto que é capaz de obter valores atualizados, você assim:

var service = new Samples.Services.FinanceService();
var stocks = service.GetLatestQuotes(...);

A variável de ações é uma matriz de objetos JavaScript que representa os dados que você recebeu. Como você faria ajusta este bloco de dados não processados em um layout HTML existente? O padrão BST está aqui para ajudá-lo. Ele requer que você defina os seguintes elementos: sua própria sintaxe de modelos HTML e dados relacionados espaços reservados;sua própria sintaxe de vinculação de dados reais para espaços reservados;uma fábrica de HTML que usa modelos e dados e produz atualizado marcação;e cole o código para obstrui-lo todos juntos enquanto oferecendo uma interface de programação gerenciável.

ASP.NET AJAX 4.0 fornece uma implementação do padrão BST fora da caixa. A estrutura para modelos do ASP.NET AJAX é definida no arquivo MicrosoftAjaxTemplates.js. Você precisa fazer referência a esse arquivo através do controle ScriptManager (ou ScriptManagerProxy) se você usar páginas mestras. Se você usa o ASP.NET MVC ou preferir para fazer referência a arquivos de script por meio do tradicional < script >marca, você também deve adicionar uma referência preliminar para MicrosoftAjax.js.

Sintaxe de modelos HTML

Anos de programação ASP.NET provaram além qualquer dúvida razoável que modelos HTML são uma excelente maneira para criar uma interface de usuário da Web a partir de dados. Um modelo HTML é uma parte do HTML que contém literais, controles ASP.NET e espaços reservados para ligação de dados. Vinculado a dados não processados e processados por um mecanismo ad hoc, um modelo HTML morphs em HTML simples para o navegador para processar. Existe um modelo para vincular dados e se originam de um bloco de marcação para exibir;até que a vinculação ocorre, o modelo está oculto do modo de exibição.

Apesar de uma descrição relativamente simples, um modelo HTML é muito difícil implementar em uma estrutura de AJAX do mundo real. Foram feitas algumas tentativas pelas bibliotecas populares, como protótipo JS, para formalizar um modelo de HTML. Enquanto houver acordo comum os recursos de um deve esperar de um modelo HTML, um modelo comum para definir um modelo de HTML em um navegador ainda não existe.

Um modelo deve ser capaz processar marcação compatível com XHTML. Um modelo deve ser processado pelo mecanismo de processamento subjacente mais rápido possível e permita que o mecanismo de processar uma grande porcentagem da marcação antes do usuário percebe que há uma resposta atrasada do aplicativo. Um modelo deve suportar uma sintaxe muito simples para ligação é fácil de ler, enquanto não estar limitado a apenas casos simples. Você deve poderá misturar marcação e código em um modelo. O ideal é que o código que aciona o processamento do modelo deve ser declarativa e não intrusivo particularmente.

Vamos examinar as características do modelo de modelo HTML com suporte ASP.NET AJAX 4.0.

Em ASP.NET AJAX 4.0, um modelo HTML é uma marca DIV, ou qualquer outra marca de recipiente, decorada com o atributo de classe de modelo sys, como mostrado abaixo:

<div>
<ul id="MyItem" class="sys-template">
       <li>
         {{ Symbol }}, {{ Quote }}, {{ Change }}
       </li>
</ul>
</div>

A classe de CSS sys-modelo é uma convenção que marca o elemento e seu conteúdo, como inicialmente invisível. Observe que o modelo de sys deve ser definido explicitamente na página mestra ou em cada página, da seguinte maneira:

<style type="text/css">
.sys-template { display:none; visibility:hidden; }
</style>

Quando processado, um modelo é fornecido um contexto de dados e corpo do modelo de pode hospedar ligações a campos públicos e propriedades do objeto de contexto de dados. Da mesma forma, qualquer elemento no modelo pode referenciar qualquer expressão JavaScript que é avaliada como uma seqüência de caracteres.

Sintaxe para ligações de dados

A sintaxe para expressar uma ligação entre um espaço reservado no modelo e dados externos é da seguinte maneira:

{{ expression }}

Como mencionado, a expressão pode ser o nome de um membro público do objeto de contexto de dados ou uma expressão JavaScript que retorna uma seqüência de caracteres. Essas expressões podem aparecer em qualquer lugar o modelo e também podem ser usados para atribuir um valor para um atributo, como mostrado abaixo:

<div>
  <ul id="MyItem" class="sys-template">
     <li>
       <asp:Label runat="server"
            Text="{{CompanyName}}" />
     </li>
  </ul>
</div>

Um modelo HTML não precisa ser feita de literais HTML simples;Você pode usar ASP.NET marcação bem. Dado o trecho de código anterior, eis a marcação emitida pelo controle de rótulo:

<span>{{ CompanyName }}</span>

Como você pode ver, o uso de um controle de servidor no código-fonte da página não prejudica o processamento do lado do cliente de modelos.

Eventos de cliente podem ser definidos em um modelo usando a sintaxe onXXX familiarizado ou por meio da função de addHandler $ na Microsoft AJAX Library.

Controle DataView e instanciação de modelo

Para exibir dados, um modelo deve ser instanciado, vinculado a dados e processado dentro de um recipiente. O controle de cliente Sys.UI.DataView pode ser usado para automatizar e simplificar a todas essas tarefas.

O controle DataView é essencialmente um componente que leva alguns dados e o ASP.NET AJAX modelo e produz marcação HTML a ser exibido dentro da página de entrada. O DataView também é referido como um componente de comportamento. Em geral, um comportamento é um componente com base em script que, uma vez anexada a um elemento DOM, altera a forma na qual o elemento HTML funciona dentro do navegador cliente. Você pode trabalhar com um comportamento de uma destas duas maneiras. Você pode anexar declarativamente o comportamento a seu elemento DOM de destino ou você pode criar uma instância do comportamento e configurá-la programaticamente. No último caso, a associação entre o comportamento e o modelo é apenas parte da configuração. Vamos analisar a abordagem declarativa primeiro.

Antes que qualquer ainda mais, porém, deixe-me esclarecer que o DataView é apenas um componente de comportamento possíveis. Nada você posteriormente ler sobre instanciação declarativa e anexo se aplica a qualquer comportamento pode ser executado ASP.NET AJAX.

Figura 1 O comportamento de DataView em ação

Anexando comportamentos declarativamente

Para anexar comportamentos a um elemento DOM, você usar o sys: anexar o atributo personalizado. Como você pode ver, o atributo é associado com um espaço para nome URI torna XHTML compatível. Você declara o prefixo sys no corpo da < >elemento:

<body xmlns:sys="javascript:Sys" ...>

O prefixo sys mapeia para o espaço para nome javascript:Sys que URI definido nMicrosoft AJAX Library. Usando o sys: anexar atributo serve apenas a finalidade de estabelecer uma associação entre um comportamento existente e um elemento HTML. Você ainda precisa instanciar o componente de comportamento. Você faz isso definindo outro atributo namespaced personalizado no corpo da < >elemento. O valor do atributo será referência ao objeto JavaScript para criar uma instância:

<body xmlns:sys="javascript:Sys"
      xmlns:dataview="javascript:Sys.UI.DataView" ...>

O nome do atributo — dataview no trecho de código anterior — é arbitrária e pode ser alterado para qualquer outra coisa que desejar. O nome que você escolhe, no entanto, ele deve ser mantido no restante do código para o comportamento de referência.

A instanciação eficaz de qualquer script anexado comportamento ocorre quando a página é carregada e o elemento DOM é processado. O navegador que está carregando a página pode não saber nada sobre como lidar com esses comportamentos definidos biblioteca. A estrutura ASP.NET AJAX é basicamente responsável pela instanciação de seus próprios comportamentos. No entanto, a estrutura ASP.NET AJAX requer instruções ad hoc de você para continuar. Em particular, você deseja que a estrutura rebatem durante o DOM processo de análise e examinar o conteúdo de qualquer elemento analisado para cuidar de qualquer sys: anexar atributos.

Figura 2 controlar um objeto DataView programaticamente

<script type="text/javascript">

// Define a global instance of the DataView
var theDataView = null;

// This function can be called from anywhere in the page to
// fill the template with passed data and update the page.
function renderTemplate(dataSource) 
{
    // Ensure we have just one copy of the DataView.
    // The DataView's constructor gets a DOM reference to the template.
    if (theDataView === null)
        theDataView = new Sys.UI.DataView($get("MyTemplate"));

    // Bind data to the template associated with the DataView
    theDataView.set_data(dataSource);

    // Force the template to render 
    theDataView.refresh();
}

</script>

Por motivos de desempenho, a estrutura ASP.NET AJAX não foi projetada para automaticamente cuidar de qualquer elemento DOM que o navegador encontra ao longo do caminho. Portanto, é até você indicar explicitamente quais elementos DOM precisa ser verificado para comportamentos anexados que oferecem suporte a instanciação declarativa. Você ativar um elemento DOM conter comportamentos instanciados declarativamente usando o sys: ativar o atributo. Usar o atributo no corpo da < >elemento e defina-o a uma lista separada por vírgulas de IDs de elemento:

<body xmlns:sys="javascript:Sys"
      xmlns:dataview="javascript:Sys.UI.DataView"
      sys:activate="customerList">

O código anterior instrui a estrutura para instanciar automaticamente qualquer comportamento que pode ser anexado ao elemento DOM customerList.

Você também pode usar o símbolo curinga (1) se você deseja ativar o documento inteiro. Use esta opção com cuidado, especialmente em páginas grandes porque ele pode introduzir um atraso de processamento. Com o comportamento de DataView totalmente configurado no corpo da < >elemento, tudo o que permanece fazer é ligar dados atualizados para o modelo:

<div id="customerList">
    <ul class="sys-template"
        sys:attach="dataview"
        dataview:data="{{ theCustomers }}">
        <li>
            <span ><b>{{ ID }}</b></span>
            <asp:label runat="server"
                 Text="{{ CompanyName }}"></asp:label>
        </li>
    </ul>
</div>

O componente DataView tem uma rica interface de programação que, entre outras coisas, inclui uma propriedade de dados. A propriedade de dados representa o contexto de dados para o modelo vinculado. Você pode definir a propriedade dados declarativamente e por meio de programação. No trecho de código abaixo, a propriedade dados declarativamente é definida como o conteúdo de uma matriz global chamado theCustomers:

<ul class="sys-template"
    sys:attach="dataview"
    dataview:data="{{ theCustomers }}">
...
</ul>

Em geral, você pode definir a propriedade dados como qualquer expressão JavaScript que é avaliada como um objeto ligável ou uma matriz de objetos. Você optar por uma abordagem declarativa quando você pretende vincular o modelo a alguns dados globais.

O exemplo de download de código intitulado A exemplo página utilizando declarativa vinculação mostra a listagem completa de uma página de exemplo. A Figura 1 mostra a página de exemplo em ação.

Para ligação através de programação, você precisará obter uma referência ao objeto DataView e chamar o método setter da propriedade dados. Recuperar DataView instância por meio de $ localizar auxiliar definida nMicrosoft AJAX Library. A identificação do componente DataView coincide com a identificação do elemento DOM que ele está anexado a. Considere o trecho de código a seguir:

<ul class="sys-template"
    sys:attach="dataview"
    id="DataView1">
...
</ul>
<input type="button"
       value="Perform binding"
       onclick="bind()" />

Você pode executar a ligação de dados somente quando o usuário explicitamente clica no botão. Eis o código que você precisa colocar em ligação função JavaScript:

<script type="text/javascript">
    function bind() {
        theDataView = $find("DataView1");
        theDataView.set_data(theCustomers);
    }
</script>

Você primeiro recupera a instância de DataView pela identificação e atribuir novo conteúdo a sua propriedade de dados.

Dicas para páginas mestras

Quando você usa uma página mestra, você geralmente deixar < corpo >marca do modelo de página no mestre. Em seguida, é necessário que você editar a página mestra para anexar qualquer comportamento necessário. Como alternativa, você pode colocar < corpo >um espaço reservado para conteúdo de marca e forçar os desenvolvedores a defini-la explicitamente no qualquer página de conteúdo.

&Lt; corpo >marca é necessária para registrar anexável comportamentos, como DataView e para habilitar elementos DOM reconhecer e instanciar comportamentos através de sys: ativar o atributo.

É preciso observar que existe uma alternativa à edição < corpo >marca. Você pode usar a nova propriedade ClientElementsToActivate no controle ScriptManager, da seguinte maneira:

<asp:ScriptManager runat="server"
                   ID="ScriptManagerProxy1"
                   ClientElementsToActivate="*">
    <Scripts>
        <asp:ScriptReference Name="MicrosoftAjaxTemplates.js" />           
    </Scripts>
    ...
</asp:ScriptManager>

Observe que apenas algumas das propriedades definidas no controle ScriptManager são espelhadas no controle do ScriptManagerProxy, que é o controle de invólucro que usam para replicar ScriptManager funcionalidade em uma página de conteúdo. No ASP.NET 4.0, no entanto, o ClientElementsToActivate está entre as algumas propriedades que você pode acessar em ambos os controles.

Você deve estar se perguntando como uma propriedade de matriz de seqüência de caracteres como ClientElementsToActivate pode afetar o comportamento de uma estrutura de JavaScript, como a estrutura ASP.NET AJAX. Quando a propriedade ClientElementsToActivate é definida, o controle do Gerenciador de script emite uma linha extra de script dentro da página que adiciona uma ou mais entradas para uma matriz interna no objeto sys.Application na Microsoft AJAX Library.

Usando o controle DataView programaticamente

Até agora, você examinamos um cenário no qual o modelo HTML é anexado a um comportamento de DataView para mistura juntos layout e os dados em HTML atualizado. Essa não é a abordagem só é possível para ligação de dados do lado do cliente.

Você também pode criar uma instância do componente DataView programaticamente e passar o modelo para ele para usar como um argumento. Figura 2 fornece uma listagem breve mas ilustrativos.

O construtor do DataView obtém uma referência DOM para o modelo a ser usado internamente. O método setter da propriedade dados obtém dados atualizados para vincular. Finalmente, o método de atualização força uma atualização de modelo HTML que exibe dados recém-ligados.

Para criar uma instância do DataView, você também pode recorrer ao $ criar método auxiliar, como mostrado abaixo:

<script type="text/javascript">
function pageLoad() {
$create(
       Sys.UI.DataView,
       {},
       {},
       {},
       $get("MyTemplate")
);
}
</script>

Um cenário muito comum em que usar uma DataView definitivamente suaviza seus esforços de programação é preencher um modelo HTML complexo com dados fornecido por um serviço da Web remoto. Vamos investigar ainda mais esse ponto.

Buscando dados de serviços da Web

A interface de programação dos recursos de componente DataView um número de membros especificamente para servir o cenário no qual o conteúdo do DataView vem de um URI remoto. O download inclui uma lista de membros de DataView que funcionam com serviços da Web.

Observe que o conteúdo do exemplo de download de código intitulado um DataView busca automática para consumir dados de um URI remoto não compreender totalmente a API inteira do componente DataView. Muitos membros mais existem para atender a outros cenários que abordarei em camadas em uma coluna futura.

O exemplo de código para download intitulado um DataView busca automática para consumir dados de um URI remoto mostra o código JavaScript que cria um DataView quando a página for carregada. O DataView está configurado para buscar seus dados imediatamente, colocando uma chamada para o método de serviço da Web especificado.

A propriedade dataProvider indica a fonte de dados, enquanto o fetchOperation define o método para invocar. Finalmente, fetchParameters é um objeto de dicionário que contém informações de parâmetro para o método. Você defini-la a um objeto JavaScript onde cada propriedade corresponde ao nome de um parâmetro formal na definição de método. Em particular, no exemplo anterior, o método GetQuotesFromConfig tem o seguinte protótipo:

[OperationContract(Name="GetQuotesFromConfig")]
StockInfo[] GetQuotes(bool isOffline);

O DataView recebe o modelo HTML para preencher por meio de $ criar função auxiliar e depois de dados tem sido buscados com êxito, ele preenche até qualquer espaços reservados no modelo.

Figura 3 ligados a dados do Rich A página da Web com AJAX e jQuery

O código de exemplo também contém um objeto de timer personalizada que atualiza periodicamente o modelo com um pouco de animação jQuery. Quando o timer de tiques, uma nova operação de busca é ordenada usando qualquer valor atual para o "offline"caixa de seleção. O "offline"caixa de seleção indica se o serviço da Web deve retornar falsas ações e os valores ou se conectar a um serviço financeiro do mundo real para capturar cotações de ações true. O serviço obtém a URL do serviço financeiro e a lista de ações do arquivo de configuração. (Consulte o código-fonte para obter detalhes.)

Próximo Mês

Figura 3 mostra uma rica e animada ligados a dados página ASP.NET AJAX que usa o processamento do lado do cliente para vincular dados brutos em um modelo HTML relativamente complexo. Em ASP.NET AJAX 4.0, você encontrar poderosas ferramentas de programação para tornar a codificação de tais páginas não mais difícil do que fazendo a ligação de dados tradicional do lado do servidor.

A página mostrada na Figura 3 é apenas o primeiro e a etapa mais simples, de um caminho mais. Próximo mês, abordarei mais recursos de modelos sofisticados e como colocar lógica em modelos HTML e Vou explorar a ligação de dados ao vivo. Fique sintonizado!

Dino Esposito é arquiteto da IDesign e co-autor de "Microsoft .NET: Arquitetura de aplicativos para a empresa"(Microsoft Press, 2008). Residente na Itália, Esposito é um palestrante sempre presente em eventos do setor no mundo inteiro. Entre em contato com ele por meio de seu blog em weblogs.asp.net/despos.