Questione : Come rilevare se gli assistenti 2005 o 2008 di SQL sono installati

Ciao, il

How può io rilevare se gli assistenti 2005 o 2008 di SQL sono installati su un calcolatore dall'interno di un'applicazione di Delfi? il
Preferably non usando il registry.

I ha trovato un certo codice in C# che potrebbe fare questo??? (vedere sotto). class= > " libero " del
> " del codeSnippet " del class= del
class= " lineNumbers " del
class= del 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
sistema >using notpretty " del class= " del id= " codeSnippet780363 del 
 di ///
        /// enumera tutti i casi dell'assistente di SQL sulla macchina.
        /// 
        /// 
        bool statico pubblico EnumerateSQLInstances ()
        {
            correctNamespace = GetCorrectWmiNameSpace della stringa ();
            se (stringa. Uguali (correctNamespace, stringa. Svuotare))
            {
                restituire falso;
            }
            mettere insieme la domanda = la stringa. Disposizione (“selezionare * a partire da SqlServiceAdvancedProperty dove SQLServiceType = 1 e PropertyName = “instanceID„ ");
            getSqlEngine di ManagementObjectSearcher = nuovo ManagementObjectSearcher (correctNamespace, domanda);
            se (getSqlEngine.Get (). == 0 di conteggio)
            {
                falso di ritorno;
            }
            Console.WriteLine (“i casi della base di dati di assistente di SQL hanno scoperto: ");
            instanceName della stringa = stringa. Vuoto;
            serviceName della stringa = stringa. Vuoto;
            versione della stringa = stringa. Vuoto;
            edizione della stringa = stringa. Vuoto;
            Console.WriteLine (“versione \ t dell'edizione \ t di nome \ t ServiceName \ t di caso„);
            foreach (sqlEngine di ManagementObject in getSqlEngine.Get ())
            {
                serviceName = sqlEngine [“ServiceName„] .ToString ();
                instanceName = GetInstanceNameFromServiceName (serviceName);
                versione = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “versione„);
                edizione = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “SKUNAME„);
                Console.Write (“{0} \ t„, instanceName);
                Console.Write (“{0} \ t„, serviceName);
                Console.Write (“{0} \ t„, edizione);
                Console.WriteLine (“{0} \ t„, versione);
            }
            di ritorno allineare;
        }
         di ///
        Il metodo di /// restituisce il namespace corretto di SQL per usare per rilevare i casi dell'assistente di SQL.
        /// 
        namespace di /// da usare per rilevare l'assistente instances di SQL
        stringa statica pubblica GetCorrectWmiNameSpace ()
        {
            Mettere insieme il wmiNamespaceToUse = “radice \ \ \ \ sqlserver di Microsoft„;
            Namespaces di List = nuovo List ();
            prova
            {
                // enumera tutti i casi di WMI di
                codice categoria del __namespace WMI di //.
                nsClass di ManagementClass =
                    nuovo ManagementClass (
                    nuovo ManagementScope (wmiNamespaceToUse),
                    nuovo ManagementPath (“__namespace„),
                    posizione di segnale minimo);
                foreach (ManagementObject NS dentro
                    nsClass.GetInstances ())
                {
                    namespaces. Aggiungere (NS [“nome„] .ToString ());
                }
            }
            interferire (ManagementException e)
            {
                Console.WriteLine (“eccezione =„ + e.Message);
            }
            se (namespaces. Conteggio > 0)
            {
                se (namespaces. Contiene (“ComputerManagement10„))
                {
                    namespace di //use katmai+
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement10„;
                }
                altrimenti se (namespaces. Contiene (“ComputerManagement„))
                {
                    namespace di //use yukon
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement„;
                }
                altrimenti
                {
                    wmiNamespaceToUse = stringa. Vuoto;
                }
            }
            altrimenti
            {
                wmiNamespaceToUse = stringa. Vuoto;
            }
            wmiNamespaceToUse di ritorno;
        }
         di ///
        il metodo di /// estrae il nome di caso dal nome di servizio
        /// 
        name= " serviceName " > del 
        stringa statica pubblica GetInstanceNameFromServiceName (serviceName della stringa)
        {
            se (! string.IsNullOrEmpty (serviceName))
            {
                se (stringa. Uguali (serviceName, “MSSQLSERVER„, StringComparison.OrdinalIgnoreCase))
                {
                    serviceName di ritorno;
                }
                altrimenti
                {
                    serviceName.Substring di ritorno (serviceName.IndexOf (“$") + 1, serviceName.Length - serviceName.IndexOf (“$„) - 1);
                }
            }
            altrimenti
            {
                stringa di ritorno. Vuoto;
            }
        }
         di ///
        /// restituisce il valore di una proprietà di WMI per un nome proprietà dato per un nome particolare di servizio dell'assistente di SQL
        /// 
        nome di servizio del >The " del serviceName " del name= del 
        namespace di wmi del >The " del wmiNamespace " del name= del 
        nome proprietà del >The " del propertyName " del name= del 
        /// 
        stringa statica pubblica GetWmiPropertyValueForEngineService (serviceName della stringa, wmiNamespace della stringa, propertyName della stringa)
        {
            propertyValue della stringa = stringa. Vuoto;
            mettere insieme la domanda = String.Format (“selezionare * a partire da SqlServiceAdvancedProperty dove SQLServiceType = 1 e PropertyName = “{0}„ e ServiceName = “{1}„ “, propertyName, serviceName);
            propertySearcher di ManagementObjectSearcher = nuovo ManagementObjectSearcher (wmiNamespace, domanda);
            foreach (sqlEdition di ManagementObject in propertySearcher.Get ())
            {
                propertyValue = sqlEdition [“PropertyStrValue„] .ToString ();
            }
            propertyValue di ritorno;
        }
    }
}
class= del

Risposta : Come rilevare se gli assistenti 2005 o 2008 di SQL sono installati

La mia fonte ha cercato appena un caso specifico dell'assistente di SQL espresso, ho trovato che un poco tempo e modificato il codice enumerare i casi ha basato un piccolo sul codice di C# avete inviato alla parte superiore. 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:

funzione GetSQLInstances (casi: TStrings): Booleano;
  funzione GetInstanceNameFromServiceName (const ServiceName: stringa): stringa;
  const
    SQLSERVER = “MSSQLSERVER„;
  cominciare
    se ServiceName = '' allora
      Risultato: = ''
    altrimenti
    cominciare
      se maiuscola (ServiceName) = SQLSERVER allora
        Risultato: = ServiceName
      altrimenti
        Risultato: = copia (ServiceName, posizione (“$„, ServiceName) +1, lunghezza (ServiceName) - posizione (“$„, ServiceName));
    estremità;
  estremità;
  funzione GetWMIPropertyValueForEngineService (const PropertyName, ServiceName, WMINameSpace: stringa): stringa;
  varietà
    SWL: TSWbemLocator;
    SWServ: ISWbemServices;
    SWObjSet: ISWbemObjectSet;
    Enum: IEnumVariant;
    tempObj: OleVariant;
    Valore: Cardinale;    
    SWObj: ISWbemObject;
    SWPropSet: ISWbemPropertySet;
    sQry: stringa;
  cominciare
    SWL: = TSWbemLocator.Create (zero);
    prova
      prova
        SWServ: = SWL.ConnectServer ('', WMINameSpace, '', '', '', '', 0, zero);
        sQry: = disposizione ('selezionare * a partire da SqlServiceAdvancedProperty dove SQLServiceType = 1 e PropertyName = '' %s '' e ServiceName = '' ''' di %s, [PropertyName, ServiceName]);
        SWObjSet: = SWServ.ExecQuery (sQry, “WQL„, wbemFlagReturnImmediately, zero);
        se SWObjSet.Count = 0 allora
        cominciare
          Risultato: = '';
          Uscita;
        estremità;
        //
        Enum: = (_NewEnum di SWObjSet.) come IEnumVariant;
        mentre (Enum.Next (1, tempObj, valore) = S_OK) fare
        cominciare
          SWObj: = IUnknown (tempObj) come SWBemObject;
          SWPropSet: = SWObj.Properties_;
          Risultato: = SWPropSet.Item (“PropertyStrValue„, 0). Get_Value;
        estremità;
      tranne
        sulla E: L'eccezione fa
        cominciare
          //WriteLn (“errore: „ + e.Message);
          Risultato: = '';
        estremità;
      estremità;
    infine
      SWL.Disconnect;
      FreeAndNil (SWL);
    estremità;
  estremità;
const
  WMI_NAMESPACES_TO_CHECK: allineamento [0..1] di stringa = (“ComputerManagement„, “ComputerManagement10„);
varietà
  GetSqlExpress: TSWbemLocator;
  Servizi: ISWbemServices;
  ObjectSet: ISWbemObjectSet;
  SObject: ISWbemObject;
  propSet: ISWbemPropertySet;
  Enum: IEnumVariant;
  tempObj: OleVariant;
  Valore: Cardinale;
  //
  sQry: stringa;
  serviceName: stringa;
  WMIPath: stringa;
  i: Numero intero;
cominciare
  Risultato: = falso;
  Instances.Clear;
  per la i: = 0 - 1 fanno
  cominciare
    WMIPath: = disposizione (“radice \ Microsoft \ SqlServer \ %s„, [WMI_NAMESPACES_TO_CHECK [i]]);
    GetSqlExpress: = TSWbemLocator.Create (zero);
    prova
      prova
        Servizi: = GetSqlExpress.ConnectServer ('', WMIPath, '', '', '', '', 0, zero);
        sQry: = disposizione ('SELEZIONARE * A PARTIRE da SqlServiceAdvancedProperty DOVE SQLServiceType = 1 E PropertyName = '' ''' del instanceID, [{SQL_INSTANCE}]);
        ObjectSet: = Services.ExecQuery (sQry, “WQL„, wbemFlagReturnImmediately, zero);
        se ObjectSet.Count = 0 allora
        cominciare
          Continuare;
        estremità;
        //
        Enum: = (_NewEnum di ObjectSet.) come IEnumVariant;
        mentre (Enum.Next (1, tempObj, valore) = S_OK) fare
        cominciare
          SObject: = IUnknown (tempObj) come SWBemObject;
          propSet: = SObject.Properties_;
          serviceName: = propSet.Item (“ServiceName„, 0). Get_Value;
          Servizio di //, caso, versione, edizione
          Instances.Add (disposizione (“%s, %s, %s, %s„,
            [serviceName,
              GetInstanceNameFromServiceName (serviceName),
              GetWMIPropertyValueForEngineService (“versione„, serviceName, WMIPath),
              GetWMIPropertyValueForEngineService (“SKUNAME„, serviceName, WMIPath)]));
        estremità;
        Risultato: = allineare;
      tranne
        sulla E: L'eccezione fa
        cominciare
          //WriteLn (“errore: „ + e.Message);
          Risultato: = falso;
        estremità;
      estremità;
    infine
      GetSqlExpress.Disconnect;
      FreeAndNil (GetSqlExpress);
    estremità;
  estremità;
estremità;
Altre soluzioni  
 
programming4us programming4us