MySql y C# Parte I

Bien, una de las grandes funciones que tiene la programación es crear aplicaciones que
almacenen datos en Bases de datos, por esa razón, este apartado está dedicado a explicar
como conectarnos a MySql (Una base de datos Gratuita) desde C# mediante la capa
intermedia de OleDB, la cual es igual para todas las bases de datos del mundo, lo único
que va a cambiar será el conection String que mas adelante explicamos a fondo.

Primero:
Necesitamos instalar la base de datos, para esto, puedes descargar MySql, en su ultima
versión, o mejor dicho la mas resiente o bien descargar el Wamps, que es un
administrador de servicios, que administra el servicio de la Base de Datos MySql, el
servidor Apache y el Php simultáneamente.

Para descargar el Wamps dale clic al siguiente link (Si no funciona Copy/Paste la barra
de navegación) .

También van a necesitar el Driver para conectarse por OledB lo descargan aqui, este
permite conectarnos a la base de datos, existen tres formas posibles (bueno que yo
conozca...)

El Oledb que acabo de mencionar

el ODBC, que es el mas antiguo
El Driver Nativo que es MySql.data que es propio para la base de datos.

Segundo:
Una vez instalado, también necesitamos una interface para conectarnos a la base de
datos y crear nuestras bases de datos y tablas para eso, descargamos el Navicat desde
aqui.

Desde el Navicat creamos una base de datos llamada data_colegio y una tabla de
nombre Alumno, con los siguientes campos

RNE Varchar 15 (Primary Key)

Nombre Varchar 30
Apellido Varchar 30

Si tienes dudas de como usar el Navicat y el Wamps dale clic aqui

Una vez creada esta tabla entramos a C#, creamos un nuevo proyecto de Nombre
cualquiera (en mi caso se llama Garrobito jejeje). y en la forma insertamos los controles
necesarios para capturar los datos (Tres TextBox y tres Label). y un Botón con el
nombre CmdGuardar (o el nombre que se les ocurra) .

Ahora insertamos un archivo de Clase, para esto, clic derecho en el explorador de

objetos, pero nó en el solution y buscamos la opción Agregar (Add) y luego Clase
(Class), le damos como nombre:
Funciones_Globales

Abrimos el archivo (Si es que no se abrió al crearlo) y en la parte de los using

agregamos:
using System.Data;
using System.Data.OleDb;

Luego dentro de la clase, creamos un procedimiento publico de nombre AddAlumno de

la siguiente forma:

public void AddAlumno(string id, string nombre, string apellido)

{
OleDbConnection cn = null;
OleDbTransaction tran = null;

try
{
///Si no se ve bien el texto, copia y pega el contenido en el blog de
notas =)
cn = new OleDbConnection("Provider=MySQLProv; Data
Source=data_colegio; User Id=root;Password=");
string query = "insert into alumno(RNE,NOMBRE, APELLIDO) values
('{0}','{1}','{2}')";
query = string.Format(query, id,nombre,apellido);

cn.Open();
OleDbCommand cmd = new OleDbCommand(query, cn);
cmd.ExecuteNonQuery();
cmd.Dispose();

}
catch (Exception ex)
{
throw ex;
}
finally
{
if (cn != null && cn.State != ConnectionState.Closed)
{
cn.Close();
cn.Dispose();
}
}

Lo salvamos y regresamos al Formulario en el evento clic del botón CmdGuardar

escribimos:

Funciones_Globales Control = new Funciones_Globales();

try
{
Control.AddAlumno(MskRNE.Text, TxtNombre.Text, TxtApellido.Text);
MessageBox.Show("Se almacenaron los registros ");
}
catch (Exception er)
{
MessageBox.Show("Error al guardar los datos ");
}
y listo, en la buena teoría si siguieron todos los pasos debería de funcionar, explicando
un poco el código:

Primera linea:
Funciones_Globales Control = new Funciones_Globales();
Declaramos una variable llama Control, de tipo Funciones_Globales (que es la clase) y
la instanciamos en memoria.

Segunda Linea:
Abrimos el Try

Tercera Linea:
Llamamos el Método AddAlumno y le enviamos los tres argumentos que esta
esperando, en mi caso mis controles son Un MasketEdit y dos textBox (observen los
prefijos), y si todo está bien mostrará el mensaje de Se almacenaron los registros, en el
caso que la función retorne un error el Catch la captura y muestra el mensaje Error al
Guardar los datos

UNIDAD 3: VISUAL C# 2005 ARREGLOS

TEMA 6: LISTBOX

ListBox uno de los nuevos Controls, es un componente DINAMICO (es decir no tiene
tamano definido) que permite procesar visualmente un conjunto de elementos de tipo
string.

La propiedad Rows que se usa al crearlo, es solo para indicarle cuantos renglones
desplegara en pantalla, es decir si se usa rows=5, en listbox se podra capturar todos los
elementos o datos que se quiera pero solo desplegara los ultimos cinco elementos.

Sin embargo existen ciertas propiedades del listbox que permiten conocer cuantos
elementos estan cargados en el listbox.

Otra importante aspecto a recordar cuando se procese o programe, es que el primer

indice de la lista es el indice numero 0(cero).

Este componente, contiene muchas propiedades y metodos que facilitan el trabajo con
datos la mas importante es su propiedad ITEMS, que a su vez tiene:

PROPIEDAD ACCION O SIGNIFICADO

Items.Add(dato): Inserta un elemento al final del listbox.

Items.Clear(): Elimina todos los elementos de la lista.

Items.Count(): Regresa la cantidad de elementos en lista.

Items.Sorted=true; Ordena los elementos de la lista usada solo al tiempo de diseno.

Items.Contains(dato): Regresa true o false, si el dato se encuentra o no se encuentra en
la lista.

Items.IndexOf(dato): Regresa el indice del objeto dentro del listbox.

Items.Insert(indice,dato): Inserta el dato en la posicion indicada.

Items.Remove(dato): Elimina el dato de el listbox.

Items.RemoveAt(indice): Elimina el dato que esta en la posicion indicada.

Items[indice]: get or set el dato en la posicion indicada (ver primera nota abajo).

Notas:

Como ya se indico anteriormente GET y SET son propiedades asociadas a todos los
objetos o controles y sus propiedades de microsoft net, por ejemplo para un textbox, si
en un programa se dice alfa = text5.text; se esta usando get, si se dice text5.text=500; se
esta usando set.

Otro ejemplo alfa=listbox2.Items[2]; se esta usando (get)

listbox2.Items[4]=“mama”; se esta usando (set).

OBSERVAR QUE NO SE USA PROPIEDAD TEXT Y RECORDAR QUE

ENTRAN Y SALEN STRINGS A LISTBOX.

Esto de get-set se puede usar para cualquier propiedad, por ejemplo alfa =
listbox8.background; se esta usando get, pero si se codifica
listbox8.background=amarillol; se esta usando set, como se observa es importante
entender y aplicar este GET-SET en todos los programas.

Capturas: Solo se ocupara un Text, el evento click del button, y el metodo Add del
ListBox.

Proceso: Se ocupara un ciclo for y los metodos count y text de ListBox.Items[indice].

Despliegues: No se ocupa porque todos los cambios son visibles.

Pero si se quiere pasar de un ListBox a otro ListBox, entonces ciclo for, count, etc.

ejemplo prog

private void button1_Click(object sender, EventArgs e)

LISTA1.Items.Add(DATO.Text);

DATO.Text = " ";

}

private void button2_Click(object sender, EventArgs e)

int r, cantidad, dato;

cantidad = LISTA1.Items.Count;

for (r = 0; r <= cantidad - 1; r++)

dato = Int32.Parse(LISTA1.Items[r].ToString());

dato = dato + 100;

LISTA1.Items[r] = dato.ToString();

};

Recordar que el primer indice en un ListBox es el cero por eso el ciclo va desde el cero
hasta la cantidad de elementos menos uno.

Corrida:

COMO ULTIMA NOTA IMPORTANTE ES QUE EXISTEN OTROS DOS

CONTROLES QUE PUEDEN COMPORTARSE Y USAR LOS MISMOS
METODOS ASOCIADOS A LISTBOX, ESTOS CONTROLES SON EL
COMBOBOX Y DATALIST.

TAREAS PROGRAMACION VISUAL C# 2005

1.- CAPTURAR EN UNA LISTA LOS SUELDOS DE 6 EMPLEADOS Y
DESPLEGARLOS EN UNA SEGUNDA LISTA AUMENTADOS EN UN 30%

2.- CAPTURAR EN UNA LISTA LOS PESOS EN KILOGRAMOS DE 6 PERSONAS

DESPLEGARLOS EN UNA SEGUNDA LISTA CONVERTIDOS A LIBRAS Y
ADEMAS SOLO LOS MAYORES DE 100 LIBRAS.

3.- CAPTURAR EN SUS 4 LISTAS RESPECTIVAS MATRICULA, NOMBRE Y

DOS CALIFICACIONES DE 5 ALUMNOS, DESPUES CALCULAR UNA LISTA
DE PROMEDIOS DE CALIFICACIONES.

4.-CAPTURAR EN SUS LISTAS RESPECTIVAS NUMEMPLEADO,

NOMEMPLEADO, DIAS TRABAJADOS Y SUELDO DIARIO DE 5 EMPLEADOS,
DESPLEGAR EN OTRA PANTALLA O PANEL LA NOMINA PERO SOLO DE
AQUELLOS EMPLEADOS QUE GANAN MAS DE $300.00 A LA SEMANA.��

Trabajar con los elementos de un

ListBox
Cosas que debes saber sobre los elementos de
un ListBox
(o cómo simular el ItemData de VB6 y otras
cosillas)
Publicado el 24/Ago/2004
Actualizado el 24/Ago/2004
Autor: Guillermo 'guille' Som

Muchas veces no sabe uno que título darle a un artículo para

indicar el contenido real del mismo, ya que en la mayoría de las
ocasiones ese título será el que "atraiga" a la gente... en esta
ocasión, mi intención es explicarte cómo trabajar con los
elementos que se añaden a un ListBox. Más concretamente cómo
se muestran dichos elementos, es decir, qué es lo que se muestra
cuando añadimos algo a un ListBox y de paso explicarte el
equivalente (o casi) del método ItemData de VB6.

En Visual Basic 6, era habitual que además de añadir una cadena al ListBox
quisiéramos añadir o relacionar también un valor numérico con dicha cadena, en
esa versión de VB usábamos el método ItemData para asociar ese valor numérico,
de forma que cada cadena contenida en el ListBox pudiese tener asociado un valor
numérico (¿cuantas veces lo he repetido?).
Para hacerlo, usábamos un código parecido a este:

With List1
.AddItem "elemento 1"
.ItemData(.NewIndex) = 1
.AddItem "elemento 2"
.ItemData(.NewIndex) = 2
End With
Pero en .NET el control ListBox no tiene un método ItemData (ni una propiedad
NewIndex que indicaba cual era el último índice añadido al ListBox), tampoco se
añaden solamente cadenas, ya que la colección Items lo que acepta son elementos
del tipo Object, por tanto podemos añadir cualquier tipo de datos en esa colección,
no solo cadenas, como ocurría en el control ListBox de VB6.

Lo que se muestra en un ListBox

En VB6, como los elementos eran de tipo String, no había problemas con lo que se
mostraba en el control, ya que lo que se mostraba era precisamente el contenido
de las cadenas que se habían añadido, pero debido a que el tipo de datos que se
agrega a la colección Items de un ListBox de .NET es del tipo Object, el .NET
Framework lo que hace es mostrar lo que devuelva el método ToString de cada
objeto, que añadimos una cadena, se muestra el contenido de la cadena, que
añadimos valores numéricos, se muestra el contenido de esos números, pero...
¿que pasa si añadimos elementos del tipo Cliente? ¿qué se muestra? fácil, lo que
devuelva el método ToString.
El problema es que si no definimos nuestra propia versión del método ToString,
el .NET devuelve el nombre completo de la clase, es decir, el espacio de nombres y
el nombre de la clase, separados por un punto entre cada elemento.
Por tanto, lo que debemos hacer es redefinir el método ToString de nuestras clases,
para que devuelva el valor que nosotros queremos que devuelva; esta es una
recomendación que siempre deberíamos tener en cuenta y que siempre
deberíamos hacer nada más crear nuestras clases... no solo si la vamos a añadir a
un ListBox, ya que ese método ToString se usa bastante por el .NET cuando
queremos obtener una representación en formato String de un objeto.

Simular el ItemData de VB6

Bien, dicho esto, vamos ahora a crear una clase que nos permita "simular" el
comportamiento de ItemData de los listboxes manejados por VB6.
Como podemos comprobar en el código anterior (incluso si nunca has trabajado con
VB6), lo que se hace es añadir una cadena al ListBox y dicha cadena la "asociamos"
con un valor entero. Por tanto, podríamos crear una clase que contenga dos
campos (o propiedades), una para el valor de la cadena y otro para el valor
numérico, por ejemplo:

Class LBItem
Public Contenido As String
Public Valor As Integer
End Class

Es decir, creamos una clase a la que podamos asignar una cadena y un entero.
Vamos a añadirle también un constructor que acepte dos parámetros, uno para
asignar a la cadena y otro para asignar al valor numérico:

Public Sub New(c As String, v As Integer)

Contenido = c
Valor = v
End Sub
De esta forma podríamos añadir elementos a un ListBox de esta forma:

ListBox1.Items.Add(New LBItem("Elemento 1", 1))

ListBox1.Items.Add(New LBItem("Elemento 2", 2))

El problema es que ese ListBox mostraría algo como esto:

Figura 1, Los objetos añadidos al ListBox

Como puedes comprobar, lo que se muestra es el nombre de la clase, no el

contenido que tiene.

Esto es así por lo que te comenté antes: el .NET usa el método ToString para
mostrar el contenido de los elementos de un ListBox, por tanto, deberíamos
redefinir el método ToString de nuestra clase para que muestre el valor adecuado,
en este caso debería mostrarse lo que hayamos asignado a la propiedad (o en este
ejemplo campo público) Contenido.
Para lograrlo, redefinamos el método ToString para que quede de esta forma:

Public Overrides Function ToString() As String

Return Contenido
End Function

Con este cambio, lo que mostrará el ListBox será lo siguiente:

Figura 2, Ahora se muestra correctamente

Como puedes comprobar esta vez se mostrará lo que esperábamos que se

mostrara en el ListBox, y de paso hemos creado una clase que nos puede servir
para "simular" al ItemData de VB6, pero con muchísima más versatilidad, ya el
valor numérico puede ser de cualquier tipo, no solo entero, y ni que decir tiene que
no solo nos limitamos a un valor, sino que podemos añadir a esa clase todo lo que
necesitemos, además sin preocuparnos de que el ListBox contenga demasiados
datos, ya que lo único que se almacena en la colección Items del ListBox son
referencias a los nuevos objetos creados.

Recuperar los elementos del ListBox

Ahora viene la segunda parte, ya que no solo es necesario saber cómo se añaden
los elementos al ListBox, sino que también debemos saber cómo recuperarlos.
Imagínate que al seleccionar un elemento del ListBox quieres mostrar el contenido
en cajas de textos.
En VB6 usaríamos la propiedad List indicándole un índice numérico y así
recuperaríamos el contenido del elemento que se encuentre en dicho índice. Pero
como en .NET lo que se añade es un objeto, debemos hacer una conversión al tipo
de objeto real que contiene:

Private Sub ListBox1_SelectedIndexChanged(ByVal sender As Object,

ByVal e As System.EventArgs) _
Handles
ListBox1.SelectedIndexChanged
Dim lbi As LBItem
lbi = CType(ListBox1.SelectedItem, LBItem)
TextBox1.Text = lbi.Contenido
TextBox2.Text = lbi.Valor.ToString
End Sub

Debido a que el elemento almacenado en la colección Items es de tipo LBItem, al

recuperarlo debemos hacer una conversión (cast), ya que la colección realmente
almacena elementos del tipo Object.

Nota:
Si en lugar de añadir objetos del tipo LBItem hubiésemos añadido,
por ejemplo datos de tipo String, también deberíamos hacer una
conversión de Object a String al recuperar el valor, aunque en el
caso de String es fácil ya que simplemente sería necesario usar el
método ToString de la propiedad SelectedItem, pero si en lugar de
String lo que tenemos son Integer o Double, tendríamos que hacer
la conversión al tipo adecuado.

Bueno, espero que te haya quedado claro lo que quería explicar,

independientemente del título del artículo.

Te lo resumo para que no te queden dudas:

-Añadir elementos a un ListBox
-Qué hacer para que se muestre correctamente el contenido de objetos definidos
por nosotros
-Cómo recuperar los elementos de un LixtBox (particularmente el que está
seleccionado)
-Crear una clase que simule el comportamiento de ItemData de VB6

Como valor añadido, en el código de ejemplo se comprueba si el elemento

seleccionado es del tipo LBItem o no, además de que se añaden elementos de tipos
diferentes para que veas un caso real, el aspecto del formulario en tiempo de
diseño sería el siguiente:
 Figura 3, El formulario de prueba en tiempo de diseño

Espero que te sea de utilidad.

Nos vemos.
Guillermo
P.S.
Aquí abajo tienes el código completo de VB y de C#.
En ese código se hace la comprobación de que el elemento seleccionado sea del
tipo LBItem, en caso contrario se usa el método ToString del Selecteditem.

El código para VB .NET

Public Class Form1
Inherits System.Windows.Forms.Form
' ...

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As

System.EventArgs) _
Handles MyBase.Load
ListBox1.Items.Add(New LBItem("Elemento 1", 1))
ListBox1.Items.Add(New LBItem("Elemento 2", 2))
'
' para trabajar con cadenas
ListBox1.Items.Add("Cadena 1")
ListBox1.Items.Add("Cadena 2")
'
' para trabajar con Integer
ListBox1.Items.Add(125)
ListBox1.Items.Add(250)
End Sub

Private Sub ListBox1_SelectedIndexChanged(ByVal sender As Object,

ByVal e As System.EventArgs) _
 Handles
ListBox1.SelectedIndexChanged
' para que valga para cualquier tipo de datos
Dim o As Object = ListBox1.SelectedItem
'
If TypeOf o Is LBItem Then
Dim lbi As LBItem
lbi = CType(o, LBItem)
TextBox1.Text = lbi.Contenido
TextBox2.Text = lbi.Valor.ToString
Else
TextBox1.Text = ListBox1.SelectedItem.ToString
TextBox2.Text = ""
End If
'
'Dim lbi As LBItem
'lbi = CType(ListBox1.SelectedItem, LBItem)
'TextBox1.Text = lbi.Contenido
'TextBox2.Text = lbi.Valor.ToString
'
' si el contenido es de tipo String
'TextBox1.Text = ListBox1.SelectedItem.ToString
'
' Si el contenido es de tipo Integer
'Dim n As Integer = CInt(ListBox1.SelectedItem)
'TextBox1.Text = n.ToString
'TextBox1.Text = ListBox1.SelectedItem.ToString
End Sub
End Class

Class LBItem
Public Contenido As String
Public Valor As Integer
'
Public Sub New(ByVal c As String, ByVal v As Integer)
Contenido = c
Valor = v
End Sub
'
Public Overrides Function ToString() As String
Return Contenido
End Function
End Class

El código para C#
public class Form1 : System.Windows.Forms.Form
{
//...
//
private void Form1_Load(System.Object sender, System.EventArgs e)
{
ListBox1.Items.Add(new LBItem("Elemento 1", 1));
ListBox1.Items.Add(new LBItem("Elemento 2", 2));
//
// para trabajar con cadenas
ListBox1.Items.Add("Cadena 1");
ListBox1.Items.Add("Cadena 2");
 //
// para trabajar con Integer
ListBox1.Items.Add(125);
ListBox1.Items.Add(250);
}
//
private void ListBox1_SelectedIndexChanged(object sender,
System.EventArgs e)
{
// para que valga para cualquier tipo de datos
object o = ListBox1.SelectedItem;
//
if( o is LBItem )
{
LBItem lbi;
lbi = (LBItem)o;
TextBox1.Text = lbi.Contenido;
TextBox2.Text = lbi.Valor.ToString();
}
else
{
TextBox1.Text = ListBox1.SelectedItem.ToString();
TextBox2.Text = "";
}
//
// LBItem lbi;
// lbi = (LBItem)ListBox1.SelectedItem;
// TextBox1.Text = lbi.Contenido;
// TextBox2.Text = lbi.Valor.ToString();
// //
// // si el contenido es de tipo string;
// TextBox1.Text = ListBox1.SelectedItem.ToString();
// //
// // Si el contenido es de tipo int;
// int n = Convert.ToInt32(ListBox1.SelectedItem);
// TextBox1.Text = n.ToString();
// TextBox1.Text = ListBox1.SelectedItem.ToString();
}
}
//
class LBItem
{
public string Contenido;
public int Valor;
//
public LBItem(string c, int v)
{
Contenido = c;
Valor = v;
}
//
public override string ToString()
{
return Contenido;
}
}
Auto completar en Visual Basic y C# 2005
Publicado el 26/Oct/2006
Actualizado el 13/Abr/2007
Autor: Guillermo 'guille' Som

Ejemplo de cómo usar auto completar en los controles ComboBox y TextBox usando Visual Basic 2005 y C# 2005
(2.0). Y como de costumbre, con código tanto para VB como para C#.

Introducción:

Aquí te muestro un par de ejemplos de cómo usar auto completar (mostrar datos de unos elementos muestras escribes)
tanto en un ComboBox como en un TextBox.

Nota:
Si necesitas dar esta funcionalidad a un ListBox (normalmente acompañado de un TextBox), te sugiero que veas el
artículo sobre este mismo tema para las versiones anteriores de .NET.

En el código de ejemplo hay tres de las ocho formas permitidas, a saber:

1- Usando los elementos de la lista del ComboBox.
2- Usando un array de tipo String con los elementos a usar en auto completar.
3- Usando la lista de direcciones recientes (como las que muestra el Internet Explorer).

La primera, como es obvio, es la que se usa con un ComboBox, las otras dos están aplicadas a cajas de texto.

Para activar la opción de auto completar, debes asignar básicamente dos propiedades:
*AutoCompleteMode en la que indicamos cómo queremos que se muestre lo que se vaya encontrando.
*AutoCompleteSource en la que le indicamos de dónde obtendrá los elementos a usar mientras se escribe.

Si el valor de AutoCompleteSource es CustomSource, entonces debemos asignar los elementos a usar en la

colección AutoCompleteCustomSource.

En este ejemplo los valores de los elementos a usar están en un array de tipo String, pero podían estar en cualquier
otro sitio, e incluso los podríamos añadir uno a uno, por medio del método Add de la colección correspondiente, pero
en lugar de añadir uno a uno, los añadimos todos de golpe con el método AddRange.

Crear el ejemplo

Para crear el ejemplo, (en VB o C#), añade un ComboBox y dos TextBox a un formulario, y en el evento Load del
formulario añade el código mostrado más abajo, que como de costumbre está tanto para Visual Basic como para C#.
Recuerda que este código solo es válido para las versiones 2005 o superiores de Visual Studio, si quieres tener esta
funcionalidad en las versiones anteriores de .NET, debes ver este otro artículo.

Espero que te sea de utilidad.

Nos vemos.
Guillermo

Nota del 13/Abr/07:

Aquí tienes un ejemplo de cómo simular auto completar accediendo a una base de datos.

El código para VB .NET (2005 o superior)

Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load

Dim a() As String = {"Pepe Luis", "Pepe Ruiz", "Juan Francisco", _

"Luisa Lopez", "Lorenzo Llamas", "Lucio Bigote", _
"Juan Fernandez", "Pedro Picapiedra", _
"Luis Gonzalez", "Luna Soleada", _
"Luis Gordillo", "Pedro Picaron"}

' Añadir los elementos al ComboBox y ListBox

' a partir del array usando AddRange

With ComboBox1
.Items.Clear()
.Items.AddRange(a)
.SelectedIndex = 0
End With

' El ListBox no tiene propiedades de auto completar

With ListBox1
.Items.Clear()
.Items.AddRange(a)
.SelectedIndex = 0
End With

' Asignar la búsqueda incremental (auto completar)

With ComboBox1
.AutoCompleteMode = AutoCompleteMode.SuggestAppend
.AutoCompleteSource = AutoCompleteSource.ListItems
End With

' Usar los datos de un array

With TextBox1
.AutoCompleteMode = AutoCompleteMode.SuggestAppend
.AutoCompleteSource = AutoCompleteSource.CustomSource
.AutoCompleteCustomSource.AddRange(a)
 End With

' Usar las direcciones del explorer

With TextBox2
.AutoCompleteMode = AutoCompleteMode.SuggestAppend
.AutoCompleteSource = AutoCompleteSource.RecentlyUsedList
End With

End Sub

El código para C# (2005 o superior)

private void Form1_Load(object sender, EventArgs e)
{
string[] a = { "Pepe Luis", "Pepe Ruiz",
"Juan Francisco", "Luisa Lopez",
"Lorenzo Llamas", "Lucio Bigote",
"Juan Fernandez", "Pedro Picapiedra",
"Luis Gonzalez", "Luna Soleada",
"Luis Gordillo", "Pedro Picaron" };

ComboBox1.Items.Clear();
ComboBox1.Items.AddRange(a);
ComboBox1.SelectedIndex = 0;

// El ListBox no tiene propiedades de auto completar

ListBox1.Items.Clear();
ListBox1.Items.AddRange(a);
ListBox1.SelectedIndex = 0;

// Asignar la búsqueda incremental (auto completar)

ComboBox1.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
ComboBox1.AutoCompleteSource = AutoCompleteSource.ListItems;

// Usar los datos de un array

TextBox1.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
TextBox1.AutoCompleteSource = AutoCompleteSource.CustomSource;
TextBox1.AutoCompleteCustomSource.AddRange(a);

// Usar las direcciones del explorer

TextBox2.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
TextBox2.AutoCompleteSource = AutoCompleteSource.RecentlyUsedList;
}

Espacios de nombres usados en el código de este artículo:

System.Windows.Forms
AutoCompletar TextBox desde base de datos

Hay que tener en cuenta que para utilizar esta opción, debes asignar las siguientes
propiedades:
AutoCompleteMode: que sirve para indicar cómo queremos que se muestren los datos
que encuentra mientras se escribe en el control.
AutoCompleteSource: que sirve para indicarle de dónde se obtendrán los datos que se
usarán mientras se escribe.
En este ejemplo se utiliza AutoCompleteSource asignado a CustomSource debido a
que la fuente de
datos la obtenemos desde una ruta personalizada.

En el evento Load del formulario, se llama a la función AutoCompletar como se

muestra debajo, asignándole el control TextBox.

Elementos de importacion:

Imports System.Data.SqlClient
Private Sub
Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
AutoCompletar(Me.TextBox1)

End Sub

Esta es la función AutoCompletar que se deberá utilizar asignándole el control

TextBox.

Public Function AutoCompletar(ByVal Control As TextBox) As AutoCompleteStringCollection

Dim Coleccion As New AutoCompleteStringCollection

Dim Comando As String

Comando = "SELECT Nombre FROM Clientes ORDER By Nombre"

'Creamos una nueva cadena de coneccion

Using Coneccion As New SqlConnection(My.Settings.Coneccion)

Dim Ejecutar As New SqlClient.SqlCommand(Comando, Coneccion)

'Abrimos la coneccion

Coneccion.Open()
Dim Lector As SqlDataReader = Ejecutar.ExecuteReader()

' Realizamos un Loop mientras se est‚ leyendo.

While
Lector.Read()
Coleccion.AddRange(New String()
{Lector(0)})

End While
'Cerramos el SqlReader
Lector.Close()

'Cerramos la coneccion
Coneccion.Close()

End Using
'Ajustamos el control TextBox o ComboBox para recibir los datos de la siguiente manera.
With Control
.AutoCompleteMode = AutoCompleteMode.Suggest

.AutoCompleteSource = AutoCompleteSource.CustomSource

.AutoCompleteCustomSource = Coleccion

End With
'Devolvemos los datos recuperados de la base de datos
Return
Coleccion

End Function

Autocompletar un TextBox en una Aplicación de Windows.

Autocompletando un TextBox desde una base de datos.
Autocompletar un TextBox en una Aplicación de Visitas:11080

Javier Vera Windows. Fecha

Autocompletando un TextBox desde una base de datos. publicación:2/13/20
11:25:33 PM

Uno de los requerimientos o facilidades más comunes es autocompletar, y en aplicaciones de Windows es

realmente fácil. Primero creamos una aplicación de Windows.
Luego arrastramos un textbox a la form.
Luego asignamos las propiedades AutoCompleteMode y AutoCompleteSource del textbox en
SuggestAppend y CustomSource.

Y luego asignamos el siguiente código.(namespace using System.Data.SqlClient; para conexion.)

//crea conexion.
SqlConnection conection = new SqlConnection(@"Data
Source=JAVIER\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog=dbprueba");
//crea comando.
SqlCommand comand = new SqlCommand("select nombre from Table_1", conection);
//abre conexion.
conection.Open();
//executa comando
SqlDataReader reader = comand.ExecuteReader();
//mientras se lea
while (reader.Read())
{
//agrege campo a la fuente de strings
this.textBox1.AutoCompleteCustomSource.Add(reader[0].ToString());
}
//cierra reader
reader.Close();
//cierra conexion.
conection.Close();