Cuestión : Cómo detectar si el servidor 2005 o 2008 del SQL está instalado

¿Hola, el

How puede yo detectar si el servidor 2005 o 2008 del SQL está instalado en una computadora dentro de un uso de Delphi? ¿el
Preferably no usando el registry.

I encontró un cierto código en C# que pudo hacer esto??? (véase abajo). class= > " claro " 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 
 de ///
        /// enumera todos los casos del servidor del SQL en la máquina.
        /// 
        /// 
        bool estático público EnumerateSQLInstances ()
        {
            correctNamespace = GetCorrectWmiNameSpace de la secuencia ();
            si (secuencia. Iguales (correctNamespace, secuencia. Vaciar))
            {
                volver falso;
            }
            encadenar la pregunta = la secuencia. Formato (“seleccionar * de SqlServiceAdvancedProperty donde SQLServiceType = 1 y PropertyName = “instanceID” ");
            getSqlEngine de ManagementObjectSearcher = nuevo ManagementObjectSearcher (correctNamespace, pregunta);
            si (getSqlEngine.Get (). == 0 de la cuenta)
            {
                falso de vuelta;
            }
            Console.WriteLine (“los casos de la base de datos de servidor del SQL descubrieron: ");
            instanceName de la secuencia = secuencia. Vacío;
            serviceName de la secuencia = secuencia. Vacío;
            versión de la secuencia = secuencia. Vacío;
            edición de la secuencia = secuencia. Vacío;
            Console.WriteLine (“versión \ t de la edición \ t del nombre \ t ServiceName \ t del caso”);
            foreach (sqlEngine de ManagementObject en getSqlEngine.Get ())
            {
                serviceName = sqlEngine [“ServiceName”] .ToString ();
                instanceName = GetInstanceNameFromServiceName (serviceName);
                versión = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “versión”);
                edición = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “SKUNAME”);
                Console.Write (“{0} \ t”, instanceName);
                Console.Write (“{0} \ t”, serviceName);
                Console.Write (“{0} \ t”, edición);
                Console.WriteLine (“{0} \ t”, versión);
            }
            de vuelta verdad;
        }
         de ///
        El método de /// vuelve el namespace correcto del SQL para utilizar para detectar casos del servidor del SQL.
        /// 
        namespace de /// a utilizar para detectar el servidor instances del SQL
        secuencia estática pública GetCorrectWmiNameSpace ()
        {
            Encadenar el wmiNamespaceToUse = “raíz \ \ \ \ sqlserver de Microsoft”;
            Namespaces de List = nuevo List ();
            intento
            {
                // enumera todos los casos de WMI de
                clase del __namespace WMI de //.
                nsClass de ManagementClass =
                    nuevo ManagementClass (
                    nuevo ManagementScope (wmiNamespaceToUse),
                    nuevo ManagementPath (“__namespace”),
                    falta de información);
                foreach (ManagementObject ns adentro
                    nsClass.GetInstances ())
                {
                    namespaces. Agregar (ns [“nombre”] .ToString ());
                }
            }
            coger (ManagementException e)
            {
                Console.WriteLine (“excepción =” + e.Message);
            }
            si (namespaces. Cuenta > 0)
            {
                si (namespaces. Contiene (“ComputerManagement10”))
                {
                    namespace de //use katmai+
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement10”;
                }
                si (namespaces. Contiene (“ComputerManagement”))
                {
                    namespace de //use yukon
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement”;
                }
                
                {
                    wmiNamespaceToUse = secuencia. Vacío;
                }
            }
            
            {
                wmiNamespaceToUse = secuencia. Vacío;
            }
            wmiNamespaceToUse de vuelta;
        }
         de ///
        el método de /// extrae el nombre del caso del nombre del servicio
        /// 
        name= " serviceName " > del 
        secuencia estática pública GetInstanceNameFromServiceName (serviceName de la secuencia)
        {
            ¡si (! string.IsNullOrEmpty (serviceName))
            {
                si (secuencia. Iguales (serviceName, “MSSQLSERVER”, StringComparison.OrdinalIgnoreCase))
                {
                    serviceName de vuelta;
                }
                
                {
                    serviceName.Substring de vuelta (serviceName.IndexOf (“$") + 1, serviceName.Length - serviceName.IndexOf (“$”) - 1);
                }
            }
            
            {
                secuencia de vuelta. Vacío;
            }
        }
         de ///
        /// vuelve el valor de una propiedad de WMI para un nombre de característica dado para un nombre particular del servicio del servidor del SQL
        /// 
        nombre del servicio del >The del " serviceName " del name= del 
        namespace del wmi del >The del " wmiNamespace " del name= del 
        nombre de característica del >The del " propertyName " del name= del 
        /// 
        secuencia estática pública GetWmiPropertyValueForEngineService (serviceName de la secuencia, wmiNamespace de la secuencia, propertyName de la secuencia)
        {
            propertyValue de la secuencia = secuencia. Vacío;
            encadenar la pregunta = String.Format (“seleccionar * de SqlServiceAdvancedProperty donde SQLServiceType = 1 y PropertyName = “{0}” y ServiceName = “{1}” “, propertyName, serviceName);
            propertySearcher de ManagementObjectSearcher = nuevo ManagementObjectSearcher (wmiNamespace, pregunta);
            foreach (sqlEdition de ManagementObject en propertySearcher.Get ())
            {
                propertyValue = sqlEdition [“PropertyStrValue”] .ToString ();
            }
            propertyValue de vuelta;
        }
    }
}
class= del

Respuesta : Cómo detectar si el servidor 2005 o 2008 del SQL está instalado

Mi fuente acaba de buscar un caso específico del servidor del SQL expreso, he encontrado que un poco rato y modificado el código de enumerar los casos basó un poco en el código de C# que usted fijó en la tapa. 
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:

función GetSQLInstances (casos: TStrings): Boleano;
  función GetInstanceNameFromServiceName (const ServiceName: secuencia): secuencia;
  const
    SQLSERVER = “MSSQLSERVER”;
  comenzar
    si ServiceName = '' entonces
      Resultado: = ''
    
    comenzar
      si mayúscula (ServiceName) = SQLSERVER entonces
        Resultado: = ServiceName
      
        Resultado: = copia (ServiceName, posición (“$”, ServiceName) +1, longitud (ServiceName) - posición (“$”, ServiceName));
    extremo;
  extremo;
  función GetWMIPropertyValueForEngineService (const PropertyName, ServiceName, WMINameSpace: secuencia): secuencia;
  var
    SWL: TSWbemLocator;
    SWServ: ISWbemServices;
    SWObjSet: ISWbemObjectSet;
    Enum: IEnumVariant;
    tempObj: OleVariant;
    Valor: Cardinal;    
    SWObj: ISWbemObject;
    SWPropSet: ISWbemPropertySet;
    sQry: secuencia;
  comenzar
    SWL: = TSWbemLocator.Create (nada);
    intento
      intento
        SWServ: = SWL.ConnectServer ('', WMINameSpace, '', '', '', '', 0, nada);
        sQry: = formato ('seleccionar * de SqlServiceAdvancedProperty donde SQLServiceType = 1 y PropertyName = '' %s '' y ServiceName = '' ''' de %s, [PropertyName, ServiceName]);
        SWObjSet: = SWServ.ExecQuery (sQry, “WQL”, wbemFlagReturnImmediately, nada);
        si SWObjSet.Count = 0 entonces
        comenzar
          Resultado: = '';
          Salida;
        extremo;
        //
        Enum: = (_NewEnum de SWObjSet.) como IEnumVariant;
        mientras que (Enum.Next (1, tempObj, valor) = S_OK) hacer
        comenzar
          SWObj: = IUnknown (tempObj) como SWBemObject;
          SWPropSet: = SWObj.Properties_;
          Resultado: = SWPropSet.Item (“PropertyStrValue”, 0). Get_Value;
        extremo;
      excepto
        en E: La excepción hace
        comenzar
          //WriteLn (“error: ” + e.Message);
          Resultado: = '';
        extremo;
      extremo;
    finalmente
      SWL.Disconnect;
      FreeAndNil (SWL);
    extremo;
  extremo;
const
  WMI_NAMESPACES_TO_CHECK: arsenal [0..1] de secuencia = (“ComputerManagement”, “ComputerManagement10”);
var
  GetSqlExpress: TSWbemLocator;
  Servicios: ISWbemServices;
  ObjectSet: ISWbemObjectSet;
  SObject: ISWbemObject;
  propSet: ISWbemPropertySet;
  Enum: IEnumVariant;
  tempObj: OleVariant;
  Valor: Cardinal;
  //
  sQry: secuencia;
  serviceName: secuencia;
  WMIPath: secuencia;
  i: Número entero;
comenzar
  Resultado: = falso;
  Instances.Clear;
  para i: = 0 a 1 hace
  comenzar
    WMIPath: = formato (“raíz \ Microsoft \ SqlServer \ %s”, [WMI_NAMESPACES_TO_CHECK [i]]);
    GetSqlExpress: = TSWbemLocator.Create (nada);
    intento
      intento
        Servicios: = GetSqlExpress.ConnectServer ('', WMIPath, '', '', '', '', 0, nada);
        sQry: = formato ('SELECCIONAR * de SqlServiceAdvancedProperty DONDE SQLServiceType = 1 Y PropertyName = '' ''' del instanceID, [{SQL_INSTANCE}]);
        ObjectSet: = Services.ExecQuery (sQry, “WQL”, wbemFlagReturnImmediately, nada);
        si ObjectSet.Count = 0 entonces
        comenzar
          Continuar;
        extremo;
        //
        Enum: = (_NewEnum de ObjectSet.) como IEnumVariant;
        mientras que (Enum.Next (1, tempObj, valor) = S_OK) hacer
        comenzar
          SObject: = IUnknown (tempObj) como SWBemObject;
          propSet: = SObject.Properties_;
          serviceName: = propSet.Item (“ServiceName”, 0). Get_Value;
          Servicio de //, caso, versión, edición
          Instances.Add (formato (“%s, %s, %s, %s”,
            [serviceName,
              GetInstanceNameFromServiceName (serviceName),
              GetWMIPropertyValueForEngineService (“versión”, serviceName, WMIPath),
              GetWMIPropertyValueForEngineService (“SKUNAME”, serviceName, WMIPath)]));
        extremo;
        Resultado: = verdad;
      excepto
        en E: La excepción hace
        comenzar
          //WriteLn (“error: ” + e.Message);
          Resultado: = falso;
        extremo;
      extremo;
    finalmente
      GetSqlExpress.Disconnect;
      FreeAndNil (GetSqlExpress);
    extremo;
  extremo;
extremo;
Otras soluciones  
 
programming4us programming4us