Autonumérico o no se que...

Hola Super.

El campo autonumérico es entero y va desde 1 en adelante salvo que indiques
una cantidad numérica de inicio distinta.

Si lo que quieres es un campo de tipo 0001, 0002, ...,9999, entonces deberás
crear un campo varchar por ejemplo varchar(4) y mantener tú este campo.

Un sugerencia es crear un id autonumérico y en base a ese valor, construir
el otro.
Es decir, si añades un registro y éste es el 19, (ID), entonces en ese
otro campo poner 00+ID = 0019.

Un saludo.

Jorge Serrano Pérez
Microsoft MVP VB.NET
PortalVB.com
http://www.portalvb.com/
Weblog de Jorge Serrano
http://weblogs.golemproject.com/jorge/


"Super" wrote:

Hola necesito hacer lo siguiente y no me imagino como

tengo en mi tabla un campo Id autonumérico, pero necesito además uno que no
sea 1, 2, 3, etc, si no 0001, 0002 ,0023,... y así sucesivamente.

como hago esto

Hola Super:

Además de lo que te dice Jorge, también puedes disponer de un campo
autonumérico normal y corriente, y a la hora de mostrar el valor,
formatearlo para que te muestre los ceros a la izquierda. Por ejemplo,

Dim i As Integer = 26
Dim s As String

s = Microsoft.VisualBasic.Format(i, "0000")
MessageBox.Show(s)

Un saludo,


Patxi Sanz
patxisanz[ARROBA]yahoo[PUNTO]es
Tudela (NA)

"Patxi Sanz" <patxisanz[ARROBA]yahoo[PUNTO]es> escribió en el mensaje
news:

Hola Super:

Además de lo que te dice Jorge, también puedes disponer de un campo
autonumérico normal y corriente, y a la hora de mostrar el valor,
formatearlo para que te muestre los ceros a la izquierda. Por ejemplo,

Dim i As Integer = 26
Dim s As String

s = Microsoft.VisualBasic.Format(i, "0000")
MessageBox.Show(s)

Hola, Patxi:

No es por corregirte, pero la mayoria de las funciones del espacio de
nombres Microsoft.VisualBasic son "envoltorios" para funciones propias de
las clases de la FCL.

Es mas eficiente (y mas "Net") escribir

s = i.ToString("0000")

Cuando llamas a Format, el runtime debe "descubrir" el tipo de dato que
recibe como primer argumento, para luego llamar "encajonar" (box) el valor
en un objeto del tipo adecuado y finalmente llamar a la funcion ToString
correspondiente (algo parecido a lo que hacia VB6 cuando se usaba late
binding). Si llamas a i.ToString, e «i» es un simbolo declarado con su
correspondiente tipo en la fuente, te ahorras una llamada (a Format), y el
codigo de descubrimiento del tipo.

Salud!

"Carlos Gómez" escribió en el mensaje
news:OEs33%

Es mas eficiente (y mas "Net") escribir

s = i.ToString("0000")

No se si será más eficiente (y más "Net"), pero de esta forma es más
claro:

s = String.Format("{0:0000}",i)
aunque eso sí, la sintáxis es algo rara

Hola:

Entiendo que la "claridad" es un concepto relativo.

Pero un criterio "cuantitativo" para medir la claridad, podria ser la
cantidad de elementos necesarios para definir un concepto (o intencion, en
este caso): dadas dos maneras de decir lo mismo, normalmente sera mas clara
la que tenga menos palabras.

i.ToString("0000")

usa un objeto y un metodo (ToString) con un argumento.

Mientras que

String.Format("{0:0000}", i)

usa una referencia estatica a una clase (String), un metodo (Format) y dos
argumentos (la especificacion de salida y el argumento). String.Format tiene
una definicion en la cual se le pasa una cadena con los marcadores de los
lugares donde debera insertar cada uno de los argumentos que se le pasaran a
continuacion. El prototipo es

Format(Formato As String, ParamArray args())

el uso {0:0000} indica que se tomara el primer argumento y se le asignara el
formato ("0000").

Si escribes String.Format("{0} " & vbCrLf & "Precio: {1:c}", descripcion,
precio) obtendras una linea parecida a:

Calzoncillos de algodón "Ovejita"
Bs. 13.650,00

(o algo por el estilo, dependiendo del producto, el precio y tu
configuracion regional).

Cuando hay demasiadas maneras de hacer la misma cosa, es bueno
estandarizarse. Y dos buenos criterios para la estandarizacion son la
simplicidad y la eficacia.

Si una objetivo puede lograrse de dos maneras, y una es mas corta que la
otra, es mejor.

Cuando llamas a String.Format el proceso es parecido al que se ejecuta
cuando llamas a Microsoft.VisualBasic.Format: se analiza un string de
formato que determina cuales son los argumentos que le siguen, se toma cada
argumento, se determina su tipo, se determina si el tipo es compatible con
la especioficacion de formato y se agrega al string de salida. Eso no es ni
mas simple ni mas eficiente que el proceso descrito para num.ToString. Me
gusta usar String.Format para armar mensajes completos. Pero prefiero
num.ToString para representar dierctamente un numero.

Entiendo que te parece mas claro. Pero creo que hay criterios objetivos que
desmienten esa apreciacion.

Salud!

Es mas eficiente (y mas "Net") escribir

s = i.ToString("0000")

No se si será más eficiente (y más "Net"), pero de esta forma es más claro:

s = String.Format("{0:0000}",i)
aunque eso sí, la sintáxis es algo rara