ja es ist schon wieder das leidige Thema
Ich hab mir einige Beiträge und die Borland Hilfe durchgelesen und bin nun zu diesen Funktionen gekommen:

Zum Senden des Streams:

TFileStream* file = new TFileStream(DateiOeffnen->FileName, fmOpenRead);
DCSocket->Socket->SendStream(file);
delete file;

Zum Empfangen:

TFileStream* file = new TFileStream(DateiSpeichern->FileName, fmCreate);
Socket->ReceiveBuf(file,Socket->ReceiveLength());
delete file;

Ich erhalte jedoch immer irgendwelche Fehler wegen unberechtigten Speicherzugriffen etc. Naja das da was nicht richtig ist wusste ich auch schon vorher, nur was ist mein Problem

Könnte mir da vielleicht jemand helfen?

Socket->ReceiveBuf(file,Socket->ReceiveLength());

So geht das nicht, da die Variable file ein Zeiger auf ein Stream-Objekt und nicht auf einen Speicherbereich darstellt. Wenn du Daten in den Stream schreiben willst, mußt du sie umkopieren:

TFileStream* file = new TFileStream(DateiSpeichern->FileName, fmCreate);
char buf[1024];
int c;
do
{
  c = Socket->ReceiveBuf(buf, sizeof(buf));
  file->Write(buf,c)
}
while (c == sizeof(buf));

Also die genaue Fehlermeldung heißt:
"Zugriffsverletzung bei Adresse 00000000. Lesen von Adresse 00000000."

Ich erhalte die Fehlermeldung, nachdem versucht wird, die ankommenden Daten zu empfangen. Es springt auf jeden Fall schonmal in die Funktion, soweit konnte ich es schon testen.

Hab deinen Code oben eingesetzt und daher müsste es ja funktionieren.
Wenn nur file nur ein Zeiger ist, muss dann die Sendefunktion nicht auch anders programmiert werden?

Nochmal danke.

die sende funktion musst du nicht ändern, da sie extram zum senden von streams gemacht ist, du kannst jedoch auf ca die selbe art und weise die SendBufer mehtode benutzen

TFileStream* file = new TFileStream(DateiSpeichern->FileName, fmCreate);
char buf[1024];
int c;
do
{
  c = Socket->ReceiveBuf(buf, sizeof(buf));
  file->Write(buf,c);
}
while (c == sizeof(buf));
delete file;

EDIT: Ich bekomme den fheler aber beim senden...

warum pruefst du file nicht ab
(zB if ( file )
Ich glaube da kommt dein Fehler her

MfG
Klaus

Wenn file den Wert 0 enthält...

Normalerweise sollte der TFileStream-Konstruktor in diesem Fall aber eine Exception werfen.

@HolyCow: Aus Deinen Beiträgen geht nicht so richtig hervor, in welcher Zeile nun genau der Fehler auftritt - beim ReceiveBuf oder beim Write?

Der Code von Burkhi sieht gut aus und sollte erst einmal funktionieren.
Allerdings würde ich die while-Bedingung so schreiben:

while (c != -1)

Wenn ich die Hilfe richtig verstanden habe, ist es nicht sicher, daß tatsächlich immer die angeforderte Anzahl an Bytes übertragen wird.

c = Socket->ReceiveBuf(buf, sizeof(buf));

Die Funktion liefert dir zurück, wieviele Zeichen tatsächlich empfangen wurden. Der zweite Parameter gibt die maximale Größe des Puffers an, der die Zeichen aufnehmen soll.
Daraus folgt: 0 <= c <= sizeof(buf)

Wenn c == sizeof(Buf) ist, so können noch weitere Zeichen empfangen worden sein, deshalb die Schleife.

Daraus folgt: 0 <= c <= sizeof(buf)

Wenn c == sizeof(Buf) ist, so können noch weitere Zeichen empfangen worden sein, deshalb die Schleife.

Hmmm, laut BCB-Hilfe ist gilt -1 <= c <= sizeof(buf). Und -1 wird zurückgegeben, wenn keine Daten übertragen wurden. (Da würde mich so nebenbei mal interessieren, wo der Unterschied zwischen c=-1 und c=0 besteht.)
Das Problem bei Deiner Schleife ist, daß sie prinzipiell beendet wird, wenn c ungleich, also speziell auch kleiner als sizeof(buf) ist. Wird also irgendwo in der Mitte der Übertragung ein Daten-Paket empfangen, dessen Länge kleiner als sizeof(buf) ist, bricht die Schleife ab, obwohl noch nicht alle Daten angekommen sind.

ich habe jetzt etwas weitergearbeitet und die Sendefunktion ist soweit nun komplett richtig .. glaub ich wenigstens.
Diese Funktion sendet mir die komplette Datei, hatte Testhalber einen Zähler drin der die Datenpackete zählte, nur das Empfangen macht noch Probleme.

//Anlegen des Streams ...
TFileStream* file = new TFileStream(DateiOeffnen->FileName, fmOpenRead);
char buf[1024]; //Buffer
int c,b;        //Testvariabeln

//Solange senden bis Buffer nichtmehr voll geschriben wird,
//also Datei zu ende ist
do
{
  //Auslesen der zu sendenden Informationen
  b = file->Read(buf,sizeof(buf));

  //Senden des Buffers
  c = DCSocket->Socket->SendBuf(buf,sizeof(buf));

  //Falls nicht gesendet werden konnte, also interner Speicher voll war,
  //solange warten, bis gesendet werden kann
  while(c == -1)
  {
     Delay(10);
     c = DCSocket->Socket->SendBuf(buf,sizeof(buf));
  }
}
while(b == sizeof(buf));

Hatte ihn mal soweit, dass die ersten 61 gesendeten Datenpackete auch ordnungsgemäß empfangen wurden (bei Bildern konnte ich dann z.B. schon einen kleinen Teil erkennen), nach diesen Packeten sprang er jedoch aus der Funktion und nach einigen Sekunden wieder zurück und ich konnte die Datei nicht mehr öffnen und erhielt einen Fehler wie "Kann Datei nicht anlegen".
Hatte alles mögliche versucht, z.B. die Datei mit FileCreate oder mit Fstream anzulegen oder was weiß ich was mir noch so alles eingefallen ist.
Naja langsamm bin ich hier am verzweifeln

Nun ja, die Empfangfunktion sieht nun so aus. Fast wie am Anfang, da ich sie eben einfach mal versucht hab von Beginn an neu zu programmieren, hilf manchmal bei mir.

TFileStream* file = new TFileStream(DateiSpeichern->FileName, fmCreate);
char buf[1024];
int c;
do
{
  c = Socket->ReceiveBuf(buf, sizeof(buf));
  if(c != -1)
    file->WriteBuffer(buf,sizeof(buf));
    Hauptfenster->Mhauptfenster->Lines->Add("-----> " + IntToStr(c));
}
while(c != -1);
delete file;

Ich erhalte jetzt in meiner Testausgabe seltsammerweise sehr oft eine "-1", das dürfte aber wegen der If-Anweisung gar nicht sein.
Nun ja, werde morgen nochmal was dran arbeiten, geh jetzt erstmal was grillen, sonst werd ich noch verrückt

So einfach kann es sein, funktioniert jetzt bei mir, endlich

Also, falls es wen interessiert, hier ist der Code nochmal:

Senden:

//Anlegen des Streams ...
TFileStream* file = new TFileStream(DateiOeffnen->FileName, fmOpenRead);
file->Seek(0,soFromBeginning);
char buf[1024]; //Buffer
int c,b;    //Testvariabeln

//Solange senden bis Buffer nichtmehr voll geschriben wird,
//also Datei zu ende ist
do
{
  //Auslesen der zu sendenden Informationen
  b = file->Read(buf,sizeof(buf));

  //Senden des Buffers
  c = DCSocket->Socket->SendBuf(buf,sizeof(buf));

  //Falls nicht gesendet werden konnt, also interner Speicher voll war,
  //solange warten, bis gesendet werden kann
  while(c == -1)
  {
    Delay(10);
    c = DCSocket->Socket->SendBuf(buf,sizeof(buf));
  }
}
while(b == sizeof(buf));

//Löschen des temporären Streams
delete file;

Empfangen:
1.Ein Filestream wird in der Headerdatei deklariert.

class TDatei : public TForm
{
[...]
  public:
    TFileStream* file;
[...]
};

2.Der Stream wird irgendwo im Programm initialisiert

if(DateiSpeichern->Execute())
{
  DSSocket->Socket->Connections[0]->SendText("senden");
  file = new TFileStream(DateiSpeichern->FileName, fmCreate);
}
else
  DSSocket->Socket->Connections[0]->SendText("abbrechen");

3. Daten werden ohne Schleife in der Read-Funktion abgespeichert.

char buf[1024]; //Buffer
int c;  //Testvariabel

//Daten auslesen und Größe speichern
c = Socket->ReceiveBuf(buf,sizeof(buf));
//Falls Daten gelesen in Filestream speichern
if(c != -1)
  file->Write(buf,c);

Hmm hätte zwar nicht gedacht, dass es ohne Schleife funktioniert, aber irgendwie geht es bei mir. Jetzt müssen nur noch paar kleiner Abfragen rein und dann solls das gewesen sein.
Naja wie auch immer, habs also doch noch geschafft.

Daher vielen Dank an die umfangreiche und freundliche Hilfe.
ThX

Man sieht sich sicher noch, bin mit meinem Programm ja noch nicht fertig

c = DCSocket->Socket->SendBuf(buf,sizeof(buf));
durch
c = DCSocket->Socket->SendBuf(buf,b);

ersetzt werden.
Bei kleineren Datenpacketen wird sonst der gesammte Buffer, obwohl er keine verwertbaren Daten beinhaltet, gesendet.

Senden:

//Anlegen des Streams ...
TMemoryStream* file = new TMemoryStream;
file->LoadFromFile("1.bmp");
//Image1->Picture->Bitmap->SaveToStream(file);
Image2->Picture->Bitmap->LoadFromStream(file);

file->Seek(0,soFromBeginning);
char buf[1024]; //Buffer
int c,b;    //Testvariabeln

//Solange senden bis Buffer nichtmehr voll geschriben wird,
//also Datei zu ende ist
do
{
  //Auslesen der zu sendenden Informationen
  b = file->Read(buf,sizeof(buf));

  //Senden des Buffers
  c = ClientSocket1->Socket->SendBuf(buf,b);

  //Falls nicht gesendet werden konnt, also interner Speicher voll war,
  //solange warten, bis gesendet werden kann
  while(c == -1)
  {
    for(int i=0;i<1000000;i++){}
    c = ClientSocket1->Socket->SendBuf(buf,sizeof(buf));
  }
}
while(b == sizeof(buf));

//Löschen des temporären Streams
delete file;

Empfangen:

char buf[1024]; //Buffer
int c;  //Testvariabel

//Daten auslesen und Größe speichern
c = Socket->ReceiveBuf(buf,sizeof(buf));
//Falls Daten gelesen in Filestream speichern
if(c != -1)
  Stream->Write(buf,c);
ListBox1->Items->Add("Recieve");
Caption=Stream->Size;
Image1->Picture->Bitmap->LoadFromStream(Stream);

Bitte um hilfe!!!!

Gruß FB4

HolyCow schrieb:

char buf[1024]; //Buffer
...
c = Socket->ReceiveBuf(buf,sizeof(buf));
...

Hmm hätte zwar nicht gedacht, dass es ohne Schleife funktioniert, aber irgendwie geht es bei mir.

wenn ich das richtig sehe, "funktioniert" Deine Variante nur bei Dateien bis zu einer Größe von 1024 Byte. Ich fürchte, um die Schleife kommst Du nicht herum - so ungefähr (ungetestet):

int bytesReseived(0);
do
{
    bytesReseived = Socket->Receive(buffer, bufferSize);
    inStream->Write(buffer, bufferSize);
}
while (bytesReseived != -1)

Gruß FB4