EnumPrinterDrivers = Zugriffsverletzung (Anfängerfrage)

[Andreas2k]

Ich würde gerne mittels EnumPrinterDrivers die Liste der installierten Druckertreiber auslesen.
Das auslesen funktioniert auch, ich bekomme die korrekte Liste doch dann haut das Programm eine Zugriffsverletzung raus.

Zitat:

---------------------------
Printer
---------------------------
Zugriffsverletzung bei Adresse 004058CF in Modul 'Printer.exe'. Lesen von Adresse 00000000.
---------------------------
OK
---------------------------

Ich bin leider ein wenig aus der übung und habe auch früher solche API geschichten gemieden. Diesmal würde ich aber gerne verstehen wie es geht und wo da der Fehler ist. Im Debugger wirkt es irgendwie als hätte ich zu viel Speicher reserviert.

Delphi-Quellcode:

function GetPrinterDrivers(): boolean;
var
    arDriverList : array of TDriverInfo2;
    pBuffer      : Pointer;
    pcbNeeded    : DWORD;
    pcReturned   : DWORD;
    ErrorTxt     : array [0..500] of char;
    i            : integer;
begin

// Aufruf mit Buffersize 0 soll die benötigte Größe in pcbNeeded schreiben.
// ^--------------------------------------------+
if not EnumPrinterDrivers(nil, nil, 2, pBuffer, 0, pcbNeeded, pcReturned) then
    begin
      GetMem(pBuffer, pcbNeeded);
    end;

result := EnumPrinterDrivers(nil, nil, 2, pBuffer, pcbNeeded, pcbNeeded, pcReturned);

if result then
   begin
     arDriverList := pBuffer;
     for i := 0 to  pcReturned -1 do form1.Memo1.Lines.add(arDriverList[i].pName);
     FreeMem(pBuffer, pcbNeeded);
   end
      else
    begin
      FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nil, GetLastError, 0, ErrorTxt, 500, nil);
      ShowMessage(ErrorTxt);
    end;
end;

[Der schöne Günther]

Spar dir den Zeiger pBuffer und nimm direkt das Array:

Delphi-Quellcode:

function GetPrinterDrivers(): boolean;
var
    arDriverList : array of TDriverInfo2;
    //pBuffer : Pointer;
     pcbNeeded : DWORD;
     pcReturned : DWORD;
     ErrorTxt : array [0..500] of char;
     i : integer;
begin

// Aufruf mit Buffersize 0 soll die benötigte Größe in pcbNeeded schreiben.
// ^--------------------------------------------+
if not EnumPrinterDrivers(nil, nil, 2, nil, 0, pcbNeeded, pcReturned) then // gib ihm doch einen Nullzeiger statt einen nicht initialisierten!
    begin
      //GetMem(pBuffer, pcbNeeded);
      SetLength(arDriverList, pcbNeeded);
    end;

 result := EnumPrinterDrivers(nil, nil, 2, @arDriverList[0], pcbNeeded, pcbNeeded, pcReturned);

if result then
   begin
     //arDriverList := pBuffer; // nope
     for i := 0 to pcReturned -1 do form10.Memo1.Lines.add(arDriverList[i].pName);
      //FreeMem(pBuffer, pcbNeeded); //macht das array nach verlassen der methode selber
    end
       else
     begin
       FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nil, GetLastError, 0, ErrorTxt, 500, nil);
       ShowMessage(ErrorTxt);
    end
end;

Der Fehler liegt wohl daran dass du nicht einfach deinen rohen Speicherbereich von x Elementen (C-Array) in dein dynamisches Delphi-Array pressen kannst. Ein Delphi-Array enthält noch mehr Informationen (Anzahl der Elemtente, Referanzzähler). Wochenendlektüre dafür gibt es hier:
http://rvelthuis.de/articles/article...html#dynarrays

In der Regel gibst du WinAPI-Aufrufen, wenn sie einen rohen Zeiger auf einen Speicherbereich haben wollen, die Adresse deines Delphi-Arrays mit Index 0 (siehe oben: "@arDriverList[0]").


PS: Ich glaube ich habe noch nie in meinem Leben (und ich mache jetzt vier Jahre Delphi) GetMem(..)/FreeMem(..) gebraucht...

[Andreas2k]

Herzlichen Dank!
jetzt läuft wirklich rund.

Und danke für den Link :-D

[jus]

Warum eigentlich so kompliziert? Es gibt doch die Unit Printers dafür, oder zumindest bei meinem Delphi 2007.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Printers, StdCtrls;

type
  TForm1 = class(TForm)
    ComboBox1: TComboBox;
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  combobox1.Items:=Printer.Printers;
  combobox1.ItemIndex:=Printer.PrinterIndex;
end;

end.

lg,
jus

[Aviator]

Zitat:

Zitat von jus (Beitrag 1363149)

Warum eigentlich so kompliziert? Es gibt doch die Unit Printers dafür, oder zumindest bei meinem Delphi 2007.

Es geht um die installierten Druckertreiber nicht um die Drucker als solche. :cyclops:

[himitsu]

Das muß auch knallen.

* pBuffer ist beim ersten Aufruf nicht initialisiert (das sollte dir auch dein Compiler um die Ohren hauen)
* GetMem ist nur bei einem ganz bestimmten "Fehler" richtig
* ist nichts installiert, würde cbBuf=0 passen und es gibt keinen Fehler
* und dann ist arDriverList ein Delphi-Array, was absolut garnichts mit dem C-Array zu zun hat
** du "sagst" dem Compiler aber, dass pBuffer dieses Array drin ist, das zufällg so lange gut geht, bis irgendwas auf die Control-Felder (Length und Type) des Delphi-Array zugreifen will, was z.B. am Ende der Prozedur passiert, wenn der Compiler dort den Speicher des Arrays freigeben will.
** das kann maximal in den Zeiger eines statischen

Delphi-Quellcode:

array[0..x] of TDriverInfo2

gecastet werden oder man muß umkopieren, bzw. die Daten direkt in ein bestehendes dynamisches Array reinschreiben

PS: Bei SetLength sollte man natürlich die Anzahl der Records und nicht der Bytes reingeben.

[Der schöne Günther]

Zitat:

Zitat von himitsu (Beitrag 1363162)

PS: Bei SetLength sollte man natürlich die Anzahl der Records und nicht der Bytes reingeben.

Ja, das ist oben in den beiden Quelltexten noch völlig falsch :!:

[Andreas2k]

Zitat:

Zitat von Der schöne Günther (Beitrag 1363167)

Zitat:

Zitat von himitsu (Beitrag 1363162)

PS: Bei SetLength sollte man natürlich die Anzahl der Records und nicht der Bytes reingeben.

Ja, das ist oben in den beiden Quelltexten noch völlig falsch :!:

Das hatte mich anfangs auch gewundert aber der erste aufruf liefert ja nur die benötigten Bytes zurück und nicht die Anzahl Einträge. pcReturned liefert nach dem ersten Aufruf 0 zurück.

Mache ich also ein SetLength(arDriverList, pcReturned);

kommt beim zweiten / finalen aufruf die Fehlermeldung

Zitat:

Der angegebene Benutzerpuffer ist für den angeforderten Vorgang nicht zulässig.

Das war auch der Grund weshalb ich irtümlich Getmem benutzt habe. Ich bekomme einfach nicht die Anz Einträge bis ich eine Buffer übergebe der groß genug ist - sprich pcbNeeded

[Andreas2k]

ich bin bisher immer noch nicht schlauer.

Der erste aufruf

Delphi-Quellcode:

EnumPrinterDrivers(nil, nil, 2, nil, 0, pcbNeeded, pcReturned)

liefert mir nur die benötigte größe in Byte - in meinem Fall sind das 10112 Byte (18 Treiber sind installiert)

mit

Delphi-Quellcode:

SetLength(arDriverList, pcbNeeded);

wird der Array 10112 Einträge groß - aber alles funktioniert.


Wie kann ich anhand der zurückgelieferten Bytes die Anzahl der Array Einträge ermitteln, die ich für ein SetLength benötige?

Oder kann ich dem Array of auch sagen das dieses insgesamt 10112 Bytes groß sein soll?

[Zacherl]

Zitat:

Zitat von Andreas2k (Beitrag 1363747)

Wie kann ich anhand der zurückgelieferten Bytes die Anzahl der Array Einträge ermitteln, die ich für ein SetLength benötige?

Das kommt drauf an. Werden neben den

Delphi-Quellcode:

DRIVER_INFO_2

Strukturen zusätzlich auch die Strings (die in den einzelnen Einträgen per Pointer referenziert werden) oder andere Sachen im Buffer abgelegt?

Nein:
Einfach die Anzahl der Bytes durch

Delphi-Quellcode:

SizeOf(TDriverInfo2)

teilen.

Ja:
In diesem Falle würde ich von Anfang an mit einem untypisiertem Buffer (

Delphi-Quellcode:

GetMem

) arbeiten. In

Delphi-Quellcode:

pcReturned

gibt die API dir die Anzahl der Elemente zurück, also kannst du einfach iterieren:

Delphi-Quellcode:

var
  Buf: PDriverInfo2;
  ..
begin
  // Größe ermitteln, etc ..
  GetMem(Buf, pcbNeeded);
  try
    if EnumPrinterDrivers(...) then
    begin
      for I := 1 to pcReturned do
      begin
        // Mach was
        // ..
        // zum nächsten Element springen
        Inc(Buf);
      end;
    end;
  finally
    FreeMem(Buf);
  end;
end;