Newsgroup: it.comp.programmare.win32
Titolo: seriale univoco

Secondo voi qual'è il modo migliore per ottenere una serie di seriali
del tipo adfg1-12kkk-003as-1mia91-asdkc o qualcosa di simile che siano
univoci?
Io avevo pensato a un qualcosa che utilizzasse nell'algoritmo come
chiave la data, l'ora, minuti, secondi, e centesimi, in modo da essere
sicuro di passare una chiave univoca, ma come faccio dalla chiave a poi
ottenere il seriale?
Grazie

 univoci?
guid ?
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemguidclasstopic.asp

non mi è molto chiaro quello che intendi e neanche il link che mi hai
segnalato....forse mi sono espresso male io...

 segnalato....forse mi sono espresso male io...
1. HRESULT CoCreateGuid(GUID * pguid);
2. WINOLEAPI StringFromCLSID(REFCLSID rclsid,LPOLESTR * ppsz);
ed ottieni una cosa tipo f5078f33-c551-11d3-89b9-0000f81fe221, garantita 
l'unicita
ciao

Ok, ti ringrazio per la risposta.Ma io volevo un seriale formato da 4 o
5 gruppi di 5 cifre alfanumerico, nel modo che mi proponi tu ho troppe
cifre e la lunghezza non mi sembra sia sempre la stessa.Servirebbe tipo
seriale dei cd di installazione abcde-abcde-abces-asdfg.

snap_ml ha scritto:

le guid erano una scorciatoia, se il formato non si adatta alle tue 
esigenze mi sa che dovrai implementare tutto da capo :-(
su questo non so aiutarti, spiacente
p.s.
comunque la lunghezza dei guid è fissa, guardati la documentazione su 
msdn per saperne di piu

Infatti sono 32 caratteri e per me sono veramente tanti.
Nella documentazione non c'è nulla per farne una stringa di lunghezza
diversa.Stavo pensando di prendere i primi 25 caratteri, ma non sono
sicuro che così riesco a mantenere l'univocità.Ho fatto una prova di
1000 richieste prendendo solo i primi 25 caratteri e non ho trovato
duplicati.Non so se fidarmi, anche perchè dovrebbero essere la chiave
di un db e quindi non possono esserci duplicati.Che ne pensi?
grazie

 di un db e quindi non possono esserci duplicati.
Ed usare un banalissmo contatore?
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

snap_ml wrote:

Se ti serve sostanzialmente una serie di numeri a caso senza particolari 
proprietà matematiche a parte l'univocità puoi fare una cosa di questo tipo:
1) Prendi l'ora: 17.18.37
2) Crei il numero decimale formato da secondi*10000+minuti*100+ora: 371837
3) Converti in base 35: 8NIC
4) Generi tanti altri caratteri a caso: adfg1-12kkk-08NIC-1mia91-asdkc
Fine. Ottieni almeno un numero diverso al secondo. Le probabilità che 
qualcuno generi un seriale alla stessa ora e allo stesso secondo è piuttosto 
bassa, che poi il generatore di numeri casuali dia la stessa combinazione 
proprio in quel momento...
Non farci però nulla che valga più di 5 euro con questo seriale... :-)
-- 
/* Costantino Grana                                */
main(int c,char**o){char*s=c?"+L7?+;:7?+:OKIK+9?;9=;"
":+9?;:<:;+9?;;;:;+9<:;<::;+RLJ;K9+":1[o],t,a=!c,m;do
for (m=*s-'0',t=a?m/c:m%c;m>>7?c=1<<m+8,!a&&puts(&a)*
*&a:t--;printf("  \0/*"+a));while ((a^=3)||a[++s]);;}
/* Original code due to Chris Brown... impressive! */

> 3) Converti in base 35: 8NIC
Tutto molto valido, ma da ... anni di esperienza a litigare con clienti 
ottusi propongo un suggerimento:
evitare i simboli 1I, 8B, GC6, 0OQ (che sono molto simili tra loro ed è 
facile sbagliarsi) e magari anche YJ (perchè molti non distinguono UIPSILON 
e la GEI .... o I lunga dir si voglia) ... he he he ;-) 

 Infatti sono 32 caratteri e per me sono veramente tanti.
Solo perchè è convertito in hex. I guid sono numeri da 128 bit che sono 
anche ampiamente usati come chiavi primarie nei db.
La rappresentazione che gli dai sta solo a te. Per esempio se invece di 
usare una base 16 usi una base 36 (A-Z + 0-9) o forse meglio meno per 
evitare collisioni tra 0 e O, la rappresentazione del guid si collassa.
-- 
Raffaele Rialdi
Microsoft .NET MVP 
http://mvp.support.microsoft.com
 -
http://italy.mvps.org
 UGIdotNET - User Group Italiano .NET
http://www.ugidotnet.org
 Weblog: 
http://blogs.ugidotnet.org/raffaele

 UIPSILON e la GEI .... o I lunga dir si voglia) ... he he he ;-)
ROTFL
(comunque verissimo)


e la GEI .... o I lunga dir si voglia) ... he he he ;-) 
2Z, 5S, 6b, 9g, UV, ... alla fine si scopre che di seriali BUONI
ce ne sono meno di 10.   ;D

 ce ne sono meno di 10.   ;D
Lettere maiuscole/minuscole nello stesso seriale? Ma allora vogliamo farci 
proprio del male :-O !!!

 proprio in quel momento...
il generatore di numeri casuali funziona in base all'ora, quindi se
qualcuno genera lo stesso seriale alla stessa ora-minuto-secondo e anche
allo stesso MILLISECONDO (difficile in effetti ^^) allora il seriale sarà
lo stesso, a patto naturalmente che il generatore usi lo stesso
algoritmo... :PPP
come probabilità è molto difficile, ma il problema è che se quel qualcuno
scopre che un pezzo del seriale corrispondeva all'ora e analizza
l'algoritmo del tuo generatore di numeri casuali, può ricostruire l'intero
seriale.
ma si fa molto prima a NOPpare qualche JMP e far credere al programma che
il seriale sia corretto :D
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

> Non farci però nulla che valga più di 5 euro con questo seriale... :-)
Perché è la prima boiata che mi è venuta in mente!


 obbligatorio usare sempre srand(time(NULL)) :-)
l'unico fattore veramente random in un computer č il tempo, o piů
precisamente il momento in cui l'utente fa determinate cose (come avviare
il programma per generare i seriali); l'unico fattore random insomma siamo
noi :D
se non inizializzi con srand(time(NULL)), tutte le volte che avvii il
programma per generare i seriali, i seriali generati risulteranno gli
stessi della volta precedente e nella stessa sequenza: vuol dire che tutti
i seriali che ha intenzione di generare li deve generare tutti una volta
sola (oppure la volta successiva deve rigenerarli tutti fino ad ottenerne
uno nuovo :P ).


 fino ad ottenerne uno nuovo :P ).
Certo, ma nulla ci obbliga ad usare _solo_ il tempo. Per esempio se uso il 
numero di file o la memoria disponibile e sommo a questo valore il risultato 
di time(NULL) ho aggiunto un fattore per evitare che due seriali generati 
nello stesso momento diano lo stesso risultato.
Altra soluzione forse più elegante è, come accennavi, generare un numero 
casuale all'avvio del programma e poi un altro quando si clicca sulla 
finestra di generazione del seriale e poi un ultimo quando si preme ok, per 
inserire nella casualità anche il ritardo introdotto dall'utente.
Del resto stiamo dicendo esattamente la stessa cosa: il metodo che ho 
proposto è un cesso, ma se non devi proteggere un programma con più di 500 
utenti, facilmente è più che sufficiente.


Potresti spiegarti meglio? come faccio a cambiargli la base?

I seriali verranno generati da una sola applicazione a step di 1000 o
2000 per volta.
Grazie per le risposte

Alla luce di quanto si qua detto credo che il sistema migliore era
quello che avevo ipotizzato all'inizio e che voi mi avete poi
confermato, e cioè la creazione di un seriale in base a un algoritmo
che utilizza la data di sistema. Dovrò abbandonare il discorso di
prendere le prime 25 lettere del GUID a meno che non riesca a capire
cosa voleva dire l'illustre Rialdi a riguardo del cambio della base del
GUID....farò delle ricerche a riguardo e vedrò cosa trovo...
Grazie a tutti..

 Potresti spiegarti meglio? come faccio a cambiargli la base?
Devi scriverti una funzione.
Se conti in base due, usi un bit e poi per contare oltre devi affiancargli 
un nuovo bit.
Se conti in base 10, usi 10 numeri (da 0 a 9) e poi per andare oltre gli 
affianchi un nuovo digit.
Se conti in base 16, usi 16 simboli (0-9, A-F) e poi ...
Se conti in base 36, usi 36 simboli (0-9, A-Z) e poi ...
Per codificare in quest'ultimo modo devi realizzarti una funzione tua che lo 
faccia.
Per esempio 100 in base 16 => 64
Il numero 100 si riscrive quindi in questi termini:
6 * 16^1 + 4 * 16^0
il che diventa: 64 (gli esponenti 1 e 0 sono la posizione dei digit)
Sempre 100 in base 36 cos'è?
2 * 36^1 + 28 * 16^0
Se il simbolo 28 del nostro alfabeto base 36 è 'R', il risultato è:
2R
In pratica il simbolo Z in base 36 equivale al numero 36
Se scrivi ad esempio il simbolo ZZ significa 1295
Spero di essere stato chiaro ...


Sei stato chiarissimo.
Avevo fatto delle ricerche e ho capito cosa intendevi dire, ma questa
tua ulteriore spiegazione mi ha aperto gli occhi.Grazie tante
ciao

 2000 per volta.
Questo è allora un probema, dato che molti avranno la parte determinata 
dall'ora uguale.
Se devi generare dei seriali univioci per un tuo software non è meglio 
generarli completamente a caso e verificare che non siano già stati generati 
cercandoli nel DB dei seriali?



Prego, ciao


Infatti anche questa potrebbe essere una ulteriore soluzione.
Mi è però venuta in mente un'altra cosa....
Io avrei pensato di usare il ToFileTime della data.
Microsoft dice:
{
L'ora del file di sistema è un valore senza segno a 64 bit in cui la
data e l'ora vengono rappresentate come numero di intervalli di 100
nanosecondi trascorsi dalle ore 00.00 del 1° gennaio 1601.
}
In questo modo dovrei avere un valore unico di sicuro.
Che ne pensi?
Mi restituisce un valore tipo questi:
1277 - 1978 - 2617- 8400 - 00
1277   1978   2617  9400 - 00
127719782618040000
Ecc.ecc.

 127719782618040000
Cosě risolvi, ma non capisco perché non li generi con dei numeri 
sequenziali. Che č praticamente quello che ottieni usando la data e 
generandoli cosě rapidamente. Sarebbe piů semplice anche tenere traccia dei 
seriali generati.
