Vorstellung und Frage

[no0B]

Guten Abend zusammen,
da ich neu hier im Forum bin möchte ich kurz Hallo sagen und auch gleich mit meiner Frage beginnen.

Soll ein einfaches Programm werden zum anpingen. Zur Zeit wird durch betätigen eines buttons eine .bat Datei geöffnet in der die IP hinterlegt ist. Jetzt will ich das so hinbekommem das ich jede x belibige ip ins Programm eintragen kann die dann in diese .bat eingetragen wird.
Ist sowas möglich ?
Irgendwelche Lösungsvorschläge ?

Vielen Dank.

[Perlsau]

Natürlich ist sowas möglich. Aber was macht die Batch-Datei dann mit der IP-Nummer? Die Frage ergibt sich aus der Vermutung, daß du eigentlich gar keine Batch-Datei benötigst, denn Delphi kann auch Programme starten, z.B. den Browser mit einer IP-Nummer zu dieser Site navigieren lassen.

[alda]

Eine ähnliche Frage wurde in einem anderen Thread gestellt: Klick mich

Meine Antwort dort könnte Dir auch weiterhelfen. Mit der Methode DSiExecuteAndCapture könntest Du die CMD.exe von Windows starten und den entsprechenden Befehl (ping) absetzen und die Rückmeldung des Pings z.B. in einem Memo anzeigen lassen (oder wo auch immer).

Hier eine Beispielsimplementierung (ungetestet, hab kein Delphi da):

Delphi-Quellcode:

function ExecuteOnCommandLine(
  const ACommand: string; // z.B. ping www.google.de
  const AOutput: TStrings; // hier wird der Konsolenoutput reingeschrieben (z.B. das Ping-Ergebniss)
  const AWorkingDirectory: string; // sofern notwendig
  var AExitCode: longword; // hier wird der ExitCode reingeschrieben zur weiteren Verarbeitung durch Dich
  const AWaitTimeInSeconds: integer;
  AOnNewLine: TDSiOnNewLineCallback): Boolean;
var
  LSuccess: boolean;
  LCmdBaseCommand: String;
begin
  LCmdBaseCommand := 'cmd.exe /c ';
  LSuccess := DSiExecuteAndCapture(LCmdBaseCommand + ACommand, AOutput, AWorkingDirectory, AExitCode, AWaitTimeInSeconds, AOnNewLine) <> 0;
  Result := LSuccess;
end;

[no0B]

In der Batch steht eigtl. nur der ping code
wie man ihn in der Eingabeaufforderung auch eingibt also ping 127.0.0.1 z.B. der dann durch den Button gestartet wir.

[pelzig]

Den Hildebrandt auf Sat1 habe ich schon mal gesehen, daher

Delphi-Quellcode:

unit Unitpingtest;

interface

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

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
var
  batname: string;

procedure TForm1.Button1Click(Sender: TObject);
var
  s: string;
  f: Textfile;
begin
  assignfile(f, batname);
  rewrite(f);
  s := '@echo off';
  writeln(f, s);
  s := 'ping' + #32 + Edit1.text;
  writeln(f, s);
  s := 'pause';
  writeln(f, s);
  closeFile(f);
  Shellexecute(handle, 'open', PChar(batname), '', '', sw_show);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Edit1.Text := '127.0.0.1';
  batname := 'e:\pingping.bat';
end;

end.

MfG

[hathor]

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls,  ShellAPI, ComCtrls;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button2: TButton;
    Panel1: TPanel;
    Edit1: TEdit;
    Label13: TLabel;
    Button1: TButton;
    Label15: TLabel;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormShow(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

//------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
begin Application.terminate; end;

function GetConsoleOutput(Command: string; Output, Errors: TStrings): Boolean;
var
  StartupInfo: TStartupInfo;
  ProcessInfo: TProcessInformation;
  SecurityAttr: TSecurityAttributes;
  PipeOutputRead: THandle;
  PipeOutputWrite: THandle;
  PipeErrorsRead: THandle;
  PipeErrorsWrite: THandle;
  Succeed: Boolean;
  Buffer: array [0 .. 255] of Char;
  NumberOfBytesRead: DWORD;
  Stream: TMemoryStream;
begin
  // Initialisierung ProcessInfo
  FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);

  // Initialisierung SecurityAttr
  FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0);
  SecurityAttr.nLength := SizeOf(SecurityAttr);
  SecurityAttr.bInheritHandle := true;
  SecurityAttr.lpSecurityDescriptor := nil;

  // Pipes erzeugen
  CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0);
  CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0);

  // Initialisierung StartupInfo
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
  StartupInfo.cb := SizeOf(StartupInfo);
  StartupInfo.hStdInput := 0;
  StartupInfo.hStdOutput := PipeOutputWrite;
  StartupInfo.hStdError := PipeErrorsWrite;
  StartupInfo.wShowWindow := sw_Hide;
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;

  UniqueString(Command);
  if CreateProcess(nil, PChar(Command), nil, nil, true,
    CREATE_DEFAULT_ERROR_MODE or CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS,
    nil, nil, StartupInfo, ProcessInfo) then
    begin
      result := true;
      // Write-Pipes schließen
      CloseHandle(PipeOutputWrite);
      CloseHandle(PipeErrorsWrite);

      if Assigned(Output) then
        begin
          // Ausgabe Read-Pipe auslesen
          Stream := TMemoryStream.Create;
          try
            while true do
              begin
                Succeed := ReadFile(PipeOutputRead, Buffer, 255,
                  NumberOfBytesRead, nil);
                if not Succeed then
                  break;
                Stream.Write(Buffer, NumberOfBytesRead);
              end;
            Stream.Position := 0;
            Output.LoadFromStream(Stream);
          finally
            Stream.Free;
          end;
        end;
      CloseHandle(PipeOutputRead);

      if Assigned(Errors) then
        begin
          // Fehler Read-Pipe auslesen
          Stream := TMemoryStream.Create;
          try
            while true do
              begin
                Succeed := ReadFile(PipeErrorsRead, Buffer, 255,
                  NumberOfBytesRead, nil);
                if not Succeed then
                  break;
                Stream.Write(Buffer, NumberOfBytesRead);
              end;
            Stream.Position := 0;
            Errors.LoadFromStream(Stream);
          finally
            Stream.Free;
          end;
        end;
      CloseHandle(PipeErrorsRead);

      WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
      CloseHandle(ProcessInfo.hProcess);
    end
  else
    begin
      result := false;
      CloseHandle(PipeOutputRead);
      CloseHandle(PipeOutputWrite);
      CloseHandle(PipeErrorsRead);
      CloseHandle(PipeErrorsWrite);
    end;
end;
//C:\Windows\System32\
function GetSystemDir: string;
var Dir: string; Len: DWord;
begin
  SetLength(Dir,MAX_PATH);
  Len:=GetSystemDirectory(PChar(Dir),MAX_PATH);
  if Len>0 then begin SetLength(Dir,Len); Result:=Dir; end
  else RaiseLastOSError;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  Output : TStringList;
  Errors : TStringList;
  p : ANSIString;
begin
p:=ExtractFilePath(Application.ExeName);
Memo1.clear;
  Output := TStringList.Create;
  Errors := TStringList.Create;
  try
if GetConsoleOutput(GetSystemDir +'\ping.exe '+Edit1.text, Output, Errors) then
      Memo1.Lines.AddStrings(Output);
  finally
    Output.free;
    Errors.free;
  end;
end;

procedure TForm1.FormShow(Sender: TObject);
begin
 Button2.Click;
end;

end.

[no0B]

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
 ShellExecute(Handle,'Open', PChar('ping.exe'),PChar('127.0.0.1')
 ,nil,SW_SHOWNORMAL);
end;

end.

Würde im Programm gerne noch ein Textfeld haben in das ich die IP eintrage die ich anpingen will.

[pelzig]

Zu dumm/unerfahren für #5?

Was willst Du denn mehr als einen funktionierenden SourceCode, bei dem man nur im FormCreate einen String ändern muß?

OMG!

MfG

[pelzig]

Zitat:

Zitat von hathor (Beitrag 1284872)

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls,  ShellAPI, ComCtrls;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button2: TButton;
    Panel1: TPanel;
    Edit1: TEdit;
    Label13: TLabel;
    Button1: TButton;
    Label15: TLabel;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormShow(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

//------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
begin Application.terminate; end;

function GetConsoleOutput(Command: string; Output, Errors: TStrings): Boolean;
var
  StartupInfo: TStartupInfo;
  ProcessInfo: TProcessInformation;
  SecurityAttr: TSecurityAttributes;
  PipeOutputRead: THandle;
  PipeOutputWrite: THandle;
  PipeErrorsRead: THandle;
  PipeErrorsWrite: THandle;
  Succeed: Boolean;
  Buffer: array [0 .. 255] of Char;
  NumberOfBytesRead: DWORD;
  Stream: TMemoryStream;
begin
  // Initialisierung ProcessInfo
  FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);

  // Initialisierung SecurityAttr
  FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0);
  SecurityAttr.nLength := SizeOf(SecurityAttr);
  SecurityAttr.bInheritHandle := true;
  SecurityAttr.lpSecurityDescriptor := nil;

  // Pipes erzeugen
  CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0);
  CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0);

  // Initialisierung StartupInfo
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
  StartupInfo.cb := SizeOf(StartupInfo);
  StartupInfo.hStdInput := 0;
  StartupInfo.hStdOutput := PipeOutputWrite;
  StartupInfo.hStdError := PipeErrorsWrite;
  StartupInfo.wShowWindow := sw_Hide;
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;

  UniqueString(Command);
  if CreateProcess(nil, PChar(Command), nil, nil, true,
    CREATE_DEFAULT_ERROR_MODE or CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS,
    nil, nil, StartupInfo, ProcessInfo) then
    begin
      result := true;
      // Write-Pipes schließen
      CloseHandle(PipeOutputWrite);
      CloseHandle(PipeErrorsWrite);

      if Assigned(Output) then
        begin
          // Ausgabe Read-Pipe auslesen
          Stream := TMemoryStream.Create;
          try
            while true do
              begin
                Succeed := ReadFile(PipeOutputRead, Buffer, 255,
                  NumberOfBytesRead, nil);
                if not Succeed then
                  break;
                Stream.Write(Buffer, NumberOfBytesRead);
              end;
            Stream.Position := 0;
            Output.LoadFromStream(Stream);
          finally
            Stream.Free;
          end;
        end;
      CloseHandle(PipeOutputRead);

      if Assigned(Errors) then
        begin
          // Fehler Read-Pipe auslesen
          Stream := TMemoryStream.Create;
          try
            while true do
              begin
                Succeed := ReadFile(PipeErrorsRead, Buffer, 255,
                  NumberOfBytesRead, nil);
                if not Succeed then
                  break;
                Stream.Write(Buffer, NumberOfBytesRead);
              end;
            Stream.Position := 0;
            Errors.LoadFromStream(Stream);
          finally
            Stream.Free;
          end;
        end;
      CloseHandle(PipeErrorsRead);

      WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
      CloseHandle(ProcessInfo.hProcess);
    end
  else
    begin
      result := false;
      CloseHandle(PipeOutputRead);
      CloseHandle(PipeOutputWrite);
      CloseHandle(PipeErrorsRead);
      CloseHandle(PipeErrorsWrite);
    end;
end;
//C:\Windows\System32\
function GetSystemDir: string;
var Dir: string; Len: DWord;
begin
  SetLength(Dir,MAX_PATH);
  Len:=GetSystemDirectory(PChar(Dir),MAX_PATH);
  if Len>0 then begin SetLength(Dir,Len); Result:=Dir; end
  else RaiseLastOSError;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  Output : TStringList;
  Errors : TStringList;
  p : ANSIString;
  before, after : string;
begin
p:=ExtractFilePath(Application.ExeName);
Memo1.clear;
  Output := TStringList.Create;
  Errors := TStringList.Create;
  try
if GetConsoleOutput(GetSystemDir +'\ping.exe '+Edit1.text, Output, Errors) then
      Memo1.Lines.AddStrings(Output);
//  Replace _
before:= Memo1.Text;
after  := StringReplace(before, '_', 'ü',  [rfReplaceAll, rfIgnoreCase]);
Memo1.Clear; Memo1.Text:= after;
  finally
    Output.free;
    Errors.free;
  end;
end;

procedure TForm1.FormShow(Sender: TObject);
begin
 Button2.Click;
end;

end.

@hathor: Ich gehe davon aus, daß der TE *NULL* Ahnung von Delphi hat und auch nicht kapiert hat, was man beim "Anmelden" in der DP berücksichtigen/angeben sollte.

Andererseits unterstelle ich (und Du vermutlich auch) dem TE auch keine "Hausaufgabe", denn dazu ist die Anforderung des TE sehr sehr viel zu gering!

MfG

[no0B]

Unerfahren ! Deswegen ja auch auch No0B :wink:

Also Absoluter Neuling im Thema Delphi nix mit "Hausaufgabe" just for fun !

Das mit der .bat hat sich erledigt wenns auch einfacher geht und ichs in Prog mit nem Textfeld einbauen kann.

Und Pelzig Bitte lass deine Unterstellungen,

Zitat:

Andererseits unterstelle ich (und Du vermutlich auch)

Am besten gibst du hierzu deinen Senf überhaupt nicht mehr ab, denn auf solche Kommentare kann ich manch anderer wahrscheinlich gern verzichten.

OMG

[pelzig]

@noOB:

ShellExecute(Handle,'Open', PChar('ping.exe'),PChar(Edit1.Text)
S ,nil,SW_SHOWNORMAL);

ist dermaßen abstrakt, daß man es einfach nicht erraten kann!

und #5 ist nur für Außerirdische zum Lesen/Verstehen geeignet!!!

Denn im Internet gibt es keine Hilfe zu Delphi!

Und darunter leiden wir Delphi-Programmierer - genau wie Du ;-)

MfG

[pelzig]

Zitat:

Zitat von no0B (Beitrag 1284877)

Unerfahren ! Deswegen ja auch auch No0B :wink:

Also Absoluter Neuling im Thema Delphi nix mit "Hausaufgabe" just for fun !

Das mit der .bat hat sich erledigt wenns auch einfacher geht und ichs in Prog mit nem Textfeld einbauen kann.

Und Pelzig Bitte lass deine Unterstellungen,

Zitat:

Andererseits unterstelle ich (und Du vermutlich auch)

Am besten gibst du hierzu deinen Senf überhaupt nicht mehr ab, denn auf solche Kommentare kann ich manch anderer wahrscheinlich gern verzichten.

OMG

Jetzt schäme ich mich für meine Antworten, da ich nur Staub in Deinen allwissenden Augen bin.

Falls der Allwissende noch lesen kann, sollte ER/die sich die erhabene Gottheit mal #1 dieses Threads anschauen...

MfG

[Daniel]

Zitat:

Zitat von pelzig (Beitrag 1284879)

Jetzt schäme ich mich für meine Antworten

Ja, das solltest Du auch. Weil sie einfach nur patzig und unfreundlich sind und Du Dich mächtig im Ton vergriffen hast.

Der Fragesteller sollte mittlerweile gelernt haben, dass es mehrere Wege zum Ziel gibt. Eine Komplett-Lösung hat er nun ebenfalls, ich denke, dass es jetzt an ihm liegt.

[hathor]

In #6 wegen Umlauten Code geändert, Anhang ersetzt mit geänderter EXE und MS Linedraw-Font hinzugefügt.

[Daniel]

Spannende Lösung - wobei man mit Blick auf die Tatsache, dass der Fragesteller eher Anfänger ist, hinzufügen sollte, dass die Umleitung der Consolen-Ausgabe eher eine Zugabe ist.

[mm1256]

Zitat:

Zitat von hathor (Beitrag 1284882)

In #6 wegen Umlauten Code geändert, Anhang ersetzt mit geänderter EXE und MS Linedraw-Font hinzugefügt.

Ich suche derzeit zufällig nach einer solchen Lösung - einfach perfekt! Vielen Dank für deine Lösung! Kleine Erweiterung: Die Stringlist wandle ich gleich um, dann funktioniert es mit den Umlauten mit jedem Font:

Delphi-Quellcode:

var
  ...
  SAnsi: AnsiString;

...
  SAnsi := AnsiString(Output.Text);
  OemToCharBuffA(PAnsiChar(SAnsi), PAnsiChar(SAnsi), Length(SAnsi));
  Output.Text := String(SAnsi);

[hathor]

Danke - mm1256 - für diesen Vorschlag.
Den Font MS Linedraw muss man dann aber austauschen.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls,  ShellAPI, ComCtrls;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button2: TButton;
    Panel1: TPanel;
    Edit1: TEdit;
    Label13: TLabel;
    Button1: TButton;
    Label15: TLabel;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormShow(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

//-----------------------------------------------------------------------------
procedure TForm1.Button1Click(Sender: TObject);
begin Application.terminate; end;

function GetConsoleOutput(Command: string; Output, Errors: TStrings): Boolean;
var
  StartupInfo: TStartupInfo;
  ProcessInfo: TProcessInformation;
  SecurityAttr: TSecurityAttributes;
  PipeOutputRead: THandle;
  PipeOutputWrite: THandle;
  PipeErrorsRead: THandle;
  PipeErrorsWrite: THandle;
  Succeed: Boolean;
  Buffer: array [0 .. 255] of Char;
  NumberOfBytesRead: DWORD;
  Stream: TMemoryStream;
begin
  // Initialisierung ProcessInfo
  FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);

  // Initialisierung SecurityAttr
  FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0);
  SecurityAttr.nLength := SizeOf(SecurityAttr);
  SecurityAttr.bInheritHandle := true;
  SecurityAttr.lpSecurityDescriptor := nil;

  // Pipes erzeugen
  CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0);
  CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0);

  // Initialisierung StartupInfo
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
  StartupInfo.cb := SizeOf(StartupInfo);
  StartupInfo.hStdInput := 0;
  StartupInfo.hStdOutput := PipeOutputWrite;
  StartupInfo.hStdError := PipeErrorsWrite;
  StartupInfo.wShowWindow := sw_Hide;
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;

  UniqueString(Command);
  if CreateProcess(nil, PChar(Command), nil, nil, true,
    CREATE_DEFAULT_ERROR_MODE or CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS,
    nil, nil, StartupInfo, ProcessInfo) then
    begin
      result := true;
      // Write-Pipes schließen
      CloseHandle(PipeOutputWrite);
      CloseHandle(PipeErrorsWrite);

      if Assigned(Output) then
        begin
          // Ausgabe Read-Pipe auslesen
          Stream := TMemoryStream.Create;
          try
            while true do
              begin
                Succeed := ReadFile(PipeOutputRead, Buffer, 255,
                  NumberOfBytesRead, nil);
                if not Succeed then
                  break;
                Stream.Write(Buffer, NumberOfBytesRead);
              end;
            Stream.Position := 0;
            Output.LoadFromStream(Stream);
          finally
            Stream.Free;
          end;
        end;
      CloseHandle(PipeOutputRead);

      if Assigned(Errors) then
        begin
          // Fehler Read-Pipe auslesen
          Stream := TMemoryStream.Create;
          try
            while true do
              begin
                Succeed := ReadFile(PipeErrorsRead, Buffer, 255,
                  NumberOfBytesRead, nil);
                if not Succeed then
                  break;
                Stream.Write(Buffer, NumberOfBytesRead);
              end;
            Stream.Position := 0;
            Errors.LoadFromStream(Stream);
          finally
            Stream.Free;
          end;
        end;
      CloseHandle(PipeErrorsRead);

      WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
      CloseHandle(ProcessInfo.hProcess);
    end
  else
    begin
      result := false;
      CloseHandle(PipeOutputRead);
      CloseHandle(PipeOutputWrite);
      CloseHandle(PipeErrorsRead);
      CloseHandle(PipeErrorsWrite);
    end;
end;
//C:\Windows\System32\
function GetSystemDir: string;
var Dir: string; Len: DWord;
begin
  SetLength(Dir,MAX_PATH);
  Len:=GetSystemDirectory(PChar(Dir),MAX_PATH);
  if Len>0 then begin SetLength(Dir,Len); Result:=Dir; end
  else RaiseLastOSError;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  Output : TStringList;
  Errors : TStringList;
  p : ANSIString;
  SAnsi: AnsiString;
begin
p:=ExtractFilePath(Application.ExeName);
Memo1.clear;
  Output := TStringList.Create;
  Errors := TStringList.Create;
  try
if GetConsoleOutput(GetSystemDir +'\ping.exe '+Edit1.text, Output, Errors) then
      Memo1.Lines.AddStrings(Output);

  SAnsi := AnsiString(Memo1.Text);
  OemToCharBuffA(PAnsiChar(SAnsi), PAnsiChar(SAnsi), Length(SAnsi));
  Memo1.Text := String(SAnsi);

  finally
    Output.free;
    Errors.free;
  end;
end;

procedure TForm1.FormShow(Sender: TObject);
begin
 Button2.Click;
end;

end.

[mm1256]

Hallo,

kleines Missverständnis, ich habe die Konvertierung in die "GetConsoleOutput" eingebaut, was aber eigentlich aufgrund der Verwendung von "Output.Text" ersichtlich war. Man kann das natürlich auch in die Form packen, aber der Einfachheit halber (Stichwort Wiederverwendung) dachte ich mir, dass das der geeignetere Platz wäre.

Man könnte natürlich "GetConsoleOutput" noch einen zusätzlichen Convert-Parameter übergeben...man könnte noch so vieles machen...macht halt jeder so wie er es für richtig hält :thumb:

[hathor]

An der gleichen Stelle hatte ich ursprünglich eine REPLACE-Funktion.
Man kann auch eine Checkbox einbauen:

Delphi-Quellcode:

...
if GetConsoleOutput(GetSystemDir +'\ping.exe '+Edit1.text, Output, Errors) then
      Memo1.Lines.AddStrings(Output);
if CheckBox1.Checked then
BEGIN
  SAnsi := AnsiString(Memo1.Text);
  OemToCharBuffA(PAnsiChar(SAnsi), PAnsiChar(SAnsi), Length(SAnsi));
  Memo1.Text := String(SAnsi);
END;
  finally
    Output.free;
    Errors.free;
  end;
end;

[Perlsau]

@no0B

Beim Delphi-Treff gibt es ein umfangreiches und sehr gut gemachtes Anfänger-Tutorial, das ich nur jedem Einsteiger wärmstens empfehlen kann. Kostet nix außer vielleicht ein paar virtuelle Schweißtropfen und die Aktivierung diverser grauer Zellen :-D

Außerdem bietet Delphi-Treff den Easy Delphi Helper an – "ein kostenloses kleines Tool, das all unsere Tipps auch für die Offline-Verwendung verfügbar macht – inkl. Suchfunktion und Favoritenverwaltung".

Viel Spaß und Erfolg dabei und einen entsprechend guten Rutsch ins neue Jahr wünsche ich dir :!:

[no0B]

Alles klar Danke werde ich mir mal anschauen.

Gleichfalls guten Rutsch. :thumb: