Question : Comment détecter si le serveur 2005 ou 2008 de SQL est installé

Bonjour, le

How peut je détecter si le serveur 2005 ou 2008 de SQL est installé sur un ordinateur d'une application de Delphes ? le
Preferably pas en employant le registry.

I a trouvé un certain code dans C# qui pourrait faire ceci ? ? ? (voir ci-dessous). class= > " clair " de
> de " codeSnippet " de class= de
class= " lineNumbers " de
class= de 
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 :
système >using " de l'id= " codeSnippet780363 de 
 de ///
        /// énumère tous les exemples de serveur de SQL sur la machine.
        /// 
        /// 
        bool statique public EnumerateSQLInstances ()
        {
            correctNamespace = GetCorrectWmiNameSpace de corde () ;
            si (corde. Égales (correctNamespace, corde. Vider))
            {
                renvoyer faux ;
            }
            ficeler la question = la corde. Format (« choisir * à partir de SqlServiceAdvancedProperty où SQLServiceType = 1 et PropertyName = « instanceID » ") ;
            getSqlEngine de ManagementObjectSearcher = nouveau ManagementObjectSearcher (correctNamespace, question) ;
            si (getSqlEngine.Get (). == 0 de compte)
            {
                faux de retour ;
            }
            Console.WriteLine (« les exemples de base de données de serveur de SQL ont découvert : ") ;
            instanceName de corde = corde. Vide ;
            serviceName de corde = corde. Vide ;
            version de corde = corde. Vide ;
            édition de corde = corde. Vide ;
            Console.WriteLine (« version d'édition de nom d'exemple \ t ServiceName \ t \ t \ t ») ;
            foreach (sqlEngine de ManagementObject dans getSqlEngine.Get ())
            {
                serviceName = sqlEngine [« ServiceName »] .ToString () ;
                instanceName = GetInstanceNameFromServiceName (serviceName) ;
                version = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, « version ») ;
                édition = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, « SKUNAME ») ;
                Console.Write (« {0} \ t », instanceName) ;
                Console.Write (« {0} \ t », serviceName) ;
                Console.Write (« {0} \ t », édition) ;
                Console.WriteLine (« {0} \ t », version) ;
            }
            de retour rectifier ;
        }
         de ///
        La méthode de /// renvoie le namespace correct de SQL pour employer pour détecter des exemples de serveur de SQL.
        /// 
        namespace de /// à employer pour détecter le serveur instances de SQL
        corde statique publique GetCorrectWmiNameSpace ()
        {
            Ficeler le wmiNamespaceToUse = « racine \ \ \ de Microsoft \ sqlserver » ;
            Namespaces de List = nouveau List () ;
            essai
            {
                // énumèrent tous les exemples de WMI de
                classe du __namespace WMI de //.
                nsClass de ManagementClass =
                    nouveau ManagementClass (
                    nouveau ManagementScope (wmiNamespaceToUse),
                    nouveau ManagementPath (« __namespace »),
                    nulle) ;
                foreach (ManagementObject NS dedans
                    nsClass.GetInstances ())
                {
                    namespaces. Ajouter (NS [« nom »] .ToString ());
                }
            }
            attraper (ManagementException e)
            {
                Console.WriteLine (« exception = » + e.Message) ;
            }
            si (namespaces. Compte > 0)
            {
                si (namespaces. Contient (« ComputerManagement10 »))
                {
                    namespace de //use katmai+
                    wmiNamespaceToUse = wmiNamespaceToUse + « \ \ ComputerManagement10 » ;
                }
                autrement si (namespaces. Contient (« ComputerManagement »))
                {
                    namespace de //use yukon
                    wmiNamespaceToUse = wmiNamespaceToUse + « \ \ ComputerManagement » ;
                }
                autrement
                {
                    wmiNamespaceToUse = corde. Vide ;
                }
            }
            autrement
            {
                wmiNamespaceToUse = corde. Vide ;
            }
            wmiNamespaceToUse de retour ;
        }
         de ///
        la méthode de /// extrait le nom d'exemple à partir du nom de service
        /// 
        name= " serviceName " > de 
        corde statique publique GetInstanceNameFromServiceName (serviceName de corde)
        {
            si (! string.IsNullOrEmpty (serviceName))
            {
                si (corde. Égales (serviceName, « MSSQLSERVER », StringComparison.OrdinalIgnoreCase))
                {
                    serviceName de retour ;
                }
                autrement
                {
                    serviceName.Substring de retour (serviceName.IndexOf (« $") + 1, serviceName.Length - serviceName.IndexOf (« $ ») - 1) ;
                }
            }
            autrement
            {
                corde de retour. Vide ;
            }
        }
         de ///
        /// renvoie les valeurs d'une propriété de WMI pour un nom de propriété donné pour un nom particulier de service de serveur de SQL
        /// 
        nom de service de >The de " serviceName " de name= de 
        namespace de wmi de >The de " wmiNamespace " de name= de 
        nom de propriété de >The de " propertyName " de name= de 
        /// 
        corde statique publique GetWmiPropertyValueForEngineService (serviceName de corde, wmiNamespace de corde, propertyName de corde)
        {
            propertyValue de corde = corde. Vide ;
            ficeler la question = le String.Format (« choisir * à partir de SqlServiceAdvancedProperty où SQLServiceType = 1 et PropertyName = « {0} » et ServiceName = « {1} » « , propertyName, serviceName) ;
            propertySearcher de ManagementObjectSearcher = nouveau ManagementObjectSearcher (wmiNamespace, question) ;
            foreach (sqlEdition de ManagementObject dans propertySearcher.Get ())
            {
                propertyValue = sqlEdition [« PropertyStrValue »] .ToString () ;
            }
            propertyValue de retour ;
        }
    }
}
class= de

Réponse : Comment détecter si le serveur 2005 ou 2008 de SQL est installé

Ma source a juste recherché un exemple spécifique de serveur de SQL exprès, j'ai trouvé qu'un peu de temps et modifié le code pour énumérer les exemples a basé sur le code de C# que vous avez signalé au dessus. 
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 :

fonction GetSQLInstances (exemples : TStrings) : Booléen ;
  fonction GetInstanceNameFromServiceName (const ServiceName : corde) : corde ;
  const
    SQLSERVER = « MSSQLSERVER » ;
  commencer
    si ServiceName = '' puis
      Résultat : = ''
    autrement
    commencer
      si haut de casse (ServiceName) = SQLSERVER alors
        Résultat : = ServiceName
      autrement
        Résultat : = copie (ServiceName, position (« $ », ServiceName) +1, longueur (ServiceName) - position (« $ », ServiceName));
    extrémité ;
  extrémité ;
  fonction GetWMIPropertyValueForEngineService (const PropertyName, ServiceName, WMINameSpace : corde) : corde ;
  variété
    SWL : TSWbemLocator ;
    SWServ : ISWbemServices ;
    SWObjSet : ISWbemObjectSet ;
    Enum : IEnumVariant ;
    tempObj : OleVariant ;
    Valeur : Cardinal ;    
    SWObj : ISWbemObject ;
    SWPropSet : ISWbemPropertySet ;
    sQry : corde ;
  commencer
    SWL : = TSWbemLocator.Create (zéro) ;
    essai
      essai
        SWServ : = SWL.ConnectServer ('', WMINameSpace, '', '', '', '', 0, zéro) ;
        sQry : = format ('choisir * à partir de SqlServiceAdvancedProperty où SQLServiceType = 1 et PropertyName = '' %s '' et ServiceName = '' ''' de %s, [PropertyName, ServiceName]) ;
        SWObjSet : = SWServ.ExecQuery (sQry, « WQL », wbemFlagReturnImmediately, zéro) ;
        si SWObjSet.Count = 0 puis
        commencer
          Résultat : = '' ;
          Sortie ;
        extrémité ;
        //
        Enum : = (_NewEnum de SWObjSet.) comme IEnumVariant ;
        tandis que (Enum.Next (1, tempObj, valeur) = S_OK) faire
        commencer
          SWObj : = IUnknown (tempObj) comme SWBemObject ;
          SWPropSet : = SWObj.Properties_ ;
          Résultat : = SWPropSet.Item (« PropertyStrValue », 0). Get_Value ;
        extrémité ;
      excepté
        sur E : L'exception font
        commencer
          //WriteLn (« erreur :  » + e.Message) ;
          Résultat : = '' ;
        extrémité ;
      extrémité ;
    finalement
      SWL.Disconnect ;
      FreeAndNil (SWL) ;
    extrémité ;
  extrémité ;
const
  WMI_NAMESPACES_TO_CHECK : rangée [0..1] de corde = (« ComputerManagement », « ComputerManagement10 ») ;
variété
  GetSqlExpress : TSWbemLocator ;
  Services : ISWbemServices ;
  ObjectSet : ISWbemObjectSet ;
  SObject : ISWbemObject ;
  propSet : ISWbemPropertySet ;
  Enum : IEnumVariant ;
  tempObj : OleVariant ;
  Valeur : Cardinal ;
  //
  sQry : corde ;
  serviceName : corde ;
  WMIPath : corde ;
  i : Nombre entier ;
commencer
  Résultat : = faux ;
  Instances.Clear ;
  pour I : = 0 à 1 font
  commencer
    WMIPath : = format (« racine \ Microsoft \ SqlServer \ %s », [WMI_NAMESPACES_TO_CHECK [I]]) ;
    GetSqlExpress : = TSWbemLocator.Create (zéro) ;
    essai
      essai
        Services : = GetSqlExpress.ConnectServer ('', WMIPath, '', '', '', '', 0, zéro) ;
        sQry : = format ('CHOISIR * À PARTIR de SqlServiceAdvancedProperty OÙ SQLServiceType = 1 ET PropertyName = '' ''' d'instanceID, [{SQL_INSTANCE}]) ;
        ObjectSet : = Services.ExecQuery (sQry, « WQL », wbemFlagReturnImmediately, zéro) ;
        si ObjectSet.Count = 0 puis
        commencer
          Continuer ;
        extrémité ;
        //
        Enum : = (_NewEnum d'ObjectSet.) comme IEnumVariant ;
        tandis que (Enum.Next (1, tempObj, valeur) = S_OK) faire
        commencer
          SObject : = IUnknown (tempObj) comme SWBemObject ;
          propSet : = SObject.Properties_ ;
          serviceName : = propSet.Item (« ServiceName », 0). Get_Value ;
          Service de //, exemple, version, édition
          Instances.Add (format (« %s, %s, %s, %s »,
            [serviceName,
              GetInstanceNameFromServiceName (serviceName),
              GetWMIPropertyValueForEngineService (« version », serviceName, WMIPath),
              GetWMIPropertyValueForEngineService (« SKUNAME », serviceName, WMIPath)]));
        extrémité ;
        Résultat : = rectifier ;
      excepté
        sur E : L'exception font
        commencer
          //WriteLn (« erreur :  » + e.Message) ;
          Résultat : = faux ;
        extrémité ;
      extrémité ;
    finalement
      GetSqlExpress.Disconnect ;
      FreeAndNil (GetSqlExpress) ;
    extrémité ;
  extrémité ;
extrémité ;
Autres solutions  
  •  MS Excel 2007 et pdf - l'exportation vers le pdf prend de longues heures !
    •
  •  Dans le Perl, comment j'ajoute une valeur à la liste, puis le contrôle pour voir si la valeur existent avant d'ajouter une nouvelle valeur
    •
  •  Comment fais j'initialiser de la HP BL460c G6 de san et de la HP XP 240000
    •
  •  Comment fais j'employer une clef de permis de volume sur un ordinateur de HP avec du CD de restauration
    •
  •  Emplacement primaire de deux SCCM dans l'annuaire actif
    •
  •  L'initiateur et la HP D2D de l'iSCSI R2 du serveur 2008 de Windows GERCENT l'issue
    •
  •  Stocker le dossier dans le mysql using connector.net et le champ de goutte
    •
  •  Carte vidéo d'USB - bit 32 sur le matériel travaillant au niveau du bit 64 ?
    •
  •  asp.net que j'essaye de convertir une forme de HTML en forme d'aspx ou ? ce qui jamais. Aide du besoin sur la façon dont à à elle.
    •
  •  Winzip 12 issues de secours du travail ?
    •
     
    programming4us programming4us