Codificando e-magazine11

Fale com Editor
É muito importante para a equipe
saber a sua opinião sobre a revis-
ta, caso tenha alguma critica, su-
gestão, ou elogio entre em conta-
to.
Caso tenha interesse em publicar
um artigo na revista envie o título
e um resumo do tema em formato
Word.
site@codificandomagazine.net
EDITORES
Alexandre Tarifa
Diego Nogare
Emerson Facunte
Sergio Gonçalves
REVISÃO
Fernanda Sallai
Giaccomo Sabino
MONTAGEM / FORMATAÇÃO
Milton Carvalhaes
EDITORAÇÃO E DIAGRAMAÇÃO
Adriano Almeida
COLABORADORES
Caio Azevedo
Danilo Marion Munhóz
Diego Nogare
Fabiano Belmonte
Juliano Schimiguel
Milton C. Filho
Ricardo Quartier
Seiti Yamashiro
Tiago Tiguen Sinzato
Produzido por:
www.codificando.net
Edição 11 Número 11 Ano 03 2009
Sumário
Conheça melhor essa nova tecnologia de ma-
nipulação de dados.
Por: Milton C.Filho
28 :. Introdução ao LINQ
04 :. Gerando Boletos Bancários II
Continuação do artigo de como gerar boletos
bancários usando o ASP.NET
Por: Seiti Yamashiro
03:. Editorial 48:. .Close ( )
Conheça esta poderosa plataforma de
relatórios.
Por: Caio Azevedo
30:. Reporting Services 2005
Aprenda como escrever nas tabelas do SAP
com o .Net SAP Connector 2.0.
Por: Diego Nogare
12 :. .NET SAP connector 2.0
Conheça as novas funcionalidades do C# 4.
Por: Fabiano Belmonte
18:. C# 4.0
Introdução sobre tecnologias de jogos.
Por: Tiago Tiguen Sinzato / Juliano Schimiguel
23:. Tecnologia de Jogos Digitais
Aprenda alguns conceitos de Rede.
Por: Danilo Marion Munhóz / Juliano Schimiguel
34:. Servidor no Contexto de Rede
Como escolher o gerador de Relatórios ?
Por: Ricardo Quartier
42:. Report Sharp Shooter

Diego Nogare
site@codificandomagazine.net
Pessoal, como de costume estamos nos esforçando para montar a revista com artigos técnicos de alta qua-
lidade e adequados às novidades/necessidades que surgem a cada dia no nosso universo.
Nesta edição, a 11ª publicada gratuitamente pelo grupo Codificando .Net, aborda artigos sobre LINQ, SQL
Server, SAP, ASP .NET, entre outras tecnologias que são muito importantes hoje no mercado nacional. Os
autores, são grandes conhecedores dos assuntos abordados, e conseguem passar de forma simples e direta
os temas propostos.
Um ponto super importante, que começamos a plantar a algum tempo e que agora está dando ótimos fru-
tos é a idéia de que os próprios membros da comunidade criem os materiais. Isso é tão bom pra todo
mundo, que cada vez mais membros ativos estão realizando atividades e conquistando seus espaços em
meio às comunidades no Brasil.
Como sempre fiz, em todas as edições, deixo aqui o espaço aberto para que vocês possam nos enviar ma-
teriais produzidos por vocês, que teremos o maior prazer em publicá-los.
Muito obrigado pela confiança
Grande Abraço,
Editorial
Edição 11 Número 11 Ano 03 2009
EDITORIAL

www.codificando.net
Codificando.nete-magazine
e-magazine
Ago / Set - 2009 | 4444
Gerando Boletos Bancários
Parte II
Continuação do artigo de como gerar boletos bancários
usando o ASP.NET
Na Parte I vimos como emitir um boleto
para impressão. O que falta é populá-lo
com dados que façam sentido. Vamos en-
tão populá-lo com dados relevantes.
Em primeiro lugar é necessário que você
tenha os dados armazenados em algum
lugar, um banco de dados talvez. Mas vou
presumir que seu código já trate dos dados
e me ater à construção de duas partes fun-
damentais do boleto: a linha digitável e o
código de barras.
Note que, embora alguns dígitos da linha
digitável sigam um padrão, cada banco
pode possuir regras próprias para gerá-la.
Entre em contato com seu banco para ter
essas informações.
Linha digitável
A linha digitável, lembrando novamente
que estou seguindo as instruções do Itaú,
possui 47 dígitos.
Abaixo segue a construção da linha, lem-
brando que DAC significa dígito de autocon-
ferência, ou simplesmente dígito verifica-
dor.
AA-
ABC.CCDDXDDDDD.DEFFFYFGGGG.
GGHHHZKUUUUVVVVVVVVVV
campo 1
10 dígitos
campo 2
11 dígitos
campo 3
11 dígitos 4 campo 5
14 dígitos
Campo 1 (AAABC.CCDDX):
• AAA = código do banco – Itaú =
341;
• B = código da moeda – Real = 9;
• CCC = código da carteira de co-
brança;
• DD = dois primeiros dígitos do
Nosso Número;
• X = DAC módulo 10 do campo 1;
Campo 2 (DDDDD.DEFFFY):
• DDDDDD = restante do Nosso Nú-
mero;
• E = DAC do grupo agência/conta/
carteira/nosso número;
• FFF = três primeiros números da
agência;
• Y = DAC módulo 10 do campo 2;
Por: Seiti Yamashiro

www.codificando.net
e-magazine
Ago / Set - 2009 | 5555
os DAC: s o módulo 10 e o módulo 11.
O cálculo do DAC módulo 10 é realizado
da seguinte forma. Tome o campo a ter
calculado o DAC. Multiplique cada alga-
rismo do campo pela sequência de mul-
tiplicadores 2, 1, 2, 1, 2, 1…, posiciona-
dos da direita para a esquerda. Some os
resultados, que chamarei de N.
Calcule o módulo 10 de N – mod10(N)
ou N%10.
O DAC será 10 – mod10(N). Caso o DAC
seja 10, considere-o como 0.
Segue abaixo um método para calcular o
DAC módulo 10:
private int CalculaDacMod10
(string campo)
{
int soma = 0;
int m;
// caso exista um número par de
algarismos, inicia a mult. por 1
if ((campo.Length % 2) == 0)
m = 1;
else
m = 2;
foreach (char c in campo)
{
soma += Convert.ToInt32(c) *
m;
m = 3 - m; //regra aplicada:
(x+y) - x = y; (x+y) - y = x
}
int dac = 10 - (soma % 10);
if (dac == 10)
return 0;
return dac;
}
O cálculo do DAC módulo 11 é bem se-
melhante.Ele depois será utilizado para
compor o DAC do código de barras.
Tendo o trecho a ter o DAC calculado,
tome seus algarismos e multiplique-os,
iniciando-se da direita para a esquerda,
pela sequência numérica de 2 a 9 ( 2, 3, 4,
Campo 3 (FGGGG.GGHHHZ):
• F = último número da agência;
• GGGGGG = conta corrente + DAC;
• HHH = zeros;
• Z = DAC módulo 10 do campo 3;
Campo 4 (K):
• K = DAC módulo 11 do código de
barras (único DAC que vai para o
código de barras);
Campo 5 (UUUUVVVVVVVVVV):
• UUUU = fator de vencimento;
• VVVVVVVVVV = valor do boleto,
sem ponto e vírgula, ou zeros, no
caso do valor ser preenchido pelo
próprio sacado.
O fator de vencimento contém 4 dígitos
e é o número de dias desde 7 de outubro
de 1997, servindo para indicar a data de
vencimento do boleto (teremos o bug do
milênio 21 de fevereiro de 2025?).
Seu cálculo é bem simples, como pode-
mos ver pelo método abaixo:
private int FatorVencimento
(DateTime date)
{
DateTime zeroDay = new
DateTime(1997, 10, 7);
return (date - zeroDay).Days;
}
DAC
Analisando as regras anteriores, temos
que a maior parte do trabalho consiste-se
em concatenar strings e calcular DACs.
Para criar nossa Linha Digitável iremos
dispor de dois algoritmos para calcular

www.codificando.net
e-magazine
Ago / Set - 2009 | 6666
5, 6, 7, 8, 9, 2, 3, 4… e assim por diante).
Some o resultado obtendo nosso N.
Calcule agora o módulo 11 de N –
mod11(N) ou N%11. O DAC será 11 –
mod11(N).
Caso o cálculo do DAC tenha dado 0, 10
ou 11, considere-o como 1.
O método abaixo faz o cálculo do DAC
módulo 11:
(string campo)
{
int soma = 0;
int m = 2;
//Invertendo a string, para fa-
cilitar o trabalho com os multi-
plicadores
char [] arr =
campo.ToCharArray();
Array.Reverse(arr);
string reversed = new String
(arr);
foreach(char c in reversed)
{
soma += Convert.ToInt32(c) *
m;
m = (m + 1 > 9 ? 2 : m + 1);
}
int dac = 11 - (soma % 11);
if (dac == 0 || dac == 10 ||
dac == 11)
return 1;
return dac;
}
Código de Barras
O padrão de código de barras para os
boletos no Brasil é o denominado 2 de 5
intercalado, que pode ser resumido nas
seguintes características:
• codifica apenas caracteres numéri-
cos (0-9);
• cada caractere é representado por
5 barras, dentre os quais 2 são mais
longas;
• codificação binária – largo é 1, es-
treito é 0;
• os espaços também possuem signifi-
cado, por isso o intercalado
Este código de barras serve apenas para
representar nossa linha digitável, transfor-
mado o que é uma seqüência de números
em uma imagem. Existem muitos controles
por aí que fazem isto, mas não encontrei
nenhum gratuito para Asp.NET.
Neste exemplo vou utilizar o arcode-
net.net. Ele pode ser testado e é completa-
mente funcional, a diferença é que, enquan-
to você não registrá-lo, ele criará uma linha
escrito barcodenet.net (ou algo assim) logo
acima do código de barras.
Embora a linha digitável possua 47 dígitos,
o número que será codificado em barras
possui apenas 44. Por quê? Porque deve-
mos nos livrar de três dos quatro DACs
que constam nela.
Assim o código de barra terá apenas um
DAC. Outra diferença importante é de que
a ordem em que os campos se apresentam
na linha digitável não é a mesma da apre-
sentada pelo código de barras.
Segue como gerar então os dígitos que
compõem o código de barras:
• 3 dígitos do código do Banco (341);
• 1 dígito com o código da moeda (3);
• 1 dígito do DAC do Código de Barras;
• 4 dígitos do fator de vencimento;
• 10 dígitos do valor do título, desconsi-
derando qualquer sinal de pontuação;
• 3 dígitos da carteira;
• 9 dígitos do Nosso Número mais seu
próprio DAC;
• 4 dígitos da agência;

www.codificando.net
e-magazine
Ago / Set - 2009 | 7777
• 6 dígitos da conta corrente, com
seu próprio DAC;
• 3 dígitos não utilizados e compos-
to por zeros (000).
Depois de gerar os dígitos que com-
põem o código de barras, é questão de
torná-lo em imagem utilizando o con-
trole comentado anteriormente:
public byte[] CodigoBarras()
{
BarcodeNETWeb barcode = new
BarcodeNETWeb();
barcode.BarcodeText = Digi-
tosCodigoBarrasComDac();
barcode.BarcodeType = BAR-
CODE_TYPE.INT2OF5;
return bar-
code.GetBarcodeBitmap
(FILE_FORMAT.PNG);
}
Código
Segue então a listagem do código fonte
utilizado neste trabalho. Claro que há
muito o que melhorar nele, mas isto fica
como exercício. =)
Note que modifiquei a classe Dados do
post anterior.
public class LinhaDigitavel
{
public int Banco { get; pri-
vate set; }
public int Moeda { get {return
9; }}
public string CarteiraCobranca
{ get; private set; }
public string NossoNumero
public string Agencia { get;
private set; }
public string ContaCorrente
public DateTime Vencimento
public decimal Valor { get;
private set; }
public LinhaDigitavel(
int banco,string carteira,
string nossonumero, string agen-
cia, string contacorrente,
DateTime vencimento, decimal va-
lor)
{
this.Banco = banco;
this.CarteiraCobranca = car-
teira;
this.NossoNumero = nossonume-
ro;
this.Agencia = agencia;
this.ContaCorrente = contacor-
rente;
this.Vencimento = vencimento;
this.Valor = valor;
}
public LinhaDigitavel(Dados da-
dos)
{
this.Banco = dados.Banco;
this.CarteiraCobranca = da-
dos.Carteira;
this.NossoNumero = da-
dos.NossoNumero;
this.Agencia = dados.Agencia;
this.ContaCorrente = da-
dos.ContaCorrente;
this.Vencimento = da-
dos.DataVencimento;
this.Valor = da-
dos.ValorDocumento;
}
public string FormatoParaImpres-
sao()
{
return
Campo1().Substring(0, 5) + "." +
Campo1().Substring(5) + " "
+ Campo2().Substring(0, 5) + "." +
+ Campo3().Substring(0, 5) + "." +
+ Campo4() + " "
+ Campo5();
}
public byte[] CodigoBarras()
{
BarcodeNETWeb barcode = new
BarcodeNETWeb();
barcode.BarcodeText = Digitos-
CodigoBarrasComDac();
barcode.BarcodeType = BARCO-
DE_TYPE.INT2OF5;
return bar-
code.GetBarcodeBitmap
(FILE_FORMAT.PNG);
}
private string Campo1()
{
string campo =
this.Banco.ToString("000")
+ this.Moeda.ToString("0")
+ this.CarteiraCobranca.Trim()
+ this.NossoNumero.Split('-')
[0].Substring(0, 2);

www.codificando.net
e-magazine
Ago / Set - 2009 | 8888
if (campo.Length != 9) throw
new Exception("Entrada in-
válida");
return campo + CalculaDacMod10
(campo).ToString("0");
}
{
string campo =
this.NossoNumero.Split('-')
[0].Substring(2, 6)
+
this.DacAgenciaContaCarteiraNoss
Numero().ToString("0")
+ this.Agencia.Substring(0, 3);
if (campo.Length != 10)
throw new Exception("Entrada in-
válida");
return campo +
CalculaDacMod10(campo).ToString
("0");
}
{
string campo =
this.Agencia.Substring(3, 1)
+ this.ContaCorrente.Split('-')
[0] +
this.ContaCorrente.Split('-')
[1] //sinto falta de explode/
implode
+ "000";
if (campo.Length != 10)
throw new Exception("Entrada in-
válida");
return campo +
CalculaDacMod10(campo).ToString
("0");
}
{
return DacCodigoBarras
().ToString("0");
}
{
return
this.FatorVencimento().ToString
("0000")
+ FormataValor(this.Valor);
}
private string FormataValor
(decimal valor)
{
string[] value =
this.Valor.ToString
("00000000.00",
Sys-
tem.Globalization.CultureInfo.In
variantCulture).Split('.');
return value[0] + value[1];
}
private int DacAgenciaConta-
CarteiraNossNumero()
{
string termo =
this.Agencia
+ this.ContaCorrente.Split('-')[0]
+ this.CarteiraCobranca
+ this.NossoNumero.Split('-')[0];
if (termo.Length != 20) throw
new Exception("Entrada inválida");
return CalculaDacMod10(termo);
}
private int DacCodigoBarras()
{
return CalculaDacMod11
(DigitosCodigoBarrasSemDac());
}
private string DigitosCodigoBar-
rasSemDac()
{
string termo =
this.Banco.ToString("000")
+ this.Moeda.ToString("0")
+ this.FatorVencimento().ToString
("0000")
+ this.Valor.ToString
("0000000000")
+ this.CarteiraCobranca
+ this.NossoNumero.Split('-')[0] +
this.NossoNumero.Split('-')[1]
+ this.Agencia
+ this.ContaCorrente.Split('-')[0]
+
this.ContaCorrente.Split('-')
[1] //sinto falta de explode/
implode
+ "000";
return termo;
}
private string DigitosCodigoBar-
rasComDac()
{
string termo = DigitosCodigo-
BarrasSemDac();
return termo.Substring(0, 4) +
DacCodigoBarras().ToString("0") +
termo.Substring(4);
}
private int FatorVencimento()
{
DateTime zeroDay = new
DateTime(1997, 10, 7);
return (this.Vencimento - ze-
roDay).Days;
}
///
/// DAC módulo 10
/// Exemplo:
/// Considerando-se a seguinte re-
presentação numérica do código de
barras:
/// 34191.1012? 34567.88005?
71234.57000? 6 16670000012345
/// Temos:

www.codificando.net
e-magazine
Ago / Set - 2009 | 9999
/// a) Multiplicando a sequência
dos campos pelo módulo 10:
/// Campo 1 341911012 Campo 2
3456788005 Campo 3 7123457000
/// X 212121212 X 1212121212 X
1212121212
/// Observação: Os campos 4 e 5
não tem DAC
/// b) Some, individualmente, os
algarismos dos resultados do
produtos:
/// Campo 1 : 6 + 4 + 2 + 9 + 2
+ 1 + 0 + 1 + 4 = 29
/// Campo 2 : 3 + 8 + 5 + 1 + 2
+ 7 + 1 + 6 + 8 + 0 + 0 + 1 + 0
= 42
/// Campo 3 : 7 + 2 + 2 + 6 + 4
+ 1 + 0 + 7 + 0 + 0 + 0 = 29
/// c) Divida o total encontrado
por 10, a fim de determinar o
resto da divisão:
/// Campo 1 : 29 / 10 = 2, resto
9
/// Campo 2 : 42 / 10 = 4, resto
2
/// Campo 3 : 29 / 10 = 2, resto
9
/// d) Calculando o DAC:
/// Campo 1 : DAC = 10 - 9 : DAC
= 1
/// Campo 2 : DAC = 10 - 2 : DAC
= 8
/// Campo 3 : DAC = 10 - 9 : DAC
= 1
/// Portanto, a sequência corre-
ta da linha digitável será:
/// 34191.10121 34567.880058
71234.570001 6 16670000012345
///
///
///
(string campo)
{
int soma = 0;
int m;
// caso exista um número par de
algarismos, inicia a mult. por 1
if ((campo.Length % 2) == 0)
m = 1;
else
m = 2;
foreach (char c in campo)
{
soma += Convert.ToInt32(c)
* m;
m = 3 - m; //regra aplica-
da: (x+y) - x = y; (x+y) - y = x
}
int dac = 10 - (soma % 10);
if (dac == 10)
return 0;
return dac;
}
///
/// Considerando o seguinte conte-
údo do Código de Barras:
/// 3419?
1667000001234511012345678800571423
457000
/// onde:
/// 341 = Código do Banco
/// 9 = Código da Moeda
/// ? = DAC do Código de Barras
/// 1667 Fator de Vencimento
(01/05/2002)
/// 0000012345 = Valor do Título
(123,45)
/// 110123456788 = Carteira/Nosso
Número/DAC (110/12345678-8)
/// 0057123457 = Agência/Conta
Corrente/DAC (0057/12345-7)
/// 000 = Posições Livres (zeros)
/// Temos:
/// a) Multiplica-se a sequência
do código de barras pelo módulo
11:
///
3419166700000123451101234567880057
123457000
/// X
4329876543298765432987654329876543
298765432
/// b) Soma-se o resultado dos
produtos obtidos no item “a” aci-
ma:
/// 12 + 12 + 2 + 81 + 8 + 42 + 36
+ 35 + 0 + 0 + 0 + 0 + 0 + 7 + 12
+15 + 16 + 15 + 2 +
/// 9 + 0 + 7 + 12 + 15 + 16 + 15
+ 12 + 63 + 64 + 56 + 0 + 0 + 20 +
21 + 2 + 18 + 24 +
/// 28 + 30 + 35 + 0 + 0 + 0 = 742
/// c) Determina-se o resto da Di-
visão:
/// 742 / 11 = 67, resto 5
/// d) Calcula-se o DAC:
/// DAC = 11 – 5 então DAC = 6
/// Portanto, a sequência correta
do código de barras será:
///
3419616670000012345110123456788005
7123457000
/// ^---DAC
///
///
///
(string campo)
{
int soma = 0;
int m = 2;
//Invertendo a string, para faci-
litar o trabalho com os
multiplicadores
char [] arr = campo.ToCharArray();
Array.Reverse(arr);

www.codificando.net
e-magazine
Ago / Set - 2009 | 10101010
string reversed = new String
(arr);
foreach(char c in reversed)
{
soma += Convert.ToInt32(c)
* m;
m = (m + 1 > 9 ? 2 : m +
1);
}
int dac = 11 - (soma % 11);
if (dac == 0 || dac == 10 ||
dac == 11)
return 1;
return dac;
}
}
public class Dados
{
public DateTime DataDocumento
{ get; set; }
public DateTime DataVencimento
{ get; set; }
public DateTime DataProces-
samento { get; set; }
public string Cedente { get;
set; }
public string SacadoResumido
{ get; set; }
public string SacadoCompleto
{ get; set; }
public int Banco { get; set; }
public string Agencia { get;
set; }
public string ContaCorrente
{ get; set; }
public string CodigoCedente
{ get; set; }
public int NumeroDocumento
{ get; set; }
public string EspecieDocumento
{ get; set; }
public string Aceite { get;
set; }
public string NossoNumero
{ get; set; }
public string Carteira { get;
set; }
public string Instrucoes
{ get; set; }
public int Quantidade { get;
set; }
public decimal Valor { get;
set; }
public decimal ValorDocumento
{ get; set; }
public string CodigoBaixa
{ get; set; }
public byte[] CodigoBarra
{
get
{
LinhaDigitavel linha = new
LinhaDigitavel(this);
return linha.CodigoBarras();
}
}
public string LinhaDigitavel
{
get
{
LinhaDigitavel linha = new
LinhaDigitavel(this);
return li-
nha.FormatoParaImpressao();
}
}
}
Um exemplo de uso do gerador de bole-
tos:
protected void btnGeraBo-
leto_OnClick(object sender, Even-
tArgs e)
{
Boleto boleto = new Boleto
(Por-
tal.Controles.Boleto.Banco.ITAU,
Server);
List dados = new List();
dados.Add(
new Por-
tal.Controles.Boleto.Dados()
{
Aceite = "N",
Agencia = "1234",
Banco = 341,
Carteira = "109",
Cedente = "Indústria ACME",
CodigoBaixa = "109/12345678-9",
CodigoCedente = "12345-6",
ContaCorrente = "12345-6",
DataDocumento = DateTime.Now,
DataProcessamento = DateTi-
me.Now,
DataVencimento = new DateTime
(2009, 4, 5),
EspecieDocumento = "DM",
Instrucoes =
@"Não receber após o vencimento",
NossoNumero = "12345678-9",
NumeroDocumento = 0000000012,
Quantidade = 0,
SacadoCompleto =
@"Padoca do Zé - LTDA CNPJ -
12.345.678/0001-23
Rua das Casas, 123
01234-123 Vl do Bairro Sao Paulo
SP",
SacadoResumido = "Padoca do Zé -
LTDA",
Valor = 0,
ValorDocumento = 2637.00m
});
boleto.Baixa(Response, dados);

www.codificando.net
e-magazine
Ago / Set - 2009 | 11111111
Seiti Yamashiro
Graduando em Ciência da Computação, desenvolvedor
web em C#/Asp.NET com banco de dados MS SQL Ser-
ver. Nas hora vagas costuma programar em PHP e im-
plantar sistemas livres em Linux, além de alimentar um
blog: http://seiti.eti.br
}
Embora existam outras opções, como cartões de cré-
dito e pagamento direto online, o boleto ainda é utili-
zado devido à familiaridade e facilidade de pagamen-
to por parte do comprador. Por isso temos de saber
gerá-lo em nossos sistemas, mesmo que utilizemos
soluções prontas.
Vimos que gerar um boleto na plataforma .Net é algo
simples, composto por uma guia impressa, alguma
lógica para a geração da linha digitável e uma ferra-
menta de terceiros para a criação do código de barras.
A parte mais difícil fica no sistema subjacente, não
abordada, onde entra o retorno do pagamento do bo-
leto e finalmente na remessa da mercadoria. Mas isto
fica para uma próxima.

www.codificando.net
e-magazine
12121212Ago / Set - 2009 |
Escrevendo nas tabelas do SAP
com o .NET SAP Connector 2.0 a-
través de RFC
Aprenda como escrever nas tabelas do SAP com
o .Net SAP Connector 2.0.
No artigo anterior sobre SAP (lendo as ta-
belas do SAP com .NET SAP Connector 2.0
através de RFC, que pode ser acessado na
10ª Edição da Revista Codificando .Net e-
Magazine), foi explicado sucintamente o
que é o SAP, e quais são as atividades/
recursos envolvidos para conseguir utilizar
RFCs para se trabalhar com o SAP. Se sen-
tir necessidade, pode consultar o artigo an-
terior, para esclarecer e alinhar as idéias.
Neste artigo, faremos o inverso do que foi
feito anteriormente. Desta vez, ao invés de
ler informação do SAP, iremos escrever
informação no SAP. Para isso, será desen-
volvida uma aplicação Windows Forms
em C# que fará a escrita em uma RFC do
SAP, com base em um DataTable (mas a
origem da informação fica a seu critério!).
Vou partir diretamente para a aplicação,
entendendo que já esteja tudo configurado,
como explicado no artigo sobre ler tabelas
do SAP.
Após a instalação do conector, um novo
ícone será adicionado nos templates que
podem fazer parte do projeto (Figura 1),
este novo item é o “SAP Connector Proxy”.
Este Proxy receberá todos os itens das
RFCs que serão conectadas através
do .Net e montará automaticamente as
classes de acessos com suas respectivas
properties (métodos Get e Set), entre ou-
tras coisas.
Para utilizar este proxy, será necessário
adicionar um novo item ao projeto, en-
tão vá até a Solution Explorer, clique
com o botão direito do mouse e aponte
para Add New Item, acompanhe este
passo na Figura 1. A tela de Template
dos itens a serem inseridos, pode ser a-
companhado na Figura 2.
Por: Diego Nogare
Figura 1. Adicionando novo item ao projeto

www.codificando.net
e-magazine
13131313Ago / Set - 2009 |
rer, para se poder visualizar as RFCs que
estão liberadas pra acesso. Vá até o Server
Explorer, procure o item do SAP (que foi
inserido após a instalação do SAP .Net
Connector 2.0), expanda a árvore do SAP
e clique com o botão direito no item
“Application Servers”, então adicione os
dados AppServerHost / Client / Pass-
word / SystemNumber e UserName. A-
companhe este passo na Figura 4.
Após este passo, será possível expandir o
“Application Servers” e visualizar o servi-
dor que você adicionou (terá o nome for-
necido ao campo AppServerHost). Ao ex-
pandir este item, será necessário configu-
rar o filtro das Functions para aparecer as
RFCs (crie um novo filtro e coloque os da-
dos para filtrar (* retorna todas)) que po-
derão ser utilizadas na aplicação. Acom-
panhe as RFCs fornecidas na Figura 5.
Agora que as RFCs já estão listadas, é só
arrastar a RFC que será acessada para
Após a adição, o item aparecerá no Solution
Explorer (neste exemplo, foi adicionado na pró-
pria raiz do projeto, mas ele pode ser adiciona-
do dentro de alguma outra pasta para melhorar
a organização), como mostra a Figura 3.
Dê dois cliques no Proxy adicionado, e
uma tela sem nenhum controle será a-
berta no painel principal do Visual Stu-
dio 2003. Esta tela que se abriu, servirá
de container para as RFCs gerarem auto-
maticamente os códigos das classes de
acesso. Este processo será explicado com
mais detalhes adiante.
Agora, para conseguir utilizar as RFCs
(que foram criadas pelos ABAPs, lem-
bra?!), é necessário adicionar os dados
do servidor do SAP (que serão forneci-
dos pelo pessoal de BASIS, isso você
também lembra, né?!) no Server Explo-
Escrevendo as tabelas do SAP com o .NET SAP Connector 2.0
Figura 2. Adicionando o proxy ao Projeto.
Figura 3. Proxy na Solution Explorer.
Figura 4: Inserindo os dados de acesso no Server
Explorer.

www.codificando.net
e-magazine
14141414Ago / Set - 2009 |
dentro do Proxy, na tela que já deve es-
tar aberta no painel principal do Visual
Studio. Caso isso ainda não esteja feito,
dê dois cliques no item do proxy na So-
lution Explorer. Quando arrastar a RFC
para cima do proxy, os dados da classe
desta RFC serão criados automatica-
mente, permitindo o acesso à seus cam-
pos através de suas properties. Acompa-
nhe na Figura 6, o proxy com uma RFC
já arrastada.
Agora que a RFC foi arrastada para o
proxy, as classes para acessar os dados
do SAP foram criados automaticamente
dentro do proxy, se for até a Solution
Explorer e exibir os itens ocultos (Show
All Files), expandindo o proxy é possí-
vel ver as classes criadas (classes exibi-
das na Figura 7).
Está faltando pouco agora, o mais compli-
cado já passou. Vamos ao código do méto-
do acessarSAP( ) criado, e chamado pelo
método LOAD do formulário. Acompanhe
a Listagem 1, onde os códigos deste méto-
do foram inseridos.
private void acessarSAP()
{
escrevendoSAP proxy = null;
try
{
proxy = new escrevendoSAP
(“String de Conexão”);
proxy.Connection.Open();
ZCPRHEADRTable tabelaSAP
= new ZCPRHEADRTable();
ZCPRHEADR linha = new ZCP-
RHEADR();
DataTable dt = new DataTable
();
montarColunas(ref dt);
foreach (DataRow dr in
dt.Rows)
{
linha.Codca = dr
["codigo"].ToString();
linha.Locen = dr
["nome"].ToString();
linha.Numrg = dr
["telefone"].ToString();
tabelaSAP.Add
(linha);
proxy.Bay2_N2rfi_Rfc_Upda_Zcprh
eadr(ref tabelaSAP);
}
proxy.CommitWork();
Figura 5: RFCs que poderão ser utilizadas.
Figura 6: RFC arrastada para o proxy.
Figura 7: As classes criadas automaticamente
pelo proxy.

www.codificando.net
e-magazine
15151515Ago / Set - 2009 |
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
proxy.Connection.Close();
proxy = null;
}
}
private void montarColunas(ref DataTable dt)
{
dt.Columns.Add("codigo");
dt.Columns.Add("nome");
dt.Columns.Add("telefone");
DataRow dr = dt.NewRow();
dr["codigo"] = "1";
dr["nome"] = "Diego";
dr["telefone"] = "12345678";
dt.Rows.Add(dr);
}
A aplicação utilizará o proxy criado, que
foi chamado de escrevendoSAP para
criar uma conexão com outro servidor
SAP (não precisa ser necessariamente o
mesmo utilizado no Server Explorer,
mas pode ser, sem problema). Os itens
que precisam ser inseridos na String de
Conexão, podem ser encontrados abai-
xo, na Listagem 3. Substitua estes itens
em vermelho pelos dados fornecidos
pelo pessoal de BASIS, como foi feito no
Server Explorer.
"ASHOST=AppServerHost
SYSNR=SystemNumber CLI-
ENT=Client USER=UserName
PASSWD=Password"
Após a informação de conexão do
proxy, será criada uma variável do tipo
“Tabela da RFC” (ZCPRHEADRTable ta-
belaSAP = new ZCPRHEADRTable();). Es-
ta variável criada será passada por parâ-
metro de referência, para o método com o
nome da RFC
(proxy.Bay2_N2rfi_Rfc_Upda_Zcprheadr
(ref tabelaSAP);) que está dentro do proxy.
Como o parâmetro foi por referência, a
variável criada passará a ter os dados li-
dos no DataTable e que serão escritos no
SAP através da RFC.
Este foreach é criado para percorrer todos
os itens do DataTable utilizado como e-
xemplo, e preencher a tabela do SAP, veja
que em todas as iterações do foreach a va-
riável linha do SAP possui seus campos
populados e a RFC de escrita no SAP é
chamada.
A Figura 8 é do SAP, após receber o valor
que inserimos dentro do DataTable no
método montarColunas. Repare que os
campos com marcação em vermelho apon-
tam para os campos que foram preenchi-
dos dentro do foreach no código da Lista-
gem 1.
Após esta análise simples e direta, é possí-
vel fazer uma escrita em tabelas do SAP
Listagem 1: Código para utilizar o proxy e as
classes criadas.
Listagem 2: Código para criar um DataTable
e popular com dados ficticios.
Listagem 3: Dados da String de Conexão
Figura 8: Resultado da informação inserida
no SAP.

www.codificando.net
e-magazine
16161616Ago / Set - 2009 |
através do Visual Studio 2003. Um pró-
ximo artigo explicará como trabalhar
com um workaround para se trabalhar
com Visual Studio 2005 e Visual Studio
2008.
Diego Nogare
Graduado em Ciência da Computação, Pós-Graduado em Engenharia
de Computação com ênfase em Desenvolvimento Web com .NET.
Colaborador do Portal Linha de Código e da revista SQL Magazine,
Líder do grupo de usuários Codificando .NET, Líder dos Microsoft
Student Partners [MSP] de São Paulo e Microsoft Most Valuable Pro-
fessional [MVP] em SQL Server, possui certificações MCP e MCTS em
SQL Server 2005, é palestrante em eventos da Microsoft, Codifican-
do .NET e INETA BR, mantém o site: www.diegonogare.net

www.codificando.net
e-magazine
18181818Ago / Set - 2009 |
C# 4.0
Conheça as novas funcionabilidades do C# 4.
Por: Fabiano Belmonte
O Visual Studio 2010 e .NET Framework 4,0
em breve estará em fase beta, e existem al-
guns novos recursos excelentes que todos
nós podemos esperar animados com este
novo lançamento. Juntamente com o Visual
Studio 2010 e do. NET Framework 4,0 vere-
mos a versão 4.0 da linguagem de programa-
ção C #. Neste artigo eu gostaria de olhar um
pouco a trás de onde começou a linguagem
de programação C # e olhar para onde An-
ders Hejlsberg do C # e sua equipe querem
chegar.
Em 1998, o projeto C # começou com o objeti-
vo de criar uma simples, moderna e orienta-
da a objeto, linguagem de programação que
se tornou conhecido como o. NET. A Micro-
soft lançou o. NET e a linguagem de progra-
mação C #, em meados 2000 e desde então, C
# tornou-se uma das mais populares lingua-
gens de programação em uso hoje. Foi lança-
do então o C# 1.0
A versão 2.0 da linguagem evoluiu de mais,
particularmente acho que e umas das maio-
res evoluções em tão pouco tempo de uma
linguagem e passou a dar suporte aos genéri-
cos, métodos anônimos, iterators, tipos parci-
ais e tipos anuláveis.
Ao conceber a versão 3.0 da linguagem a ên-
fase foi para permitir a LINQ (Language In-
tegrated Query), que exigia a adição das se-
guintes funcionalidades:
• Implictly Typed Local Variables.
• Extension Methods.
• Lambda Expressions.
• Object and Collection Initializers.
• Annonymous types.
• Implicitly Typed Arrays.
• Query Expressions and Expression
Trees.
No passado linguagens de programa-
ção foram projetadas com um deter-
minado paradigma em mente, e como
tal, temos linguagens que foram, co-
mo exemplo, destinadas a serem ori-
entadas a objeto ou funcionais. Hoje,
porém, as linguagens que a ser conce-
bidas com vários paradigmas em
mente. Na versão 3.0 da linguagem
de programação C # adquiriu várias
capacidades funcionais normalmente
associados a programação para per-
mitir Language Integrated Query
(LINQ).
Na versão 4.0 do C # continua a evo-
luir, embora desta vez, a equipe do C
# foram inspiradas por linguagens
dinâmica como Perl, Python e Ruby.
A realidade é que existem vantagens
e desvantagens para ambas as lingua-
gens seja ela escrita estaticamente e
dinamicamente.
Outro paradigma alem do design e
inovação é concorrente que é um pa-

www.codificando.net
e-magazine
19191919Ago / Set - 2009 |
radigma que tem certamente influencia-
ram o desenvolvimento do Visual Studio
2010 e do. NET Framework 4.0.
Agora o que o C# traz de novo:
• Dynamically Typed Objects.
• Optional and Named Parameters.
• Improved COM Interoperability.
• Safe Co- and Contra-variance.
•
Chega de papo e vamos olhar para algum
exemplos em C # 4.0 utilizando essas ino-
vações língua ...
Em C # Hoje você pode ter, o seguinte có-
digo que é uma instância de uma clase es-
crita estaticamente . NET então chama o
método Add em que a classe para obter a
soma de dois inteiros:
Calculator calc = GetCalculator();
int sum = calc.Add(10, 20);
Nosso código fica ainda mais interessante
se a classe Calculadora não é escrita estati-
camente, mas está escrito em COM, Ruby,
Python, ou mesmo JavaScript. Mesmo se
soubéssemos que a classe é uma calcula-
dora. objeto NET, mas não sabemos qual o
tipo específico que é, então, teria de utili-
zar reflection para descobrir atributos e o
tipo em tempo de execução e, em seguida,
dinamicamente invocar o método Add.
object calc = GetCalculator();
Type type = calc.GetType();
object result = type.InvokeMember
("Add",BindingFlags.InvokeMethod,
null,new object[] { 10, 20 });
int sum = Convert.ToInt32(result);
Se a calculadora classe foi escrito em Ja-
vaScript, então nosso código ficaria algo
como a seguinte.
ScriptObect calc = GetCalculator();
object result = calc.InvokeMember
("Add", 10, 20);
int sum = Convert.ToInt32
(result);
Com C # 4,0 teríamos simplesmente escre-
ver o seguinte código:
dynamic calc = GetCalculator();
int result = calc.Add(10, 20);
No exemplo acima declaramos uma variá-
vel calc, cujo tipo estático é dinâmico. Sim,
você leu corretamente que nós escrevemos
estaticamente nosso objeto a ser dinâmico.
Teremos então dinâmico usando método
invocação para chamar o método Add e em
seguida, dinâmico conversão para converter
o resultado da dinâmica de uma invocação
digitado estaticamente inteiro.
Você está ainda encorajado a usar tipagem
estática sempre que possível, porque os be-
nefícios que oferecem línguas escrita estati-
camente nós. Usando C # 4,0, no entanto,
deve ser menos doloroso nessas ocasiões em
que você tem de interagir com objetos dina-
micamente digitados.
Outro grande benefício do uso de C # 4.0 é
que a linguagem suporta agora facultativa e
parâmetros nomeados e por isso vamos a-
gora dar uma olhada em como esta caracte-
rística irá mudar a maneira de conceber e
escrever o seu código.
Um desenho padrão você ver como muitas
vezes que um determinado método está so-
brecarregado, porque o método deve ser
chamado com um número variável de parâ-
C#4.0

www.codificando.net
e-magazine
20202020Ago / Set - 2009 |
metros.
Vamos assumir que temos o seguinte
método OpenTextFile juntamente com
três sobrecargas do método com dife-
rentes assinaturas. Sobrecargas do mé-
todo primário em seguida chame o mé-
todo primário de passar os valores pa-
drão no lugar desses parâmetros para
os quais um valor não foi especificado
na chamada para o método sobrecarre-
gado.
public StreamReader OpenTextFile
(string path, Encoding encoding,
bool detectEncoding, int buffer-
Size) { }
(string path, Encoding encoding,
bool detectEncoding) { }
(string path, Encoding encoding)
{ }
(string path) { }
No C # 4.0 O método primário pode ser
refactored para usar parâmetros opcio-
nais como mostra o seguinte exemplo:
public StreamReader OpenText-
File(string path,Encoding en-
coding = null,bool detectEn-
coding = false,int bufferSize
= 1024) { }
Perante esta declaração, é agora possí-
vel chamar o método OpenTextFile o-
mitindo um ou mais dos parâmetros
opcionais.
OpenTextFile("foo.txt", Encod-
ing.UTF8);
Também é possível usar o C # 4,0 su-
porte para parâmetros nomeados e, co-
mo tal, o método pode ser chamado O-
penTextFile omitindo um ou mais dos pa-
râmetros opcionais, enquanto especifican-
do também outro parâmetro pelo nome.
OpenTextFile("foo.txt", Encoding.UTF8,
bufferSize: 4098);
O nome dos argumentos deve ser forneci-
do somente estância última embora desde
quando eles podem ser fornecidas em
qualquer ordem.
Se você alguma vez escrito qualquer códi-
go que executa um certo grau de interope-
rabilidade COM você provavelmente visto
como o código seguinte.
object filename = "test.docx";
object missing = Sys-
tem.Reflection.Missing.Value;
doc.SaveAs(ref filename,
ref missing, ref missing, ref miss-
ing,ref missing, ref missing, ref
missing,ref missing, ref missing, ref
missing);
Com os parâmetros opcionais e nomeado
linguagem C # 4,0 prevê melhorias signifi-
cativas na interoperabilidade COM e, por-
tanto, o código acima pode agora ser re-
factored tal que o convite é apenas:
doc.SaveAs("foo.txt");
Ao realizar a interoperabilidade COM vo-
cê perceber que você é capaz de omitir a
ref modifer embora o uso do modificador
ref ainda é necessário quando não exer-
çam COM interoperabilidade.
Com as versões anteriores das tecnologias
era necessário também um navio Primary
Interop Assembly (PIA), juntamente com
C#4.0

www.codificando.net
e-magazine
21212121Ago / Set - 2009 |
o seu aplicativo gerenciado. Isso não é
necessário quando se utiliza C # 4.0,
porque o compilador irá injetar vez o
interop tipos diretamente para as As-
sembly de seu aplicativo gerenciado e
só vai injetar os tipos que você está u-
sando e não de todos os tipos encontra-
dos no interior da PIA.
O último aperfeiçoamento lingüístico
que vamos explorar é co-variância e
contra-variância e vamos começar por
explorar com a co-variância. NET ma-
trizes.
string[] names = new string[] {
"Anders Hejlsberg",
"Mads Torgersen",
"Scott Wiltamuth",
"Peter Golde" };
Write(names);
Desde versão 1.0 em um array o. NET
Framework foi co-variante significando
que uma matriz de strings, por exem-
plo, pode ser passada para um método
que espera um array de objetos. Como
tal, a matriz acima pode ser transmitida
para o seguinte Escreve método que es-
pera um array de objetos.
private void Write(object[] ob-
jects)
{
}
Infelizmente, em matrizes. NET não são
co-seguro variante como podemos ver
na seguinte código. Partindo do pressu-
posto de que os objetos variável é uma
matriz de strings da seguinte terá êxito.
objects[0] = "Hello World";
Embora se uma tentativa é feita para a-
tribuir um inteiro à matriz de strings
uma ArrayTypeMismatchException é
jogado.
objects[0] = 1024;
Em ambos os C # 2.0 e C # 3,0 invarian-
tes são genéricos e, portanto, um erro
compilador iria resultar o seguinte có-
digo:
List<string> names = new
List<string>();
Write(names);
Quando o Escreve método é definido
como:
public void Write(IEnumerable<object>
objects) { }
Generics com C # 4,0 apoiar agora segu-
ra co-variância e contra-variância atra-
vés do uso das palavras-chave dentro e
fora contextuais. Vamos dar uma olha-
da em como isso muda a definição do
<T> IEnumerable e IEnumerator <T>
interfaces.
public interface IEnumerable<out
T>
{
IEnumerator<T> GetEnumerator
();
}
public interface IEnumerator<out
T>
{
T Current { get; }
bool MoveNext();
}
Você perceberá que o tipo de parâmetro
T da interface IEnumerable foi prefixa-
do com o fora contextuais palavra-
chave. Dado que a interface IEnumera-
C#4.0

www.codificando.net
e-magazine
22222222Ago / Set - 2009 |
ble é somente leitura, não há capacida-
de especificada na interface para inserir
novos elementos com a lista, ela é segu-
ra para o tratamento de algo mais deri-
vados como algo menos derivados.
Com a palavra-chave fora contextuais
estamos afirmando que contratualmen-
te IEnumerable <out T> segurança é co-
variante. Dado que IEnumerable <out
T> segurança é co-variante podemos
agora escrever o seguinte código:
IEnumerable<string> names = Get-
TeamNames();
IEnumerable<object> objects =
names;
Porque a interface IEnumerable <out
T> utiliza a palavra-chave no contexto
do compilador podem motivo que a a-
tribuição acima é seguro.
Utilizando a palavra-chave no contexto
podemos alcançar seguro contra-
variância, ou seja, tratar algo menos de-
rivados como algo mais derivados.
public interface IComparer<in T>
{
int Compare(T x, T y);
}
Dado que IComparer <in T> é segura
contra-variante podemos agora escre-
ver o seguinte código:
IComparer<object> objectComparer
= GetComparer();
IComparer<string> stringComparer
= objectComparer;
Embora o actual build CTP do Visual
Studio 2010 e do. NET Framework 4,0
tem suporte limitado para a variância
melhorias em C # 4,0 a próxima versão
beta permite que você use o novo para
dentro e para fora contextuais tais como
palavras-chave em tipos IComparer <in
T>. O. NET Framework equipa está a
atualizar os tipos, no âmbito de ser co-
seguro e contra-variante.
Eu mostrei aqui alguns recursos que
você pode achar útil para explorar as
capacidades da linguagem de progra-
mação C # 4,0 e gostaria de encorajá-lo
a também fazer download e instalar a
versão beta.
Bons Códigos...
C#4.0
Fabiano Belmonte
Senior Architect da InfoMoney.com, especialista em aplica-
ções e-Business com larga experiência em B2B
(Submarino.Com e Saraiva.Com). Trabalha há 5 anos com a
tecnologia .Net, aplicando conhecimentos nas diversas á-
reas: instituições financeiras (sistema SPB), e-Commerce,
gerenciamento logístico entre outras. Trabalhando com Vi-
sual Studio desde suas primeiras versões, responsável pela
implementação de uma Metodologia de trabalho e melho-
ras significativas no resultados e na qualidade do time de
Desenvolvimento de muitas empresas por onde passou co-
mo (Saraiva.Com) e ferramentas como TFS (Team Foundati-
on Server).
Foi palestrante em eventos como Codificando. NET 2008 e
outros eventos sobre Tecnologia .NET.

www.codificando.net
e-magazine
23232323Ago / Set - 2009 |
Tecnologias para o Desenvolvimen-
to de Jogos Digitais
Introdução sobre tecnologias de jogos.
Por: Tiago Tiguen Sinzato / Juliano Schimiguel
Introdução
Motor de jogo (também conhecido pelo
termo em inglês, game engine, ou
simplesmente engine) é um programa de
computador e/ou conjunto de
bibliotecas, para simplificar e abstrair o
desenvolvimento de jogos ou outras
aplicações com gráficos em tempo real,
para videogames e/ou computadores
rodando sistemas operacionais. A
funcionalidade tipicamente fornecida
por um motor de jogo inclui: um motor
gráfico para renderizar gráficos 2D e/ou
3D, um motor de física para simular a
física ou simplesmente para fazer
detecção de colisão, suporte a animação,
sons, inteligência artificial, networking,
gerência de memória, gerência de
arquivos, gerência de linha de execução,
um grafo de cena e, suporte a uma
linguagem de script. O processo de
desenvolvimento de jogos é
freqüentemente agilizado quando usado
o mesmo motor de jogo para criar
diferentes jogos.
A maioria dos motores de jogo são
distribuídos em forma de API
(Application Programming Interface ou
Interface de Programação de
Aplicativos), porém, alguns motores são
distribuídos em conjunto de ferramentas,
que agilizam e simplificam ainda mais o
desenvolvimento do jogo, como por
exemplo: IDEs, scripts pré-programados,
e programas que “empacotam” e deixam
pronto o jogo para distribuição. Esses
motores “completos” são chamados de
Middleware. Pelo fato de serem
distribuídos com outras ferramentas, eles
suprem a necessidade da compra de
outras ferramentas, reduzindo os custos.
Como exemplo, pode-se citar: Blender,
Gamebryo, Havok, RAD Game Tools,
RenderWare e, Unreal Engine.
Um motor de jogo pode ser dividido em
duas principais categorias: motor gráfico
e motor de física. Motores gráficos lidam
com os gráficos, sendo responsáveis de
processar dados abstraídos de alto nível e
gerar dados de baixo nível intendíveis
pelo hardware. Como exemplo, pode-se
citar: Crystal Space, Irrlicht, OGRE e
RealmForge. Motores de física lidam com
a física, sendo resposáveis por simular
ações reais, através de variáveis como
gravidade, massa, fricção, força e
flexibilidade. Como exemplo, pode-se
citar: Bullet, COLLADA e ODE.
História

www.codificando.net
e-magazine
24242424Ago / Set - 2009 |
O termo “game engine” originou-se no
meio da década de 1990, especialmente em
conexão com jogos 3D, como tiro em
primeira pessoa a exemplo dos jogos
Doom e Quake que ao invés de construir o
jogo do zero, outros desenvolvedores
licenciaram os núcleos destes jogos,
usando-os como base para seus próprios
motores de jogo. Com o amadurecimento,
os motores de jogo deixaram de se
restringir ao desenvolvimento de jogos.
Eles são usados em outras áreas, como
treinamento, uso médico e simulações
militares.
Como a maioria dos jogos 3D estão, cada
vez mais, se limitando ao poder da GPU e
PPU(Graphics Processing Unit ou Unidade
de Processamento Gráfico/Unidade de
Processamento de Física), as perdas de
desempenho das linguagens de
programação de alto nível, como C#, Java e
Python, deixam der ser válidas, enquanto
os ganhos de produtividade oferecidos por
essas linguagens trabalham em benefício
dos desenvolvedores de motores de jogo.
Abstração de hardware
Motores de jogo fornecem abstração de
hardware, permitindo a um programador
desenvolver jogos sem a necessidade de
conhecer a arquitetura da plataforma-alvo,
que pode ser um console ou um sistema
operacional. Por esse motivo, muitos
motores são desenvolvidos a partir de API
existentes, como OpenGL, DirectX,
OpenAL e SDL, ou até mesmo a partir de
outro motor, que pode facilitar o seu
desenvolvimento. A abstração de
hardware também é essencial para o
desenvolvimento de motores de jogo
multiplataforma.
Motores de tiro em primeira
pessoa
Um bom e conhecido subconjunto de
motores de jogo são os motores de tiro
em primeira pessoa 3D. Enquanto jogos
de estratégia em tempo real e
simuladores de vôo apostam na
qualidade gráfica, jogos deste gênero
apostam na ação.
O motor mais conhecido deste gênero é
o Doom. A classificação de bom motor
do gênero é exigente, pois o que é
considerado avançado em um ano, no
ano seguinte pode ser considerado
padrão. É comum serem criados novos
motores com base em velhos motores,
misturando novas funções, mas
mantendo algumas antigas. Quando um
motor mantém desenvolvimento focado
nos gráficos, o jogo pode perder no
quesito “ação”. Um bom exemplo disso é
o jogo CellFactor: Revolution, que teve
seu desenvolvimento parado; o jogo
agora está disponível para download
completo e gratuito.
Principais motores de jogos
Motores tradicionais: 3D GameStudio -
C4 Engine - DX Studio - Esperient Crea-
tor – Irrlicht - Ketsji(Blender) - NeoAxis
Engine - Panda3D - RPG Toolkit -
Torque Game Engine - Truevision3D -
Unity - Unreal Engine
Motores de física: Bullet - Havok – ODE
Motores gráficos: Crystal Space - OGRE
– OpenSceneGraph
Motores proprietários: 3D GameStudio -
Tecnologia para Desenvolvimento de Jogos Digitais

www.codificando.net
e-magazine
25252525Ago / Set - 2009 |
C4 Engine - DX Studio - Esperient Crea-
tor - Havok - NeoAxis Engine - Torque
Game Engine - Truevision3D - Unity -
Unreal Engine
Motores código aberto: Bullet - Crystal
Space - Irrlicht - Ketsji (Blender) - ODE -
OGRE - OpenSceneGraph - Panda3D -
RPG Toolkit
Desenvolvimento nas platafor-
mas Atuais
Cada plataforma possui seu kit de
desenvolvimento proprietário e pago,
porém, além do computador existem
alternativas para desenvolver jogos
para essas plataformas.
• Microsoft Xbox 360: Possui seu kit
de desenvolvimento profissional,
porém com alternativa grátis cha-
mada Microsoft XNA Studio Ex-
press, podendo ser desenvolvidos
jogos para PC e para Xbox.
• Sony Playstation 3: A plataforma
da Sony é uma das mais fechadas,
que possui seu kit de desenvolvi-
mento com custo alto. Porém a
ultima novidade é que sairá um
concorrente para a ferramenta da
Microsoft, XNA chamada Phyre
Engine que possibilitará usuários
a criarem seus jogos utilizando
toda a potência do Playstation 3.
• Sony Playstation Portable: Tam-
bém como o Playstation 3, o Porta-
ble da Sony também é bem fecha-
do e o desenvolvimento gratuito
nessa plataforma é feito de manei-
ra ilegal através de ferramentas
criadas por usuários que utilizam
falhas do console para rodar esse
tipo de aplicativo.
• Nintendo Wii: A Nintendo tam-
bém possui o seu kit de desenvol-
vimento profissional, e devido às
duas maiores concorrentes esta-
rem brigando pelo desenvolvi-
mento gratuito começaram rumo-
res de que o Wii também terá a
sua ferramenta para usuários.
• Nintendo DS: Assim como o PSP,
o console portátil da Nintendo
não possui qualquer tipo de ferra-
menta para usuários desenvolve-
rem jogos ou aplicativos sem utili-
zar o kit oficial.
Computador: A plataforma PC é a mais aber-
ta, e possui uma quantidade muito grande
de opções para desenvolvimento não só de
jogos amadores como profissionais de bai-
xo ou nenhum custo.
Celular: O desenvolvimento de jogos e aplica-
tivos para celular cresceu muito devido a
evolução rápida desses dispositivos, hoje
também é possível criar jogos em 3D para
celulares. As duas plataformas mais utili-
zadas são a Symbian e o Java (JME), po-
rém a Microsoft anunciou que será dispo-
nibilizada na versão 3.0 do XNA a opção
de desenvolvimento de jogos para plata-
forma Windows Mobile.
6. Ferramentas desenvolvimento para PC
Para desenvolver jogos para PC, temos a op-
ção de utilizar diretamente as APIs gráficas
(DirectX e OpenGL) porém teremos que re-
desenvolver muita coisa, gastando muito tem-
po. A opção mais viável é utilizar engines
prontas e disponíveis para cada parte do Ga-
me, essas engines variam de qualidade, lingua-
gem, facilidade, preço e complexidade. Cabe a

www.codificando.net
e-magazine
26262626Ago / Set - 2009 |
nós testá-las e encontrar a engine que mais se
adéqüe as necessidades do Game. Segue uma
lista de engines para cada parte:
Engines gráficas
Irrlicht (http://irrlicht.sourceforge.net),
muito boa engine gráfica em C++, foco em
3D, intuitiva e fácil de usar;
OGRE (http://www.ogre3d.org), engine
gráfica muito experiente em C++, foco em
3D, complexa e com bastante material;
XNA (http://msdn.microsoft.com/xna/),
engine gráfica em C# da Microsoft, foco em
3D, que compila para ambiente PC e
XBOX360, SDL (http://www.libsdl.org),
engine gráfica e sonora simples de usar,
foco em 2D, nativa em C++;
Allegro (http://alleg.sourceforge.net), en-
gine gráfica experiente e simples de usar,
foco em 2D, nativa em C++;
GLScene (http://www.glscene.org), engine
gráfica em OpenGL muito completa, foco
em 3D, desenvolvida para Delphi;
Game Maker (http://
www.yoyogames.com) O Game Maker
é escrito em Delphi, motivo pelo qual
não tem versões para outros sistemas
que não a Microsoft Windows.
Engines físicas
ODE (http://www.ode.org), engine física
totalmente open e free nativa em C++,
simples e fácil de usar;
Newton (http://
www.newtondynamics.com), engine de
física muito completa e fácil de usar na-
tiva em C++, uso profissional pago;
Ageia (http://www.ageia.com), engine
de física também muito completa e fácil
de usar nativa em C++, recentemente
comprada pela Nvidia, uso profissional
pago;
Engines sonoras:
Irrklang (http://www.ambiera.com/
irrklang/), engine de som criada em
C++ para trabalhar especialmente com
a Irrlicht;
Fmod (http://www.fmod.org), engine
muito experiente em C++;
OpenAL (http://www.openal.org),
engine muito experiente em C++;
SDL (http://www.libsdl.org), engine
gráfica e sonora simples de usar, nativa
em C++.
Após relacionar as engines que iremos utili-
zar, basta escolher a IDE C++ preferida para
iniciar o desenvolvimento:
Microsoft C++ Express Edition (http://
www.microsoft.com/express/vc/ ), grátis
para o uso somente no Windows;
Code::Blocks C++ (http://
www.codeblocks.org), grátis e presente no
Windows e no Linux;
Dev C++ (http://www.bloodshed.net/
devcpp.html), grátis e somente para Win-
dows.
7. Ferramentas para desenvolvimento rápido
de Games
Uma alternativa rápida para quem não possui
uma equipe ou tempo para desenvolvimento
são ferramentas que possuem um pré-formato
de game ou funcionalidades. Essas ferramentas
reúnem várias engines e disponibilizam um fra-
mework para o desenvolvimento rápido de um
Game. Segue alguns exemplos:

www.codificando.net
e-magazine
27272727Ago / Set - 2009 |
Game Maker (http://yoyogames.com), ferra-
menta de desenvolvimento de jogos plata-
forma Windows;
RPG Maker (http://tkool.jp/products/rpgxp/
eng/), ferramenta para desenvolvimento
RPGs;
Mugen (http://www.mgbr.net), ferramenta
para desenvolvimento de jogos de luta;
3D Game Studio (http://
www.3dgamestudio.com), ferramenta para
desenvolvimento de jogos 2D e 3D;
True Vision 3D (http://
www.truevision3d.com), ferramenta para
desenvolvimento de jogos 2D e 3D.
8. Ferramentas para desenvolvimento para
Celular
Para desenvolver em JME, basta baixar o Eclip-
se IDE junto com o plugin EclipseME e o Java
Wireless Toolkit da Sun Com esses aplicativos
instalados, você irá possuir uma estação comple-
ta de desenvolvimento e emulação de aplicativos
e games em JME. A grande maioria dos disposi-
tivos móveis de hoje possuem suporte a JME.
http://www.eclipse.org/
http://www.eclipseme.org
http://java.sun.com/products/sjwtoolkit/
Conclusão
Estamos na sétima geração de videogames, na
última geração temos: Sony Playstation 3, Mi-
crosoft Xbox 360 e Nintendo Wii em consoles,
e: Playstation Portable (PSP), Nintendo DS e
Celular para portáteis e com isso a indústria
internacional de jogos está crescendo muito a
cada dia, e desde 2003 ela já rende mais que a
indústria de filmes. A previsão para os próxi-
mos cinco anos é que a área cresça 20% ao ano.
Só no ano de 2007, foram movimentados 50
bilhões de dólares. O surgimento de novas tec-
nologias tem atuado como um grande catalisa-
dor para a convergência digital ao tornar o de-
senvolvimento de aplicações para sistemas em-
barcados tão fáceis e acessíveis ao público quan-
to no caso dos PCs. Por outro lado, a abertura
desse mercado, aliado ao sucesso vivenciado
pelo entretenimento digital na indústria de
PCs, é um forte sinal do sucesso esperado da
área de jogos para PCs, consoles e Celulares.
Referências
http://www.gamedev.com.br/
http://pt.wikipedia.org/wiki/Brasil
Tiago Tiguein Sinzato
Aluno do Curso de Tecnologia em Análise e Desenvolvi-
mento de Sistemas Universidade Cruzeiro do Sul, Campus
Anália Franco São Paulo, SP.
Prof. Dr. Juliano Schimiguel
Professor do Curso de Tecnologia em Análise e Desenvolvi-
Anália Franco São Paulo.

www.codificando.net
e-magazine
28282828Ago / Set - 2009 |
Introdução ao LINQ
Conheça melhor essa nova tecnologia de manipulação de dados.
Por: Milton C.Filho
Salve galera,
Iniciaremos hoje uma série de artigos so-
bre LINQ abordando seus princípios,
mecanismos, utilização e dicas de boas
práticas.
No artigo de hoje falarei o que é o LINQ
e suas principais utilizações.
Vamos começar ?!
O que é LINQ?
LINQ (Language Integrated Query) são
recursos do framework 3.5 que propor-
ciona para o desenvolvedor uma forma
prática de realizar consultas, desde con-
sultas em base de dados até consultas
em arquivos XML, coleções de objetos
etc. Sua sintaxe é bem parecida com a do
SQL e traz a vantagem de poder traba-
lhar dentro do Visual Studio com a lin-
guagem de sua escolha, tornando assim
o entendimento e o aprendizado bem
mais fácil.
O LINQ é apresentado de cinco princi-
pais formas:
LINQ To SQL
Usado para manipular bases de dados
SQL Server, de forma bem prática e rápi-
da converte as querys do LINQ em
querys SQL gerando assim todas as con-
sultas e querys de manipulação (Insert,
Update, Delete) . Também possibilita ma-
pear toda a sua base de dados e transfor-
mar as tabelas em classes. Desta forma
você poderá trabalhar na sua base de da-
dos da mesma forma que trabalha com
classes do .Net Framework ou classes
próprias.
-LINQ To XML
Usado para manipular aquivos XML, po-
dendo assim consultar, criar e inserir da-
dos em arquivos XML de uma maneira
prática.
-LINQ To Objects
Usado para manipular coleções de obje-
tos do .Net Framework ou coleções pró-
prias, ou seja, você pode manipular qual-
quer coleção de objetos desde que este
objeto herde da Interface INumera-
ble<T>.
-LINQ To DataSet
Usado para manipular DataSets podendo
realizar consultas nas tabelas do DataSet.
-LINQ To Entities.
Usado para manipular dados de outras
bases de dados podendo mapear toda a
sua base de dados em classes do .Net

www.codificando.net
e-magazine
29292929Ago / Set - 2009 |
Framework e trabalhar com essas clas-
ses fazendo consultas, inserções, exclu-
sões, atualizações de uma forma bem
prática.
Nos próximos artigos aprenderemos
mais alguns conceitos e veremos a utili-
zação do LINQ na prática. Espero que
tenham gostado e até o próximo.
Introdução ao LINQ
Milton C. Filho
Cursando o 6º semestre do curso de Sistemas de Informação
na faculdade Barretos, formado em técnico em informática
pelo Centro Paula Souza de Barretos, trabalha com desenvolvi-
mento de sistemas web com o foco tecnologias Microsoft.

www.codificando.net
e-magazine
30303030Ago / Set - 2009 |
Explorando Microsoft Reporting
Services 2005.
Conheça esta poderosa plataforma de relatórios.
Por: Caio Azevedo
Olá pessoal, iniciamos aqui uma série de
artigos onde faremos uma abordagem
prática e teórica, dessa poderosa e pou-
co explorada que é o Reporting Services.
Nesse primeiro momento veremos a
versão do SQL 2005, por ainda ser a fer-
ramenta padrão de banco de dados na
maioria dos nossos clientes, mas em bre-
ve faremos uma explanação da versão
2008, bom divertimento.
Parte 1 – Introdução ao repor-
ting services
O Microsoft SQL Reporting Services,
RS, é uma plataforma de relatórios com-
pleta. Parte integrante do framework de
Business Intelligence baseada em servi-
ços, ferramentas, APIs para desenvolvi-
mento, publicação e gerenciamento dos
relatórios, o RS foi inicialmente apresen-
tando como um add-on do SQL Server
2000 no inicio de 2000. Atualmente, sua
versão mais recente, é a do SQL 2008,
mas aqui cobriremos aquela, parte inte-
grante do SQL Server 2005, por ser a so-
lução de banco de dados mais comu-
mente utilizada.
Os relatórios do RS são baseados na lin-
guagem RDL (Report Definition Lan-
guage), que nada mais é que um dialeto
XML criado pela Microsoft. E, uma vez
que o ambiente do RS esta intimamente
integrada à plataforma .net framework,
suas ferramentas de desenvolvimento
são os Visual Studio 2005 e 2008, ainda
que o próprio SQL Server 2005 tenha um
shell do Visual Studio 2005 chamado Bu-
siness Intelligence Development Studio
(BIDS).
Com o RS é possível criar soluções de
relatórios como parte de uma aplicação,
os chamados Local Mode, que são simila-
res ao modelo utilizado no Cristal Re-
ports ou Microsoft Access, além desse,
temos o modelo de relatórios remoto que
operam como uma aplicação web hospe-
dados em um Web Application Server
(IIS) e acessíveis via protocolo HTTP. Fi-
nalmente temos através da ferramenta
Report Builder, uma forma de disponibi-
lizar para os usuários criar seus próprios
relatórios, atendendo assim ambientes
corporativos, desenvolvedores, arquite-
tos e usuários.
Para qualquer solução de relatórios que
faz uso do ambiente do RS faz-se uso
dos elementos apresentados na figura
abaixo, sendo que a interação entre esses
elementos varia conforme o modelo do
relatório, mas eles sempre estarão pre-
sentes, do processo de criação ao consu-

www.codificando.net
e-magazine
31313131Ago / Set - 2009 |
mo pelo usuário final.
Na figura 1.1, temos o diagrama da re-
lação entre os principais elementos de
uma solução baseada em reporting ser-
vices, relação que detalharemos a se-
guir:
Relatório
Correspondem ao front-end dos dados
devidamente formatados e que corres-
pondem a uma representação gráfica,
funcional e operacional de um arquivo
RDL, com características especificas
conforme seu tipo. Os relatórios podem
ser invocados por uma aplicação clien-
te, seja ele uma aplicação Windows,
Web, por qualquer tecnologia que con-
suma WebService ou mesmo pelo am-
biente do próprio report ing services.
Aplicação cliente
São as aplicações capazes de implemen-
tar, gerenciar e visualizar os relatórios,
sendo os principais, o Report Manager,
o BIDS, Visual Studio,aplicações .net
Windows e web por meio do controle
ReportViewer, além do aplicativo Offi-
ce-Model Report Builder.
Estrutura de dados volátio
São as estruturas em memória que cria-
mos para armazenar temporariamente o
resultado das consultas que serão visuali-
zadas nos relatórios, essas consultas são
implementadas na forma de stored proce-
dures, views, instruções T-SQL além de
cubos OLAP.
Db access engine
São os diversos mecanismos possíveis
para acesso aos dados, corresponde às
fontes de dados: de acesso ao SQL Ser-
ver, Oracle, OLE DB, ODBC bem como
Analysis Server Databases – OLAP.
Repositórios de dados
São as fontes de dados das quais se extrai
as informações para os relatórios criados
e acessados via os DB Access Engines.
O RS suporta alguns dos mais úteis tipos
de relatórios auxiliando os usuários na
melhor distribuição das informações, são
eles:
Tabular: utilizado para distribuição das
informações como uma tabela, com um
numero de colunas previamente estabele-
cidos, similar aos dados do excel;
Livre: as informações são posicionadas
arbitrariamente como for melhor conve-
niente para o usuário, por exemplo, rela-
tórios do tipo, master-detail;
Chart: aos dados são apresentados grafi-
camente;
Correlação: as informações do relatório
são correlacionadas nos dois eixos carte-
sianos formando uma matriz, por exem-
Explorando Microsoft Reporting Services 2005
Figura 1.1 – Correlação entre elementos do
Reporting Services

www.codificando.net
e-magazine
32323232Ago / Set - 2009 |
plo, um relatório das condições de tem-
peratura de um conjunto de cidades;
DrillDown: relatórios que permitem
seções expansíveis, tais como relatórios
de correlação, produtos x vendas, que
permitem exibir subcategorias dos pro-
dutos;
Interativos: são relatórios que permi-
tem uso das funcionalidades especiais,
tais como documentMap, links, dentre
outras, por exemplo relatórios similar
ao modo de exibição de documento
PDFs com o Adobe Reader com marca-
dores.
Não menos úteis são as funcionalidades
nativas dos relatórios, tais como para-
metrização das pesquisas para campos
datas, seleções múltiplas e texto livre;
recurso de navegação entre páginas;
zoom; pesquisa; exportação para diver-
sos formatos (XML, CVS, TIFF, PDF,
Excel); ordenação por colunas; formata-
ção condicional, dentre outros.
É isso ai pessoal, até aqui só co-
meçamos nossa exploração ao
fantástico mundo do reporting
service, na próxima edição vere-
mos o primeiro dos modelos de
relatórios, os ditos “Local Mode”
abraço e até lá e lembrem-se “may
the force be with you”.
Figura 1.2 – relatório tabular
Figura 1.3 – relatório de correlação
Figura 1.4 – relatório drilldown
Figura 1.5 – relatório interativo
Figura 1.6 – funcionalidades

www.codificando.net
e-magazine
33333333Ago / Set - 2009 |
Caio Azevedo
Graduado em Ciência da Computação, Engenharia Civil e
louco por ciências exatas em especial física e matemática.
Coordenador da Célula Microsoft da Magna Sistema e Arqui-
teto Microsoft, palestrante, tecno-colunista, instrutor da
treinando .net e membro da comunidade codificando.net.
MCP, MCAD, MCSD, MCTS e MCPD. E fanático pela série star
wars – “may the force be with you.”
Blog: http://caioadotnet.blogspot.com/

www.codificando.net
e-magazine
34343434Ago / Set - 2009 |
Servidores no Contexto de Redes
Plataforma Microsoft
Aprenda alguns conceitos de Rede.
Por: Danilo Marion Munhóz / Juliano Schimiguel
1. Introdução
Redes de computadores estão em todo
lugar, como por exemplo: em grandes,
médias ou pequenas empresas, escolas,
instituições e universidades entre outros
lugares. Atualmente é muito importante
entender o que são redes, sua utilização
e seu funcionamento podendo assim se
tornar um especialista em redes. O artigo
aborda um tema muito importante den-
tro do campo da informática, pois uma
rede de computadores hoje é o método
mais fácil e muito utilizado para acelerar
o processo de transmissão e compartilha-
mento da informação. O objetivo do arti-
go é demonstrar que a utilização dela
pode ser positiva, que uma rede baseada
em servidor é mais vantajosa, e o quanto
é a praticidade de uma Rede Microsoft, a
princípio utilizando o Software MS Win-
dows NT Server, e também os atuais SQL
Server 2008, Windows Server 2008 Stan-
dard.
Computadores conectados em rede po-
dem trocar informações de maneira fácil
e rápida, pois a troca de informações en-
tre eles se torna mais eficiente. As infor-
mações são direcionadas de um compu-
tador para outro através da rede por in-
termédio de um usuário. Este artigo trata
de mostrar como se faz e como funciona
uma Rede Microsoft, também mostrando
que as redes de computadores são um
sistema sofisticado e complexo de ferra-
mentas muito importantes.
2. Conceito de Redes LANs
2.1 Rede Ponto-a-Ponto
As redes LANs (Local Área Network) co-
mo são chamadas as redes locais, caracte-
rizam-se como sendo redes que permi-
tem a interconexão de equipamentos de
comunicação de dados numa pequena
região. Costuma-se considerar pequena
região distâncias entre 100m e 25km. Os
dois maiores tipos de LANs são: Rede
Ponto-a-Ponto e Rede Baseada em Servidor.
Uma rede ponto-a-ponto normalmente é
definida pela falta de um servidor dedi-
cado que determine um controle central
sobre a rede. Não existem servidores em
uma rede ponto-a-ponto; usuários sim-
plesmente compartilham recursos, como
impressoras, espaço em disco.
Essas redes são organizadas como Grupos
de Trabalho (Workgroups). Um Workgroup
possui um nível de controle de segurança
muito pequeno. Não existe um controle

www.codificando.net
e-magazine
35353535Ago / Set - 2009 |
central para validar quais usuários podem
ou não utilizar a rede e seus recursos.
Quando estamos logados neste tipo de re-
de, temos acesso a todos os recursos com-
partilhados da rede que não exigem uma
senha específica para controlar qual usuá-
rio poderá ou não utilizar determinado re-
curso.
Para controlar o acesso individual ao re-
curso compartilhado, devemos especificar
uma senha para cada recurso da rede, pois
como já vimos anteriormente, não existe
um controle central sobre a rede. Isto pode
ser bastante inconveniente.
Redes ponto-a-ponto não são otimizadas
para compartilhar recursos. Geralmente,
quando alguns usuários estão acessando
um recurso em determinado equipamento
da rede, o usuário daquele equipamento
nota uma significante degradação da per-
formance no equipamento. Este tipo de re-
de também tem muita limitação no núme-
ro de licenças para que poucos usuários
consigam acessar simultaneamente o mes-
mo recurso. Elas têm algumas vantagens,
especialmente para pequenas empresas
que não querem fazer um grande investi-
mento em hardware e software servidor.
Uma rede baseada em servidor normal-
mente é definida pela presença de servido-
res na rede que provêm segurança e admi-
nistração centralizada para a rede. Os ser-
vidores têm diversos papéis na rede. Redes
baseadas em servidores possuem clientes
que utilizam os serviços providos por es-
tes, como armazenamento de arquivos e
impressão. Clientes são computadores me-
nos potentes que computadores servido-
res.
2.2 Rede Baseada em Servidor
Uma rede baseada em servidor que utili-
za o software MS Windows NT Server,
pode ser organizada em domínios, que
são vários computadores clientes conec-
tados a um servidor que controla a segu-
rança na rede. A segurança do domínio e
permissão de logon são controlados por
servidores especiais chamados de Con-
troladores de Domínio (Domain Controlers).
Existe um Controlador de Domínio Mestre
(Master Domain Controler) Chamado de
PDC (Primary Domain Controler) ou
(Controlador de Domínio Primário) que po-
de ser assistido pelos Controladores de Do-
mínio Secundários, chamados de BDC
(Backup Domain Controlers) ou
(Controladores de Domínio Backup). Os u-
suários não podem acessar os recursos
da rede enquanto não forem validados
pelo PDC.
Redes baseadas em servidores possuem
grandes vantagens:
• Servidor dedicado otimizado;
• Armazenamento de arquivos centrali-
zado, permitindo Backup de dados Im-
portantes;
• Fácil gerenciamento para um grande
número de usuários;
• Exigência de senha para acesso aos re-
cursos compartilhados da rede.
Redes baseadas em servidores não pos-
suem muitas desvantagens, entretanto
também é importante conhecê-las:
• Alto investimento para o hardware de-
dicado (Servidor);
• Alto investimento para o sistema ope-
racional servidor e licenças para os cli-
Servidores no Contexto de Redes Plataforma Microsoft

www.codificando.net
e-magazine
36363636Ago / Set - 2009 |
entes;
• Requer um Administrador de Redes dedi-
cado.
As estações de trabalho são os computado-
res clientes da rede e normalmente não
compartilham recursos para a rede. Os cli-
entes da rede rodam sistemas operacionais
como MS-DOS, MS-Windows 95, MS-
Windows 98, MS Windows NT Workstation e
às vezes podem ter o sistema operacional
MS-Windows NT Server. Em uma rede lo-
cal Microsoft, podemos ter clientes Macin-
tosh e Novell, para utilizar ferramentas de:
• Desenvolvimento de Sistemas;
• Consulta a Banco de Dados;
• Apresentação e Análise de Informa-
ções.
Os servidores da rede são máquinas mais
potentes que os clientes que compartilham
recursos para a rede como: impressoras,
discos entre outros. Em uma rede Micro-
soft o servidor terá o sistema operacional
MS-Windows NT Server como PDC. Tam-
bém podemos ter servidores Novell e Unix
em uma rede Microsoft, sendo que para
conversar com Novell a Microsoft provê um
protocolo que possibilita a conexão com
esses servidores. No servidor Unix é neces-
sário ter o software SAMBA instalado e
configurado corretamente para que máqui-
nas com sistemas operacionais da Micro-
soft possam acessá-lo. Abaixo temos as ca-
racterísticas necessárias para que o SAM-
BA funcione corretamente:
• Geralmente possui um sofisticado sistema
operacional;
• Grande memória interna;
• Armazena grande quantidade de infor-
mações;
• Sistema de interrupção;
• Sistema de I/O assíncrono;
• Dispositivos para facilitar e controlar
comunicação;
• Software para controle de comunica-
ção;
• Software para controle de banco de da-
dos;
• Multiprogramação e esquema de prio-
ridade;
• Compartilha recursos;
• Define os tipos de interconexão, siste-
ma operacional, protocolos e até aplica-
tivos a serem usados na rede;
• SGBD (Sistema Gerenciador de Banco
de Dados;
• Servidor de Arquivos e Impressão;
• Servidor de Comunicação;
• E-mail.
2.3 Protocolos
Os Protocolos são regras e procedimen-
tos para comunicação. A utilização das
regras de comunicação aplica-se da mes-
ma maneira no ambiente de computado-
res. Quando diversos computadores es-
tão interligados em rede, as regras e pro-
cedimentos técnicos que administram
sua comunicação e interação são chama-
dos de protocolos.
Toda a operação técnica de transmissão
de dados através da rede precisa ser di-
vidida em etapas sistemáticas distintas.
Em cada uma delas, ocorrem certas a-
ções distintas que não podem ocorrer em
nenhuma outra. Cada uma tem suas pró-
prias regras e procedimentos, ou proto-
colo. Elas devem ser utilizadas em uma
ordem consistente, que seja igual em to-
dos os computadores da rede. No com-
putador remetente, essas etapas devem

www.codificando.net
e-magazine
37373737Ago / Set - 2009 |
ser realizadas de cima para baixo. Na má-
quina receptora, devem ser realizadas de
baixo para cima.
NetBEUI é o padrão e significa NetBIOS
Extended User Interface. A sigla NetBIOS sig-
nifica Network Basic Input/Output System. O
protocolo NetBEUI implementa o protoco-
lo de transporte NetBIOS Frame (NBF),
que foi desenvolvido pela IBM para traba-
lhar em grupos de trabalho utilizando OS/-
2 e LAN Manager.
O protocolo NetBEUI foi também desen-
volvido para trabalhar em grupos de tra-
balho com até 200 computadores. Neste
protocolo não pode ser roteado entre re-
des, isto é, está limitado a pequenas redes
locais. A versão 3.0 do NetBEUI é uma atu-
alização da Microsoft do mesmo protocolo
da IBM. Ele fornece ferramentas para que
um programa estabeleça uma sessão com
outro programa através da rede. É muito
popular porque muitos programas aplica-
tivos o suportam.
Além disso, o protocolo NetBEUI é um
protocolo simples, rápido e eficiente que é
fornecido com todos os produtos de rede
da Microsoft. Está disponível desde mea-
dos dos anos 80 e foi fornecido com o pri-
meiro produto de rede Microsoft, o MS-
NET. As vantagens desse protocolo inclu-
em seu pequeno tamanho de pilhas
(importante para computadores baseados
em MS-DOS), sua velocidade de transfe-
rência de dados na mídia da rede, fácil im-
plementação e sua compatibilidade com
todas as redes baseadas em Microsoft.
Em ambos os computadores envolvidos no
processo de transmissão de dados, é neces-
sário seguir cada etapa da mesma maneira,
assim os dados recebidos terão a mesma
aparência de quando enviados. Portanto,
é necessário que os dois computadores
envolvidos utilizem o mesmo protocolo,
pois protocolos diferentes realizarão eta-
pas diferentes no processo de envio e
recebimento dos dados.
2.4 MS Windows NT
O Windows NT Workstation 4.0, tem a
mesma interface conhecida e funcional
apresentada pelo Microsoft Windows 95.
Mas por trás dele está o robusto sistema
operacional de 32 bits e multitarefa que a
Microsoft criou para usuários avança-
dos. Essa versão fundamentou-se nos
mesmos princípios de projeto das ver-
sões anteriores e conserva seus avanços
mais importantes. O Windows NT
Workstation continua sendo compatível
com muitos outros sistemas operacio-
nais, sistemas de arquivos e redes. Ele
roda em computadores com conjuntos
de instruções complexas (Complex Ins-
truction Set Code – CISC) e computado-
res com conjuntos de instruções reduzi-
das (Reduced Instruction Set Code –
RISC). O Windows NT também suporta
a computação de alto desempenho, for-
necendo suporte de kernel ao multipro-
cessamento simétrico.
Windows NT é um sistema operacional
32-bits multitarefa, que faz parte da fa-
mília de sistemas operacionais Micro-
soft. E Está disponível em duas versões:
• Windows NT Workstation, Desenvol-
vido para trabalhar como membro
de uma rede organizada em Grupo
de Trabalho (Workgroup), como
um cliente de um domínio Win-

www.codificando.net
e-magazine
38383838Ago / Set - 2009 |
dows NT Server, como cliente de u-
ma rede Novell NetWare, ou como
uma estação de trabalho stand-alone.
É recomendado para usuários que
precisam de um sistema operacional
com um alto nível de segurança;
• Windows NT Server, Muito idêntico ao
Windows NT Workstation, mas com
alguns recursos que habilitam o Win-
dows NT Server a trabalhar como um
sistema operacional de rede (NOS –
Network Operating System).
Windows NT é um sistema operacional
seguro para microcomputadores de 32-bits
com uma interface gráfica. Não é uma revi-
são de outra versão do Windows como
Windows 3.x ou Windows for Workgroup
3.x, mas um novo sistema operacional. A
interface gráfica do Windows NT 4.0 utili-
za a mesma interface gráfica do Windows
95.
Diferentemente de muitos sistemas opera-
cionais, Windows NT pode rodar em uma
variedade de plataformas. Windows NT
foi desenvolvido para rodar em platafor-
mas Intel 80386 DX, 80486 e computadores
baseados em processadores Pentium, bem
como em computadores RISC (Reduced
Instruction Set Computers). Windows NT
suporta os seguintes processadores:
• IBM PowerPC;
• MIPS R4x00;
• DEC Alpha AXP;
• Intel 386 e superiores.
O Windows NT pode rodar diferentes ti-
pos de aplicações simultaneamente. En-
quanto o usuário está trabalhando em uma
aplicação, outra aplicação pode estar ro-
dando em segundo plano. Um sistema o-
peracional multitarefa oferece os meios
para um computador processar mais de
uma tarefa de cada vez. Um verdadeiro
sistema operacional multitarefa pode e-
xecutar tantas tarefas quantos forem os
processadores. Quando houver mais ta-
refas do que processadores, o computa-
dor precisará alocar os intervalos de
tempo de modo que os processadores
disponíveis dediquem uma determinada
parcela de tempo para cada tarefa, alter-
nando entre as tarefas até que tudo este-
ja terminado. Este sistema faz com o
computador pareça estar trabalhando
em diversas tarefas ao mesmo tempo.
O Windows NT 4.0 suporta três tipos de
sistemas de arquivos:
• File Allocation Table (FAT): Sistema
de Arquivos utilizado com o MS-
DOS;
• New Technology File System (NTFS):
Sistema de Arquivos implementa-
do pelo Windows NT;
• Virtual File Allocation Table (VFAT):
Sistema de Arquivos implementa-
do pelo Windows 95.
O Windows NT pode rodar os seguintes
tipos de aplicações:
• DOS 16-bits;
• Windows 3.x 16-bits (Win16);
• POSIX (Implementação UNIX);
• OS/2 1.x;
• New 32-bits (Win32).
O Windows NT suporta os seguintes
protocolos de rede:
• TCP/IP;
• DLC;

www.codificando.net
e-magazine
39393939Ago / Set - 2009 |
• NetBEUI;
• AppleTalk;
• NWLink (Microsoft’s 32-bits Windows
NT IPX/SPX).
Entre algumas características do Windows
NT Server, podemos citar:
• Windows NT Server permite estabelecer
sessões ilimitadas com clientes, enquanto
o Windows NT Workstation permite so-
mente 10;
• Windows NT Server suporta até quatro
processadores, enquanto o Windows NT
Workstation pode suportar somente dois;
• Windows NT Server pode suportar 256
sessões simultâneas através do RAS, en-
quanto que o Windows NT Workstation
permite apenas uma;
• Windows NT Server pode importar e ex-
portar replicações de diretórios, enquanto
o Windows NT Workstation pode somen-
te importar.
O Windows NT Server oferece serviços pa-
ra Macintosh, validação de logon e tolerân-
cia a falhas de disco, enquanto o Windows
NT Workstation não oferece nada disso. O
gerenciamento de rede inclui monitoração
do comportamento da rede como parte de
uma abordagem específica à resolução de
problemas. Se o planejamento, a monitora-
ção e o gerenciamento forem efetuados de
modo adequado, a necessidade de resolu-
ção será mínima. Ao planejar uma rede, o
administrador deve implementar planos e
procedimentos para evitar problemas an-
tes que apareçam. Estes planos incluem
backups, padronização, atualizações regu-
lares e documentação.
Existem utilitários disponíveis para ajudar
o administrador da rede nessas tarefas. O
Windows NT tem programas internos
de monitoração e gerenciamento de re-
de, que oferecem estatísticas de utiliza-
ção e desempenho, além de registros de
evento.
Como parte do gerenciamento da rede, é
importante estabelecer uma linha de ba-
se do comportamento típico da rede. Isso
é feito ao longo do tempo e deve ser bem
documentado. Se realmente surgirem
problemas, a linha de base é o primeiro
recurso a que o administrador pode re-
correr para comparação com padrões de
utilização diária, gargalos em potencial,
contagens de erro e estatísticas gerais de
desempenho. Os Softwares de Redes Mi-
crosoft de Servidores disponíveis no
mercado atualmente são os: SQL Server
2008 e o Windows Server 2008 Standard.?
2.5 SQL Server 2008
O SQL Server 2008 baseia-se na visão da
Plataforma de Dados da Microsoft, o que
ajuda as organizações no gerenciamento
dos dados, em qualquer local e a qual-
quer momento. Ele permite que você ar-
mazene seus dados a partir de documen-
tos estruturados, semi-estruturados ou
mesmo não estruturados, como imagens
e músicas, diretamente dentro do banco
de dados. O SQL Server 2008 fornece um
vasto conjunto de serviços integrados
que permitem que você faça muito mais
com seus dados como consulta, pesqui-
sa, sincronização, relatórios e análises.
Os dados podem ser armazenados em
grandes servidores de um data center e
acessados a partir deles para desktops e
dispositivos móveis, fornecendo controle
sobre os dados, não importando o local
em que estão armazenados.

www.codificando.net
e-magazine
40404040Ago / Set - 2009 |
O SQL Server 2008 permite que você utilize
seus dados em aplicativos personalizados
desenvolvidos no Microsoft .NET e Visual
Studio, na arquitetura SOA (service-
oriented architecture - arquitetura orienta-
da a serviços) e em processos de negócios
por meio do Microsoft BizTalk Server, en-
quanto os profissionais da informação po-
dem acessar os dados diretamente nas fer-
ramentas que utilizam no dia-a-dia, como o
Microsoft Office System 2007. O SQL Ser-
ver 2008 fornece uma plataforma de dados
confiável, produtiva e inteligente para to-
das as suas necessidades relacionadas aos
dados.
2.6 Windows Server 2008 Stan-
dard
O Windows Server 2008 é o mais sólido sis-
tema operacional da família Windows Ser-
ver já lançado. Com os recursos internos
aprimorados para Web e virtualização, o
Windows Server 2008 foi projetado para
aumentar a confiabilidade e flexibilidade
da infra-estrutura de seus servidores, aju-
dar a reduzir custos e ganhar tempo. Pode-
rosas ferramentas proporcionam maior
controle sobre os servidores, bem como ta-
refas de gerenciamento e configuração sim-
plificadas. Somado a isso, os recursos de
segurança aprimorados agem na proteção
do sistema operacional para assegurar a
rede e os dados, proporcionando uma base
sólida e altamente confiável.
2.7 Softwares Servidores Micro-
soft
Os Softwares Servidores Microsoft estão
classificados em:
• Precursores: MS-DOS; OS/2.
• Família DOS: 1.0; 2.0; 3.0; 95; 98;
ME.
• Família NT Servidores: 3.1; 3.5;
3.51; 4.0; 200; Server 2003; Server
2008.
• Outros: Fundamentals for Legacy
PCs; Home Server.
• Futuros: 7 (Seven); Azure.
Cancelados: Neptune, Nashville, Cairo.
Existem muitos recursos de suporte de
rede que o administrador pode acessar
para ajudar a resolução de problemas,
como por exemplo, Microsoft TechNet e
BBS.
Conclusão
Redes foram criadas pelo propósito de
poder compartilhar informações, e para
que essa informação chegue mais rápido
para o seu destino final, e também para
interligar cada computador e de cada
ponto diferente de uma sala até de um
continente. No caso de servidores é im-
portante ressalvar que dentro de uma
empresa, por exemplo, a informação na
rede é processada com uma maior efici-
ência e rapidez. Uma rede que funcione
por si só ainda não foi inventada. É pre-
ciso incluir novos usuários. É preciso ex-
cluir usuários existentes. É preciso insta-
lar e compartilhar novos recursos, além
de dar as devidas permissões de acesso.
Permissões de acesso são normas associ-
adas ao recurso, geralmente um diretó-
rio de arquivos ou uma impressora. As
permissões regulamentam o acesso dos
usuários ao recurso. Tudo isso significa
que, depois que uma rede estiver instala-
da, será indispensável, a necessidade de
gerenciá-la.

www.codificando.net
e-magazine
41414141Ago / Set - 2009 |
Referências
Giungi, D.; Liesenberg, H.K.E.; Pires, F.; Al-
meida, R.Q. de; Ussami, M.C. (1998). Soluções
Microsoft para Redes Locais, UNICAMP – U-
niversidade Estadual de Campinas [on-line].
Disponível em: http://www.apostilando.com/
download.php?cod=394&categoria=Redes. Úl-
timo acesso: 14.06.2009.
Microsoft, Servidores, Windows Server. Resu-
mos das Edições do Microsoft Windows Server
2008 [on-line]. Disponível em: http://
www.microsoft.com/brasil/servidores/sql/
overview.mspx. Último acesso: 14.06.2009
Microsoft, Servidores, SQL Server. Microsoft
SQL Server, Visão Geral [on-line]. Disponível
em: http://www.microsoft.com/brasil/
servidores/windowsserver2008/editions/
overview.mspx. Último acesso: 14.06.2009
Microsoft, TechNet. TechCenter do Windows
Server. Recursos do Windows Server 2008 [on-
line]. Disponível em: http://
technet.microsoft.com/pt-br/windowsserver/
default.aspx. Último acesso: 14.06.2009
Wikipédia, Windows Server 2008. Cronologia
dos Softwares Servidores Microsoft [on-line].
Disponível em: http://pt.wikipedia.org/wiki/
Windows_Server_2008. Último acesso:
14.06.2009
Danilo Marion Munhóz
Aluno de Tecnologia em Análise e Desenvolvimento de Siste-
mas FATEPA – Faculdade de Tecnologia Unianchieta – Centro
Universitário Anchieta.
Prof. Dr. Juliano Schimiguel
Professor do Curso de Tecnologia em Análise e Desenvolvi-
Anália Franco São Paulo.

www.codificando.net
e-magazine
Ago / Set - 2009 | 42424242
Report Sharp Shooter
Como escolher o gerador de Relatórios ?
Para usar software de terceiros em nossos
projetos temos a mesma sensação de tirar
fotos das Cataratas do Iguaçu. À primeira
vista, as Cataratas tiram a nossa respiração
e é super promissor, mas você também não
consegue ver as pedras escondidas e tem
que estar equipado para emergências!
O mesmo acontece com software. Você não
consegue ver o futuro e se preparar para
ele! Mesmo quando parece que você en-
controu a ferramenta certa, você nunca sa-
berá o que o seu cliente irá querer de você
amanhã, e que tarefas você terá que pro-
gramar no futuro.
Então, agora a história… Alguns meses a-
trás, eu me deparei com a necessidade de
desenvolver uma solução de ERP de gran-
de escala para a minha empresa com mui-
tas características específicas. Eu não quero
cansá-los com toda a especificação da mi-
nha aplicação, eu apenas gostaria de dizer
que requeria a geração de centenas de rela-
tórios diferentes e era impossível de prever
todas as particularidades que os relatórios
que meus clientes poderiam necessitar ao
longo do tempo.
O desafio maior era como encontrar uma
ferramenta de relatórios para meus aplica-
tivos! Eu me perguntei: “Que critério eu
devo usar para escolher a ferramenta certa
e que não vá me fazer cair dos 80 metros
das Cataratas do Iguaçu na água fervida
do suporte diário e debugging quando
meus clientes quisessem realizar uma ou
outra tarefa?”
Quando você começar a desenvolver al-
gum sistema de relatórios, é impossível
predizer de uma vez quais tipos de rela-
tórios serão necessários para o seu clien-
te pela sua aplicação. E eu nunca encon-
trei clientes que pudessem formular seus
requerimentos suficientemente. Você en-
controu?
Um sistema de relatórios é usualmente
estendido por novos relatórios através
do tempo e você precisa cuidar e dar
manutenção constantemente. Todo de-
senvolvedor já se deparou com a situa-
ção de quando o cliente fala: “Está bom,
muito bom... mas eu quero que este texto
fique aqui e não ali, eu quero que esta
coluna mostre outra informação...” E daí
por diante. Se a sua ferramenta de rela-
tórios não puder resolver, estas questões
você vai se sentir caindo das muito fala-
das Cataratas do Iguaçú...
O que fazer? Escrever sua própria ferra-
menta de relatórios? Com o cronograma
disponível, inaceitável! A pior situação
ainda é quando você enfrenta estes pro-
Por: Ricardo Quartier

www.codificando.net
e-magazine
Ago / Set - 2009 | 43434343
tórios é muito conveniente; isto permite
a você qualquer novo dado que for cal-
culado com base na fonte dos dados. Pa-
ra fazer isso, você precisa apenas fazer
mudanças no modelo de relatório.
Habilidade de dinamicamente
configurar parâmetros em um
modelo de relatórios dependen-
do da fonte de dados.
Habilidade para dinamicamente confi-
gurar parâmetros na base da fonte de
dados permite flexibilidade na apresen-
tação dos dados dependendo dos valo-
res da fonte dos dados. Um modelo se
torna versátil e isto o permite minimizar
o número dos modelos de relatórios a
serem desenvolvidos. Isto é especial-
mente vital quando o desenvolvimento
futuro pode ser requerido.
Habilidade de se extrair qual-
quer dado com qualquer confi-
guração em qualquer parte do
documento final.
Habilidade de se extrair qualquer dado
em qualquer lugar do relatório já rende-
rizado permite a você gerar o relatório
manualmente, inteiro ou em parte, caso
a funcionalidade provida não permitir
resolver uma ou outra questão. É claro,
que você deve fugir de criar relatórios
manualmente, mas isto reserva uma fle-
xibilidade que deixará você confidente
para apresentar os dados de qualquer
forma que você possa precisar.
Então, uma vez que é impossível a ferra-
menta de relatórios ideal, você precisa
de um produto que, de um lado, proveja
muitas características avançadas, mas de
blemas quando sua aplicação está quase
pronta!
Após dias procurando, testando, pen-
sando e brigando, eu encontrei algum
critério em como encontrar a solução de
relatórios correta e me precaver dos mai-
ores riscos potenciais quando uma ferra-
menta de relatórios não prover a necessi-
dade que eu precisar depois:
Bom designe de modelos de re-
latórios.
É uma grande sorte quando uma ferra-
menta de relatórios tem um design que
permite criar a maioria das ferramentas
do dia a dia e rapidamente e intuitiva-
mente relatórios com tarefas específicas.
Mesmo se a funcionalidade da ferramen-
ta de relatórios possa ser estendida, o
design deve prover a funcionalidade pa-
ra dar certeza a resolver todas as suas
tarefas principais. Na outra mão, nenhu-
ma ferramenta de relatórios provê toda a
funcionalidade que você precisa. Sendo
assim, o próximo critério principal é:
Arquitetura aberta a plug-ins.
Arquitetura Open plug-in é vital! Se
você encontrar alguma tarefa que é im-
possível de resolver com as característi-
cas fornecidas, pelo menos, você poderá
programar a funcionalidade requerida
você mesmo.
Habilidade de manipular a fonte
de dados no modelo de relató-
rio.
Habilidade de manipular a fonte de da-
dos diretamente em um modelo de rela-

www.codificando.net
e-magazine
Ago / Set - 2009 | 44444444
ência com você agora.
Primeiro de tudo, o que eu gostei mais
no Report Sharp-Shooter é que ele tem a
arquitetura open plug-in.
Um documento e seus próprios elemen-
tos definem a lógica não apenas da saída
e comportamento no design, mas o mais
importante, eles definem a lógica da ge-
ração do documento. Isto significa que
você pode facilmente estender a funcio-
nalidade da ferramenta redefinindo a
lógica dos elementos providos ou cria-
dos por você mesmo.
Por exemplo, o produto tem um elemen-
to para saída do list footer. Na maioria
dos relatórios, é requerida a saída do fo-
oter não à direita após a list, mas na par-
te de baixo da página onde a lista acaba.
Eu resolvi este assunto de forma muito
simples: Eu criei um novo elemento re-
definindo a lógica do já existente. Aqui,
eu adicionei uma nova propriedade,
GrowToBottom que decide quando a
list footer deve ser colocada na parte de
baixo da página.
Nós redefinimos a lógica da geração des-
te elemento no método Render onde nós
limitamos o espaço livre na página gera-
da para deslocar os elementos que foram
gerados pela classe base na parte inferior
da página:
Public Class AdvancedFooter Inhe-
rits Perpetuum-
Soft.Reporting.DOM.Footer
Private _growToBottom As Boolean
= False
<System.ComponentModel.Category
("Behavior")> _
outro lado, que permita maior extensão
quando e caso você necessite. Sem falar
o quanto é muito melhor quando você
pode programar alguma nova funciona-
lidade você mesmo, na base de uma fer-
ramenta de relatórios do que ter que mu-
dar para um novo componente em plena
corrida!
As ferramentas de relatórios que tem u-
ma Arquitetura de plug-in e suporte pa-
ra scripting são flexíveis o suficiente pa-
ra resolver as tarefas mais complexas.
Arquitetura Open plug-in permite a pro-
gramar a funcionalidade requerida e uso
das novas características em um desen-
volvimento futuro.
Usando scripting, você pode definir con-
figurações do modelo dinamicamente,
cuidar da fonte de dados e até gerenciar
o processo programaticamente, por e-
xemplo, gerar partes separadas de um
documento manualmente.
Após dias de procura e testes em muitas
ferramentas disponíveis no mercado de
software de diferentes vendedores mun-
diais, eu encontrei um produto que fun-
ciona com quase todas as minhas expec-
tativas e requerimentos, Report Sharp-
Shooter é a ferramenta ideal para relató-
rios, ela realmente me surpreendeu com
a flexibilidade que é provida. Eu termi-
nei minha solução de ERP há cinco me-
ses, ela funciona muito bem e os meus
clientes estão bem satisfeitos. Como eu
previ a diversidade de relatórios que eu
tive que desenvolver funcionou como
uma bola de neve, mas eu tenho que ad-
mitir que consegui cuidar de tudo e fico
contente de compartilhar minha experi-

www.codificando.net
e-magazine
Ago / Set - 2009 | 45454545
que eu não preciso mais.
Perpetuum-
Soft.Reporting.DOM.ReportControl.
ControlTypes.Remove(GetType
(Perpetuum-
Soft.Reporting.DOM.Footer))
Perpetuum-
Soft.Reporting.DOM.ReportControl.
ControlTypes.Add(GetType
(CustomControl.AdvancedFooter))
O que me fez fã deste produto é o scrip-
ting que esta ferramenta de relatórios
oferece de suporte.
Você pode usar qualquer linguagem de
programação .NET (VB.NET ou C#) co-
mo uma linguagem de script. Ela permi-
te realizar muitas tarefas economizando
assim muito tempo, uma vez que a mai-
oria das outras ferramentas de relatórios
tem uma linguagem de scripting que de-
ve ser aprendida do início.
Os scripts do Report Sharp-Shooter pro-
vêm acesso completo a todos os elemen-
tos dos relatórios e você pode manipulá-
los programaticamente. Um modelo de
relatório e um relatório mesmo represen-
tam o open object model.
Scripts permitem buscar a Informação
sobre o relatório corrente e influenciá-lo.
Você pode usar quaisquer características
da sua aplicação ou bibliotecas de tercei-
ros com os scripts!
Existe a habilidade de atribuir a expres-
são a cada propriedade e o valor de cada
propriedade será calculado dinamica-
mente.
Quando qualquer relatório for gerado,
um script especial será executado e lá
<System.ComponentModel.DefaultVal
ue(False)> _
<PerpetuumSoft.Framework.Serializ
ation.XSerializable()> _
<PerpetuumSoft.Reporting.DOM.Repo
rtBindable()> _
Public Property GrowToBottom() As
Boolean
Get
Return _growToBottom
End Get
Set(ByVal value As Boolean)
_growToBottom = value
End Set
End Property
Public Overrides Sub Render()
If Me.GrowToBottom Then
MyBase.Prepare()
If (MyBase.Engine.FreeHeight
> MyBase.Size.Height) Then
Engine.UsedHeight =
(Engine.UsedHeight +
(MyBase.Engine.FreeHeight - My-
Base.Size.Height))
End If
End If
MyBase.Render()
End Sub
End Class
Como você pode ver, é muito fácil. Eu
também gostaria de chamar a sua aten-
ção para o comportamento do controle
no design que pode ser definido por atri-
butos padrões tendo o mesmo destino
como do Visual Studio, assim como os
especiais.
Por exemplo, o atributo ReportBindable
notifica que é possível fazer uma cone-
xão com esta propriedade. Isto significa
que a nova propriedade
“GrowToBottom” pode ser atribuída não
somente como uma constante mas como
um valor calculado.
Um novo controle pode ser facilmente
registrado no designer e preliminarmen-
te, eu removo o velho controle, uma vez

www.codificando.net
e-magazine
Ago / Set - 2009 | 46464646
or que $ 20.00.
iif(GetData("Products.UnitPrice") > 20,
"Hightlight", "Normal")
E aqui está!
Mais um exemplo. Eu quero numerar as
páginas com algum grupo de dados.
É claro, tem uma variável para numera-
ção contínua, mas para este caso em par-
ticular, nós podemos tirar vantagem dos
scripts.
Para se fazer isso, eu defino uma variá-
vel comum contendo uma nova página:
private GroupPageCount as integer
Inicio a variável antes da gera-
ção: GroupPageCount = 0;
você poderá fazer todas as configurações
requeridas.
Sendo assim os scripts no Report Sharp-
Shooter trazem a possibilidade de não
somente o ajuste das características pro-
vidas, mas desenvolver novas também!
Agora, eu gostaria de mostrar alguns e-
xemplos para você. Eu usei a linguagem
VB. NET aqui.
Eu vou demonstrar como programar u-
ma funcionalidade com relativa facilida-
de, mas do outro lado, isto poderia ser
praticamente impossível de se fazer sem
scripting. Para ser mais fácil de enten-
der, eu tenho uma data usando a função
GetData (“SourceName.FiledName”)
onde o SourceName é o nome da fonte e
o FieldName é o nome do campo fonte.
Então, por exemplo, eu quero ajustar a apa-
rência dos dados dependendo dos seus valo-
res.
Para se fazer isso nós precisamos dina-
micamente definir o estilo para um ele-
mento que exibe um valor.
Então, nós definimos a seguinte expressão para
a propriedade Style de um elemento de relató-
rio:
iif(<Condition >, "Hightlight", "Normal")
<Condition > - é algum critério na base
da fonte dos dados.
"Hightlight" e "Normal" aqui são nomes
de estilos vindos de uma tabela de esti-
los que eu defini antes.
Então, por exemplo, eu quero destacar
todos os produtos onde o preço for mai-
Figura 1. Design do Report Sharp Shooter
Figura 2. Exemplo pronto selecionando pela cor !

Codificando e-magazine11

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (20)

Semelhante a Codificando e-magazine11

Semelhante a Codificando e-magazine11 (20)

Codificando e-magazine11