Converter Texto para ProperCase
Quando se inserem registos em bases
de dados é necessário ter algum cuidado como a informação se encontra e o que se
grava. Muitos utilizadores finais, quer por falta de conhecimentos informáticos,
quer por falta de cuidado, não regista a informação correctamente sendo pois muito
usual encontrar registos (como nome próprios, moradas, etc) escritos a maiúsculas
ou sem elas.
Os exemplos de “JORGE PAULINO” ou
“jorge paulino” são por isso normais em muitos casos, e a existência de diversos
registos com diversos formatos também. A solução de alguns programadores passa por
converter tudo para maiúsculas, mas não é sem dúvida uma solução agradável.
Para prevenir isso pode-se utilizar
uma pequena função que converte o texto para o chamado
ProperCase, ou seja, a primeira letra de cada palavra a maiúsculas e as
restantes a minúsculas. Para isso usamos a instrução
StrConv() que permite efectuar a conversão para um formato definido. Como a conversão
para ProperCase converte todas as palavras na frase, e existem algumas que se devem
evitar (como é o caso de "e", "da", "do", "dos", "das" e outras variações), pode-se
usar esta função que corrige este “problema”:
'''
<summary>
'''
Converte o nome para ProperCase e coloca algumas palavras
'''
(menor ou igual a 3 caracteres) em minúsculas. Isto para evitar
''' as palavras: "e", "da", "do", "dos", "das"
e outras variações.
''' </summary>
''' <param name="str">Nome
a converter</param>
Private
Function ProperCase(ByVal str
As String) As
String
Try
' Separa o nome convertido(através do StrConv) para uma variável
Dim strSplit() As String = StrConv(str,
VbStrConv.ProperCase).Split(" "c)
Dim result
As String = String.Empty
' Faz um ciclo em todas as palavras encontradas
For x
As Byte = 0 To
strSplit.Length - 1
' Caso a dimenção seja igual
ou inferior a 3 converte
' para minúsculas. Caso contrário
apenas contrói o resultado
If strSplit(x).Length <= 3 Then
result
&= strSplit(x).ToLower + Space(1)
Else
result
&= strSplit(x) + Space(1)
End If
Next
' Retorna o nome convertido
Return
result
Catch ex As Exception
' Em caso de erro retorna o texto em branco
Return
String.Empty
End
Try
End Function
Depois a utilização da função, por
exemplo, no evento Click de um botão:
Private
Sub Button1_Click(ByVal sender
As System.Object, ByVal e
As System.EventArgs) Handles
Button1.Click
' Nome a converter
Dim strNomeCompleto As
String = "antonio josé
da silva oliveira"
‘ Mostra o resultado após conversão
Debug.WriteLine(ProperCase(strNomeCompleto))
End
Sub
DataGridView e ContextMenu
Na DataGridView
não é possível normalmente, e sem utilizar qualquer código, seleccionar uma célula
utilizando o botão direito do rato – o que é incomodo principalmente quando se mostrar
um menu. Ou seja o que é necessário é seleccionar a célula com o botão do lado esquerdo do rato
e depois mostrar o menu com o botão do lado direito do rato.
Como isto não é
prático nem funcional, podemos ultrapassar isto utilizando este código:
'
Executa quando algum item(ToolStripMenuItem) é seleccionado
Sub tsMenu_Click(ByVal
sender As System.Object,
ByVal e As System.EventArgs)
' Mostra a informação com o
texto do ToolStripMenuItem
Debug.WriteLine(CType(sender,
ToolStripMenuItem).Text)
End Sub
' No evento MouseDown da DataGridView
Private
Sub DataGridView1_MouseDown(ByVal sender
As Object, ByVal e As System.Windows.Forms.MouseEventArgs)
Handles DataGridView1.MouseDown
' Verifica se o botão usado
é o direito
If
e.Button = Windows.Forms.MouseButtons.Right Then
' Verifica onde foi clicado com o ponteiro do rato
Dim hti
As DataGridView.HitTestInfo = DataGridView1.HitTest(e.X, e.Y)
' Caso tenha sido clicado numa célula e existam linhas
If hti.Type = DataGridViewHitTestType.Cell
And hti.RowIndex >= 0
Then
' Selecciona a célula onde
se efectuou o clique
DataGridView1.CurrentCell = DataGridView1(hti.ColumnIndex,
hti.RowIndex)
'
Caso não seja uma célula em branco (nova linha)
If Not DataGridView1.CurrentCell.Value
Is System.DBNull.Value Then
' Cria um novo ContextMenuStrip
(texto, separador, texto), sem imagens,
' e define que ao se clicar
num item corre o Sub "tsMenu_Click"
Dim menustrip As
New ContextMenuStrip
menustrip.Items.Add("VBTuga Blog",
Nothing, AddressOf
tsMenu_Click)
menustrip.Items.Add("-")
menustrip.Items.Add(DataGridView1.CurrentCell.Value, Nothing, AddressOf
tsMenu_Click)
' Mostra o ContextMenuStrip onde foi clicado com o rato
menustrip.Show(Me.DataGridView1, New
Point(e.X, e.Y))
End If
End
If
End
If
End Sub
PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!
A utilização de menus permite navegar
nas diversas opções de uma aplicação de uma forma organizada. É normal que as aplicações
utilizem menus e, quando assim se justifique, menus de atalho. Estes menus (popupmenu)
são normalmente específicos para um determinado objecto e resultam do clicar com
o botão direito do rato (botão de opções).
Além de mais específicos estão próximos
do(s) objecto(s) e utilizam muitas vezes opções personalizadas. Para isso é necessário
criá-los dinamicamente, ou seja, criar o menu através de código no decorrer do programa.
Por exemplo, ao seleccionarmos um item de uma lista podemos queres associar ao menu
o texto dele.
A criação de um menu através do “Menu Editor” e chama-lo através da instrução
PopupMenu limita-nos ao itens predefinidos.
Para a criação de menus dinamicamente pode-se utilizar alguns dos API’s disponíveis
e tornar estes versáteis e mais próximos das necessidades do utilizador.
Vamos ver um exemplo simples da criação
de menus e sub-menus utilizando API’s:
Option Explicit
' Declaração das funções
API's
' Cria um novo menu
vazio
Private Declare Function
CreatePopupMenu Lib "user32" ()
As Long
' Elimina um específico
menu, libertando a memória usada por ele
Private Declare Function
DestroyMenu Lib "user32" (ByVal
hMenu As Long) As Long
' Adiciona um novo item
a um menu existente
Private Declare Function
AppendMenu Lib "user32"
Alias "AppendMenuA" (ByVal hMenu
As Long, ByVal
wFlags As Long, ByVal
wIDNewItem As Long, ByVal
lpNewItem As Any) As Long
' Permite verificar
qual o menu que foi seleccionado
Private Declare Function
TrackPopupMenu Lib "user32" (ByVal
hMenu As Long, ByVal
wFlags As Long, ByVal
X As Long, ByVal
Y As Long, ByVal
nReserved As Long, ByVal
hwnd As Long, lprc As Any)
As Long
' Verifica a posição
do cursor no ecrã
Private Declare Function
GetCursorPos Lib "user32" (lpPoint
As PointAPI) As Long
' Declaração das constantes.
Estas constantes não estão todas usadas
' mas são as disponíveis
para a utilização de menus dinâmicos
Private Const MF_INSERT As Long =
&H0&
Private Const MF_CHANGE As Long =
&H80&
Private Const MF_APPEND As Long =
&H100&
Private Const MF_DELETE As Long =
&H200&
Private Const MF_REMOVE As Long =
&H1000&
Private Const MF_BYCOMMAND As Long
= &H0&
Private Const MF_BYPOSITION As Long
= &H400&
Private Const MF_SEPARATOR As Long
= &H800&
Private Const MF_ENABLED As Long =
&H0&
Private Const MF_GRAYED As Long =
&H1&
Private Const MF_DISABLED As Long
= &H2&
Private Const MF_UNCHECKED As Long
= &H0&
Private Const MF_CHECKED As Long =
&H8&
Private Const MF_USECHECKBITMAPS As Long
= &H200&
Private Const MF_STRING As Long =
&H0&
Private Const MF_BITMAP As Long =
&H4&
Private Const MF_OWNERDRAW As Long
= &H100&
Private Const MF_POPUP As Long = &H10&
Private Const MF_MENUBARBREAK As Long
= &H20&
Private Const MF_MENUBREAK As Long
= &H40&
Private Const MF_UNHILITE As Long
= &H0&
Private Const MF_HILITE As Long =
&H80&
Private Const MF_SYSMENU As Long =
&H2000&
Private Const MF_HELP As Long = &H4000&
Private Const MF_MOUSESELECT As Long
= &H8000&
Private Const TPM_RETURNCMD As Long
= &H100&
' Tipo para a posição
do rato no ecrã
Private Type PointAPI
X As
Long
Y As
Long
End Type
Private
menu As Long
Private submenu As Long
' No evento MouseDown
do Form cria o menu
Private Sub Form_MouseDown(Button As Integer,
Shift As Integer, X As Single,
Y As Single)
Dim
cursor As PointAPI
Dim result
As Long
' Caso tenha sido usado o botão direito do rato
If Button = vbRightButton Then
' Cria o sub
popup menu
submenu = CreatePopupMenu()
Call AppendMenu(submenu, MF_STRING, 10, "Sub-Menu 1")
Call AppendMenu(submenu, MF_STRING, 11, "Sub-Menu 2")
' Cria o popup menu
menu = CreatePopupMenu()
Call AppendMenu(menu, MF_STRING, 1, "Menu
1")
Call AppendMenu(menu, MF_GRAYED, 2, "Menu 2")
Call AppendMenu(menu, MF_SEPARATOR, 3, "")
' Insere o sub-menu no menu
Call AppendMenu(menu, MF_POPUP, submenu,
"Menu 3")
Call AppendMenu(menu, MF_CHECKED, 4, "Menu 4")
' Recolhe a informação do cursor do rato
Call GetCursorPos(cursor)
' Verifica o resultado seleccionado de acordo
com o índice
result = TrackPopupMenu(menu, TPM_RETURNCMD, cursor.X,
cursor.Y, 0, Me.hwnd, 0)
' De acordo com o resultado (escolha) executa
algo. Neste
'
caso mostra apenas na janela “Immediate”
Select Case result
Case 1
Debug.Print
"Menu 1"
Case 2
Debug.Print
"Menu 2"
Case 4
Debug.Print
"Menu 4"
Case 10
Debug.Print
"Sub-Menu 1"
Case 11
Debug.Print
"Sub-Menu 2"
End Select
End If
End Sub
‘ No evento Unload do
Form limpa os menus
Private Sub Form_Unload(Cancel As Integer)
' Limpa os menus criados da memória
Call DestroyMenu(menu)
Call
DestroyMenu(submenu)
End Sub
Este exemplo pretende mostrar a simplicidade
e utilidade deste menus e como melhorar as aplicações com a adição destes. Este
código poderá ser adaptado e colocado num módulo ou classe para ser reutilizado
na aplicação.
PS: Como sempre, qualquer dúvida,
comentário ou correcção ao artigo é sempre bem vinda!
O controlo DataGridView é um dos controlos mais versáteis, sendo também simples de utilizar, para mostrar informação com base em uma fonte de dados. Possui alguns wizards possibilitando de uma forma simples, ligar a uma base de dados, gerando automaticamente as colunas e linhas.
No entanto, é possível colocar os dados na DataGridView com poucas linhas de código, permitindo-nos mais versatilidade na utilização deste controlo. Mas para além das inúmeras propriedades que este controlo possui, existem algumas tarefas em que o código é obrigatório para que se obtenha o efeito desejado.
O objectivo deste artigo é mostrar como colocar informação numa DataGridView, podendo-se alterar os dados (modificar, apagar e inserir) e efectuar algumas personalizações e operação.
Para começar é necessário criar uma tabela e definir um dos campos com chave primária. Só assim a DataGridView saberá qual é o campo que vai modificar na base de dados. Neste caso será utilizado o SQL Server mas o exemplo também se aplica ao Microsoft Access, alterando apenas para as suas classes.
Imports System.Data.SqlClient
' Declaração de variáveis privadas
Private da As SqlDataAdapter
Private ds As DataSet
' No Form Load vamos colocar a informação para actualizar a DataGridView
Private Sub DataGridViewExample_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
' Texto de ligação à base de dados
Dim myConnectionString As String = _
"Data Source=.\SQLEXPRESS;AttachDbFilename='C:\myDatabase.mdf';" & _
"Integrated Security=True;User Instance=True"
' Cria uma nova ligação à base de dados
Dim connection As New SqlConnection(myConnectionString)
' Cria um novo SqlDataAdapter que servirá para actualizar o DataSet
Dim SQL As String = "SELECT * FROM myTable"
da = New SqlDataAdapter(SQL, connection)
' Cria um DataSet, ou seja, uma representação em memória da informação
ds = New DataSet
' Coloca a informação da tabela definida no DataSet
da.Fill(ds, "myTable")
' Define que a fonte de dados da DataGridView é a nossa DataSet
' criando automáticamente as colunas e linhas de dados
Me.DataGridView1.DataSource = ds.Tables("myTable")
' Limpa a ligação à base de dados. Não é necessário fechar a ligação
' porque esta não foi aberta através do comando .Open()
connection = Nothing
End Sub
Neste momento a DataGridView já tem dados. Para gravarmos as alterações que efectuarmos, como apagar, modificar e inserir, só necessitamos de efectuar o seguinte (num botão por exemplo):
Private Sub btnGravar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnGravar.Click
' Cria automaticamente o comando para permite actualizar a DataSet
Dim cb As New SqlCommandBuilder(da)
' Actualiza na DataSet, e por sua vez na tabela, as alterações efectuadas
da.Update(ds, "myTable")
End Sub
E já está! Ou seja, como muito pouco código consegue-se colocar informação na DataGridView e actualizar a informação na base de dados.
Mas vamos agora fazer algumas personalizações, como exemplo, das muitas que são possíveis:
Colorir linhas e alterar a Font através de uma pesquisa
Este pequeno exemplo pretende colorir as linhas e alterar a Font onde existe a palavra “Lisboa”. Pode-se também alterar outras propriedades nas linhas da DataGridView
' Inicia um ciclo em todas as linhas
For Each row As DataGridViewRow In Me.DataGridView1.Rows
' Caso não seja um nova linha (a última)
If Not row.IsNewRow Then
' Inicia um ciclo em todas as células/colunas da linha actual
For Each cell As DataGridViewCell In row.Cells
' Verifica se a célula, após convertida para maiúscula, tem a palavra
' "LISBOA" e caso seja verdadeiro coloca a cor de fundo, nova Font
‘ e salta para a próxima
If cell.Value.ToString.ToUpper.Contains("LISBOA") Then
With Me.DataGridView1.Rows(row.Index).DefaultCellStyle
.BackColor = Color.SpringGreen
.Font = New Font("Verdana", 12)
End With
Exit For
End If
Next ' Fim do ciclo nas colunas
End If
Next ' Fim do ciclo nas linhas
Alterar alinhamento de texto nas colunas
Este pequeno exemplo pretende alterar o alinhamento do texto nas células e header (cabeçalho) da coluna 1
' Alterações na coluna 1
With Me.DataGridView1.Columns(1)
' Altera o alinhamento das células para o centro
.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter
' Altera o alinhamento da header para o centro
.HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter
End With
Seleccionar uma linha de acordo com um número (ID)
Este pequeno exemplo pretende seleccionar uma linha de acordo com um número (ID) utilizando uma função auxiliar que identifica a posição ou índice na DataGridView
' Função que pesquisa na coluna 0 por um id e devolve a posição na lista
Private Function getDataGridViewIndex(ByVal id As Integer) As Integer
For Each row As DataGridViewRow In Me.DataGridView1.Rows
If Not row.IsNewRow Then
If row.Cells(0).Value = id Then
Return row.Index
End If
End If
Next
Return 0
End Function
E a utilização:
Dim result As Integer = getDataGridViewIndex(10)
With Me.DataGridView1
' Define que a selecção será efectuada na linha toda
.SelectionMode = DataGridViewSelectionMode.FullRowSelect
' Define que a célula/linha actual é a da pesquisa
.CurrentCell = DataGridView1.Rows(result).Cells(0)
' Define que a primeira linha a aparecer visível no topo da
' DataGridView é a encontrada (caso a lista seja grande)
.FirstDisplayedScrollingRowIndex = result
End With
Em suma, o controlo DataGridView é bastante simples de utilizar e permite diversas personalizações o que facilita bastante o programador/utilizador. É o controlo ideal para visualizar e alterar informação na base de dados sobre a forma de grelha.
PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!
Esta é a segunda parte de um artigo que pretende mostrar como se executam algumas tarefas simples de gestão de dados em SQL. A primeira parte foi dedicada a comandos de inserção, actualização e eliminação de dados e esta segunda parte será dedicada a selecção de dados e à execução de operações que retornam apenas um valor (ExecuteReader e ExecuteScalar).
SELECÇÃO DE DADOS
A selecção de dados é a execução de um comando que retorna os registos da selecção efectuada através de linhas (rows). É quando existe a necessidade de aceder ao servidor para mostrar os dados inseridos, quer em lista, em caixas de texto, impressão, etc.
Esta selecção tem uma estrutura bastante semelhante às anteriormente mostradas , existindo pequenas alterações.
Imports System.Data.SqlClient
' Texto de ligação à base de dados
Dim myConnectionString As String = _
"Data Source=.\SQLEXPRESS;AttachDbFilename='C:\myDatabase.mdf';" & _
";Integrated Security=True;User Instance=True"
' Selecção à tabela "MyTable" em que o campo "username"
' será passado através de parâmetros posteriormente
Dim SQL As String = "SELECT * FROM myTable WHERE [username] = @username"
' Cria uma nova ligação à base de dados
Dim connection As New SqlConnection(myConnectionString)
' Criação do comando indicando a instrução e a ligação
Dim command As New SqlCommand(SQL, connection)
' Indicação dos parâmetros da selecção
command.Parameters.Add("@username", SqlDbType.VarChar).Value = "jpaulino"
' Abre a ligação
connection.Open()
' Executa o comando colocando num SqlDataReader os resultados
Dim reader As SqlDataReader = command.ExecuteReader()
' Caso existam rows (linhas)
If reader.HasRows Then
' Executa um ciclo nas linhas existentes mostrando o campo “username”
While reader.Read()
Debug.WriteLine(reader.Item("username"))
End While
End If
' Fecha a ligação e limpa as variáveis
connection.Close()
connection = Nothing
command = Nothing
Este exemplo mostra apenas como visualizar um campo (“username”) mas o importante é a instrução de selecção que poderá ser muito mais complexa, usando agrupamentos, somatórios, mais campos de selecção, etc.
SELECCIONAR UM RESULTADO APENAS
O método ExecuteScalar executa uma selecção e retorna a primeira coluna da primeira linha. É mais rápido na execução do que o ExecuteReader e é utilizado para seleccionar um resultado apenas, com por exemplo, apenas um campo de um registo, o total de registos inseridos, o ultimo ID inserido, etc.
Imports System.Data.SqlClient
' Texto de ligação à base de dados
Dim myConnectionString As String = _
"Data Source=.\SQLEXPRESS;AttachDbFilename='C:\myDatabase.mdf';" & _
";Integrated Security=True;User Instance=True"
' Selecciona da tabela "MyTable" o máximo/último ID (identificador único)
Dim SQL As String = " SELECT MAX(ID) FROM myTable"
' Cria uma nova ligação à base de dados
Dim connection As New SqlConnection(myConnectionString)
' Criação do comando indicando a instrução e a ligação
Dim command As New SqlCommand(SQL, connection)
' Abre a ligação
connection.Open()
‘ Executa o comando e guarda em “total” o último registo
Dim total As Integer = command.ExecuteScalar()
Debug.WriteLine("Último registo inserido = " + total.ToString)
' Fecha a ligação e limpa as variáveis
connection.Close()
connection = Nothing
command = Nothing
Essencialmente estes são os comandos mais utilizados e os métodos mais práticos para a gestão de dados num servidor SQL.
PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!
