Descarga delphi wmi class generator - Descarga del código fuente delphi wmi class generator

delphi wmi class generator

código fuente de delphi

1.0.0.0

Descargar

Delphi Wmi Class Generator es una aplicación que crea clases de Object Pascal completamente documentadas para acceder a WMI (Instrumental de administración de Windows).

Características

El código generado es compatible con Delphi 7, 2005, BDS/Turbo 2006 y RAD Studio 2007-2010, XE-XE7 y Free Pascal Compiler 2.2.4 (win32).
Cree clases completamente documentadas compatibles con la función de información de ayuda, disponible desde Delphi 2005.

Nota: el idioma de descripción de los métodos, parámetros y propiedades depende del idioma de las ventanas donde se generan las unidades.

Cree funciones auxiliares para recuperar la descripción de los valores devueltos para las propiedades y funciones.

Limitaciones

La aplicación genera código listo para usar en un 99% aprox. En muchos de los casos, sin embargo, algunas clases WMI exponen metadatos en un formato incorrecto o la estructura de los metadatos no es compatible con el algoritmo utilizado para crear el código Pascal del objeto; en tales casos, debe parchear el código manualmente.

En esta página puedes encontrar las clases con problemas. otra opción es descargar las clases parcheadas generadas directamente desde el repositorio,

Internos

La herramienta extrae y analiza los metadatos (propiedades, métodos, calificadores, valores válidos y descripciones) almacenados en la clase WMI para recrear una clase compatible con Object Pascal.

Cada clase Object pascal generada por la aplicación desciende de la clase base TWmiClass, esta clase encapsula el acceso al wmi, convierte los valores (OleVariant) devueltos por la clase que llama a tipos nativos y almacena en una colección interna (buffer) los valores. de las propiedades y la dirección de las instancias.

La clase TWmiClass se puede compilar en dos modos.

Uso de la biblioteca Microsoft WMI Scripting V1.2

Este contenedor (WbemScripting_TLB) es generado por el compilador Delphi, esta opción mejora el acceso inicial al WMI (esta opción no es compatible con FPC). Si utiliza este modo, debe incluir en sus proyectos la unidad WbemScripting_TLB.

Usando enlace tardío

Esta opción es útil cuando necesita generar pequeños archivos exe. el rendimiento es un poco más lento en la ejecución inicial.

Para elegir entre estos 2 modos debes comentar o descomentar en la unidad uWmiDelphiClass la siguiente línea

 { $DEFINE WbemScripting_TLB }

Uso

En la ventana principal de la aplicación debes seleccionar el espacio de nombres y la clase a generar (por defecto están seleccionadas todas las clases del espacio de nombres WMI) y presionar el botón "Generar unidades", luego la herramienta creará una carpeta en la ubicación de El exe con el nombre del espacio de nombres y dentro de esta carpeta se creará un proyecto de consola de prueba, una copia del archivo uWmiDelphiClass.pas y las clases seleccionadas. Cada clase se almacena en una unidad separada con el nombre formado por la letra "u" más el nombre de la clase Wmi, por ejemplo el nombre de la unidad para la clase Win32_BIOS será uWin32_BIOS.pas .

Población

En el repositorio de código fuente puede encontrar un conjunto de demostraciones del uso de las clases generadas.

consulte esta aplicación de consola muy simple, que utiliza la clase WMI Win32_BaseBoard.

 program TestWin32_BaseBoard;

{ $APPTYPE CONSOLE }

uses
  SysUtils,
  uWin32_BaseBoard in ' ....root_CIMV2uWin32_BaseBoard.pas ' , 
  uWmiDelphiClass in ' ....uWmiDelphiClass.pas ' ; // the base class

procedure TestBaseBoard ;
var
  BaseBoard : TWin32_BaseBoard;
begin
  BaseBoard:=TWin32_BaseBoard.Create;
  try
    Writeln( ' Base Board Info ' );
    Writeln( ' --------------- ' );
    Writeln( ' Manufacturer ' +BaseBoard.Manufacturer);
    Writeln( ' Model        ' +BaseBoard.Model);
    Writeln( ' SKU          ' +BaseBoard.SKU);
    Writeln( ' SerialNumber ' +BaseBoard.SerialNumber);
    Writeln( ' PartNumber   ' +BaseBoard.PartNumber);
    Writeln( ' Tag          ' +BaseBoard.Tag);
    Readln;
  finally
    BaseBoard.Free;
  end ;
end ;

begin
  try
    TestBaseBoard;
  except
    on E:Exception do
    begin
      Writeln(E.Classname, ' : ' , E.Message);
      Readln;
    end ;
  end ;
end .

Esta herramienta fue compilada usando Delphi XE.

Código fuente de muestra

Ejemplo de código fuente creado por la aplicación para la clase WMI Win32_Share.

 // / <summary>
// / Unit generated using the Delphi Wmi class generator tool, Copyright Rodrigo Ruz V. 2010
// / Application version 0.1.0.113
// / WMI version 7600.16385
// / Creation Date 23-12-2010 22:39:55
// / Namespace rootCIMV2 Class Win32_Share
// / MSDN info about this class http://msdn2.microsoft.com/library/default.asp?url=/library/en-us/wmisdk/wmi/Win32_Share.asp
// / </summary>

{ $IFDEF FPC }
 { $MODE DELPHI } { $H+ }
 { $DEFINE OLD_DELPHI }
{ $ENDIF }

unit uWin32_Share;

interface

uses
 Classes,
 Activex,
 Variants,
 ComObj,
 uWmiDelphiClass;

type
{ $IFDEF FPC }
  Cardinal=Longint;
  Int64=Integer;
  Word=Longint;
{ $ENDIF }
{ $IFNDEF FPC }
  { $IF CompilerVersion <= 15 }
    { $DEFINE OLD_DELPHI }
  { $IFEND }
{ $ENDIF }
  { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
  // / <summary>
  // / The Win32_Share class represents a shared resource on a Win32 system. This may be a disk drive, printer, interprocess communication, or other shareable device.
  // / Example: C:PUBLIC.
  // / </summary>
  { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
  TWin32_Share= class (TWmiClass)
  private
    FAccessMask                         : Cardinal;
    FAllowMaximum                       : Boolean;
    FCaption                            : String;
    FDescription                        : String;
    FInstallDate                        : TDateTime;
    FMaximumAllowed                     : Cardinal;
    FName                               : String;
    FPath                               : String;
    FStatus                             : String;
    FType                               : Cardinal;
  public
   constructor Create(LoadWmiData : boolean=True); overload;
   destructor Destroy;Override;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / This property has been deprecated in favour of the GetAccessMask method of this 
   // / class due to the expense of calling GetEffectiveRightsFromAcl. The value will 
   // / be set to NULL
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property AccessMask : Cardinal read FAccessMask;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The AllowMaximum property indicates whether the number of concurrent users for this resource has been limited.
   // / Values: TRUE or FALSE. A value of TRUE indicates the number of concurrent users of this resource has not been limited and the value in the MaximumAllowed property is ignored.
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property AllowMaximum : Boolean read FAllowMaximum;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The Caption property is a short textual description (one-line string) of the 
   // / object.
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property Caption : String read FCaption;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The Description property provides a textual description of the object. 
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property Description : String read FDescription;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The InstallDate property is datetime value indicating when the object was 
   // / installed. A lack of a value does not indicate that the object is not installed.
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property InstallDate : TDateTime read FInstallDate;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The MaximumAllowed property indicates the limit on the maximum number of users allowed to use this resource concurrently. The value is only valid if the AllowMaximum member set to FALSE 
   // / Example: 10.
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property MaximumAllowed : Cardinal read FMaximumAllowed;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The Name property indicates the alias given to a path set up as a share on a  Win32 system.
   // / Example: public.
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property Name : String read FName;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The Path property indicates the local path of the Win32 share.
   // / Example: C:Program Files
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property Path : String read FPath;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The Status property is a string indicating the current status of the object. 
   // / Various operational and non-operational statuses can be defined. Operational 
   // / statuses are "OK", "Degraded" and "Pred Fail". "Pred Fail" indicates that an 
   // / element may be functioning properly but predicting a failure in the near 
   // / future. An example is a SMART-enabled hard drive. Non-operational statuses can 
   // / also be specified. These are "Error", "Starting", "Stopping" and "Service". The 
   // / latter, "Service", could apply during mirror-resilvering of a disk, reload of a 
   // / user permissions list, or other administrative work. Not all such work is on-
   // / line, yet the managed element is neither "OK" nor in one of the other states.
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property Status : String read FStatus;
   { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
   // / <summary>
   // / The Type property specifies the type of resource being shared. Types include 
   // / disk drives, print queues, interprocess communications (IPC), and general 
   // / devices.
   // / </summary>
   { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
   property { $IFDEF OLD_DELPHI } _Type { $ELSE } & Type { $ENDIF } : Cardinal read FType;
   function Create ( const Access : OleVariant; const Description : String; const MaximumAllowed : Cardinal; const Name : String; const Password : String; const Path : String; const { $IFDEF OLD_DELPHI } _Type { $ELSE } & Type { $ENDIF } : Cardinal): Integer;overload;
   function SetShareInfo ( const Access : OleVariant; const Description : String; const MaximumAllowed : Cardinal): Integer;
   function GetAccessMask : Integer;
   function Delete : Integer;
   procedure SetCollectionIndex (Index : Integer); override;
  end ;


  { $IFDEF UNDEF }{ $REGION 'Documentation' }{ $ENDIF }
  // / <summary>
  // / Return the description for the value of the property TWin32_Share.Type
  // / </summary>
  { $IFDEF UNDEF }{ $ENDREGION }{ $ENDIF }
  function GetTypeAsString ( const APropValue:Cardinal) : string;

implementation


function GetTypeAsString ( const APropValue:Cardinal) : string;
begin
Result:= ' ' ;
  case APropValue of
    0 : Result:= ' Disk Drive ' ;
    1 : Result:= ' Print Queue ' ;
    2 : Result:= ' Device ' ;
    3 : Result:= ' IPC ' ;
    2147483648 : Result:= ' Disk Drive Admin ' ;
    2147483649 : Result:= ' Print Queue Admin ' ;
    2147483650 : Result:= ' Device Admin ' ;
    2147483651 : Result:= ' IPC Admin ' ;
  end ;
end ;

{ TWin32_Share }

constructor TWin32_Share.Create(LoadWmiData : boolean=True);
begin
  inherited Create(LoadWmiData, ' rootCIMV2 ' , ' Win32_Share ' );
end ;

destructor TWin32_Share.Destroy;
begin
  inherited ;
end ;

procedure TWin32_Share.SetCollectionIndex (Index : Integer);
begin
  if (Index>= 0 ) and (Index<=FWmiCollection.Count- 1 ) and (FWmiCollectionIndex<>Index) then
  begin
    FWmiCollectionIndex:=Index;
    FAccessMask          := VarCardinalNull( inherited Value [ ' AccessMask ' ]);
    FAllowMaximum        := VarBoolNull( inherited Value [ ' AllowMaximum ' ]);
    FCaption             := VarStrNull( inherited Value [ ' Caption ' ]);
    FDescription         := VarStrNull( inherited Value [ ' Description ' ]);
    FInstallDate         := VarDateTimeNull( inherited Value [ ' InstallDate ' ]);
    FMaximumAllowed      := VarCardinalNull( inherited Value [ ' MaximumAllowed ' ]);
    FName                := VarStrNull( inherited Value [ ' Name ' ]);
    FPath                := VarStrNull( inherited Value [ ' Path ' ]);
    FStatus              := VarStrNull( inherited Value [ ' Status ' ]);
    FType                := VarCardinalNull( inherited Value [ ' Type ' ]);
  end ;
end ;


// static, OutParams=1, InParams>0
function TWin32_Share.Create ( const Access : OleVariant; const Description : String; const MaximumAllowed : Cardinal; const Name : String; const Password : String; const Path : String; const { $IFDEF OLD_DELPHI } _Type { $ELSE } & Type { $ENDIF } : Cardinal): Integer;
var
  objInParams                : OleVariant;
  objOutParams               : OleVariant;
begin
  objInParams                 := GetInstanceOf.Methods_.Item( ' Create ' ).InParameters.SpawnInstance_();
  objInParams.Properties_.Item( ' Access ' ). Value  := Access;
  objInParams.Properties_.Item( ' Description ' ). Value  := Description;
  objInParams.Properties_.Item( ' MaximumAllowed ' ). Value  := MaximumAllowed;
  objInParams.Properties_.Item( ' Name ' ). Value  := Name ;
  objInParams.Properties_.Item( ' Password ' ). Value  := Password;
  objInParams.Properties_.Item( ' Path ' ). Value  := Path;
  objInParams.Properties_.Item( ' Type ' ). Value  := { $IFDEF OLD_DELPHI } _Type { $ELSE } & Type { $ENDIF } ;
  objOutParams                := WMIService.ExecMethod(WmiClass, ' Create ' , objInParams, 0 , GetNullValue);
  Result := VarIntegerNull(objOutParams.ReturnValue);
end ;


// not static, OutParams=1, InParams>0
function TWin32_Share.SetShareInfo ( const Access : OleVariant; const Description : String; const MaximumAllowed : Cardinal): Integer;
var
  ReturnValue : OleVariant;
begin
  ReturnValue := GetInstanceOf.SetShareInfo(Access,Description,MaximumAllowed);
  Result      := VarIntegerNull(ReturnValue);
end ;


// not static, OutParams=1, InParams=0
function TWin32_Share.GetAccessMask : integer;
var
  ReturnValue : OleVariant;
begin
  ReturnValue := GetInstanceOf.GetAccessMask;
  Result      := VarIntegerNull(ReturnValue);
end ;

// not static, OutParams=1, InParams=0
function TWin32_Share.Delete : integer;
var
  ReturnValue : OleVariant;
begin
  ReturnValue := GetInstanceOf.Delete;
  Result      := VarIntegerNull(ReturnValue);
end ;
end .

¿Busca el instalador? Verifique el área de lanzamiento

Expandir

Información adicional

Versión 1.0.0.0
Tipo código fuente de delphi
Fecha de actualización 2025-01-02
tamaño 2.91MB
Proviene de Github

Aplicaciones relacionadas

Contoso Data Generator V2

2024-11-11
Aplicación Lingostar Class

2024-03-23
Aplicación de clase Yunhui

2023-06-07
Clase de '09

2022-08-03
Escape de primera clase: el tren del pensamiento

2022-08-01
Clase PHP MSN

2010-01-29

Recomendado para ti

chat.petals.dev

Otro código fuente

1.0.0
GPT Prompt Templates

Otro código fuente

1.0.0
GPTyped

Otro código fuente

GPTyped 1.0.5
BlackShark

código fuente de delphi

Release 4.0
Código fuente del libro complementario de desarrollo de aplicaciones avanzadas de Delphi7

código fuente de delphi
Desarrollo de aplicaciones de red Delphi7 (IntraWeb)

código fuente de delphi
waymo open dataset

Otro código fuente

December 2023 Update
wp functions

Otras categorias

1.0.0
slugify

Otras categorias

Version 4.6.0 (10 September 2024)

Información relacionada Todo