Como usar o SQL Server com o .NET

Nesta parte do tutorial do Bookshelf em .NET, ensinamos como armazenar dados permanentes no Microsoft SQL Server em execução em uma VM do Compute Engine.

Esta página faz parte de um tutorial com várias páginas. Para ver do início e ler as instruções de configuração, consulte o artigo App Bookshelf em .NET.

Criar a instância do SQL Server

  1. Crie uma nova instância do Compute Engine.

    Acessar a página "Instâncias de VM"

  2. Em Código da instância, digite library.

  3. Em Zona, selecione us-west1-a.

  4. Na seção Disco de inicialização, clique em Alterar.

  5. Selecione a guia Imagens do aplicativo, escolha a imagem SQL Server 2014 Standard no Windows Server 2012 R2 e clique no botão Selecionar.

  6. Clique em Criar para criar a instância de VM.

  7. Quando estiver pronto, clique no nome da instância. Pode demorar alguns minutos para a instância ficar pronta. Quando a instância estiver pronta, ela ficará visível na lista de instâncias.

  8. Na página Detalhes da instância, clique em Definir senha do Windows.

  9. Para criar a conta de usuário na sua instância, digite um nome de usuário de sua escolha e clique em Definir. Anote a senha fornecida e feche a caixa de diálogo.

Criar o banco de dados do SQL Server

  1. Na lista Instâncias de VM, clique no link RDP ao lado da instância do SQL Server. Faça login com o nome de usuário e a senha que você definiu durante a criação da instância.

  2. No menu Iniciar do Windows, digite SQL Server 2014 Manage.

  3. Clique com o botão direito do mouse em SQL Server 2014 Management Studio e selecione Executar como administrador.

  4. Na janela Conectar ao servidor, clique em Conectar.

  5. Clique com o botão direito em Bancos de dados e selecione Novo banco de dados.

  6. Nomeie o banco de dados bookshelf e clique em OK.

Configurar o SQL Server

  1. No SQL Server 2014 Management Studio, clique na pasta Segurança referente à instância library do SQL Server.

  2. Clique com o botão direito em Logins e selecione Novo login.

  3. Em Nome de login, digite dotnetapp.

  4. Para o método de Autenticação, clique em Autenticação do SQL Server.

  5. Em Senha, digite uma senha da sua preferência. Não ative a opção Aplicar política de senha.

  6. Altere o Banco de dados padrão para ser o banco de dados bookshelf que você acabou de criar.

  7. No lado esquerdo da caixa de diálogo Novo login, clique em Mapeamento de usuários e siga as etapas a seguir:

    1. Para o banco de dados bookshelf, clique na caixa de seleção Mapear.

    2. Em Associação à função de banco de dados para: bookshelf, clique em todas as funções, exceto as seguintes:

      • db_denydatareader

      • db_denydatawriter

  8. Clique em OK para criar a nova conta de login do banco de dados.

  9. Como o usuário criado está configurado para usar a autenticação do SQL Server, agora o SQL Server precisa ser configurado para permitir esse método de autenticação. No SQL Server 2014 Management Studio, clique com o botão direito do mouse na instância Library do SQL Server que você criou e selecione Propriedades.

  10. No menu à esquerda da caixa de diálogo "Propriedades do servidor", clique em Segurança.

  11. Na configuração Autenticação do servidor, selecione Modo de Autenticação do SQL Server e do Windows e clique em OK.

  12. Para reiniciar o serviço SQL Server, clique com o botão direito do mouse na instância Library do SQL Server e selecione Reiniciar.

Criar uma regra de firewall para o SQL Server

Configure uma regra de firewall para permitir o tráfego na porta 1433, a fim de que outros clientes possam se conectar à instância do SQL Server recém-criada por meio da Internet.

  1. No Console do Google Cloud Platform, acesse a seção Regras de firewall.

    Abrir as Regras de firewall

  2. Clique em Adicionar regra de firewall e preencha os seguintes campos:

    1. No novo Nome da regra de firewall, digite allow-tcp-1433.

    2. Em Filtro de origem, selecione Intervalos de IP.

    3. Para permitir o acesso de todos os endereços IP, digite 0.0.0.0/0 em Intervalos de IPs de origem.

    4. Em Portas e protocolos permitidos, digite tcp:1433.

  3. Para criar a regra de firewall, clique em Criar.

Como definir configurações

  1. No diretório getting-started-dotnet\aspnet\2-structured-data, clique duas vezes em 2-structured-data.sln para abrir o app de amostra no Visual Studio.

  2. No painel Gerenciador de soluções, clique em Web.config.

  3. Em Web.config, conclua as etapas a seguir:

    1. Defina GoogleCloudSamples:ProjectId como código do projeto.

    2. Defina GoogleCloudSamples:BookStore como sqlserver.

    3. Perto do final do arquivo, em <connectionStrings>, localize o subelemento XML connectionStrings com o atributo name="LocalSqlServer". Atualize o valor de connectionString com o endereço IP externo, o nome do banco de dados, o nome de usuário e a senha da sua instância do SQL Server. Por exemplo, a connectionString de um SQL Server remoto no IP 104.155.20.171 com database = bookshelf, user = dotnetapp e password = test ficaria assim:

      connectionString="Data Source=104.155.20.171;Initial Catalog=bookshelf;Integrated Security=False;User ID=dotnetapp;Password=test;MultipleActiveResultSets=True"

  4. Salve e feche Web.config.

  5. No menu do Visual Studio, clique em Compilar e Compilar solução para criar a solução.

  6. Para criar as tabelas de banco de dados, no menu do Visual Studio, acesse Ferramentas > Gerenciador de pacotes NuGet > Console do gerenciador de pacotes. No prompt PM >, digite o seguinte comando:

    Add-Migration Init
    
  7. Crie as tabelas no banco de dados do SQL Server que são usadas para armazenar os dados de livros para o aplicativo Bookshelf. No Console do gerenciador de pacotes, digite o seguinte comando:

    Update-Database
    

Como executar o aplicativo na máquina local

No Visual Studio, pressione F5 para executar o projeto. Agora, navegue nas páginas da Web do aplicativo para adicionar, editar e excluir livros.

Estrutura do app

Este diagrama mostra os componentes do app e como se encaixam. Ele segue o padrão ASP.NET MVC clássico. A interface IBookStore entre o BooksController e o DbBookStore permite alternar para o armazenamento de dados de livros no Cloud Datastore sem precisar modificar o código.

Estrutura do aplicativo Bookshelf

Noções básicas sobre o código

Esta seção analisa o código do aplicativo e explica como ele funciona.

O modelo de dados

A classe Book contém informações sobre um livro, além de campos adicionais que são usados em tutoriais posteriores.

    [Bind(Include = "Title, Author, PublishedDate, Description")]
    public class Book
    {
        [Key]
        public long Id { get; set; }

        [Required]
        public string Title { get; set; }

        public string Author { get; set; }

        [Display(Name = "Date Published")]
        [DataType(DataType.Date)]
        public DateTime? PublishedDate { get; set; }

        public string ImageUrl { get; set; }

        [DataType(DataType.MultilineText)]
        public string Description { get; set; }

        public string CreatedById { get; set; }
    }

O DbSet do Entity Framework converte consultas LINQ e operações Create, Read, Update e Delete (CRUD) em consultas SQL. A classe ApplicationDbContext guarda um DbSet de Livros.

public class ApplicationDbContext : DbContext
{
    // ...
    public DbSet<Book> Books { get; set; }

Como processar envios do usuário com formulários

O formulário HTML para adicionar/editar permite que os usuários adicionem e editem envios de livros.

Imagem do formulário para adicionar/editar

O formulário HTML é criado usando modelos Razor. Esse tipo de modelo especifica se o formulário incluirá campos de texto de entrada para título, autor, data de publicação e descrição:

<form action="/Books/@Model.FormAction/@Model.Book.Id" method="post" id="book-form" enctype="multipart/form-data">
    @Html.AntiForgeryToken()
    <div class="form-group">
        @Html.LabelFor(model => model.Book.Title)
        @Html.EditorFor(model => model.Book.Title, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Book.Title, "", new { @class = "text-danger" })
    </div>

    <div class="form-group">
        @Html.LabelFor(model => model.Book.Author)
        @Html.EditorFor(model => model.Book.Author, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Book.Author, "", new { @class = "text-danger" })
    </div>

    <div class="form-group">
        @Html.LabelFor(model => model.Book.PublishedDate)
        @Html.EditorFor(model => model.Book.PublishedDate, new { htmlAttributes = new { @class = "form-control", @type = "text" } })
        @Html.ValidationMessageFor(model => model.Book.PublishedDate, "", new { @class = "text-danger" })
    </div>

    <div class="form-group">
        @Html.LabelFor(model => model.Book.Description)
        @Html.EditorFor(model => model.Book.Description, new { htmlAttributes = new { @class = "form-control", @type = "text" } })
        @Html.ValidationMessageFor(model => model.Book.Description, "", new { @class = "text-danger" })
    </div>

    <button type="submit" class="btn btn-success">Save</button>
</form>

Como processar envios do formulário

Quando você clica em Adicionar livro, o método BooksController.Create() exibe o formulário. Depois que o usuário o preenche e clica em Salvar, o método BooksController.Create() recebe o conteúdo do formulário e o envia para o banco de dados do SQL Server por meio do método IBookStore::Create(). Observe que o método Create é anotado com HttpPost.

        // GET: Books/Create
        public ActionResult Create()
        {
            return ViewForm("Create", "Create");
        }

        // POST: Books/Create
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Create(Book book)
        {
            if (ModelState.IsValid)
            {
                _store.Create(book);
                return RedirectToAction("Details", new { id = book.Id });
            }
            return ViewForm("Create", "Create", book);
        }

A classe DbBookStore chama a classe ApplicationDbContext para executar consultas e realizar operações de CRUD para os dados armazenados no banco de dados do SQL Server. A consulta SQL é criada com o uso de um mapeador objeto-relacional (ORM, na sigla em inglês) chamado Entity Framework. Os mapeadores objeto-relacional permitem escrever modelos de dados, como classes C# simples, e geram o SQL inteiro para você.

Os métodos de CRUD do DbBookStore, como Create(), são chamadas simples para a classe ApplicationDbContext.

public void Create(Book book)
{
    var trackBook = _dbcontext.Books.Add(book);
    _dbcontext.SaveChanges();
    book.Id = trackBook.Id;
}

Como listar livros

Depois que os livros forem adicionados, clique no link Livros para acessar a página /Books, que lista todos os livros armazenados no banco de dados do SQL Server. O método List() faz o trabalho de listar todos os livros usando dados recuperados do banco de dados.

public BookList List(int pageSize, string nextPageToken)
{
    IQueryable<Book> query = _dbcontext.Books.OrderBy(book => book.Id);
    if (nextPageToken != null)
    {
        long previousBookId = long.Parse(nextPageToken);
        query = query.Where(book => book.Id > previousBookId);
    }
    var books = query.Take(pageSize).ToArray();
    return new BookList()
    {
        Books = books,
        NextPageToken = books.Count() == pageSize ? books.Last().Id.ToString() : null
    };
}

O método List() compõe uma consulta LINQ que lê livros do DbSet de Books. A consulta fica um pouco complicada para implementar paginação. A consulta lê dez livros e armazena o Id do último livro em NextPageToken. Quando você clica no botão Mais, o método List() descompacta nextPageToken para receber o Id do último livro e consulta livros com códigos maiores.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…