Was passiert hier?

[steppo]

kann mir jemand genau erklären was und vor allem wie etwas passiert.
Das heißt, wie wird der name ausgelesen und an die variablen übergeben.
entschuldigung, aber eine zeilenweise erklärung wäre sehr nett.

Delphi-Quellcode:

function CurrentComputerName: string;
var
  a: array[0..255] of Char;
  b: Dword;
begin
  b := SizeOf(a);
  GetComputerName(a, b);
  Result := a;
end;

[edit=Admin]Delphi-Tags ( [ delphi]... [ /delphi] ) eingefügt. Künftig bitte selber machen. Danke Mfg, Daniel[/edit]

[Christian Seehase]

Moin Steppo,

erst einmal herzlich willkommen.

Delphi-Quellcode:

// Es wird eine Funktion ohne Parameter deklariert, die einen String als Ergebnis zurückliefert
function CurrentComputerName: string;

// Beginn Variablendeklaration
var 
  // Die Variable a wird als eine eindimensionale Tabelle vom Typ Char (Zeichen) mit 256 Einträgen deklariert
  // jeder Eintrag kann direkt über a[0] bis a[255] angesprochen werden
  // Ein array of Char entspricht, im Wesentlichen, einem String
  a: array[0..255] of Char; 
  // Die Variable b wird als ganze Zahl ohne Vorzeichen mit einer Grösse von 32 Bit deklariert (Wertebereich 0 bis 4294967295)
  b: Dword; 

  // Beginn des Funktionsablaufes
begin 
  // b erhält als Wert die Anzahl Byte, die von a belegt werden, also 256
  b := SizeOf(a); 
  // GetComputerName ist eine Windows API Funktion, die den Namen des Rechners ausliest, auf dem sie ausgeführt wird
  // Vor Ausführung der Funktion sollte der erste Parameter leer sein (am Besten mit binär 0 gefüllt), 
  // und der zweite Parameter muss die Anzahl Zeichen enthalten, die der erste Parameter aufnehmen kann
  // Nach Ausführung der Funktion enthält der erste Parameter den Namen des Rechners, als nullterminierten String,
  // dass heist das Ende des Strings wird durch eine binäre 0 gekennzeichnet, 
  // und der zweite Parameter enthält die Anzahl Zeichen, aus denen der Rechnername besteht
  GetComputerName(a, b); 
  // Das ausgelesene Ergebnis wird als Rückgabewert für die Funktion gesetzt
  // Bei einer Funktionsdeklaration existiert die Variable Result immer, und ist vom Typ des Rückgabewertes der Funktion
  Result := a; 
end;

War's das, was Du wissen wolltest?

[Luckie]

Ich würde es aber besser so machen:

Delphi-Quellcode:

function ComputerName: string;
var
  Size : DWORD;
begin
  result := '';
  Size := MAX_COMPUTERNAME_LENGTH;
  SetLength(result, Size);
  if GetComputerName(PChar(result), Size) then
    SetLength(result, Size-1)
  else
    result := '';
end;

[steppo]

Danke für deine erklärung. war echt gut.

Doch ich meinte eigentlich wo das ganze ausgelesen wird und wie aus dieser fülle von zeichen nämlich 256 die richtigen aussortiert werden.
es werden ja 256 felder von dem definierten array bereitgestellt wobei jedes einzelne ja auch gefüllt wird. wie findet die selektierung statt?
Es muß ja ein etwas komplizierterer vorgang sein, sonst könnte ja das ganze als string ausgelesen werden.


kannst du mir auch sagen wo der name gespeichert wird.
das problem ist, daß beim ändern des namens mit setcomputername zwar der computername geändert wird, diese änderung unter Arbeitsplatz,eigenschaften,netzwerkidentifikation nicht übernommen werden. dies geschieht erst, wenn ich in der registry den hostnamen ändere.

und noch eine Frage:
woran erkenne ich, daß ich ein array definieren muß um mit der funktion arbeiten zu können.
als beispiel die getcomputername funktion
GetComputerName(IpBufferChar;var nSize:Cardinal);
Was heißt dieses IpBuffer?
danke für deine Mühe.
steppo

[steppo]

Ich wünsche euch allen einen guten Rutsch ins neue Jahr.

[Christian Seehase]

Moin Steppo,

ok, dann noch mal von Vorne

Genau wie Luckie würde ich es auch anders machen, als in Deinem Code.

Delphi-Quellcode:

function CurrentComputerName: string;

var
  pComputerName : PChar;
  dwSize        : DWORD;

begin
  // Rückgabewert initialisieren
  Result        := '';
  // Mindestgrösse gemäss PSDK
  dwSize        := MAX_COMPUTERNAME_LENGTH+1;
  // Speicher reservieren (AllocMem initialisiert den Speicher auch gleich auf binär 0)
  pComputerName := AllocMem(dwSize);
  // Resourcenschutzblock (Hier: Sicherstellen, dass der belegte Speicher wieder freigeben wird)
  try
    // Namen auslesen
    if GetComputerName(pComputerName,dwSize) then
    begin
      // Wenn erfolgreich als Rückgabewert setzen
      Result := trim(pComputerName);
    end;
  finally
    // Speicher wieder freigeben (dwSize stimmt wahrscheinlich nicht mehr deshalb die Konstante)
    FreeMem(pComputerName,MAX_COMPUTERNAME_LENGTH+1);
  end;
end;

Genaugenommen erwartet die Funktion als ersten Parameter die Adresse eines Speicherbereiches, in dem die Funktion ihr Ergebnis speichern kann.
Dieses Ergebnis ist dann der Rechnername als nullterminierter String. In C ist es üblich, dass Strings keine Längenangabe haben, sondern ihr Ende durch eine binäre 0 gekennzeichnet wird.
Die Funktion schreibt ab dem ersten durch den Pointer adressierten Byte den Rechnernamen in den Buffer, und am Ende eine binäre 0.
Durch das trim(..) werden die letzten Nullen im String abgeschnitten, und nur der Name zurückgegeben.
Strings (Wichtig: Hugestrings, also standardmässig gesehen die, die als string deklariert werden, nicht die String[..]) in Object Pascal haben einen anderen Aufbau. Hier existiert vor den eigentlichen Daten noch eine Längenangabe und, was hier jetzt nicht so interessant ist, einen Referenzzähler, anhand festgestellt werden kann, ob der String noch benutzt wird oder nicht.
Durch diese Längenangabe benötigt Pascal keine Endekennung.

Der Computername selber steht an verschiedenen Stellen, und ich weiss nicht, von welcher Stelle der stammt, den die Funktion ausliest.

Zur array Deklaration:
Alle API Funktionen, die Werte in übergebenen Parametern zurückliefern, benötigen dazu die Adresse eines Speicherbereiches, an den sie die Daten schreiben können. Dies entspricht den var Parametern in Delphi, die es in C nicht gibt.

Die Funktion hätte man auch so aufrufen können:

Delphi-Quellcode:

function CurrentComputerName: string;

var
  pComputerName : PChar;
  dwSize        : DWORD;

begin
  dwSize := MAX_COMPUTERNAME_LENGTH+1;
  Result := StringOfChar(#00,dwSize);
  GetComputerName(@Result[1],dwSize);
  Result := trim(Result);
end;

Würde man sich die Funktion selber importieren, unter Verwendung der "normalen" Deklaration, und nicht die Variante die Borland vorgegeben hat sähe das so aus:

GetComputerName(const pBuffer : PChar;const dwSize : PDWORD)

und müsste dann so aufgerufen werden:

GetComputerName(pBuffer,@dwSize)

da die Funktion ja im zweiten Parameter etwas zurückgeben will, benötigt sie dessen Adresse. Dies hat Borland durch die Verwendung von var Parameter ersetzt, was dann allerdings manchmal dazu führt, dass einige API Funktionen nicht so verwendbar sind, wie von MS vorgesehen.
Dazu müsste man sie sich selber importieren.

Den Rechner umzubenennen, ginge, zumindest unter NT ff, mit NetWkstaSetInfo.

[steppo]

O.k. werde mich weiter damit beschäftigen. Wird langsam etwas klarer.
danke für eure hilfe und ein erfolgreiches neues Jahr.
steppo

[Lefko]

Zitat von steppo:

kannst du mir auch sagen wo der name gespeichert wird.
das problem ist, daß beim ändern des namens mit setcomputername zwar der computername geändert wird, diese änderung unter Arbeitsplatz,eigenschaften,netzwerkidentifikation nicht übernommen werden. dies geschieht erst, wenn ich in der registry den hostnamen ändere.

Zitat von Christian Seehase:

Der Computername selber steht an verschiedenen Stellen, und ich weiss nicht, von welcher Stelle der stammt, den die Funktion ausliest.

Tja, ich hab mir mal die procedure oben von Luckie geklaut, aber ich erhalte nur einen leeren String als Computername... in der Netzwerkidentifikation steht er aber!


Gibt es eine relativ einfache Möglichkeit, einen Rechner eindeutig zu identifizieren?

Ich will, dass mein Prog nur an einem bestimmten Computer ein paar sachen macht/nicht macht!
Da dachte ich, ich mach das über den Computernamen, aber so klappt das nicht, jemand ne andre idee?

MfG Lefko

[Christian Seehase]

Moin Lefko,

GetComputerName funktioniert bei Dir nicht?

Dann könntest Du noch die Umgebungsvariable COMPUTERNAME auslesen (GetEnvironmentVariable oder ExpandEnvironmentStrings), obwohl ich mir nicht erklären kann, warum die Funktion bei Dir nicht geht.

Hast Du Dir mal angeschaut, was GetLastError zurückliefert?

[Lefko]

Zitat von Christian Seehase:

Moin Lefko,
GetComputerName funktioniert bei Dir nicht?

stimmt immernoch, der string ist leer...

(hier nochmal die kurze function von Luckie dazu: )

Delphi-Quellcode:

function ComputerName: string; 
var
  Size : DWORD;
begin
  result := '';
  Size := MAX_COMPUTERNAME_LENGTH;
  SetLength(result, Size);
  if GetComputerName(PChar(result), Size) then
    SetLength(result, Size-1)
  else
    result := '';
end;

Zitat von Christian Seehase:

Dann könntest Du noch die Umgebungsvariable COMPUTERNAME auslesen (GetEnvironmentVariable oder ExpandEnvironmentStrings), obwohl ich mir nicht erklären kann, warum die Funktion bei Dir nicht geht.

Ich hab Showmessage(GetEnvironmentVariable(COMPUTERNAME)) geschrieben; auch dieser string ist '', also leer.

Zitat von Christian Seehase:

Hast Du Dir mal angeschaut, was GetLastError zurückliefert?

Der Wert von GetLastError ist 0.
---------

Ähm, vielleicht ist ja auch gar kein Name eingetragen?! Ich meine, bei der Netzwerkidentifikation steht zwar der, den ich dem PC mal gegeben hab beim Windows-Installieren, aber sonst... wo kann man den denn so ändern, damit ich nachsehen kann?

MfG Lefko.