Distribuzione di un programa

[blackman85]

Ciao a tutti, avrei alcune domande da fare:
1) Le aziende grandi tipo microsoft come fanno a far memorizzare le impostazioni ai loro programmi? Ad esempio internet explorer per memorizzare le impostazioni utilizza un database?
2) Se un azienda sviluppa un programma ad esempio in c++ o in java che si appoggia ad un database ad esempio mysql, come fa poi a creare un installer per coloro che vogliono utilizzare il programma? Cioè serve un installer che installi anche il database?
3) Penso si sia capito, alla fine voglio sapere in che modo avviene la distribuzione di un programma cioè in che modo avviene la fase in cui si crea un installer.

Spero di essermi spiegato bene e sono curioso di conoscere le risposte.
Grazie a tutti...

[Oceans11]

Microsoft usa quel calderone del registro di sistema!!!!! In rari casi file di configurazione.
In java ho sempre visto usare classi apposite che gestiscono uno o più file per le impostazioni del programma, che è anche comoda e pulita come soluzione (a mio parere)

Per i db non ti so dire, però:

1) non ho mai visto (oppure mi sfugge in questo momento) un applicazione che ha la sua configurazione appoggiata su db, soprattutto visto che

2) mi risulta difficile pensare ad applicazioni con configurazioni tanto grandi da poter trarre beneficio dall'uso di un db in luogo del filesystem.

[-Slash]

Su linux le configurazioni dei programmi in genere sono memorizzate in semplici file di testo, contenuti nella directory principale dell'utente in cartelle nascoste aventi il nome del programma...

Su windows credo venga utilizzato il registro :D

[qwerty86]

Bhè ci sono programma di grandi dimensioni che usano il db per i loro dati e usano magari anche una tabella per le impostazioni del programma. Difficilmente però un programma che non usa il db lo userà solo per memorizzare la configurazione.

[fero86]

su Windows le applicazioni possono mettere i loro files di configurazione in una sottodirectory della cartella %APPDATA%, ma il piu delle volte non é consigliabile perché é inutile implementare algoritmi di parsing o piu in generale di lettura di un formato di file quando hai il registro che ti permette di ottenere direttamente i dati. in Java invece si usano le Preferences API: http://java.sun.com/javase/6/docs/technotes/guides/preferences/index.html

se vuoi usare il registro di sistema di Windows se ti interessa io mi sono scritto alcune classi C++ per usarlo in maniera semplice e diretta. questo é il codice delle classi:

RegKey.h
#pragma once


class CRegKey;

class CRegValue
{
private:
HKEY m_hKey;
LPCTSTR m_pszName;

public:
CRegValue(HKEY a_hKey, LPCTSTR pszName);

operator DWORD () const;
operator tstring () const;

DWORD operator = (DWORD dwValue);
LPCTSTR operator = (LPCTSTR pszValue);
wstring operator = (REFGUID rguid);

VOID Erase();
};


class CRegKey
{
private:
HKEY m_hKey;

inline CRegKey(const CRegKey&) {}
inline VOID operator = (const CRegKey&) {}

public:
inline CRegKey(HKEY a_hKey) :
m_hKey(a_hKey)
{
}

CRegKey(HKEY hkParent, LPCTSTR pszPath);
CRegKey(const CRegKey &rkParent, LPCTSTR pszPath);
virtual ~CRegKey();

CRegValue operator [] (LPCTSTR pszValueName);
const CRegValue operator [] (LPCTSTR pszValueName) const;

inline DWORD operator = (DWORD dwValue)
{
return operator [] (NULL) = dwValue;
}

inline LPCTSTR operator = (LPCTSTR pszValue)
{
return operator [] (NULL) = pszValue;
}

inline wstring operator = (REFGUID rguid)
{
return operator [] (NULL) = rguid;
}

VOID DeleteSubKey(LPCTSTR pszPath);
};

RegKey.cpp
#include "StdAfx.h"
#include "RegKey.h"

#include "Main.h"


static VOID CheckResult(LONG lResult);


CRegValue::CRegValue(HKEY a_hKey, LPCTSTR pszName) :
m_hKey(a_hKey),
m_pszName(pszName)
{
}


CRegValue::operator DWORD () const
{
DWORD dwValue;
DWORD cbValue = sizeof(DWORD);
LONG lResult = ::RegQueryValueEx(m_hKey, m_pszName, NULL, NULL, (LPBYTE)&dwValue, &cbValue);
::CheckResult(lResult);
return dwValue;
}

CRegValue::operator tstring () const
{
DWORD cbData = 0;

LONG lResult = ::RegQueryValueEx(m_hKey, m_pszName, NULL, NULL, NULL, &cbData);
::CheckResult(lResult);

DWORD cchData = cbData / sizeof(TCHAR);
LPTSTR pszData = new TCHAR[cchData + 1];
lResult = ::RegQueryValueEx(m_hKey, m_pszName, NULL, NULL, (LPBYTE)pszData, &cbData);
if (lResult != ERROR_SUCCESS)
{
delete pszData;
::RaiseError(lResult);
}
else
{
pszData[cchData] = 0;
tstring strData = pszData;
delete pszData;
return strData;
}
}


DWORD CRegValue::operator = (DWORD dwValue)
{
LONG lResult = ::RegSetValueEx(m_hKey, m_pszName, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
::CheckResult(lResult);
return dwValue;
}

LPCTSTR CRegValue::operator = (LPCTSTR pszValue)
{
DWORD cbValue = (::lstrlen(pszValue) + 1) * sizeof(TCHAR);
LONG lResult = ::RegSetValueEx(m_hKey, m_pszName, 0, REG_SZ, (LPBYTE)pszValue, cbValue);
::CheckResult(lResult);
return pszValue;
}

wstring CRegValue::operator = (REFGUID rguid)
{
WCHAR szGuid[0x100];
VERIFY(::StringFromGUID2(rguid, szGuid, 0x100));

DWORD cbGuid = (::lstrlen(szGuid) + 1) * sizeof(WCHAR);
LONG lResult = ::RegSetValueExW(m_hKey, m_pszName, 0, REG_SZ, (LPBYTE)szGuid, cbGuid); // FIXME
::CheckResult(lResult);

return szGuid;
}


VOID CRegValue::Erase()
{
LONG lResult = ::RegDeleteValue(m_hKey, m_pszName);
::CheckResult(lResult);
}


CRegKey::CRegKey(HKEY hkParent, LPCTSTR pszPath)
{
LONG lResult = ::RegCreateKeyEx(hkParent, pszPath, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &m_hKey, NULL);
::CheckResult(lResult);
}

CRegKey::CRegKey(const CRegKey &rkParent, LPCTSTR pszPath)
{
LONG lResult = ::RegCreateKeyEx(rkParent.m_hKey, pszPath, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &m_hKey, NULL);
::CheckResult(lResult);
}

CRegKey::~CRegKey()
{
LONG lResult = ::RegCloseKey(m_hKey);
::CheckResult(lResult);
}


CRegValue CRegKey::operator [] (LPCTSTR pszValueName)
{
return CRegValue(m_hKey, pszValueName);
}

const CRegValue CRegKey::operator [] (LPCTSTR pszValueName) const
{
return CRegValue(m_hKey, pszValueName);
}


VOID CRegKey::DeleteSubKey(LPCTSTR pszPath)
{
LONG lResult = ::RegDeleteKey(m_hKey, pszPath);
::CheckResult(lResult);
}


VOID CheckResult(LONG lResult)
{
if (lResult != ERROR_SUCCESS)
{
::RaiseError(lResult);
}
}

la funzione RaiseError non definita in questo codice non fa altro che chiamare l'API RaiseException; le classi infatti sono progettate per lanciare eccezioni in caso di errori, cosi possono essere usate in maniera molto piu semplice e diretta. esempio d'uso:

/* apre o crea una chiave "TuaApplicazione" all'interno della chiave HKCU\Software */
CRegKey rkSettings(HKEY_CURRENT_USER, _T("Software\\TuaApplicazione"));

/* scrive la stringa "pippo" nel valore di default della chiave */
rkSettings = L"pippo";

/* scrive il DWORD 0x00000005 nel valore "Setting1" della chiave */
rkSettings[_T("Setting1")] = 5;

/* scrive la stringa "pluto" nel valore "Setting2" della chiave */
rkSettings[_T("Setting2")] = L"pluto";

[fero86]

ah dimenticavo, il tipo tstring é un tipo mio, l'ho definito in StdAfx.h:

#include <string>
using namespace std;

#ifdef UNICODE
#define tstring wstring
#else
#define tstring string
#endif


peró siccome io nei miei progetti definisco sempre la macro UNICODE fai conto che tstring sia wstring.