Pergunta : Como detetar se o usuário 2005 ou 2008 do SQL é instalado

Olá!, o

How pode mim detetar se o usuário 2005 ou 2008 do SQL é instalado em um computador dentro de uma aplicação de Delphi? o
Preferably não usando o registry.

I encontrou algum código em C# que pôde fazer este??? (ver abaixo). class= > " desobstruído " do
> do " codeSnippet " do class= do
class= " lineNumbers " do
class= do 
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 " do class= " do id= " codeSnippet780363 do 
 de ///
        /// enumera todos os exemplos do usuário do SQL na máquina.
        /// 
        /// 
        bool de estática público EnumerateSQLInstances ()
        {
            correctNamespace = GetCorrectWmiNameSpace da corda ();
            se (corda. Iguais (correctNamespace, corda. Esvaziar))
            {
                retornar falso;
            }
            amarrar a pergunta = a corda. Formato (“selecionar * de SqlServiceAdvancedProperty onde SQLServiceType = 1 e PropertyName = “instanceID” ");
            getSqlEngine de ManagementObjectSearcher = ManagementObjectSearcher novo (correctNamespace, pergunta);
            se (getSqlEngine.Get (). == 0 da contagem)
            {
                falso do retorno;
            }
            Console.WriteLine (do “os exemplos da base de dados de usuário SQL descobriram: ");
            instanceName da corda = corda. Vazio;
            serviceName da corda = corda. Vazio;
            versão da corda = corda. Vazio;
            edição da corda = corda. Vazio;
            Console.WriteLine (do “versão da edição do nome exemplo \ t ServiceName \ t \ t \ t”);
            foreach (sqlEngine de ManagementObject em getSqlEngine.Get ())
            {
                serviceName = sqlEngine [“ServiceName”] .ToString ();
                instanceName = GetInstanceNameFromServiceName (serviceName);
                versão = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “versão”);
                edição = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “SKUNAME”);
                Console.Write (“{0} \ t”, instanceName);
                Console.Write (“{0} \ t”, serviceName);
                Console.Write (“{0} \ t”, edição);
                Console.WriteLine (“{0} \ t”, versão);
            }
            do retorno retificar;
        }
         de ///
        O método de /// retorna o namespace correto do SQL para usar-se para detetar exemplos do usuário do SQL.
        /// 
        namespace de /// a usar-se para detetar o usuário instances do SQL
        corda de estática pública GetCorrectWmiNameSpace ()
        {
            Amarrar o wmiNamespaceToUse = “raiz \ \ \ de Microsoft \ sqlserver”;
            Namespaces de List = List novo ();
            tentativa
            {
                // enumera todos os exemplos de WMI de
                classe do __namespace WMI de //.
                nsClass de ManagementClass =
                    ManagementClass novo (
                    ManagementScope novo (wmiNamespaceToUse),
                    ManagementPath novo (“__namespace”),
                    zero);
                foreach (ManagementObject ns dentro
                    nsClass.GetInstances ())
                {
                    namespaces. Adicionar (ns [“nome”] .ToString ());
                }
            }
            travar (ManagementException e)
            {
                Console.WriteLine (“exceção =” + e.Message);
            }
            se (namespaces. Contagem > 0)
            {
                se (namespaces. Contem (“ComputerManagement10”))
                {
                    namespace de //use katmai+
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement10”;
                }
                mais se (namespaces. Contem (“ComputerManagement”))
                {
                    namespace de //use yukon
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement”;
                }
                mais
                {
                    wmiNamespaceToUse = corda. Vazio;
                }
            }
            mais
            {
                wmiNamespaceToUse = corda. Vazio;
            }
            wmiNamespaceToUse do retorno;
        }
         de ///
        o método de /// extrai o nome do exemplo do nome do serviço
        /// 
        name= " serviceName " > do 
        corda de estática pública GetInstanceNameFromServiceName (serviceName da corda)
        {
            se (! string.IsNullOrEmpty (serviceName))
            {
                se (corda. Iguais (serviceName, “MSSQLSERVER”, StringComparison.OrdinalIgnoreCase))
                {
                    serviceName do retorno;
                }
                mais
                {
                    serviceName.Substring do retorno (serviceName.IndexOf (“$") + 1, serviceName.Length - serviceName.IndexOf (“$”) - 1);
                }
            }
            mais
            {
                corda do retorno. Vazio;
            }
        }
         de ///
        /// retorna o valor dos bens imóveis de WMI para um nome de propriedade dado para um nome particular do serviço do usuário do SQL
        /// 
        nome do serviço do >The do " serviceName " do name= do 
        namespace do wmi do >The do " wmiNamespace " do name= do 
        nome de propriedade do >The do " propertyName " do name= do 
        /// 
        corda de estática pública GetWmiPropertyValueForEngineService (serviceName da corda, wmiNamespace da corda, propertyName da corda)
        {
            propertyValue da corda = corda. Vazio;
            amarrar a pergunta = o String.Format (“selecionar * de SqlServiceAdvancedProperty onde SQLServiceType = 1 e PropertyName = “{0}” e ServiceName = “{1}” “, propertyName, serviceName);
            propertySearcher de ManagementObjectSearcher = ManagementObjectSearcher novo (wmiNamespace, pergunta);
            foreach (sqlEdition de ManagementObject em propertySearcher.Get ())
            {
                propertyValue = sqlEdition [“PropertyStrValue”] .ToString ();
            }
            propertyValue do retorno;
        }
    }
}
class= do

Resposta : Como detetar se o usuário 2005 ou 2008 do SQL é instalado

Minha fonte apenas procurou um exemplo específico do usuário do SQL expresso, eu encontrei que pouca estadia e modificado o código enumerar os exemplos baseou um pouco no código que de C# você afixou na parte superior. 
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:

função GetSQLInstances (exemplos: TStrings): Bôoleano;
  função GetInstanceNameFromServiceName (const ServiceName: corda): corda;
  const
    SQLSERVER = “MSSQLSERVER”;
  começar
    se ServiceName = '' então
      Resultado: = ''
    mais
    começar
      se UpperCase (ServiceName) = SQLSERVER então
        Resultado: = ServiceName
      mais
        Resultado: = cópia (ServiceName, posição (“$”, ServiceName) +1, comprimento (ServiceName) - posição (“$”, ServiceName));
    extremidade;
  extremidade;
  função GetWMIPropertyValueForEngineService (const PropertyName, ServiceName, WMINameSpace: corda): corda;
  var
    SWL: TSWbemLocator;
    SWServ: ISWbemServices;
    SWObjSet: ISWbemObjectSet;
    Enum: IEnumVariant;
    tempObj: OleVariant;
    Valor: Cardinal;    
    SWObj: ISWbemObject;
    SWPropSet: ISWbemPropertySet;
    sQry: corda;
  começar
    SWL: = TSWbemLocator.Create (nada);
    tentativa
      tentativa
        SWServ: = SWL.ConnectServer ('', WMINameSpace, '', '', '', '', 0, nada);
        sQry: = formato ('selecionar * de SqlServiceAdvancedProperty onde SQLServiceType = 1 e PropertyName = '' %s '' e ServiceName = de '' ''' %s, [PropertyName, ServiceName]);
        SWObjSet: = SWServ.ExecQuery (sQry, “WQL”, wbemFlagReturnImmediately, nada);
        se SWObjSet.Count = 0 então
        começar
          Resultado: = '';
          Saída;
        extremidade;
        //
        Enum: = (_NewEnum de SWObjSet.) como IEnumVariant;
        quando (Enum.Next (1, tempObj, valor) = S_OK) fazer
        começar
          SWObj: = IUnknown (tempObj) como SWBemObject;
          SWPropSet: = SWObj.Properties_;
          Resultado: = SWPropSet.Item (“PropertyStrValue”, 0). Get_Value;
        extremidade;
      exceto
        em E: A exceção faz
        começar
          //WriteLn (“erro: ” + e.Message);
          Resultado: = '';
        extremidade;
      extremidade;
    finalmente
      SWL.Disconnect;
      FreeAndNil (SWL);
    extremidade;
  extremidade;
const
  WMI_NAMESPACES_TO_CHECK: disposição [0..1] de corda = (“ComputerManagement”, “ComputerManagement10”);
var
  GetSqlExpress: TSWbemLocator;
  Serviços: ISWbemServices;
  ObjectSet: ISWbemObjectSet;
  SObject: ISWbemObject;
  propSet: ISWbemPropertySet;
  Enum: IEnumVariant;
  tempObj: OleVariant;
  Valor: Cardinal;
  //
  sQry: corda;
  serviceName: corda;
  WMIPath: corda;
  i: Inteiro;
começar
  Resultado: = falso;
  Instances.Clear;
  para i: = 0 a 1 fazem
  começar
    WMIPath: = formato (“raiz \ Microsoft \ SqlServer \ %s”, [WMI_NAMESPACES_TO_CHECK [i]]);
    GetSqlExpress: = TSWbemLocator.Create (nada);
    tentativa
      tentativa
        Serviços: = GetSqlExpress.ConnectServer ('', WMIPath, '', '', '', '', 0, nada);
        sQry: = formato ('SELECIONAR * de SqlServiceAdvancedProperty ONDE SQLServiceType = 1 E PropertyName = do '' ''' instanceID, [{SQL_INSTANCE}]);
        ObjectSet: = Services.ExecQuery (sQry, “WQL”, wbemFlagReturnImmediately, nada);
        se ObjectSet.Count = 0 então
        começar
          Continuar;
        extremidade;
        //
        Enum: = (_NewEnum de ObjectSet.) como IEnumVariant;
        quando (Enum.Next (1, tempObj, valor) = S_OK) fazer
        começar
          SObject: = IUnknown (tempObj) como SWBemObject;
          propSet: = SObject.Properties_;
          serviceName: = propSet.Item (“ServiceName”, 0). Get_Value;
          Serviço de //, exemplo, versão, edição
          Instances.Add (formato (“%s, %s, %s, %s”,
            [serviceName,
              GetInstanceNameFromServiceName (serviceName),
              GetWMIPropertyValueForEngineService (“versão”, serviceName, WMIPath),
              GetWMIPropertyValueForEngineService (“SKUNAME”, serviceName, WMIPath)]));
        extremidade;
        Resultado: = retificar;
      exceto
        em E: A exceção faz
        começar
          //WriteLn (“erro: ” + e.Message);
          Resultado: = falso;
        extremidade;
      extremidade;
    finalmente
      GetSqlExpress.Disconnect;
      FreeAndNil (GetSqlExpress);
    extremidade;
  extremidade;
extremidade;
Outras soluções  
 
programming4us programming4us