regedit

Bonsoir

Tu utilises les API que tu trouves dans MSDN.
Par exemple, tu utilises
RegOpenKeyEx
et si le résultat de la fonction n'est pas nul, la clef n'existe pas

Aski

"Armando R." <artools@free.fr> a écrit dans le message de
news:41ed5f02$0$20339$626a14ce@news.free.fr...

Bonsoir,
comment vérifier si une clé existe déjà dans le registre.
Merci.

Salut Armando! :O)

Voici la dernière version de ma classe CRegistry. François y a apporté
quelques modifications récemment (je te colle un exemple d'utilisation après
la classe) :
'***
'***********************************************************************
' Module contenant les fonctions nécessaires à la gestion des registres
'***********************************************************************
Option Explicit


'Membres Privées
'------------------------------------

'Constantes générales
Private Const ERROR_NO_MORE_ITEMS As Long = &H103&
Private Const ERROR_MOREDATA As Long = &H234&
Private Const NO_ERROR As Long = &H0&

Private Const REG_SZ As Long = 1&
Private Const REG_DWORD = 4

'------------------------------------
'Droits d'accès
Private Const DELETE = (&H10000)
Private Const READ_CONTROL = (&H20000)
Private Const WRITE_DAC = (&H40000)
Private Const WRITE_OWNER = (&H80000)
Private Const SYNCHRONIZE = (&H100000)

Private Const STANDARD_RIGHTS_READ = (READ_CONTROL)
Private Const STANDARD_RIGHTS_WRITE = (READ_CONTROL)
Private Const STANDARD_RIGHTS_EXECUTE = (READ_CONTROL)

Private Const STANDARD_RIGHTS_ALL = (&H1F0000)

Private Const KEY_QUERY_VALUE = (&H1)
Private Const KEY_SET_VALUE = (&H2)
Private Const KEY_CREATE_SUB_KEY = (&H4)
Private Const KEY_ENUMERATE_SUB_KEYS = (&H8)
Private Const KEY_NOTIFY = (&H10)
Private Const KEY_CREATE_LINK = (&H20)
Private Const KEY_WOW64_32KEY = (&H200)
Private Const KEY_WOW64_64KEY = (&H100)
Private Const KEY_WOW64_RES = (&H300)
Private Const KEY_READ = ((STANDARD_RIGHTS_READ Or KEY_QUERY_VALUE _
Or KEY_ENUMERATE_SUB_KEYS Or KEY_NOTIFY) And (Not SYNCHRONIZE))
Private Const KEY_WRITE = ((STANDARD_RIGHTS_WRITE Or KEY_SET_VALUE _
Or KEY_CREATE_SUB_KEY) And (Not SYNCHRONIZE))
Private Const KEY_EXECUTE = ((KEY_READ) And (Not SYNCHRONIZE))
Private Const KEY_ALL_ACCESS = ((STANDARD_RIGHTS_ALL Or KEY_QUERY_VALUE _
Or KEY_SET_VALUE Or KEY_CREATE_SUB_KEY Or KEY_ENUMERATE_SUB_KEYS Or _
KEY_NOTIFY Or KEY_CREATE_LINK) And (Not SYNCHRONIZE))

'Types

Private Type FILETIME
dwLowDateTime As Long
dwHighDateTime As Long
End Type

'Fonctions importées

Private Declare Function RegCloseKey _
Lib "advapi32.dll" _
( _
ByVal hKey As Long _
) As Long

Private Declare Function RegCreateKeyEx _
Lib "Advapi32" _
Alias "RegCreateKeyExA" _
( _
ByVal hKey As Long, _
ByVal lpSubKey As String, _
ByVal Reserved As Long, _
ByVal lpClass As String, _
ByVal dwOptions As Long, _
ByVal samDesired As Long, _
lpSecurityAttributes As Any, _
phkResult As Long, _
lpdwDisposition As Long _
) _
As Long

Private Declare Function RegSetValueEx _
Lib "advapi32.dll" _
Alias "RegSetValueExA" _
( _
ByVal hKey As Long, _
ByVal lpValueName As String, _
ByVal Reserved As Long, _
ByVal dwType As Long, _
ByRef lpData As Any, _
ByVal cbData As Long _
) As Long

Private Declare Function RegOpenKeyEx _
Lib "Advapi32" _
Alias "RegOpenKeyExA" _
( _
ByVal hKey As Long, _
ByVal lpSubKey As String, _
ByVal ulOptions As Long, _
ByVal samDesired As Long, _
phkResult As Long _
) _
As Long

Private Declare Function RegDeleteValue _
Lib "advapi32.dll" _
Alias "RegDeleteValueA" _
( _
ByVal hKey As Long, _
ByVal lpValueName As String _
) As Long

Private Declare Function RegDeleteKey _
Lib "advapi32.dll" _
Alias "RegDeleteKeyA" _
( _
ByVal hKey As Long, _
ByVal lpSubKey As String _
) As Long

Private Declare Function GetSystemDirectory _
Lib "kernel32" _
Alias "GetSystemDirectoryA" _
( _
ByVal lpBuffer As String, _
ByVal nSize As Long _
) As Long

Private Declare Function RegEnumKeyEx _
Lib "advapi32.dll" _
Alias "RegEnumKeyExA" _
( _
ByVal hKey As Long, _
ByVal dwIndex As Long, _
ByVal lpName As String, _
ByRef lpcbName As Long, _
ByVal lpReserved As Long, _
ByVal lpClass As String, _
ByRef lpcbClass As Long, _
ByRef lpftLastWriteTime As Any _
) As Long

Private Declare Function RegEnumValue _
Lib "advapi32.dll" _
Alias "RegEnumValueA" _
( _
ByVal hKey As Long, _
ByVal dwIndex As Long, _
ByVal lpValueName As String, _
ByRef lpcbValueName As Long, _
ByVal lpReserved As Long, _
ByRef lpType As Long, _
ByRef lpData As Any, _
ByRef lpcbData As Long _
) As Long

Private Declare Function RegQueryValueEx _
Lib "advapi32.dll" _
Alias "RegQueryValueExA" _
( _
ByVal hKey As Long, _
ByVal lpValueName As String, _
ByVal lpReserved As Long, _
ByRef lpType As Long, _
ByRef lpData As Any, _
ByRef lpcbData As Long _
) As Long


Private Declare Sub CopyMemory _
Lib "kernel32" _
Alias "RtlMoveMemory" _
( _
Destination As Any, _
Source As Any, _
ByVal Length As Long _
)

' Énumérations Publiques
Public Enum eBaseKeyHandle
bkhClassesRoot = &H80000000
bkhCurrentUser = &H80000001
bkhLocalMachine = &H80000002
bkhUsers = &H80000003
bkhPerformanceData = &H80000004
bkhCurrentConfig = &H80000005
bkhDynData = &H80000006
End Enum

Public Enum eCreationDisposition
REG_CREATED_NEW_KEY = (&H1&)
REG_OPENED_EXISTING_KEY = (&H2&)
End Enum


'*******************************************************************
' Créer une clé de registre
'*******************************************************************

'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
'Ajout du paramètre CreationDisposition qui permet à
'l'utilisateur de savoir quelle opération a été effectuée
'(clé existante / clé créée)
'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Public Function CreateKey _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
Optional CreationDisposition As eCreationDisposition _
) As Boolean

Dim hKey As Long

CreateKey = RegCreateKeyEx(bkh, sKey, 0, vbNullString, _
0, 0, ByVal 0&, hKey, CreationDisposition) = 0
RegCloseKey hKey

End Function

'*******************************************************************
' Modifie une valeur de type REG_SZ
'*******************************************************************
Public Sub SetSZValue _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
ByRef sValueName As String, _
ByRef sValueData As String _
)

Dim hKey As Long

If RegOpenKeyEx(bkh, sKey, 0, KEY_SET_VALUE, hKey) = NO_ERROR Then
RegSetValueEx hKey, sValueName, 0, REG_SZ, _
ByVal sValueData, Len(sValueData)
RegCloseKey hKey
End If
End Sub

'*******************************************************************
' Modifie une valeur de type REG_DWORD
'******************************************************************
Public Sub SetDWORDValue _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
ByRef sValueName As String, _
ByRef lValueData As Long _
)

Dim hKey As Long

If RegOpenKeyEx(bkh, sKey, 0, KEY_SET_VALUE, hKey) = NO_ERROR Then
RegSetValueEx hKey, sValueName, 0, REG_DWORD, _
lValueData, 4
RegCloseKey hKey
End If
End Sub

'*******************************************************************
' Supprime la clé demandé
'*******************************************************************
Public Sub DeleteKey _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String _
)

RegDeleteKey bkh, sKey

End Sub

'*******************************************************************
' Supprime la valeur
'*******************************************************************
Public Sub DeleteValue _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
ByRef sValueName As String _
)

Dim hKey As Long

If RegOpenKeyEx(bkh, sKey, 0, KEY_SET_VALUE, hKey) = NO_ERROR Then
RegDeleteValue hKey, sValueName
End If

End Sub

'*******************************************************************
' Renvoi un tableau de clés
'*******************************************************************
Public Function GetKeys _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String _
) As String()

Dim hKey As Long
Dim lKeyCount As Long
Dim sName As String
Dim sData As String
Dim lNameLen As Long
Dim sKeys() As String
Dim RC As Long
Dim TimeStruct As FILETIME

sKeys = Split("", " ")
If RegOpenKeyEx(bkh, sKey, 0, KEY_ENUMERATE_SUB_KEYS, hKey) = NO_ERROR
Then
RC = 0
Do
lNameLen = 255
sName = String$(lNameLen, vbNullChar)

RC = RegEnumKeyEx(hKey, lKeyCount, sName, lNameLen, _
ByVal 0&, vbNullString, ByVal 0&, TimeStruct)

Do While (RC = ERROR_MOREDATA) And (lNameLen < 512)
lNameLen = lNameLen + 255
sName = String$(lNameLen, vbNullChar)

RC = RegEnumKeyEx(hKey, lKeyCount, sName, lNameLen, _
ByVal 0&, vbNullString, ByVal 0&, TimeStruct)
Loop

If RC = 0 Then 'Valeur énumérée correctement, peut être ajoutée
ReDim Preserve sKeys(lKeyCount) As String
sKeys(lKeyCount) = Left$(sName, lNameLen)

lKeyCount = lKeyCount + 1
End If

'S'arrête à la moindre erreur et en particulier ERROR_NO_MORE_ITEMS
Loop Until (RC)
RegCloseKey hKey
End If

GetKeys = sKeys

End Function

'*******************************************************************
' Renvoi la valeur REG_SZ demandée
'*******************************************************************
Public Function GetRawValueStr _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
ByRef sValueName As String _
) As String

Dim hKey As Long
Dim lDataBufferSize As Long
Dim iData As Integer

If RegOpenKeyEx(bkh, sKey, 0, KEY_QUERY_VALUE, hKey) = NO_ERROR Then
'Premier query pour obtenir la taille des données
If RegQueryValueEx(hKey, sValueName, 0, _
0, ByVal 0&, lDataBufferSize) = NO_ERROR Then

GetRawValueStr = String$(lDataBufferSize, vbNullChar)
RegQueryValueEx hKey, sValueName, 0, ByVal 0&, _
ByVal GetRawValueStr, lDataBufferSize
End If
RegCloseKey hKey
End If
End Function

'*******************************************************************
' Renvoi la valeur REG_DWORD demandée
'*******************************************************************
Public Function GetRawValueBytes _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
ByRef sValueName As String _
) As Byte()

Dim hKey As Long
Dim bBuffer() As Byte
Dim lDataBufferSize As Long
Dim iData As Integer

If RegOpenKeyEx(bkh, sKey, 0, KEY_QUERY_VALUE, hKey) = NO_ERROR Then
'Premier query pour obtenir la taille des données
If RegQueryValueEx(hKey, sValueName, 0, _
0, ByVal 0&, lDataBufferSize) = NO_ERROR Then

ReDim bBuffer(lDataBufferSize - 1) As Byte
RegQueryValueEx hKey, sValueName, 0, ByVal 0&, _
bBuffer(0), lDataBufferSize

GetRawValueBytes = bBuffer
End If
RegCloseKey hKey
End If
End Function

'*******************************************************************
' Renvoi la valeur REG_SZ ou REG_DWORD sous forme de String
'*******************************************************************
Public Function GetValueStr _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
ByRef sValueName As String _
) As String

Dim hKey As Long
Dim lDataBufferSize As Long
Dim iData As Integer
Dim lDataType As Long

If RegOpenKeyEx(bkh, sKey, 0, KEY_QUERY_VALUE, hKey) = NO_ERROR Then
'Premier query pour obtenir la taille des données
If RegQueryValueEx(hKey, sValueName, 0, _
0, ByVal 0&, lDataBufferSize) = NO_ERROR Then

GetValueStr = String$(lDataBufferSize, vbNullChar)
RegQueryValueEx hKey, sValueName, 0, lDataType, _
ByVal GetValueStr, lDataBufferSize

Select Case lDataType
Case REG_SZ
GetValueStr = Left$(GetValueStr, Len(GetValueStr) - 1)
Case REG_DWORD
GetValueStr = CStr(DWDataToLong(GetValueStr))
End Select
End If
RegCloseKey hKey
End If
End Function

'*******************************************************************
' fonction utilitaire
'*******************************************************************
Private Function DWDataToLong(DWData As String) As Long
If LenB(DWData) = 8 Then
CopyMemory DWDataToLong, ByVal DWData, 4
End If
End Function


'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
'Les noms de valeur peuvent contenir 'Donc les résultats pouvaient être erronés
'avec la version précédente
'On pourrait un système par callback
'a l'aide de callbyname
'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
'*******************************************************************
' Renvoi un tableau de values
'*******************************************************************
Public Function GetValuesName _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String _
) As String()

Dim hKey As Long
Dim lKeyCount As Long
Dim sName As String
Dim lNameLen As Long
Dim sValues() As String
Dim RC As Long

If RegOpenKeyEx(bkh, sKey, 0, KEY_QUERY_VALUE, hKey) = NO_ERROR Then

Do
lNameLen = 255
sName = String$(lNameLen, vbNullChar)

RC = RegEnumValue(hKey, lKeyCount, sName, lNameLen, 0, ByVal 0&,
_
ByVal 0&, ByVal 0&)

'buffer trop petit, on tente si possible d'augmenter la taille
'The maximum size of a value name is as follows:
'Windows Server 2003 and Windows XP: 16,383 characters
Do While (RC = ERROR_MOREDATA) And (lNameLen < 32767)
lNameLen = lNameLen + 255
sName = String$(lNameLen, vbNullChar)

RC = RegEnumValue(hKey, lKeyCount, sName, lNameLen, 0, ByVal
0&, _
ByVal 0&, ByVal 0&)
Loop

If RC = 0 Then
ReDim Preserve sValues(lKeyCount) As String
sValues(lKeyCount) = Left$(sName, lNameLen)

lKeyCount = lKeyCount + 1
End If

'S'arrête à la moindre erreur et en particulier ERROR_NO_MORE_ITEMS
Loop Until (RC)
RegCloseKey hKey

End If

GetValuesName = sValues

End Function

'*******************************************************************
' Renvoi un tableau de values
'*******************************************************************
Public Function GetValues _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String _
) As String()

Dim hKey As Long
Dim lKeyCount As Long
Dim sName As String
Dim sData As String
Dim lNameLen As Long
Dim lDataLen As Long
Dim sValues() As String
Const BUFFER_SIZE As Long = 255

If RegOpenKey(bkh, sKey, hKey) = 0 Then

sName = Space$(BUFFER_SIZE)
sData = Space$(BUFFER_SIZE)
lNameLen = BUFFER_SIZE
lDataLen = BUFFER_SIZE

Do While RegEnumValue(hKey, lKeyCount, sName, lNameLen, 0, ByVal 0&,
_
ByVal sData, lDataLen) <> ERROR_NO_MORE_ITEMS

ReDim Preserve sValues(lKeyCount) As String
sValues(lKeyCount) = Left$(sName, lNameLen) & "=" & Left$(sData,
_
lDataLen - 1)

lKeyCount = lKeyCount + 1

sName = Space$(BUFFER_SIZE)
sData = Space$(BUFFER_SIZE)

lNameLen = BUFFER_SIZE
lDataLen = BUFFER_SIZE

Loop
RegCloseKey hKey

End If

GetValues = sValues

End Function

'*******************************************************************
' Renvoi vrai si la clé de registre existe
'*******************************************************************
Public Function KeyExists _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String _
) As Boolean

Dim hKey As Long

KeyExists = RegOpenKeyEx(bkh, sKey, 0, STANDARD_RIGHTS_READ, hKey) NO_ERROR
If KeyExists Then
RegCloseKey hKey
End If
End Function

'*******************************************************************
' Renvoi vrai si la clé existe
'*******************************************************************
Public Function ValueExists _
( _
ByRef bkh As eBaseKeyHandle, _
ByRef sKey As String, _
ByRef sValueName As String _
) As Boolean

Dim hKey As Long

If RegOpenKeyEx(bkh, sKey, 0, REG_QUERY_VALUE, hKey) = NO_ERROR Then
ValueExists = (RegQueryValueEx(hKey, sValueName, 0, _
0, ByVal 0, 0) = NO_ERROR)
RegCloseKey hKey
End If
End Function
'***



Tu peux vérifier l'existence d'une clé comme ceci :
'***
Dim reg As CRegistry
Set reg = New CRegistry

Debug.Print reg.KeyExists(rkcLocalMachine, "softwareODBCODBC.INI")
'***

--
Cordialement
Yanick
MVP pour Visual Basic

"Armando R." <artools@free.fr> a écrit dans le message de
news:41ed5f02$0$20339$626a14ce@news.free.fr...

Bonsoir,
comment vérifier si une clé existe déjà dans le registre.
Merci.

Bonsoir Zoury

Merci pour ta bibliothèque.
Tu gâches un peu le plaisir. J'ai mis un *certain temps* pour en constituer
une semblable.
Il ne manque qu'une fonction renommant une clef comme on le fait à la main,
sans passer pas la suppression qui oblige à tout réécrire. Je n'ai rien
trouver, ni en API, ni en C.

Aski

"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message de
news:OBOLjQZ$EHA.2572@tk2msftngp13.phx.gbl...

Salut Armando! :O)

Voici la dernière version de ma classe CRegistry. François y a apporté
quelques modifications récemment (je te colle un exemple d'utilisation

après

la classe) :

Salut Aski!

Merci pour ta bibliothèque.
Tu gâches un peu le plaisir. J'ai mis un *certain temps* pour en

constituer

une semblable.

haha! désolé! :O)
c'était justement le but de la partagé... éviter du boulot aux autres.

Il ne manque qu'une fonction renommant une clef comme on le fait à la

main,

sans passer pas la suppression qui oblige à tout réécrire. Je n'ai rien
trouver, ni en API, ni en C.

Tu as bien cherché. :O)
Lorsque l'on renomme un clé sous RegEdit, c'est exactement ce qui se
produit. Il n'y a pas de méthode permettant de renommer la clé sans la
recréer. Je pourrai toujours l'ajouter à la classe, j'avoue que ce serait
très pratique.

--
Cordialement
Yanick
MVP pour Visual Basic

Bonsoir Yanick,

"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message de
news:OzoLvdZ$EHA.3924@TK2MSFTNGP15.phx.gbl...

Salut Aski!


> Merci pour ta bibliothèque.
> Tu gâches un peu le plaisir. J'ai mis un *certain temps* pour en
constituer
> une semblable.

haha! désolé! :O)
c'était justement le but de la partagé... éviter du boulot aux autres.

Absolument d'accord avec toi. Je reconnais avoir souvent profité de ces
partages très fructueux et cordiaux sous VB et VC. :O8)))
Mais il faut constater que lorsqu'on te donne tout mâché, on apprend moins.

> Il ne manque qu'une fonction renommant une clef comme on le fait à la
main,
> sans passer pas la suppression qui oblige à tout réécrire. Je n'ai rien
> trouver, ni en API, ni en C.

Tu as bien cherché. :O)
Lorsque l'on renomme un clé sous RegEdit, c'est exactement ce qui se
produit. Il n'y a pas de méthode permettant de renommer la clé sans la
recréer. Je pourrai toujours l'ajouter à la classe, j'avoue que ce serait
très pratique.

Il va y avoir un peu de récursivité, non ?

Cordialement

Henri

> Mais il faut constater que lorsqu'on te donne tout mâché, on apprend

moins.

Ça dépend de l'attitude du programmeur je dirais...

Personnellement lorsque que je trouve un bout de code tout fait, je le lit
attentivement et tente de le comprendre (fouille l'aide pour les nouvelles
fonctions) et voir même de l'amélioré si possible. J'apprends tout au temps
et peut-être même plus car je n'aurais peut-être jamais découvert cette
façon de faire en le fesant moi même..

J'avoue toutefois que certaines personnes accepte sans questions tout ce
qu'on leur donne (et pas juste en informatique)... souvent ils ne
comprennent même pas ce qui se passe! Ces gens n'apprendrons possiblement
jamais rien de plus que ce que leurs professeurs leurs ont entrés dans la
tête à grand coup de pelle. ;O)

Il va y avoir un peu de récursivité, non ?

sans aucun doute. <zelle>quoi que si je peux l'éviter.. je sauverez bien
quelques millisecondes précieuses . :OD </zelle>

--
Cordialement
Yanick
MVP pour Visual Basic

> J'apprends tout au temps

Oh là!! je voulais écrire "j'apprends tout autant" :O)

--
Cordialement
Yanick
MVP pour Visual Basic

Hello Yanick,

"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message de
news:%23OQPtxZ$EHA.3376@TK2MSFTNGP12.phx.gbl...

> Mais il faut constater que lorsqu'on te donne tout mâché, on apprend
moins.

Ça dépend de l'attitude du programmeur je dirais...

Personnellement lorsque que je trouve un bout de code tout fait, je le lit
attentivement et tente de le comprendre (fouille l'aide pour les nouvelles
fonctions) et voir même de l'amélioré si possible. J'apprends toutau tant
et peut-être même plus car je n'aurais peut-être jamais découvert cette
façon de faire en le fesant moi même..

J'avoue toutefois que certaines personnes accepte sans questions tout ce
qu'on leur donne (et pas juste en informatique)... souvent ils ne
comprennent même pas ce qui se passe! Ces gens n'apprendrons possiblement
jamais rien de plus que ce que leurs professeurs leurs ont entrés dans la
tête à grand coup de pelle. ;O)

J'applaudis des 2 mains ta synthèse :-)))

> Il va y avoir un peu de récursivité, non ?

sans aucun doute. <zelle>quoi que si je peux l'éviter.. je sauverez bien
quelques millisecondes précieuses . :OD </zelle>

Effectivement, on trouve souvent une solution non récursive qui n'augmente
pas trop le code et gagne en clarté (exemples des tris et de la recherche de
l'arborescence).

Une remarque, en étudiant plus à fond ton code : pour l'enregistrement des
valeurs et surtout leur lecture, il serait intéressant d'ajouter le cas des
valeurs REG_BINARY et de considérer REG_EXPAND_SZ (&H2) au même titre que
REG_SZ.

Cordialement

Henri

> Effectivement, on trouve souvent une solution non récursive qui n'augmente
pas trop le code et gagne en clarté (exemples des tris et de la recherche

de

l'arborescence).

Une remarque, en étudiant plus à fond ton code : pour l'enregistrement des
valeurs et surtout leur lecture, il serait intéressant d'ajouter le cas

des

valeurs REG_BINARY et de considérer REG_EXPAND_SZ (&H2) au même titre que
REG_SZ.

Bien d'accord et bien noté. Il est vrai que l'on croise souvent ces types de
données.


--
Cordialement
Yanick
MVP pour Visual Basic

Hello,

Concernant la non récursivité, il existe en fait deux techniques pour
renommer une clé de registre.
1°/ Utiliser RegSaveKey/RegRestoreKey
Mais :
- ne fonctionne que sous NT, 2k, XP, ...
- demande d'utiliser un fichier temporaire

1° bis/ Utiliser regedit en ligne de commande pour faire la même
opération... fonctionne sous 9x
Mais :
- Demande d'utiliser un fichier temporaire
- Demande d'éditer le fichier avant réécriture (=> parsing... beurk), en
supposant bien entendu que le format des fichiers reg ne change pas trop...

2°/ SHCopyKey qui "recursively copies the subkeys and values of the source
subkey to the destination key. SHCopyKey does not copy the security
attributes of the keys."
Ou comment éviter de faire ce que le shell fait pour nous :-)
Il y a quand même une petite restriction au niveau des plateformes:
"Windows 2000, Windows NT 4.0 with Internet Explorer 5, Windows 98, Windows
95 with Internet Explorer 5"


'Note a Zoury :
'Un peu de machage de travail, si ça te tente?
Private Declare Function SHCopyKey _
Lib "shlwapi" _
Alias "SHCopyKeyA" _
( _
ByVal hkeySrc As Long, _
ByVal szSrcSubKey As String, _
ByVal hkeyDest As Long, _
ByVal fReserved As Long _
) _
As Long

Public Sub CopyKey(ByRef bkhSrc As eBaseKeyHandle, _
ByRef sKeySrc As String, _
ByRef bkhDst As eBaseKeyHandle, _
ByRef sKeyDst As String _
)

Dim hKey As Long

'Note :
'Remplacer RegCreateKeyEx par RegOpenKeyEx équivalent
'si la fonction ne doit pas automatiquement créer
'la clé de destination
If RegCreateKeyEx(bkhDst, sKeyDst, 0, vbNullString, _
0, KEY_WRITE, ByVal 0&, hKey, ByVal 0&) = NO_ERROR Then
Debug.Print SHCopyKey(bkhSrc, sKeySrc, hKey, 0)
RegCloseKey hKey
End If
End Sub


Voila voila :-)

--
François Picalausa

"Aski" <aski@free.com> a écrit dans le message de news:
O4mUEni$EHA.2568@TK2MSFTNGP11.phx.gbl

Hello Yanick,

"Zoury" <yanick_lefebvre at hotmail dot com> a écrit dans le message
de news:%23OQPtxZ$EHA.3376@TK2MSFTNGP12.phx.gbl...

Mais il faut constater que lorsqu'on te donne tout mâché, on
apprend moins.

Ça dépend de l'attitude du programmeur je dirais...

Personnellement lorsque que je trouve un bout de code tout fait, je
le lit attentivement et tente de le comprendre (fouille l'aide pour
les nouvelles fonctions) et voir même de l'amélioré si possible.
J'apprends toutau tant et peut-être même plus car je n'aurais
peut-être jamais découvert cette façon de faire en le fesant moi
même..

J'avoue toutefois que certaines personnes accepte sans questions
tout ce qu'on leur donne (et pas juste en informatique)... souvent
ils ne comprennent même pas ce qui se passe! Ces gens n'apprendrons
possiblement jamais rien de plus que ce que leurs professeurs leurs
ont entrés dans la tête à grand coup de pelle. ;O)

J'applaudis des 2 mains ta synthèse :-)))

Il va y avoir un peu de récursivité, non ?

sans aucun doute. <zelle>quoi que si je peux l'éviter.. je sauverez
bien quelques millisecondes précieuses . :OD </zelle>

Effectivement, on trouve souvent une solution non récursive qui
n'augmente pas trop le code et gagne en clarté (exemples des tris et
de la recherche de l'arborescence).

Une remarque, en étudiant plus à fond ton code : pour
l'enregistrement des valeurs et surtout leur lecture, il serait
intéressant d'ajouter le cas des valeurs REG_BINARY et de considérer
REG_EXPAND_SZ (&H2) au même titre que REG_SZ.

Cordialement

Henri