Stoor registerwaardes in WinCE met 'n C#-toepassing

Question

Ek werk aan 'n WinCE 6.0-stelsel met 'n raakskerm wat sy kalibrasiedata (x-y-ligging, offset, ens.) in die stelselregister (HKLM\HARDWARE OUCH) stoor.Op die oomblik plaas ek die cal-waardes in registersleutels wat tydens boutyd in die OS-beeld geplaas word.Dit werk goed vir die monitor waarvan ek die oorspronklike cal-waardes kry, maar wanneer ek hierdie beeld in 'n ander stelsel met 'n ander monitor laai, is die raakskermwyserligging (te verstane) af, want die twee monitors het nie dieselfde cal-waardes nie. .

My probleem is dat ek nie weet hoe om waardes behoorlik in die register te stoor sodat hulle na 'n kragsiklus voortduur nie.Sien, ek kan die skerm op die tweede stelsel herkalibreer, maar die nuwe waardes bestaan ​​net in vlugtige geheue.Ek het aan my baas voorgestel dat ons net vir ons klant kan sê om die krag te alle tye op die eenheid te laat -- dit het nie goed gegaan nie.

Ek het raad nodig oor hoe om die nuwe konstantes in die register te stoor, sodat ons die monitors een keer kan kalibreer voordat dit na ons kliënt gestuur word, en nie aparte OS-beelde hoef te maak vir elke eenheid wat ons bou nie.

'n C#-metode waarvan bekend is dat dit in CE6.0 werk, sal nuttig wees.Dankie.

- Odbasta

Answer 1

Ek dink waarna jy waarskynlik soek, is die Flush-funksie van die RegistryKey-klas.Dit is gewoonlik nie nodig nie (die register word by verstek lui-gespoel), maar as die krag op die toestel afgeskakel word voordat die stelsel kans het om dit te doen, sal veranderinge weggegooi word:

http://msdn.microsoft.com/en-us/library/microsoft.win32.registrykey.flush.aspx

Hierdie funksie is beskikbaar in .NET Compact Framework weergawe 2.0 en beter.

Answer 2

Opvolg op hierdie vraag:

Dankie DannySmurf, die spoel van die registersleutel was uiteindelik wat gedoen moes word.Daar was egter 'n paar stappe wat ek gemis het voordat ek daardie stadium bereik het.So, hier is wat aan die lig gekom het:

• Ek het 'n RAM-gebaseerde register gebruik, waar die register volgens ontwerp nie voortduur na 'n koue selflaai nie.Ek moes die register oorskakel na korf-gebaseerde.

• Wanneer jy oorskakel na 'n korf-gebaseerde registerstruktuur, moet jy seker maak dat die korf op 'n nie-vlugtige medium bestaan.Dit word in die platform.reg-lêer gespesifiseer:

  [HKEY_LOCAL_MACHINE\init\BootVars]
  "SystemHive"="\\Hard Disk\\system.hv"
  "ProfileDir"="\\Documents and Settings"
  "RegistryFlags"=dword:1               ; Flush hive on every RegCloseKey call
  "SystemHiveInitialSize"=dword:19000   ; Initial size for hive-registry file 
  "Start DevMgr"=dword:1
  

• Sodra die system.hv-lêer op die hardeskyf is (CF-kaart in my geval), sal die waardes in die register voortduur na 'n koue selflaai.Let daarop dat die system.hv-lêer al die HKLM-sleutels bevat.

• Dit is ook belangrik om daarop te let dat enige drywers wat tydens selflaai geïnisieer moet word, as sodanig in die .reg-lêers van die oplossing gespesifiseer moet word.Ek moes byvoorbeeld seker maak dat die hardeskyfbestuurders (PCMCIA) gelaai is voordat ek die stelselkorflêer van hulle probeer lees het.Die manier om dit te doen is om 'n opdrag in die volgende formaat rondom elke bestuurder se init-sleutel by te voeg:

  ;HIVE BOOT SECTION
  [HKEY_LOCAL_MACHINE\Drivers\PCCARD\PCMCIA\TEMPLATE\PCMCIA]
    "Dll"="pcmcia.dll"
    "NoConfig"=dword:1
    "IClass"=multi_sz:"{6BEAB08A-8914-42fd-B33F-61968B9AAB32}=PCMCIA Card Services"
    "Flags"=dword:1000
  ;END HIVE BOOT SECTION
  

Dit, plus baie geluk, gaan daaroor.

Answer 3

Soos ek verstaan ​​het, moet jy weet hoe om 'n waarde vir die register te stel tydens looptyd.Ek hoop die kodes hieronder kan jou help.

met behulp van Microsoft.Win32;

    /// <summary>
    /// store a key value in registry. if it don't exist it will be created. 
    /// </summary>
    /// <param name="mainKey">the main key of key path</param>
    /// <param name="subKey">the path below the main key</param>
    /// <param name="keyName">the key name</param>
    /// <param name="value">the value to be stored</param>
    public static void SetRegistry(int mainKey, String subKey, String keyName, object value)
    {
        if (mainKey != CURRENT_USER && mainKey != LOCAL_MACHINE)
        {
            throw new ArgumentOutOfRangeException("mainKey", "\'mainKey\' argument can only be AppUtils.CURRENT_USER or AppUtils.LOCAL_MACHINE values");
        }

        if (subKey == null)
        {
            throw new ArgumentNullException("subKey", "\'subKey\' argument cannot be null");
        }

        if (keyName == null)
        {
            throw new ArgumentNullException("keyName", "\'keyName\' argument cannot be null");
        }

        const Boolean WRITABLE = true;
        RegistryKey key = null;

        if (mainKey == CURRENT_USER)
        {
            key = Registry.CurrentUser.OpenSubKey(subKey, WRITABLE);

            if (key == null)
            {
                key = Registry.CurrentUser.CreateSubKey(subKey);
            }
        }
        else if (mainKey == LOCAL_MACHINE)
        {
            key = Registry.LocalMachine.OpenSubKey(subKey, WRITABLE);

            if (key == null)
            {
                key = Registry.LocalMachine.CreateSubKey(subKey);
            }
        }

        key.SetValue(keyName, value);

    }

    /// <summary>
    /// find a key value in registry. if it don't exist the default value will be returned.
    /// </summary>
    /// <param name="mainKey">the main key of key path</param>
    /// <param name="subKey">the path below the main key</param>
    /// <param name="keyName">the key name</param>
    /// <param name="defaultValue">the value to be stored</param>

    public static object GetRegistry(int mainKey, String subKey, String keyName, object defaultValue)
    {
        if (mainKey != CURRENT_USER && mainKey != LOCAL_MACHINE)
        {
            throw new ArgumentOutOfRangeException("mainKey", "\'mainKey\' argument can only be AppUtils.CURRENT_USER or AppUtils.LOCAL_MACHINE values");
        }

        if (subKey == null)
        {
            throw new ArgumentNullException("subKey", "\'subKey\' argument cannot be null");
        }

        if (keyName == null)
        {
            throw new ArgumentNullException("keyName", "\'keyName\' argument cannot be null");
        }

        RegistryKey key = Registry.CurrentUser.OpenSubKey(subKey);

        if (mainKey == CURRENT_USER)
        {
            key = Registry.CurrentUser.OpenSubKey(subKey);
        }
        else if (mainKey == LOCAL_MACHINE)
        {
            key = Registry.LocalMachine.OpenSubKey(subKey);
        }

        object result = defaultValue;

        if (key != null)
        {
            result = key.GetValue(keyName, defaultValue);
        }

        return result;
    }