Registryschlüssel löschen



  • @maloo : dein text auf meine antowrt :

    "@ konvenienz: Bist du dir sicher, dass ihr es auf einem WindowsNT-System geschafft habt einen Registryschlüssel zu löschen, der Unterschlüssel (nicht Werte!!!) enthielt? Laut Microsoft und meinen eigenen Erfahrungen ist dies unmöglich. Schaue dir in der WindowsSDK-Hilfe mal den Begriff RegDeleteKey an. Dort steht es eigentlich schwarz auf weiss.
    Nichts für ungut und noch ein schönes Wochenende wünscht"

    wo steht in diesem abnschitt das man erst die unterschlüssel löschen muss ????
    sorry aber das hast du nicht geschrieben ! nur das es laut sdk unmöglich ist ! und das ist eben nicht unmöglich und steht auch dort nicht drin !!!!!
    aber egal ....

    beispeilcode ...mal sehen diesen code haben wir in eine komerzeille software software eingebaut. ich schau mal was sich da machen lässt.

    ciao



  • ist nur gut, dass ich es mittlerweile gelöst habe *g*

    Habe übrigens zwei Funktionen und lösche die Unterschlüssel rekursiv... Sicherlich finden sich Ansatzpunkte zur Optimierung, aber ich bin damit zufrieden... naja ich schreib es halt mal auf. Ist aber ein bissle länger :-))

    Er macht das was er soll :-))

    hier der Code:

    //Registrierungsverzeichnis und -einträge aus /Reports/ löschen
    
    //Schleifenfunktion
    bool schleife(AnsiString &SubKey)
        {
        bool erfolg = true;
        bool geoeffnet;
        TRegistry *pReg = new TRegistry;                //dynamische Speicherreservierung für Registrypointer
        TStringList *Keyname = new TStringList;         //dynamische Speicherreservierung für StringListzeiger
        Registry::TRegKeyInfo Info;                     //Typ definition für Schlüsselinformationen
        AnsiString DelKey;
    
        try                                             //Exeptionsabfangen try , catch
            {
            geoeffnet = pReg->OpenKey(SubKey,false);    //Oeffnen des Unterschlüssels
            DelKey = SubKey;                            //zwischenspeicherung des Unterschlüssels
            if (geoeffnet == true)                      //ist Unterschlüssel geöffnet
                {                                       //Unterschlüssel ist geöffnet
                 if (pReg->HasSubKeys())              //hat Unterschlüssel Unterschlüssel
                    {                                   //Unterschlüssel hat Unterschlüssel
                    pReg->GetKeyInfo(Info);             //Hole Schlüsselinformationen
                    pReg->GetKeyNames(Keyname);         //Hole Schlüsselnamen
                    int lauf;
                    for (lauf=0;lauf<=Info.NumSubKeys-1;lauf++) //läuft bis (Anzahl der Schlüssel)-1,da String ab 0 beginnt
                        {
                        SubKey = Keyname->Strings[lauf];        //Name pro Zeile der Liste
                        SubKey = DelKey + SubKey + "\\";        //kompletter Schlüsselpfad
                        schleife(SubKey);                       //rekrusiver aufruf, falls Unterschlüssel,
                        }                                       //noch Unterschlüssel hat
                    schleife(DelKey);                           //nach Beendigung, rekurvsiver Aufruf,damit oberster
                     }                                          //Unterschlüssel auch gelöscht werden kann
                 else                                 //hat keine Unterschlüssel
                    {
                 pReg->CloseKey();                      //aktuellen Schlüssel schließen
                 erfolg = pReg->DeleteKey(SubKey);      //aktuellen Schlüssel löschen
                    }
                }
            }
        catch (...)                                     //Exeptionbehandlung
            {
            ;
            }
        delete Keyname;                                 //Löschen des dynamischen Speicherplatzes der StringListe
        delete pReg;                                    //Löschen des dynamischen Speicherplatzes des Registryzeigers
        return(erfolg);                                 //booleanscher Rückgabewert der Funktion
        }
    
    //Loeschfunktion
    bool reg_loeschen()
        {
            TRegistry *pReg = new TRegistry;            //dynamischer Speicher für Registrypointer
            TStringList *Keyname = new TStringList;     //dynamischer Speicher für String-Liste
            Registry::TRegKeyInfo Info;                 //Typ definition für Schlüsselinformationen
            bool erfolg;
            AnsiString DelKey;
            AnsiString ToDelKey;
            AnsiString SubKey;
            DelKey = "\\Software\\L+P\\Reports";        //Hauptschlüssel
            try                                         //Exeptions abfangen.
                {         //try-Klammer oeffnen
                 pReg->RootKey = HKEY_CURRENT_USER;     //Rootkey auf CURRENT_USER setzen
                 pReg->KeyExists(DelKey);               //Existiert der Hauptschlüssel
                 ToDelKey = DelKey + "\\";
                 if (pReg->OpenKey(ToDelKey,false))     //Hauptschlüssel öffnen für weitere abfragen
                    {
                     if (pReg->HasSubKeys())            //hat der Schlüssel Unterschlüssel?
                        {                               //Schlüssel hat Unterschlüssel
                         pReg->GetKeyInfo(Info);        //Schlüsselinformationen auslesen
                         pReg->GetKeyNames(Keyname);    //Schlüsselnamenauslesen
                         int lauf;
                         for (lauf=0; lauf<=Info.NumSubKeys-1;lauf++) //läuft bis Anzahl der Unterschlüssel-1, da
                            {                                         //die stringListe mit 0 anfangen muss, die Anzahl
                                                                      //aber mit 1 beginnt
                            SubKey = Keyname->Strings[lauf];          //String jeder zeile
                            SubKey = ToDelKey + SubKey + "\\";        //kompletter Baumpfad
                            erfolg = schleife(SubKey);                //Aufruf der Schleifenfunktion
                            }
                            if (erfolg == true)                       //bei Erfolg (alle Unterschlüssel zu "Reports"
                                {                                     //sind gelöscht)
                                erfolg = reg_loeschen();              //rekursiver aufruf der Funktion um den Schlüssel
                                }                                     //"Reports" auch zu löschen
    
                        }
                     else                                             //Schlüssel hat keine Unterschlüssel
                        {
                        pReg->CloseKey();                             //schließe Hauptschlüssel
                        erfolg=pReg->DeleteKey(ToDelKey);             //lösche hauptschlüssel
    
                        }
                    }
                }        //try-Klammer geschlossen
            catch(...)                                                // abfangen von Exeptions
                {
                ;
                }
            delete Keyname;                                           //Lösche Dynamischen Speicher der StringListe
            delete pReg;                                              //Lösche Dynamischen Speicher des Registryzeigers
            return (erfolg);                                          //booleanscher Rückgabe der Funktion
        }
    
    int main()
    {
            TRegistry *pReg = new TRegistry;
            AnsiString MainKey;
            AnsiString ReportKey;
            MainKey = "\\Software\\L+P";
            ReportKey = MainKey + "\\Reports";
            bool geloescht;
            pReg->RootKey = HKEY_CURRENT_USER;
            if (pReg->KeyExists(ReportKey))
                {
                 geloescht = reg_loeschen();
                 if (geloescht== true)
                    {
                     cout<<"Die Registry wurde geloescht!"<<endl;
                    }
                 else
                    {
                     cout<<"Die Registry wurde nicht geloescht!"<<endl;
                    }
                }
            else
            cout<<"ReportsKey wurde bereits geloescht"<<endl;
            cout << "taste druecken";
            getchar();
            return 0;
    }
    

    @maloo kannst ihn ja leicht verändern (bzw. allgemeiner machen) und ihn auf deiner Seite aufnehmen

    mfg



  • @konvinienz: Da haben wir wohl konstruktiv aneinander vorbei geredet. Ist ja auch nicht so wild, da ja eine Lösung gefunden wurde und ich für meinen Teil etwas dazugelernt habe (Befehl für das rekursive Löschen).
    An dieser Stelle mal ein Danke Schön für den Quelltext.
    Kommt natürlich mit Quellenangabe ins Tutorial auf meiner Page. Vielleicht kürzt Junix oder Jansen das Thema auch auf das wesentliche und schiebt es hier in die FAQ !?



  • Nur noch ein kurzer Hinweis:
    Mein abgeänderter Code von gestern funktioniert auch unter NT 4.0 SP5.
    (Kompiliert mit BCB 5 Pro)
    Eventuell ist der ganze Aerger ein Problem, hervorgerufen durch die ältere BCB-Version.
    Oder von MS:
    Ich hatte kuerzlich das Problem, das der Registrycode einer Anwendung auf genau zwei NT4-Maschinen nicht lief. Auf anderen (Identische Version/SP) aber keine Probleme machte.

    Tschuess



  • @Barnie: Waren die Nutzerrechte auch überall gleich - wäre ja mal interessant, ob die Windows-SDK dahingehend etwas verschweigt.



  • Auf dem Win2k System war ich Admin. (User hab ich da nicht getestet.)
    Unter WinNT war ich nur User.

    Tschuess



  • und wie löscht man einen einzelnen string, z.b. unter "run"? ich will ja nich den ganzen ordner "run" löschen 😃



  • Was heisst Löschen auf Englisch?
    Und was für TRegistry-Methoden mit entsprechendem Namen gibt's noch?



  • hast du kein wörterbuch? löschen=delete
    und ich würd dir DeleteValue vorschlagen
    ich hoffe, ich konnte dir helfen 😃 😃 😃



  • 😉


Anmelden zum Antworten