Os Microsoft Reports têm um conjunto de funções que permitem personalizar a informação que é colocada nos relatórios. Através do Expression Editor, podemos visualizar diversas funções já incorporadas, disponíveis na categoria Common Functions, e com isto, conseguir formatar, modificar, personalizar a visualização dos dados.
No entanto, é possível também a utilização de código personalizado, de modo a não nos limitamos às funções disponíveis, não obrigando à manipulação dos dados na aplicação/base de dados.
Para utilizar código personalizado no relatório, é necessário ir ás propriedades do relatório (menu Report – Report Properties) e escolher o separador Code.
Na caixa de texto disponível, colocar o código a usar.
Neste exemplo ilustrativo, irá ser utilizada uma função que através de um código de País, irá formatar o valor para o formato correcto (Euros ou Dólares).
Este é o código que está na imagem anterior:
Function currencyFormat(ByVal value As Double, ByVal countryCode As String) As String
Select Case countryCode
Case "PT"
Return String.Format("{0:n} €", value)
Case "US"
Return String.Format("$ {0:n}", value)
Case Else
Return String.Format("{0:n}", value)
End Select
End Function
Se editarmos o relatório com um editor XML ou mesmo com um editor de texto (por exemplo o Notepad), o código personalizado que definimos encontra-se entre as tags <Code> ... </Code>
Para utilizar o código criado, na indicação dos campos a listar, utilizar o Expression Editor, clicando com o botão direito do rato e seleccionando “Expression …”.
Aqui, indica-se =Code.<nome da função> de modo a indicar que estamos a utilizar código personalizado. Neste caso será a seguinte expressão, onde o primeiro campo indicará o valor, e o segundo indicará o código do País.
=Code.currencyFormat(Fields!price.Value,Fields!countryCode.Value)
Pode-se verificar também que o Intellissense não irá reconhecer a nova função, uma vez que não é compilado e não é possível interpretar o código criado. De qualquer maneira, é apenas necessário garantir que a função se encontra correctamente indicada, e os parâmetros bem definidos.
O resultado final é um relatório com diferentes formatos para diferentes códigos de Países
Este foi um exemplo de como utilizar código personalizado nos relatórios e mostrar que, com este método, é possível ter relatórios muito mais flexíveis.
PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!
O armazenamento de imagens em bases de dados, designado por BLOB's(binary large object), é um processo muito comum quando se trabalha com dados. Existem vantagens e desvantagens em guardar as imagens na base de dados, ou apenas o seu caminho ou URL, e se no SQL Server o processo é simples, como podem ver no artigo Inserir Imagens no SQL Server, em outras bases de dados, como o Access, o processo é mais complicado.
O objectivo deste artigo não é enumerar as vantagens e desvantagens de ambos os métodos, mas sim mostrar com se pode mostrar as imagens num relatório em ambos os métodos. Neste caso será mostrado apenas para SQL Server, e deverá ser semelhante para outras bases de dados, excepto Access, uma vez que a imagem é guardada como objecto.
Imagem na base de dados
Caso a imagem esteja guardada na base de dados, é apenas necessário inserir um controlo Image, da Toolbox, no controlo Table.
Depois, e nas propriedades do controlo, definir como Value o campo respectivo da base de dados, a Source como Database e o MIMEType adequado. Neste exemplo será seleccionado image/png.
Caminho na base de dados
Caso na base de dados apenas esteja gravado o caminho para o ficheiro ou URL, pode-se inserir um controlo Image, da Toolbox, no controlo Table, como no exemplo anterior, mas na propriedade Value indica-se: ="File://" & Nome do Campo.
Define-se também a propriedade Source como External.
Finalmente, através de código ou nas propriedade do ReportViewer, é necessário indicar que este permite a utilização de imagens externas, definindo EnableExternalImages como True.
Me.ReportViewer1.LocalReport.EnableExternalImages = True
Como podem nestes dois exemplos, para os dois métodos possível, os relatórios são muito flexíveis e permitem de uma forma bastante simples mostrar as imagens guardadas ou através dos caminhos guardados
PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!
Os Microsoft Reports são ficheiros XML, com uma extensão diferente (*.rdlc), que guardam o esquema do relatório, imagens embebidas, código personalizado, etc. No entanto, e por serem ficheiros fáceis de editar (usando um simples editor XML ou mesmo através do Notepad), podem ser modificados, alterando com isso, e sem ser necessário compilar a aplicação, o resultado pretendido.
Isto trás algumas vantagens e, obviamente, algumas desvantagens.
Se por um lado conseguimos ver o conteúdo do ficheiro e analisar um eventual problema, não colocamos toda a aplicação num só ficheiro e não aumentamos o tamanho do executável, por outro lado, não garantimos a protecção do relatório. Estes são alguns pontos que devem ser considerados na escolha da opção a usar.
Para se utilizar um relatório embebido no executável, é necessário apenas seleccionar o relatório, na janela Soluction Explorer, e definir na propriedade Build Action como Embedded Resource.
Depois, utilizar uma função semelhante à seguinte, para extrair o relatório embebido para uma Stream.
''' <summary>
''' Extrai dos Resources da aplicação, o relatório para uma Stream
'''</summary>
''' <param name="reportName">Nome do relatório</param>
Private Function GetReport(ByVal reportName As String) As IO.Stream
' Recolhe a informação da Assembly
Dim currentAssembly As Reflection.Assembly = _
Reflection.Assembly.GetExecutingAssembly()
' Irá guarda o caminho + nome do ficheiro
Dim resource As String = String.Empty
' Verifica nos Resources se encontra o relatório pretendido
Dim arrResources As String() = _
currentAssembly.GetManifestResourceNames()
For Each resource In arrResources
If resource.Contains(reportName) Then Exit For
Next
' Coloca o relatório embebido na Stream
Dim resourceStream As IO.Stream = _
currentAssembly.GetManifestResourceStream(resource)
Return resourceStream
End Function
Finalmente, definir como nome do relatório, a Stream retornada pela função, através do método LoadReportDefinition().
Dim rptStream As IO.Stream = GetReport("rptProducts.rdlc")
Me.ReportViewer1.LocalReport.LoadReportDefinition(rptStream)
E já está … um método simples, prático, e que poderá proteger os relatório, caso seja pretendido.
PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!
Existem algumas formas de calcular expressões matemáticas, mas na maioria delas, é necessário efectuar uma série de validações, como propriedades distributivas, funções trigonométricas, etc., e a utilização de um grande número de linhas de código.
Uma forma simples de calcular uma expressão matemática, através de uma string, é usando o Microsoft Script Control, um controlo ActiveX normalmente disponível no sistema operativo, e já com alguns anos, mas que ainda pode ajudar bastante na simplificação do código.
Para utilizar este controlo, é apenas necessário adicionar uma referência ao Microsoft Script Control 1.0, no separador COM.
Depois no código é apenas necessário:
Dim ScriptEngine As New MSScriptControl.ScriptControl
ScriptEngine.Language = "VBScript"
Dim expression As String = "(10 + 154) * 300 / (40 - 4)^2"
Dim result As String = ScriptEngine.Eval(expression)
Debug.Writeline(result)
Isto irá mostrar o resultado da expressão, que neste caso é 37,962962962963
Mas podem-se usar expressões mais complexas, com funções trigonométricas incluídas. Como exemplo (expressão sem sentido):
Dim expression As String = "sin(30)*cos(9)/tan(4)*2"
Este controlo permite também efectuar outras operações, como por exemplo:
Dim msg As String = "Msgbox(""Isto é um teste ..."")"
ScriptEngine.ExecuteStatement(msg)
Mas para mais informação sobre elas, deixo aqui este link, entre muitos outros disponíveis: How To Call Functions Using the Script Control
PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!
