Você está na página 1de 23

Unidade IV

Unidade IV
7 Persistência

Persistência é a característica que indica que o objeto sobrevive à finalização de determinado


processo. Sem isso, ele só existiria na RAM, perdendo‑se após o encerramento da atividade de origem.
Dessa forma, uma vez que as classes foram criadas e utilizadas como objetos dentro de programas
codificados, elas podem assumir os seguintes aspectos de existência dentro das aplicações: objetos
transientes e/ou objetos persistentes.

Todo objeto transiente atua em meios voláteis, ou seja, trabalhando sempre em memória. Por exemplo:
a partir do momento em que uma sessão é finalizada, ou a execução de um software, todo e qualquer
dado contido no objeto utilizado será perdido, de maneira que sua recuperação será irreversível.

Objeto persistente tem como característica não atuar em meios voláteis; assim, a partir da execução,
todos os dados trafegados serão armazenados em disco ou em uma base de dados alocada em servidor,
por exemplo, garantindo que um objeto pode ser recuperado após a finalização do software.

Observação

Uma vez trabalhando com objeto persistente, pode‑se garantir a


excelência no tráfego de dados de uma camada para outra, ou seja, pode‑se
afirmar que um objeto instanciado e carregado saindo de um ponto A
chegará ao próximo ponto da camada com os mesmos valores inseridos
no ponto A, assim sendo utilizado para efetuar uma persistência dentro da
base de dados.

Saiba mais

O LINQ proporciona padrões intuitivos para o desenvolvimento de


consultas e atualização de dados, além de poder ser estendida para dar
suporte a qualquer tipo de banco de dados. O Visual Studio inclui rotinas de
LINQ ou DLINQ que permitem o uso em coleções do .NET Framework, bancos
de dados do SQL SERVER, conjuntos de dados ADO.NET e documentos XML.

Para mais detalhes, consulte:

144
Programação Orientada a Objetos II

SHARP, J. Consultando informações em banco de dados. In: ___.


Microsoft Visual C# 2010: passo a passo. Porto Alegre: Bookman, 2011.
p. 567‑96.

7.1 Reporting Service

Reporting Service é considerado como uma plataforma de geração de relatórios com base em
servidor que fornece funcionalidade de relatório, podendo‑se agregar para diversas fontes de dados. As
ferramentas que o compõem são funcionais no ambiente do Microsoft Visual Studio e são completamente
integradas com as ferramentas e os componentes associados do Microsoft SQL Server.
(Logon inicial)

Cliente
Logon no serviço web
Método LogonUser() 1

5 Autenticação
tíquete

Servidor de relatório

Serviço web

Serviço web 2

4 Verdadeiro se as
credenciais forem
válidas
Extensão de segurança
IAuthenticationExtension.LogonUser()

Validar nome do
usuário e senha 3

Repositório de usuários

Figura 190 – Ciclo de execução Reporting Service

145
Unidade IV

Saiba mais

O Reporting Service porporciona facilidade para apresentar, de maneira


detalhada, todo o resultado do desenvolvimento de código C# por meio de
relatórios dinâmicos, podendo estes ser acionados a qualquer instante na
execução da aplicação. Para mais detalhes e complemento de estudos, veja:

REPORTING services (SSRS). Microsoft Developer Network. 2015.


Disponível em: <https://msdn.microsoft.com/pt‑br/library/ms159106.
aspx>. Acesso em: 15 jun. 2015.

7.2 Windows Presentation Foundation

Windows Presentation Foundation (WPF) pode ser considerado como um mecanismo de resolução
independente e renderização vetorial, criado simplesmente para tirar proveito dos mecanismos
modernos, pensando em hardware, no universo de desenvolvimento gráfico.

Esta visão pode acontecer para desenvolvedores que abordam os principais recursos e conceitos
de WPF.

Saiba mais

O WPF pode ser considerado como uma apresentação de última geração


para criar aplicações com base em Windows com experiência de usuário
visualmente agradável. O desenvolvimento com WPF tem como frente
aplicações web. Para informações complementares sobre WPF, veja:

INTRODUÇÃO ao WPF. Microsoft Developer Network. 2015. Disponível em:


<https://msdn.microsoft.com/pt‑br/library/aa970268%28v=vs.110%29.
aspx>. Acesso em: 16 jun. 2015.

7.3 Trabalhando com CommandBuilder

Quando se inicia a especificação da propriedade SelectCommand, ela gera dinamicamente em


tempo de execução, assim como por meio de uma ferramenta de consulta que usa comando textual do
desenvolvedor, onde pode se especificar:

• InsertCommand: define a inserção de linha na fonte de dados por meio de um RowState Added.
Inserir valores para todas as colunas, que poderão ser atualizadas.

146
Programação Orientada a Objetos II

• UpdateCommand: define a atualização de linha na fonte de dados por meio de RowState Modified.
Atualiza valores para todas as colunas selecionadas.

• DeleteCommand: define a exclusão de linha na fonte de dados por meio de RowState Deleted.
Exclui valores para todas as colunas selecionadas.

Observação

Atuação com CommandBuilder enriquece ainda mais a camada


de persistência a dados, tornando‑a eficaz e sendo a ponte entre
o acesso ao banco de dados, suas ações e o retorno para a camada de
interface, informando ao usuário o retorno positivo ou negativo da ação
correspondente ao comando informado.

Lembrete

Objeto persistente tem como característica não atuar em meios voláteis;


assim, a partir da execução, todos os dados trafegados serão armazenados em
disco ou em uma base de dados alocada em servidor, por exemplo, garantindo
que um objeto possa ser recuperado após a finalização do software.

SqlDataAdapter adapter = new SqlDataAdapter(


“SELECT * FROM dbo.Customers”, connection);
SqlCommandBuilder builder = new SqlCommandBuilder(adapter);
builder.QuotePrefix = “[“;
builder.QuoteSuffix = “]”;

adapter.SelectCommand.CommandText =
“SELECT CustomerID, ContactName FROM dbo.Customers”;
builder.RefreshSchema();
custDS.Tables.Remove(custDS.Tables[“Customers”]);
adapter.Fill(custDS, “Customers”);

7.4 DataSet

DataSet pode ser considerado um cache de memória dos dados recuperados de uma fonte de dados,
ou seja, é um componente que consiste em uma coleção de objetos DataTable, que pode se relacionar a
outros com o DataRelation. Um DataSet pode ler e gravar dados utilizando, por exemplo, arquivo XML.

Em uma implementação típica de várias camadas, por exemplo, as etapas para criar e atualizar um
DataSet, atualizando os dados originais, são:

• Criar e preencher cada DataTable em um DataSet com os dados de uma fonte de dados usando
um DataAdapter.

147
Unidade IV

• Alterar os dados individuais em objetos DataTable, adicionar, atualizar ou excluir objetos DataRow.

• Chamar o método GetChanges para criar um segundo DataSet que apresente somente as
alterações nos dados.

• Chamar o método Update para o DataAdapter, passando o segundo DataSet como um argumento.

• Chamar o método Merge para a mesclagem das alterações do segundo DataSet.

• Chamar o AcceptChanges sobre o DataSet. Como alternativa, chamar RejectChanges para cancelar
as alterações.

Observação

Os itens relacionados ao DataSet não estão completos neste título.


Sugerimos que, por isso, você verifique o menu Help da linguagem C# no
menu de opções do seu Visual Studio para obter mais detalhes e conhecer
outras funções.

using System;
using System.Data;
using System.Data.SqlClient;

namespace Microsoft.AdoNet.DataSetDemo
{
class NorthwindDataSet
{
staticvoid Main()
{
string connectionString = GetConnectionString();
ConnectToData(connectionString);
}
privatestaticvoid ConnectToData(string connectionString)
{
SqlConnection connection =
new SqlConnection(connectionString))
{

SqlDataAdapter adapter = new SqlDataAdapter();

adapter.TableMappings.Add(“Table”, “Suppliers”);

connection.Open();
Console.WriteLine(“The SqlConnection is open.”);

SqlCommand command = new SqlCommand(


“SELECT SupplierID, CompanyName FROM dbo.Suppliers;”,
connection);
command.CommandType = CommandType.Text;

148
Programação Orientada a Objetos II

adapter.SelectCommand = command;

DataSet dataSet = new DataSet(“Suppliers”);


adapter.Fill(dataSet);
SqlDataAdapter productsAdapter = new SqlDataAdapter();
productsAdapter.TableMappings.Add(“Table”, “Products”);
SqlCommand productsCommand = new SqlCommand(
“SELECT ProductID, SupplierID FROM dbo.Products;”,
connection);
productsAdapter.SelectCommand = productsCommand;

productsAdapter.Fill(dataSet);
connection.Close();
Console.WriteLine(“The SqlConnection is closed.”);
DataColumn parentColumn =
dataSet.Tables[“Suppliers”].Columns[“SupplierID”];
DataColumn childColumn =
dataSet.Tables[“Products”].Columns[“SupplierID”];
DataRelation relation =
new System.Data.DataRelation(“SuppliersProducts”,
parentColumn, childColumn);
dataSet.Relations.Add(relation);
Console.WriteLine(
“The {0} DataRelation has been created.”,
relation.RelationName);
}
}

}
}

8 Introdução ao XML

Extensible Markup Language (XML) é uma linguagem de marcadores, como a HTML, que foi concebida
para descrever dados. Encontra‑se como uma vantagem, considerando‑se que ela é extensível, ou seja,
não possui um limite no número de tags que podem ser criadas, colocando a linguagem em uma
posição de autodefinição. Para que se possa trabalhar com os dados XML, usa‑se a Document Type
Definition (DTD).

Segue um exemplo:

<?xml version=”1.0”?>

<lembrete>

<para>José data=”10/05/2015”</para>

<de>Lauro</de>

<cabecalho>Lembre‑se</cabecalho>

149
Unidade IV

<corpo>Amanha voce tem prova de programação orientada a objetos</corpo>

</lembrete>

Alerta.xml

A primeira linha do documento (<?xml version=”1.0”?>) é uma declaração XML e deve sempre ser
incluída, pois define a versão XML que está sendo utilizada. Neste caso estamos especificando a versão
1.0 da XML.

A segunda linha (<lembrete>) define o primeiro elemento do documento – o elemento‑raiz (nó‑raiz).


Esta linha é seguida pelos seus elementos‑filhos:

<para>José data=”10/05/2015”</para>

<de>Lauro</de>

<cabecalho>Lembre‑se</cabecalho>

<corpo>Amanha voce tem prova de programação orientada a objetos</corpo>

Estas quatro linhas definem quatro elementos‑filhos da raiz (para, de, cabecalho e corpo)

A última linha define o fim do elemento-raiz: </lembrete>

8.1 Criar XML

Para que um novo arquivo XML seja criado na linguagem C#, a classe utilizada será XmlTextWriter.
Essa classe fornece uma maneira eficaz de gerar streams ou arquivos contendo dados XML em
conformidade com a W3C Extensible Markup Language. Nesse item podemos encontrar diversos
métodos e propriedades que auxiliarão no trabalho pesado para implementação na prática.

Iniciando‑se o desenvolvimento, pode‑se utilizar a classe usando o namespace System.Xml e criar o


objeto XmlTextWriter, assim, na sequência, incluindo elementos Xml. A classe comporta métodos para
incluir tipos de elemento de um arquivo XML, conforme figura a seguir:

150
Programação Orientada a Objetos II

Figura 191 – Métodos da classe XmlTextWriter

Observação

Essa lista não está completa, portanto será necessário que o aluno
verifique o menu Help da linguagem C# do menu de opções do Visual
Studio para obter mais detalhes e conhecer outras funções para o
desenvolvimento do recurso.

Na geração do XML, utilizando a classe XmlTextWriter, serão efetuados os seguintes passos:

• Criar um documento.

• Incluir elementos.

• Incluir subelementos.

• Incluir atributos.

• Fechar documento.

<?xml version=”1.0 encoding=”utf‑8”>


<desenhos>
<titulo>Tom &amp Jerry</titulo>
<titulo>Chaves</titulo>
<titulo>Cavalo de Fogo</titulo>
</desenhos>
Namespace utilizado:
using System;
using System.Data;
using System.Windows.Forms;
using System.Xml;

151
Unidade IV

O código C# para gerar este arquivo usando a classe XmlTextWriter é dado a seguir:

private void btnCriarXML_Click(object sender, EventArgs e)


{
try
{
XmlTextWriter writer = new XmlTextWriter(@”c:\dados\desenhos.xml”, null);
//inicia o documento xml
writer.WriteStartDocument();
//escreve o elmento raiz
writer.WriteStartElement(“desenhos”);
//Escreve os sub‑elementos
writer.WriteElementString(“titulo”, “Tom & Jerry”);
writer.WriteElementString(“titulo”, “Chaves”);
writer.WriteElementString(“titulo”, “Cavalo de Fogo”);
// encerra o elemento raiz
writer.WriteEndElement();
//Escreve o XML para o arquivo e fecha o objeto escritor
writer.Close();
MessageBox.Show(“Arquivo XML gerado com sucesso.”);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}

Lembrete

Extensible Markup Language (XML) é uma linguagem de marcadores,


como a HTML, que foi concebida para descrever dados. Encontra‑se como
uma vantagem, considerando‑se que ela é extensível, ou seja, não possui
um limite no número de tags que podem ser criadas, colocando a linguagem
em uma posição de autodefinição.

8.2 DataGridView

DataGridView pode ser considerado um controle que permite fornecer ao usuário a exibição de
registros em linhas e colunas, ideal para efetuar pesquisa de registros:

152
Programação Orientada a Objetos II

Figura 192 – Form Cadastro de Clientes

Observação

O componente DataGridView está alocado na Caixa de Ferramentas do


Visual Studio.

Figura 193 – Form Cadastro Cliente – DataGridView

153
Unidade IV

using System;
using System.Drawing;
using System.Windows.Forms;

public class Form1 : System.Windows.Forms.Form


{
private Panel buttonPanel = new Panel();
private DataGridView songsDataGridView = new DataGridView();
private Button addNewRowButton = new Button();
private Button deleteRowButton = new Button();

public Form1()
{
this.Load += new EventHandler(Form1_Load);
}
private void Form1_Load(System.Object sender, System.EventArgs e)
{
SetupLayout();
SetupDataGridView();
PopulateDataGridView();
}
private void songsDataGridView _CellFormatting(object sender,
System.Windows.Forms.DataGridViewCellFormattingEventArgs e)
{
if (e != null)
{
if (this. songsDataGridView.Columns[e.ColumnIndex].Name == “Release
Date”)
{
if (e.Value != null)
{
try
{
e.Value = DateTime.Parse(e.Value.ToString())
.ToLongDateString();
e.FormattingApplied = true;
}
catch (FormatException)
{
Console.WriteLine(“{0} is not a valid date.”, e.Value.
ToString());
}
}
}
}
}
private void addNewRowButton_Click(object sender, EventArgs e)
{
this. songsDataGridView.Rows.Add();
}
private void deleteRowButton_Click(object sender, EventArgs e)
{
if (this. songsDataGridView.SelectedRows.Count > 0 &&
this.songsDataGridView.SelectedRows[0].Index !=
this.songsDataGridView.Rows.Count ‑ 1)
{

154
Programação Orientada a Objetos II

this.songsDataGridView.Rows.RemoveAt(
this.songsDataGridView.SelectedRows[0].Index);
}
}
private void SetupLayout()
{
this.Size = new Size(600, 500);
addNewRowButton.Text = “Add Row”;
addNewRowButton.Location = new Point(10, 10);
addNewRowButton.Click += new EventHandler(addNewRowButton_Click);

deleteRowButton.Text = “Delete Row”;


deleteRowButton.Location = new Point(100, 10);
deleteRowButton.Click += new EventHandler(deleteRowButton_Click);

buttonPanel.Controls.Add(addNewRowButton);
buttonPanel.Controls.Add(deleteRowButton);
buttonPanel.Height = 50;
buttonPanel.Dock = DockStyle.Bottom;

this.Controls.Add(this.buttonPanel);
}
private void SetupDataGridView()
{
this.Controls.Add(songsDataGridView);
songsDataGridView.ColumnCount = 5;
songsDataGridView.ColumnHeadersDefaultCellStyle.BackColor = Color.Navy;
songsDataGridView.ColumnHeadersDefaultCellStyle.ForeColor = Color.White;
songsDataGridView.ColumnHeadersDefaultCellStyle.Font =
new Font(songsDataGridView.Font, FontStyle.Bold);

songsDataGridView.Name = “songsDataGridView”;
songsDataGridView.Location = new Point(8, 8);
songsDataGridView.Size = new Size(500, 250);
songsDataGridView.AutoSizeRowsMode =
DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders;
songsDataGridView.ColumnHeadersBorderStyle =
DataGridViewHeaderBorderStyle.Single;
songsDataGridView.CellBorderStyle = DataGridViewCellBorderStyle.Single;
songsDataGridView.GridColor = Color.Black;
songsDataGridView.RowHeadersVisible = false;

songsDataGridView.Columns[0].Name = “Release Date”;


songsDataGridView.Columns[1].Name = “Track”;
songsDataGridView.Columns[2].Name = “Title”;
songsDataGridView.Columns[3].Name = “Artist”;
songsDataGridView.Columns[4].Name = “Album”;
songsDataGridView.Columns[4].DefaultCellStyle.Font =
new Font(songsDataGridView.DefaultCellStyle.Font, FontStyle.Italic);
songsDataGridView.SelectionMode =
DataGridViewSelectionMode.FullRowSelect;
songsDataGridView.MultiSelect = false;
songsDataGridView.Dock = DockStyle.Fill;

songsDataGridView.CellFormatting += new
DataGridViewCellFormattingEventHandler(

155
Unidade IV

songsDataGridView_CellFormatting);
}
private void PopulateDataGridView()
{
string[] row0 = { “11/22/1968”, “29”, “Revolution 9”,
“Beatles”, “The Beatles [White Album]” };
string[] row1 = { “1960”, “6”, “Fools Rush In”,
“Frank Sinatra”, “Nice ‘N’ Easy” };
string[] row2 = { “11/11/1971”, “1”, “One of These Days”,
“Pink Floyd”, “Meddle” };
string[] row3 = { “1988”, “7”, “Where Is My Mind?”,
“Pixies”, “Surfer Rosa” };
string[] row4 = { “5/1981”, “9”, “Can’t Find My Mind”,
“Cramps”, “Psychedelic Jungle” };
string[] row5 = { “6/10/2003”, “13”,
“Scatterbrain. (As Dead As Leaves.)”,
“Radiohead”, “Hail to the Thief” };
string[] row6 = { “6/30/1992”, “3”, “Dress”, “P J Harvey”, “Dry” };

songsDataGridView.Rows.Add(row0);
songsDataGridView.Rows.Add(row1);
songsDataGridView.Rows.Add(row2);
songsDataGridView.Rows.Add(row3);
songsDataGridView.Rows.Add(row4);
songsDataGridView.Rows.Add(row5);
songsDataGridView.Rows.Add(row6);

songsDataGridView.Columns[0].DisplayIndex = 3;
songsDataGridView.Columns[1].DisplayIndex = 4;
songsDataGridView.Columns[2].DisplayIndex = 0;
songsDataGridView.Columns[3].DisplayIndex = 1;
songsDataGridView.Columns[4].DisplayIndex = 2;
}
[STAThreadAttribute()]
static void Main()
{
Application.EnableVisualStyles();
Application.Run(new Form1());
}
}

8.3 Exportando com CSV

Para efetuar o desenvolvimento exportando um arquivo, podemos trabalhar com a classe


StringBuilder. Ela é uma classe que representa uma sequência mutável de caracteres, em que ela não
poderá ser herdada. Seu namespace é definido por meio das seguintes linhas:

System.Object;
System.Text.StringBuilder
System.Text;

156
Programação Orientada a Objetos II

Sua Sintaxe para C#:

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class StringBuilder : ISerializable

A seguir, um exemplo da codificação:

public class ExportExcel<T> where T : class


{
private StringBuilder sb;

public ExportExcel()
{
sb = new StringBuilder();
if (HttpContext.Current != null)
Context = HttpContext.Current;
}

public string Filename { get; set; }


public HttpContext Context { get; set; }

public void Export(List<T> l, Expression<Func<T, object>> expression)


{
if (string.IsNullOrEmpty(Filename))
return;

build(l, expression);

Context.Response.AddHeader(“content‑disposition”, “attachment;file‑
name=” + Filename);
Context.Response.Charset = string.Empty;
Context.Response.Cache.SetCacheability(HttpCacheability.NoCache);
Context.Response.ContentType = «application/CSV»;
Context.Response.Write(sb.ToString());
Context.Response.End();
}

public string ToString(List<T> l, Expression<Func<T, object>>


expression)
{
build(l, expression);
return sb.ToString();
}

private void build(List<T> l, Expression<Func<T, object>> expression)


{
sb = new StringBuilder();
List<string> propertiesName = new List<string>();
NewArrayExpression array = expression.Body as NewArrayExpression;
foreach (object obj in (IEnumerable<object>)(array.Expressions))
{
string propertyName = obj.ToString().Remove(0, obj.ToString().
IndexOf(«.») + 1);

157
Unidade IV

propertyName = propertyName.Replace(“)”, “”);


sb.Append(propertyName + “;”);
propertiesName.Add(propertyName);
}
sb.AppendLine();

foreach (var i in l)
{
foreach (var propertyName in propertiesName)
{
sb.Append(getPropertyValue(i, propertyName).ToString() +
“;”);
}
sb.AppendLine();
}
}

internal static object getPropertyValue(object obj, string propertyName)


{
const System.Reflection.BindingFlags bindingFlags = System.Reflection.
BindingFlags.Public | System.Reflection.BindingFlags.Instance;

var pi = typeof(T).GetProperties(bindingFlags).Where(prop => prop.


Name == propertyName).SingleOrDefault();
return pi.GetValue(obj, null);
}
}

Resumo

Vimos como podemos combinar e integrar diversas possibilidades e


a importância de uma camada de persistência no desenvolvimento de
aplicações. Consolidar o entendimento de regra de negócio na camada
de persistência possibilita que a aplicação responda a toda a análise
efetuada, bem como a apresentação de mensagens e travas sistêmicas
que serão inseridas nessa camada.

Vimos também o Reporting Service, que possibilita recursos para o


desenvolvedor de trabalho com relatórios com base em servidores, que irão
possibilitar a geração de relatórios com diversas fontes de dados. Também
estudamos o componente DataGridView, que auxilia os desenvolvedores
a codificarem e apresentarem ao usuário a exibição de linhas e colunas,
com o intuito de garantir as ações de consulta e também possibilitando
alteração e exclusão de linhas dentro do próprio DataGridView.

Abordamos também a construção de arquivos XML, que são capazes


de encapsular classes, como XMLTextWriter, que são capazes de armazenar
métodos e propriedades que irão auxiliar no trabalho mais árduo para

158
Programação Orientada a Objetos II

a implementação na prática. Atualmente, arquivos XML são essenciais


na performance e no dinamismo de uma aplicação, sendo utilizadas em
desenvolvimento desktop e web.

Encerramos detalhando como exportar arquivos CSV utilizando recursos


como StringBuilder e Reflection, que irão proporcionar ao desenvolvedor
aplicar seus conceitos para garantir que informações apresentadas para o
usuário em tela possam ser exportadas para um arquivo CSV, melhorando
a aquisição e a manipulação de informações para o usuário.

159
FIGURAS e ILUSTRAÇÕES

Figura 4

EXEMPLO de execução do PDCA. Grupo Unip‑Objetivo.

Figura 190

IC696010.GIF. Disponível em: <https://i‑msdn.sec.s‑msft.com/dynimg/IC696010.gif>. Acesso em: 15


jun. 2015

Referências

ARAÚJO, E. C. Introdução à linguagem C#. DevMedia, Rio de Janeiro, [s.d.]. Disponível em: <http://www.
devmedia.com.br/introducao‑a‑linguagem‑c/27711>. Acesso em: 9 jun. 2015.

BOOCH, G.; RUMBAUGH, J.; JACOBSON, I. UML: guia do usuário. 2. ed. Rio de Janeiro: Campus, 2006.

CAMARA, F. Orientação a objeto com .NET. 2. ed. Florianópolis: Visual Books, 2006.

CLASSE GroupBox. Microsoft Developer Network. 2015. Disponível em: <https://msdn.microsoft.com/


pt‑br/library/system.windows.forms.groupbox%28v=vs.110%29.aspx>. Acesso em: 12 jun. 2015.

CONSTRUTORES de instâncias (Guia de Programação em C#). Microsoft Developer Network. 2015.


Disponível em: <https://msdn.microsoft.com/pt‑br/library/k6sa6h87.aspx>. Acesso em: 12 jun. 2015.

FOWLER, M. UML essencial: um breve guia para a linguagem‑padrão de modelagem de objetos. São
Paulo: Bookman, 2006.

GUEDES, G. T. UML: uma abordagem prática. São Paulo. Novatec, 2006.

HERANÇA (Guia de programação em C#). Microsoft Developer Network. 2015. Disponível em: <https://
msdn.microsoft.com/pt‑br/library/ms173149.aspx>. Acesso em: 15 jun. 2015.

INTRODUÇÃO ao WPF. Microsoft Developer Network. 2015. Disponível em: <https://msdn.microsoft.


com/pt‑br/library/aa970268%28v=vs.110%29.aspx>. Acesso em: 16 jun. 2015.

JOMORI, S. M.; VOLPE, R. L. D; ZABEU, A. C. P. Qualidade de software. Revista Banas Qualidade, São
Paulo, ano 13, n. 141, fev. 2004.

LIBERTY, J.; XIE, D. Programando C# 3.0. Rio de Janeiro: Alta Books, 2009.

LIMA, E.; REIS, E. C# e .Net para desenvolvedores. Rio de Janeiro: Campus, 2002.

160
MANZANO, J.A. Estudo dirigido de Microsoft Visual C# 2010 Express. São Paulo: Érica, 2010.

MÉTODO Form.Close. Microsoft Developer Network. 2015. Disponível em: <https://msdn.microsoft.


com/pt‑br/library/system.windows.forms.form.close(v=vs.110).aspx>. Acesso em: 11 jun. 2015.

MÉTODO MessageBox.Show. Microsoft Developer Network. 2015. Disponível em: <https://msdn.


microsoft.com/pt‑br/library/system.windows.forms.messagebox.show%28v=vs.110%29.aspx>. Acesso
em: 10 jun. 2015.

PROPRIEDADE Control.Enabled. Microsoft Developer Network. 2015. Disponível em: <https://msdn.


microsoft.com/pt‑br/library/system.windows.forms.control.enabled%28v=vs.110%29.aspx>. Acesso
em: 12 jun. 2015.

PROPRIEDADE Control.Visible. Microsoft Developer Network. 2015. Disponível em: <https://msdn.


microsoft.com/pt‑br/library/system.windows.forms.control.visible%28v=vs.110%29.aspx>. Acesso em:
12 jun. 2015.

PROPRIEDADE Form.AutoSizeMode. Microsoft Developer Network. 2015. Disponível em: <https://msdn.


microsoft.com/pt‑br/library/system.windows.forms.form.autosizemode%28v=vs.110%29.aspx>. Acesso
em: 12 jun. 2015.

REIS, D. F. UML (Unified Modeling Language) e Unified Software Development Process (Unified
Process). DevMedia, Rio de Janeiro, [s.d.]. Disponível em: <http://www.devmedia.com.br/uml‑unified
‑modeling‑language‑e‑unified‑software‑development‑process‑unified‑process/11217>. Acesso em: 9
jun. 2015.

REPORTING services (SSRS). Microsoft Developer Network. 2015. Disponível em: <https://msdn.
microsoft.com/pt‑br/library/ms159106.aspx>. Acesso em: 15 jun. 2015.

SANTOS, R. Introdução a programação orientada a objetos usando Java. Rio de Janeiro: Campus, 2003.

SEBESTA, R. W. Conceitos de linguagens de programação. Porto Alegre: Bookman, 2011.

SHARP, J. Consultando informações em banco de dados. In: ___. Microsoft Visual C# 2010: passo a
passo. Porto Alegre: Bookman, 2011. p. 567‑96.

SINTES, T. Aprenda orientação a objetos em 21 dias. São Paulo: Pearson, 2002.

UNIVERSIDADE FEDERAL DO RIO GRANDE DO SUL (UFRGS). Calculando com o zero: dividindo por zero.
Porto Alegre: UFRGS, [s.d.]. Disponível em: <http://www.mat.ufrgs.br/~portosil/passa7d.html>. Acesso
em: 22 jun. 2015.

161
Sites

<http://www.microsoft.com/brasil/msdn>.

<https://www.visualstudio.com/pt‑br/visual‑studio‑homepage‑vs.aspx>.

162
163
164
Informações:
www.sepi.unip.br ou 0800 010 9000