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 von 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;
  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

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