Partilhar via

Demonstra Passo a passo: Adicionando dados dinâmicos a um site existente

  • Artigo

Esta explicação passo a passo mostra como modificar um site da Web ASP.NET existente para incluir recursos de estrutura de dados dinâmicos.Além disso, ele mostra maneiras de personalizar um site Dados Dinâmicos.No participante da explicação passo a passo, você terá um funcional Web site que usa o modelo de dados para interagir com o banco de dados.Além disso, você terá que modelos de campo personalizado que definem como os campos de dados são processados para exibição e edição.

Um aspecto de definição de dados dinâmicos do ASP.NET é sua habilidade de inferir em time de execução que a aparência e o comportamento dos campos de dados nos dados de modelam que representa o banco de dados.Essas informações são usadas, em seguida, nos controles de dados com o suporte de modelos de campo, para eliminar a necessidade de códigos repetitivos na camada de apresentação.

Esta explicação passo a passo mostra como você pode fazer o seguinte com uma quantidade mínima de código:

  • Interagir com o modelo de dados.Dados dinâmicos incorpora recursos para ajudar você a criar um aplicativo orientado a dados que pode executar criar, ler, atualizar e excluir operações (CRUD).

  • Personalize como os usuários ver e edição campos de dados criando modelos de campo.Dados dinâmicos seleciona os modelos de campo apropriado com base nas informações que são inferidas do modelo de dados.

Você irá siga estas etapas:

  • Criar um Web do site e modificá-lo para oferecer suporte a dados dinâmicos.O meta principal desta tarefa é criar o modelo de dados que será usado pelos dados dinâmicos para interagir com o banco de dados.

  • criar modelos de campo.Modelos de campo são controles de usuário que definem a interface do usuário para como os dados são exibidos e editados.

  • criar uma página personalizada para exibir uma tabela.Esta página mostra como dados dinâmicos interage com o banco de dados e mostra que você precisa de apenas um mínimo de código para esta tarefa.

  • Testar integração de dados dinâmicos.Isso permite que você verifique se dados dinâmicos de recursos foi integrados no site da Web.Você pode interagir com o modelo de dados e verifique se o aplicativo funciona sistema autônomo esperado.sistema autônomo parte desse processo, você irá gerar e manipular erros.

Pré-requisitos

Para concluir os exemplos neste tópico, você precisa do seguinte:

  • Microsoft Visual Studio 2008 serviço empacotar 1 ou Visual Web Developer 2008 Express Edition serviço empacotar 1.

  • O banco de dados de exemplo AdventureWorksLT.Para obter informações sobre como baixar e instalar o banco de dados de exemplo do SQL servidor, consulte Exemplos de produtos do Microsoft SQL servidor: Banco de dados no site da CodePlex.Certifique-se de instalar a versão correta do banco de dados de exemplo para a versão do SQL servidor que você está executando (Microsoft SQL Server 2005 ou Microsoft SQL Server 2008).

Criação de uma Web de dados dinâmicos site

Nesta seção você irá criar um site da Web de dados dinâmico em Visual Studio. Você irá iniciar com um padrão ASP.NET Web site e, em seguida, transforme-as em um site que ofereça suporte a recursos de dados dinâmicos.Para fazer isso, você irá fazer o seguinte:

  • criar um site da Web ASP.NET.

  • Conectar-se o site a um banco de dados.Este banco de dados contém a tabela cujas colunas (campos de dados) serão acessadas para exibição personalizada e edição.

  • configurar o site para usar controles de dados dinâmicos.Isso permite a integração dos recursos de dados dinâmicos do Web site.

Em seguida, você irá criar e configurar o modelo de dados que você irá trabalhar com.Você fará o seguinte:

  • Crie classes de modelo de dados com base em um banco de dados do SQL servidor..

  • Adicionar metadados para o modelo de dados para habilitar validação personalizada da entrada do usuário e para habilitar um posteriormenteCalendar controle para modificar os campos de dados.

Preparando um site Web para dados dinâmicos

Esta seção mostra como criar um site da Web ASP.NET, como adicionar um banco de dados e como configurar o site da Web para integrar os recursos de dados dinâmicos.

Para criar um ASP.NET Web site

  1. Inicie o Visual Studio

  2. No Arquivo menu, clicar Novoe, em seguida, clicar Site da Web.

    A caixa de diálogo New Web Site é exibida.

  3. Em Modelos Instalados do Visual Studio, selecione ASP.NET Web Site.

  4. Próximo a Local, selecionar Sistema de arquivos e na segunda caixa, digite o nome da pasta onde você deseja manter as páginas do Web site.Por exemplo, digite o nome da pasta C:\WebSites\DynamicDataWebSite.

  5. Na lista Language, selecione a linguagem de programação que você preferir trabalhar.

  6. Clique em OK.

    Visual Studio cria as pastas e arquivos de um site da Web ASP.NET.

A próxima etapa é adicionar um banco de dados para o site.Este banco de dados contém a tabela cujas colunas (campos de dados) serão acessadas para exibição e edição.

Para adicionar o banco de dados para o site da Web

  1. No Gerenciador de Soluções, clique com o botão direito do mouse na pasta App_Data e clique em Adicionar Item Existente.

  2. No Adicionar item existente caixa de diálogo, digite o local onde você instalou o arquivo de banco de dados AdventureWorksLT (AdventureWorksLT.mdf) e, em seguida, clicar Adicionar.

    Isso cria uma cópia do arquivo de banco de dados em que o projeto.

Agora você pode configurar o site para integrar recursos de dados dinâmicos.

Para configurar o site da Web

  1. In O gerenciador de soluções, abra o arquivo Web.config.

  2. Adicione as referências assembly para os assemblies a seguintes:

    • System.Web.Routing

    • System.Web.DynamicData

    • System.ComponentModel.DataAnnotations

    O exemplo a seguir mostra como adicionar os assemblies.Certifique-se de que usar as versões de montagem correta.

    <system.web>
  <compilation>
    <assemblies>

      <add assembly="System.Web.Routing, Version=3.5.0.0,            Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>      <add assembly="System.Web.DynamicData, Version=3.5.0.0,            Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>      <add assembly="System.ComponentModel.DataAnnotations,            Version=3.5.0.0,            Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
    </assemblies>
  </compilation>

  3. Configurar o asp prefixo da marca para fazer referência a System.Web.DynamicData namespace, conforme mostrado no exemplo a seguir:

    <system.web>
  <pages>
    <controls>

      <add tagPrefix="asp" namespace="System.Web.DynamicData"          assembly="System.Web.DynamicData, Version=3.5.0.0,          Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
    </controls>
  </pages>
</system.web>

  4. Salve e feche o arquivo Web.config.

O modelo de dados de configuração

Esta seção mostra como criar o modelo de dados que é um componente-chave atingir o comportamento dinâmico para o site da Web.Nesta explicação passo a passo você irá usar um modelo de dados do LINQ para SQL.No entanto, você pode usar um modelo de dados ADO.NET entidade estrutura.Esta seção também mostra como adicionar informações de metadados para o modelo de dados.

Para criar o modelo de dados

  1. In O gerenciador de soluções, clicar com o botão direito do mouse no nome do projeto, clique em Adicionar pasta ASP.NETe, em seguida, clique em App_Code.

  2. Clique com o botão direito do mouse na pasta App_Code e então clique em Adicionar Novo Item

  3. Em O Visual Studio installed templates, clicar LINQ to SQL classes.

  4. No Nome , digite o nome de AdventureWorksLT.dbml para o modelo de banco de dados.

  5. Clique em Adicionar.

    O objeto Relational Designer (Designer Relacional de Objetos) é exibido.Para obter mais informações, consulte Object Relational Designer (O/R Designer).

  6. Na Designer Relacional de Objetos, clicar no servidor Explorer link.

  7. In Gerenciador de servidores, under Conexões de dados, expandir o AdventureWorksLT_Data.mdf nó e, em seguida, expandir o Tabelas nó.

  8. arrastar a tabela de cliente para a janela do Designer Relacional de Objetos.

  9. salvar e fechar o arquivo AdventureWorksLT.dbml.

    Você criou o modelo de dados que representa o banco de dados AdventureWorksLT.

O procedimento a seguir mostra como adicionar validação personalizada de entrada do usuário.Ele também mostra como usar um Calendar controle para processar a interface do usuário para a exibição e edição de DateTime campos de dados

Para adicionar validação personalizada e metadados ao modelo de dados

  1. In O gerenciador de soluções, clicar com o botão direito do mouse na posta App_Code pasta e, em seguida, clique em Adicionar novo item.

  2. Under Visual Studio installedtemplates, click Class.

  3. No Nome caixa, digite o nome da tabela de banco de dados (sistema autônomo definido no modelo de dados) que contém sistema autônomo dados para o modelo de campo personalizado exibir.Para esta explicação passo a passo, você estará trabalhando com o Customer classe. Portanto, criar um arquivo de classe chamado cliente.cs ou cliente.vb.Esse arquivo irá conter também uma classe associada que você criar posteriormente para aplicar atributos a campos de dados.

  4. Adicionar o Partial palavra-chave em Visual Basic ou o partial palavra-chave em Visual C# para o Customer definição de classe para torná-lo em uma classe parcial.

  5. Se você estiver criando a classe em Visual C#, exclua o construtor padrão.

    O exemplo a seguir mostra a declaração de classe atualizada.

    public partial class Customer {

}

    Partial Public Class Customer

End Class

  6. Adicionar referências para o System.Web.DynamicData e System.ComponentModel.DataAnnotations espaços para nome usando o Imports palavra-chave em Visual Basic ou o using palavra-chave em Visual C#, conforme mostrado no exemplo a seguir:

    using System.Web.DynamicData;
using System.ComponentModel.DataAnnotations;

    Imports System.Web.DynamicData
Imports System.ComponentModel.DataAnnotations

  7. No mesmo arquivo criar outra classe parcial que atuará sistema autônomo a classe de metadados associados.Você pode usar qualquer nome para a classe.Para esta explicação passo a passo, o nome da classe CustomerMetadata, conforme mostrado no exemplo a seguir:

    public partial class CustomerMetadata
{

}

    Partial Public Class CustomerMetadata

End Class

  8. Aplicar o MetadataTypeAttribute atributo para o Customer classe parcial. O atributo do parâmetro, especifique CustomerMetadata, que é o nome da classe metadados associados que você criou na etapa anterior

    O exemplo a seguir mostra o Customer classe parcial com o atributo aplicado.

    [MetadataType(typeof(CustomerMetadata))]
public partial class Customer {

}

    <MetadataType(GetType(CustomerMetadata))> _
Partial Public Class Customer

End Class

  9. Na classe metadados, criar um campo público chamado ModifiedDate que é tipado sistema autônomo Object.

    A classe de metadados, você criar um campo para cada dados cuja exibição de campos e edição o comportamento que você deseja personalizar.Para o nome de campo na classe de metadados, use o mesmo nome sistema autônomo o nome no campo de dados que você deseja modificar.

  10. Aplicar o UIHintAttribute atributo para o ModifiedDate campo. Para o parâmetro, especifique "DateCalendar".Este é o nome de um modelo de campo que você criará posteriormente.

    Observação:

    O Object é usado sistema autônomo um marcador no tipo de metadados para representar o campo de dados. Dados dinâmicos infere o tipo real do modelo de dados.

    O exemplo a seguir mostra o UIHintAttribute atributo aplicado.

    public partial class CustomerMetadata
{
    [UIHint("DateCalendar")]
    public object ModifiedDate;
}

    Partial Public Class CustomerMetadata
    <UIHint("DateCalendar")> _
    Public ModifiedDate As Object
End Class

  11. Na classe metadados, criar campos de públicos para o FirstName e LastName Propriedades.

  12. Aplicar o RegularExpressionAttribute campos de atributo dos dados FirstName e LastName. Especifique um padrão de expressão regular que permite que apenas caracteres alfabéticos, espaços e hifens, e isso limita o nome a 40 caracteres.Incluir uma mensagem de erro personalizada a ser exibido se a validação falhar

    O exemplo a seguir mostra o FirstName e LastName campos com o atributo aplicado.

    [RegularExpression(@"^[a-zA-Z''-'\s]{1,40}$",     ErrorMessage="Entered characters are not allowed.")]
public object FirstName;

[RegularExpression(@"^[a-zA-Z''-'\s]{1,40}$",    ErrorMessage = "Entered characters are not allowed.")]
public object LastName; 

    <RegularExpression("^[a-zA-Z''-'\s]{1,40}$", _    ErrorMessage:="Entered characters are not allowed.")> _
Public FirstName As Object

<RegularExpression("^[a-zA-Z''-'\s]{1,40}$", _    ErrorMessage:="Entered characters are not allowed.")> _
Public LastName As Object

    Observe que os campos de dados correspondem Customer colunas da tabela que são definidas no modelo de dados. Você pode usá-las apenas para adicionar informações de metadados que usa dados dinâmicos quando ele processa esses campos de dados.

    O padrão da expressão regular permite até 40 caracteres maiúsculos e minúsculos, bem sistema autônomo vários caracteres especiais que são comuns para nomes em inglês.

  13. Salve e feche o arquivo de classe.

Agora você pode registrar o contexto do modelo de dados para que dados dinâmicos podem acessar informações de metadados.

Para registrar o contexto de modelo de dados

  1. In O gerenciador de soluções, clicar com o botão direito do mouse no nome do projeto e, em seguida, clique em Adicionar novo item.

  2. Em O Visual Studio installed templates, selecionar Global aplicativo classe e, em seguida, clicar Adicionar.

    Adiciona um arquivo global.asax ao site.

  3. Adicionar um @ Import diretiva com um Namespace atributo que faz referência a System.Web.DynamicData namespace, sistema autônomo mostrado no exemplo a seguir:

    <%@ Import Namespace="System.Web.DynamicData" %>

  4. No Application_Start método, registrar o contexto de dados com a opção de scaffolding desabilitado, sistema autônomo mostrado no exemplo a seguir.

    Esse inscrição informa dados dinâmicos que modelo de dados para usar.Ela também informa dados dinâmicos não para ativar a tabelas que serão visíveis para scaffolding.Essa última etapa não é necessária, mas ele é usado aqui para enfatizar que o Web site não usa a scaffolding.

    MetaModel model = new MetaModel();
model.RegisterContext(typeof(AdventureWorksLTDataContext), 
new ContextConfiguration() {ScaffoldAllTables = false });

    Dim model As MetaModel = New MetaModel()
model.RegisterContext(GetType( _
    AdventureWorksLTDataContext), _
    New ContextConfiguration() With { _
    .ScaffoldAllTables = False})

  5. salvar e fechar o arquivo global.asax.

Criando modelos de campo

Modelos de campo são controles de usuário que usa dados dinâmicos para processar a interface do usuário para exibir e editar campos de dados.Dados dinâmicos requer modelos de campo existir para cada tipo de campo de dados é representado no contexto de dados.(Se nenhum modelo de campo existe para um tipo de campo de dados específico e nenhum modelo de campo pode ser encontrado as regras alternativas, dados dinâmicos lança uma exceção.)

Se você criar um site Dados Dinâmicos, o site inclui um conjunto de modelos de campo que representam tipos de dados do banco de dados típico.Elas são criadas junto com modelos de página, uma página mestra e arquivos de folha de estilos em cascata.No entanto, neste passo-a-passo, você está aprendendo como adicionar recursos de dados dinâmicos a um site existente.Portanto, presume que você não tem acesso aos modelos de campo padrão.

Os modelos de campo que você criar nesta explicação passo a passo, será semelhante os modelos padrão em um site da Web dinâmico de dados.Para obter mais informações, consulte Visão geral do ASP.NET dinâmico dados campo modelos.Você pode ver os modelos de campo padrão que são gerados quando você cria um site que usa a scaffolding.Para obter mais informações, consulte Demonstra Passo a passo: Criando um novo site do Dynamic dados Using a scaffolding.

Esta seção mostra como criar os seguintes modelos:

  • Modelos de campo que processam a interface do usuário para exibir e editar String Digite os campos de dados.

  • Modelos de campo que processam a interface do usuário para exibir e editar DateTime Digite os campos de dados.

Criando modelos de campo para dados de string

Esta seção mostra como criar modelos de campo para processar a interface do usuário para exibir e editar String campos de dados.

Para criar modelos de campo para exibir e edição campos de dados String

  1. In O gerenciador de soluções, clicar com o botão direito do mouse no nome do projeto e, em seguida, clique em Nova pasta.

  2. Renomeie a nova pasta DynamicData.

    Observação:

    Você deve usar os nomes de pastas descritas neste procedimento, já que os nomes tem um significado especial em dados dinâmicos .

  3. In O gerenciador de soluções, clicar com o botão direito do mouse o DynamicData pasta e, em seguida, clique em Nova pasta.

  4. Renomeie a nova pasta FieldTemplates.

  5. In O gerenciador de soluções, clicar com o botão direito do mouse o FieldTemplates pasta e, em seguida, clique em Adicionar novo item.

  6. Em O Visual Studio installed templates, clicar Campo de dados dinâmicos.

  7. No Nome , digite Texto.ascx.Certifique-se de selecionar Coloque o código no arquivo separado.

  8. Clique em Adicionar.

    Dois modelos de campo chamado Texto.ascx and Text_Edit.ascx são criados.O primeiro controle apresenta a interface do usuário para a exibição de String campos de dados. O segundo controle apresenta a interface do usuário para edição String campos de dados.

  9. em aberto the Text_Edit.ascx arquivo e no @ Controle diretiva, conjunto o AutoEventWireup atributo à true.

  10. salvar e fechar os arquivos de controle do usuário.

    Agora você criou os modelos de campo que processam a interface do usuário para exibir e editar String campos de dados.

Criando modelos de campo DateTime

Esta seção mostra como criar modelos de campo para processar a interface do usuário para exibir e editar DateTime campos de dados. O modelo de campo de exibição usa uma representação de data abreviada que exclui o time.O modelo de campo de edição usa o Calendar controle para permitir que o usuário insira um novo valor.

Para criar um modelo de campo para exibir e edição campos de dados DateTime

  1. In O gerenciador de soluções, clicar com o botão direito do mouse o DynamicData\FieldTemplates pasta e, em seguida, clique em Adicionar novo item.

  2. Em O Visual Studio installed templates, clicar Campo de dados dinâmicos.

  3. No Nome , digite DateCalendar.ascx.Certifique-se de selecionar Coloque o código no arquivo separado.

  4. Clique em Adicionar.

    Dois modelos de campo chamado DateCalendar.ascx and DateCalendar_Edit.ascx são criados.O primeiro controle apresenta a interface do usuário para a exibição de DateTime campos de dados. O segundo controle apresenta a interface do usuário para edição DateTime campos de dados.

  5. em aberto the DateCalendar.ascxarquivo .

  6. No Literal controlar, exclua o FieldValueString atribuição para o Text atributo, conforme mostrado no exemplo a seguir.

    <asp:Literal ID="Literal1" />

  7. salvar e fechar o arquivo de controle de usuário.

  8. Abra o DateCalendar.ascx.vb or DateCalendar.ascx.csarquivo de code-behind campo modelo.

  9. Substituir o controle de usuário OnDataBinding método para formatar o DateTime valor para exibição excluindo o time, sistema autônomo mostrado no exemplo a seguir. O valor do campo está disponível em FieldValue.

    protected override void OnDataBinding(EventArgs e)
{
  base.OnDataBinding(e);
  string shortDate = string.Empty;
  if (FieldValue != null)
  {
    DateTime dt = (DateTime)FieldValue;
    shortDate = dt.ToShortDateString();
  }
  Literal1.Text = shortDate;
}

    Protected Overloads Overrides Sub OnDataBinding( _
    ByVal e As EventArgs)
    MyBase.OnDataBinding(e)
    Dim shortDate As String = String.Empty
    If FieldValue IsNot Nothing Then
      Dim dt As DateTime = Format(CType(FieldValue, DateTime), "d")
      shortDate = dt.ToShortDateString()
    End If
    Literal1.Text = shortDate
End Sub

  10. salvar e fechar o arquivo code-behind.

  11. em aberto the DateCalendar_Edit.ascxarquivo .

  12. No @ Controle diretiva, conjunto o AutoEventWireup atributo à true.

  13. No TextBox controlar, substitua o FieldValueString expressão na Text atributo com personalizado GetDateString() método, sistema autônomo mostrado no exemplo a seguir.

    <asp:TextBox ID="TextBox1"  
  Text='<%# GetDateString() %>' >
</asp:TextBox>

  14. Adicione a seguinte marcação para o arquivo para definir o Calendar controle que processa UI para permitir uma maneira alternativa de edição de datas.

    <asp:Calendar ID="Calendar1"  
  VisibleDate=
    '<%# (FieldValue != null) ? FieldValue : DateTime.Now %>'
  SelectedDate=
    '<%# (FieldValue != null) ? FieldValue : DateTime.Now %>'
  OnSelectionChanged="Calendar1_SelectionChanged" />

    <asp:Calendar ID="Calendar1"  
  VisibleDate=
  '<%# If(FieldValue,DateTime.Now)%>'
  SelectedDate=
  '<%# If(FieldValue,DateTime.Now) %>'
  OnSelectionChanged="Calendar1_SelectionChanged" />

  15. salvar e fechar o arquivo de modelo de campo.

  16. Abra o DateCalendar_Edit.ascx.vb or DateCalendar_Edit.ascx.csarquivo de code-behind .

  17. Adicionar um GetDateString método. No método, o usuário do processo de entrada sistema autônomo inserido através de TextBox controle. O método formata a data usando um formato de data abreviada que exclui o time.

    O exemplo a seguir mostra como fazer isto:

    protected string GetDateString()
{
  if (FieldValue != null)
  {
    DateTime dt = (DateTime)FieldValue;
    return dt.ToShortDateString();
  }
  else
    return string.Empty;
}

    Protected Function GetDateString() As String
  If FieldValue <> Nothing Then
    Dim dt As DateTime = Format(CType(FieldValue, DateTime), "d")
      Return dt.ToShortDateString()
  Else
    Return String.Empty
  End If
End Function

  18. Adicionar um manipulador para o Calendar do controle SelectionChanged evento.

  19. No manipulador, defina o Text propriedade das TextBox controle do calendário para uma versão formatada da data selecionada. Isso exibe a seleção do usuário corrente na caixa de texto.

    O exemplo a seguir mostra o manipulador.

    protected void Calendar1_SelectionChanged(
  object sender, EventArgs e)
{
  // Display value using the short date format.
  TextBox1.Text = 
  Calendar1.SelectedDate.ToString("d");
}

    Protected Sub Calendar1_SelectionChanged( _
    ByVal sender As Object, ByVal e As EventArgs)
    ' Display value using the short date format.
    TextBox1.Text = Calendar1.SelectedDate.ToString("d")
End Sub

  20. salvar e fechar os arquivos de modelo de campo.

    Agora você criou os modelos de campo que processam a interface do usuário para exibir e editar DateTime campo de dados tipos. Os modelos de campo instruem dados dinâmicos para aplicar formatação apropriada e validação.Se a validação falhar, os modelos de campo também geram mensagens de erro apropriada.

Criando uma página personalizada para exibir a tabela de clientes

Esta seção mostra como criar uma página personalizada que exibe a tabela cliente usando um GridView controle com comportamento dinâmico.

O comportamento do controle dinâmico é estabelecido, faça o seguinte:

A tabela de banco de dados contém String e DateTime tipos de campos de dados. Portanto, quando você usa o GridView controle com o comportamento dinâmico para exibir os dados da tabela, dados dinâmicos usará os modelos de campo personalizado que você criou.

Para criar uma página personalizada para exibir a tabela Customers

  1. In O gerenciador de soluções, clicar com o botão direito do mouse no nome do projeto e, em seguida, selecionar Adicionar novo item.

  2. Em Modelos instalados do Visual Studio, escolha Formulário Web.

    No Nome , digite Customers.aspx.Certifique-se de selecionar Place code in separate arquivo.

  3. No @ página diretiva, conjunto o AutoEventWireup atributo à true.

  4. No modo de exibição de código fonte, adicione um DynamicDataManager controlar ao corpo da página, sistema autônomo mostrado no exemplo a seguir:

    <body>

    <asp:DynamicDataManager ID="DynamicDataManager1"      />

</body>

    The DynamicDataManager Instrui o controle de dados dinâmicos para lidar com sistema autônomo controles de dados na página sistema autônomo controles dinâmicos.

  5. From a Dados Guia de do Caixa de ferramentas, add a LinqDataSource controle para a página.

  6. Set the EnableUpdate property of the LinqDataSource control to true.

    Isso permite que as operações de atualização para o controle de dados.

  7. conjunto o LinqDataSource do controle TableName propriedade à tabela que você deseja usar (clientes).

  8. conjunto o ContextTypeName propriedade para o contexto clsistema autônomos () dadosAdventureWorksLTDataContext), sistema autônomo mostrado no exemplo a seguir:

    <asp:LinqDataSource ID="LinqDataSource1"  
  TableName="Customers"  ContextTypeName="AdventureWorksLTDataContext"  EnableUpdate="true">
</asp:LinqDataSource>

  9. From a Dados Guia de do Caixa de ferramentas, add a GridView controle para a página.

    Esse controle será usado para exibir e modificar os campos de dados.

  10. conjunto o GridView do controle DataSourceID propriedade para a ID das LinqDataSource controle, sistema autônomo mostrado no exemplo a seguir:

    <form ID="Form1"  >

    <asp:GridView ID="GridView1"   
      DataSourceID="LinqDataSource1" >
    </asp:GridView>
</form>

  11. conjunto o GridView do controle AutoGenerateColumns propriedade para false e defina o AutoGenerateEditButton propriedade para true, sistema autônomo mostrado no exemplo a seguir:

    <asp:GridView ID="GridView1"   
  AutoGenerateEditButton="true"  AutoGenerateColumns="false" >
</asp:GridView>

    Isso permite que a operação de edição e desativa a geração automático de colunas que são baseados em tabela do banco de dados.Em vez disso, você usará um DynamicField controles para popular o GridView controle.

  12. conjunto o GridView do controle AllowPaging e AllowSorting propriedades para true, conforme mostrado no exemplo a seguir:

    <asp:GridView ID="GridView1"   

  AllowPaging="true"  AllowSorting="true" >
</asp:GridView>

  13. Adicione três DynamicField os controles para o Columns propriedade e conjunto seus DataField()Propriedades de "FirstName", "LastName" e "ModifiedDate".

    DynamicField controles use dados dinâmicos do ASP.NET para ler dados de modelo de dados e formatá-lo usando o modelo de campo apropriado. Observe que não tem de incluir qualquer informação no DynamicField controles adicionais sobre como ler ou formatar os dados. Essas tarefas serão manipuladas automaticamente pelas dados dinâmicos.

    O exemplo a seguir mostra a marcação para o GridView controle depois de adicionar a DynamicField controles.

    <asp:GridView ID="GridView1"
 >

  <Columns>    <asp:DynamicField DataField="FirstName" />    <asp:DynamicField DataField="LastName" />    <asp:DynamicField DataField="ModifiedDate" />  </Columns>
</asp:GridView>
    Observação:

    O DynamicField controle não estiver no Caixa de ferramentas.Portanto, você deve adicioná-lo sistema autônomo marcação em fontemodo de exibição de .

  14. salvar e fechar o Customers.aspxarquivo .

    Agora você criou a página personalizada para acessar a tabela Customers.

  15. Abra o Customers.aspx.cs or Customers.aspx.vbarquivo de code-behind .

  16. Adicionar uma referência para o System.Web.DynamicData espaço para nome usando o Imports palavra-chave em Visual Basic ou o using palavra-chave em Visual C#, sistema autônomo mostrado no exemplo a seguir:

    using System.Web.DynamicData;

    Imports System.Web.DynamicData

  17. Criar um Page_Init método, conforme mostrado no exemplo a seguir:

    protected void Page_Init(object sender, 
EventArgs e)
{    }

    Protected Sub Page_Init(ByVal sender As Object, _
ByVal e As EventArgs)

End Sub

  18. No Page_Init método, o registro a GridView controle com o DynamicDataManager Para ativar o comportamento dinâmico.

    O exemplo a seguir mostra como fazer isto:

    protected void Page_Init(object sender, 
EventArgs e)
{
    DynamicDataManager1.RegisterControl(GridView1);
}

    Protected Sub Page_Init(ByVal sender As Object, _
    ByVal e As EventArgs)
    DynamicDataManager1.RegisterControl(GridView1)
End Sub

  19. fechar o arquivo code-behind

Testando dados dinâmicos

Esta seção mostra como se certificar de que recursos de dados dinâmicos foi integrados no site da Web.Você pode interagir com o banco de dados por meio do modelo de dados e verifique se a integração funciona.Você verá que, quando você modifica dados, se você fornecer valores inválidos, mensagens de erro são geradas pela dados dinâmicos com base nas informações que ele infere do banco de dados.

Para testar recursos de dados dinâmicos foram integrados

  1. In O gerenciador de soluções, clicar com o botão direito do mouse o Customers.aspx página e selecionar Exibir no navegador.

    O navegador mostra uma página que exibe a tabela Customers com as colunas selecionadas.

  2. Em qualquer linha, clicar edição e desmarcar o nome.

  3. Na mesma linha, clicar Atualização.

    Dados dinâmicos exibirá uma mensagem de erro que avisa que uma seqüência de caracteres vazia não é permitida para o campo de nome de dados.

  4. Na mesma linha, clicar Cancelar.

  5. Em qualquer linha, clicar edição e, em seguida, alterar o sobrenome.

  6. Na mesma linha, clicar Atualização.

    Dados dinâmicos atualiza o banco de dados.Porque você inseriu um valor válido para o último nome, os dados passam o controle de validação que são parte do modelo de campo criado anteriormente.

  7. Em qualquer linha, clicar edição e insira caracteres não alfabéticos para o nome ou sobrenome.

  8. Na mesma linha, clicar Atualização.

    Dados dinâmicos exibe a mensagem de erro personalizada que você especificou com a expressão regular, que avisa que você digitou os caracteres que não são permitidos.

  9. Na mesma linha, clicar Cancelar.

  10. Em qualquer linha, clicar edição e desmarcar a data.

  11. Na mesma linha, clicar Atualização.

    Dados dinâmicos exibirá uma mensagem de erro que avisa você que uma seqüência de caracteres vazia não é permitido para o ModifiedDate campo de dados.

  12. Na mesma linha, clicar Cancelar.

  13. Em qualquer linha, clicar edição e em seguida, altere a data usando o Calendar controle.

  14. Na mesma linha, clicar Atualização.

    Dados dinâmicos atualiza o banco de dados.Porque você inseriu um valor permitido para a data, os dados passam o controle de validação que são parte do modelo de campo criado anteriormente.

Próximas etapas

Esta explicação passo a passo ilustrou os princípios básicos do dados dinâmicos do ASP.NET e como adicionar recursos de dados dinâmicos a um site da Web ASP.NET existente.Quando você integrar recursos de dados dinâmicos em um site da Web ASP.NET existente, você pode fazer o seguinte:

  • Interagir com o banco de dados subjacente.Dados dinâmicos incorpora recursos-chave para um aplicativo orientado a dados, sistema autônomo criar, ler, atualizar e excluir operações (CRUD).

  • Exibir e edição campos de dados, como dados dinâmicos seleciona o modelo de campo apropriado com base nas informações que são inferidas do banco de dados.

Você pode desejar testar recursos adicionais.Sugestões para exploração adicional incluem o seguinte:

Para obter informações Geral, convém fazer o seguinte:

Consulte também

Conceitos

Visão geral de modelo Dados Dinâmicos ASP.NET

Visão geral do ASP.NET dinâmico dados campo modelos

Visão geral sobre modelos de página e scaffolding de dados dinâmicos do ASP.NET

Visão geral de dados dinâmicos do ASP.NET

Date

History

Motivo

Julho de 2008

Tópico adicional.

Alteração de recurso do SP1.