Newsgroup: it.comp.lang.visual-basic
Titolo: CUID o GUID o LCID

Quale è il nome corretto e l'Api per ricavarlo?
Grazie Andrea

> Quale è il nome corretto e l'Api per ricavarlo?
Il nome corretto ?
GUID -> [G]lobally [U]nique [ID]entifier
E' l'alias utilizzato in COM/OLE di UUID (Universally Unique
Identifier). Come si evince dal nome, è un codice identificativo
che si suppone "universalmente unico" (nessuna macchina può
creare un codice duplicato; o almeno è statisticamente improbabile).
L'algoritmo di generazione di codici UUID è stato creato dalla
Open Software Foundation (OSF). Lo standard prende il nome
OSF DCE 3. A questo standard fa riferimento il sotto-sistema
RCP (Remote Procedure Call) di Microsoft; di conseguenza
anche OLE. In OLE i codici GUID vengono utilizzati per
l'identificazione delle classi componenti (nel qual caso i GUID
prendono il nome CLSID - Class Identifier) o per l'identificazione
delle interfacce (in questo caso prendono il nome IID - Interface
Identifier).
Per creare un GUID, si può utilizzare la funzione CoCreateGuid()
(Ole32), che genera l'integer a 128 bit (in effetti la generazione
del GUID è demandata alla funzione UuidCreate() di Rpc32, di
cui CoCreateGuid() è la funzione helper di Ole32).
Per trasformare il valore numerico in stringa, si usa la funzione
StringFromGuid2().
Abbiamo discusso questi argomenti poco tempo fa. Il thread,
lunghetto, era "[?] Creazione GUID".
Ti riporto in coda la routine per la creazione di un GUID.
CUID -> [C]reator [U]ser [ID]entifier
(questa è la definizione che io conosco di CUID).
Viene utilizzata in MAPI per l'identificazione dei messaggi,
in unione con CGID (Creator Group Identifier).
Viene utilizzato per diversi scopi e con diverse definizioni
sia in Unix che in Windows.
In relazione a MAPI, si può considerare un sinonimo di
GUID, visto che l'origine è la stessa.
LCID  -> [L]o[C]ale [ID]entifier
Codice (composito) che identifica una serie di impostazioni
relative al linguaggio e alla personalizzazione delle impostazioni
internazionali (localizzazione) di data, ora e valuta.
E' un valore a 32 bit (Long) composito. E' definito da due macro:
(le due macro le riporto in coda)
DWORD MAKELCID(
  WORD wLanguageID
  WORD wSortID
);
wLanguageID è la combinazione dell'identificativo del linguaggio
primario e del sotto-linguaggio (localizzazione o variante).
Per l'italiano, ad esempio è la combinazione di LANG_ITALIAN
e SUBLANG_ITALIAN, piuttosto che SUBLANG_ITALIAN_SWISS.
E' definito dalla macro:
        WORD MAKELANGID(
          USHORT usPrimaryLanguage,
          USHORT usSubLanguage
        );
wSortID è l'identificativo del tipo di ordinamento. I modelli di
ordinamento sono definiti da una serie di costanti. Per l'italia
il valore è SORT_DEFAULT.
Una buona tabella di LCID definiti la trovi qui:
http://www.asp-examples.com/objects/VBScript/vsmscLCID.htm
-----------------------------------------------------------------
Public Const S_OK As Long = 0
Public Type GUID
     Data1 As Long
     Data2 As Long
     Data3 As Long
     Data4(8) As Byte
End Type
Private Declare Function CoCreateGuid Lib "ole32.dll" ( _
     pguid As GUID) As Long
Private Declare Function StringFromGUID2 Lib "ole32.dll" ( _
     rguid As Any, _
     ByVal lpstrClsId As Long, _
     ByVal cbMax As Long) As Long
Per la creazione di un GUID puoi procedere in questo modo:
Dim udtGUID As GUID
Dim strGUID As String
Dim bytGUID() As Byte
Dim lngLen As Long
Dim lngRet As Long
'40 byte
lngLen = 40
bytGUID = String(lngLen, 0)
'Crea un nuovo GUID
lngRet = CoCreateGuid(udtGUID)
'lngRet è un HRESULT, wrapper per gli errori
'generati da UuidCreate()
If  lngRet = S_OK Then
    'Converte in stringa
    lngRet = StringFromGUID2( _
                  udtGUID, _
                  VarPtr(bytGUID(0)), _
                  lngLen)
    If lngRet > 0 then
        strGUID = bytGUID
        'Il valore lngRet include il terminatore
        strGUID = Left$(strGUID, lngRet - 1)
    End if
Else
    'Errore: CoCreateGuid() fallito
End if
La stringa risultante comprende anche le key "{}-"
-----------------------------------------------------------------
Macro per la definizione di LCID:
#define MAKELCID(lgid, srtid)  _
            ((DWORD)((((DWORD)((WORD  )(srtid))) << 16) | _
             \ ((DWORD)((WORD  )(lgid)))))
#define MAKELANGID(p, s)   _
            ((((WORD  )(s)) << 10) | (WORD  )(p))


Non riapro il discorso che senno' non ne usciamo vivi, ma ho notato che,
nonostante lungo il corso del thread tu abbia usato una GUID con un Integer
e 7 Byte, in coda al post hai inserito la prima dichiarazione, con tre Long
e 8 Byte...
Temo che il dubbio su questa particolare conversione della struttura mi
rimarra' per sempre :)
Tralascio la storia dell'As Any, quella l'ho capita (o meglio, ho capito
perche' usi As Any, anche se non mi hai convinto a non usare As GUID :))
Ciaotutti,
Alessandro

 perche' usi As Any, anche se non mi hai convinto a non usare As GUID :))
Non volevo "convincerti" ad usare un metodo piuttosto che un altro.
Solo mettere in evidenza diversi metodi di approccio, fortunatamente
entrambi giustificati da una logica di base.
A me preme sostanzialmente la compatibilità di progetto, ossia il
progetto deve essere in ogni caso adeguato a soddisfare tutte le
possibili varianti del problema (dato che seguo progetti piuttosto
corposi, questo è pre-requisito fondamentale. Non si può tornare
ogni settimana su una routine per verificare la compatibilità per
una mutata specifica tecnica - non sempre comunque).
PS.
WARNING !!!
DO NOT REPLY TO THIS POST.
IT MAY LEAD TO AN IMPREDICTABLE RESOULT :)))


This message will self-destruct in five seconds...
Four...
Three...
Two...
One...
Thanks for your cooperation.
Ciaotutti,
Alessandro