Is this the correct way to send a Bitmap over sockets?

[eliss.carmine]

I'm using TCP/IP to send a Bitmap object over Sockets. This is my first
time using C# at all so I don't know if this is the "right" way to do
it. I've already found out several times the way I was doing something
was really inefficient and could reduce 10 lines of code with 2, etc.

For reading, I am using a TcpClient and I call

NetworkStream ns = client.GetStrea m(); to get a stream

stream.Read(buf fer, 0, buffer.Length);

now already my question is, how do I make buffer so that I don't have
to arbitrarily make it 1 MB? What if my Bitmap is larger than 1 MB? Do
I need to read multiple times and then "join" the buffers? How would I
do that?

MemoryStream ms = new MemoryStream(bu ffer);

Bitmap = new Bitmap(ms);

Does this seem like the correct way to send the Bitmap over my Socket?

I also found that saving the Bitmap as a PNG before sending makes it
smaller. Is this a good idea, and can I compress it even more?
bm.Save(ms, System.Drawing. Imaging.ImageFo rmat.Png);
Thanks so much for reading a question from a newbie. I know this might
not make sense to some of you, or seem trivial.

[Marc Gravell]

Can you not save / load directly to / from the NetworkStream?

bm.Save(ns, System.Drawing. Imaging.ImageFo rmat.Png);

Marc

[Lenard Gunda]

Hi,

I just tried sending an image (will post a sample in a minute).

GDI+ throws an error if you try to save into the NetworkStream directly.
I don't know why. You can however read the image from the NetworkStream
directly.

-Lenard

Marc Gravell wrote:

Can you not save / load directly to / from the NetworkStream?

bm.Save(ns, System.Drawing. Imaging.ImageFo rmat.Png);

Marc

[Lenard Gunda]

Hi,

I played a little with this problem, and came up with the following
solution.

For sending, you could use:

TcpListener listener = new TcpListener ( 9998 );
listener.Start ();
TcpClient client = listener.Accept TcpClient ();
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromFile ( @"..file.." );
using ( MemoryStream ms = new MemoryStream () )
{
image.Save ( ms, ImageFormat.Png );
byte[] imageBuffer = ms.GetBuffer ();
stream.Write ( imageBuffer, 0, (int)ms.Length );
}

stream.Close ( 500 );
client.Close ();
listener.Stop ();

Here you don't have to worry about the buffer, because MemoryStream will
handle it for you. For some reason you cannot use the NetworkStream
directly (to save the image into that). GDI+ throws an exception if you
try that. I guess it has something to do with network streams not being
searchable (but that is just a guess).

On the receiving end, you can however read directly from the
NetworkStream. So you could create a method like:

private Image ReceiveBitmap ()
{
TcpClient client = new TcpClient ();
client.Connect ( "127.0.0.1" , 9998 );
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromStrea m ( stream );

stream.Close ();
client.Close ();

return image;
}

This will read your image and return it to the caller. As you can see
you do not need to worry about the length of the buffer, because the
image loader will read the correct number of bytes.

Note however, that I did not do any error checking above.

Another way to solve the problem is to not send just the image onto the
network stream, rather first the size (say an Int32) and then the
contents of the buffer. On the receiving end you would then always read
an Int32 (the length), allocate a buffer that fits the data, and then
receive into that buffer. That way you allocate just as much space as
you need.

Hope this helps

-Lenard


el***********@g mail.com wrote:

I'm using TCP/IP to send a Bitmap object over Sockets. This is my first
time using C# at all so I don't know if this is the "right" way to do
it. I've already found out several times the way I was doing something
was really inefficient and could reduce 10 lines of code with 2, etc.

For reading, I am using a TcpClient and I call

NetworkStream ns = client.GetStrea m(); to get a stream

stream.Read(buf fer, 0, buffer.Length);

now already my question is, how do I make buffer so that I don't have
to arbitrarily make it 1 MB? What if my Bitmap is larger than 1 MB? Do
I need to read multiple times and then "join" the buffers? How would I
do that?

MemoryStream ms = new MemoryStream(bu ffer);

Bitmap = new Bitmap(ms);

Does this seem like the correct way to send the Bitmap over my Socket?

I also found that saving the Bitmap as a PNG before sending makes it
smaller. Is this a good idea, and can I compress it even more?
bm.Save(ms, System.Drawing. Imaging.ImageFo rmat.Png);
Thanks so much for reading a question from a newbie. I know this might
not make sense to some of you, or seem trivial.

[Dave Sexton]

Hi,

I'm using TCP/IP to send a Bitmap object over Sockets. This is my first
time using C# at all so I don't know if this is the "right" way to do
it. I've already found out several times the way I was doing something
was really inefficient and could reduce 10 lines of code with 2, etc.

For reading, I am using a TcpClient and I call

NetworkStream ns = client.GetStrea m(); to get a stream

stream.Read(buf fer, 0, buffer.Length);

now already my question is, how do I make buffer so that I don't have
to arbitrarily make it 1 MB? What if my Bitmap is larger than 1 MB? Do
I need to read multiple times and then "join" the buffers? How would I
do that?

MemoryStream ms = new MemoryStream(bu ffer);

Bitmap = new Bitmap(ms);

Does this seem like the correct way to send the Bitmap over my Socket?

I also found that saving the Bitmap as a PNG before sending makes it
smaller. Is this a good idea, and can I compress it even more?
bm.Save(ms, System.Drawing. Imaging.ImageFo rmat.Png);
Thanks so much for reading a question from a newbie. I know this might
not make sense to some of you, or seem trivial.

Network programming is never trivial ;)

First, I have to ask, why do you want to do that? (There may be a better
way)

Next, try the code after my signature if you really need to use Sockets.
Beware there is no error handling logic, which I'm sure you'll want to
implement otherwise the app could easily crash.

--
Dave Sexton

using System;
using System.Net.Sock ets;
using System.Threadin g;
using System.Drawing;
using System.Runtime. Serialization.F ormatters.Binar y;
using System.IO;
using System.Net;

namespace Testing
{
class Program
{
const int port = 9483; // arbitrary

static void Main(string[] args)
{
StartServer();

SendBitmap();

Console.WriteLi ne("Press [enter] to exit");
Console.ReadLin e();
}

static void SendBitmap()
{
Bitmap bitmap = new Bitmap(300, 500);
byte[] bytes = null;

Console.WriteLi ne("Client: Created Bitmap: {0}x{1}", bitmap.Width,
bitmap.Height);

Console.WriteLi ne("Client: Serializing Bitmap");

using (MemoryStream stream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter ();
formatter.Seria lize(stream, bitmap);

bytes = stream.ToArray( );
}

Console.WriteLi ne("Client: Connecting to Server");

using (TcpClient client = new TcpClient("loca lhost", port))
{
Console.WriteLi ne("Client: Sending Bitmap");

client.GetStrea m().Write(bytes , 0, bytes.Length);
}

Console.WriteLi ne("Client: Bitmap Sent");
}

static Bitmap AcceptBitmap(Tc pClient client)
{
NetworkStream stream = client.GetStrea m();

byte[] bytes = new byte[1024];
int read = 0;

using (MemoryStream bitmapStream = new MemoryStream())
{
Console.WriteLi ne("Server: Receiving Bitmap");

while ((read = stream.Read(byt es, 0, 1024)) != 0)
// read = 0 indicates that the Socket was closed
bitmapStream.Wr ite(bytes, 0, read);

// reset position to beginning of stream
bitmapStream.Po sition = 0;

Console.WriteLi ne("Server: Bitmap Received");

BinaryFormatter formatter = new BinaryFormatter ();

Console.WriteLi ne("Server: Deserializing Bitmap");

return (Bitmap) formatter.Deser ialize(bitmapSt ream);
}
}

static void StartServer()
{
TcpListener listener = new TcpListener(IPA ddress.Loopback , port);

Thread thread = new Thread(delegate ()
// the listener will run in the background
{
listener.Start( );

Bitmap bitmap = null;

using (TcpClient client = listener.Accept TcpClient())
{
Console.WriteLi ne("Server: Client Connected");

bitmap = AcceptBitmap(cl ient);

Console.WriteLi ne("Server: Received Bitmap: {0}x{1}", bitmap.Width,
bitmap.Height);
}

listener.Stop() ;
});

thread.IsBackgr ound = true;
thread.Start();

Console.WriteLi ne("Server: Server Started");
}
}
}

[Dave Sexton]

Hi Lenard,

I like your idea of saving the bitmap directly to the stream. I used a
BinaryFormatter in my example, but it seems unnecessary now :)

However, you shouldn't use the GetBuffer method since it might return the
stream + empty buffer bytes. Use ToArray() instead.

"MemoryStream.T oArray Method"
http://msdn2.microsoft.com/en-us/lib...m.toarray.aspx

--
Dave Sexton

"Lenard Gunda" <ms**@frenzy.hu wrote in message
news:%2******** ********@TK2MSF TNGP03.phx.gbl. ..

Hi,

I played a little with this problem, and came up with the following
solution.

For sending, you could use:

TcpListener listener = new TcpListener ( 9998 );
listener.Start ();
TcpClient client = listener.Accept TcpClient ();
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromFile ( @"..file.." );
using ( MemoryStream ms = new MemoryStream () )
{
image.Save ( ms, ImageFormat.Png );
byte[] imageBuffer = ms.GetBuffer ();
stream.Write ( imageBuffer, 0, (int)ms.Length );
}

stream.Close ( 500 );
client.Close ();
listener.Stop ();

Here you don't have to worry about the buffer, because MemoryStream will
handle it for you. For some reason you cannot use the NetworkStream
directly (to save the image into that). GDI+ throws an exception if you
try that. I guess it has something to do with network streams not being
searchable (but that is just a guess).

On the receiving end, you can however read directly from the
NetworkStream. So you could create a method like:

private Image ReceiveBitmap ()
{
TcpClient client = new TcpClient ();
client.Connect ( "127.0.0.1" , 9998 );
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromStrea m ( stream );

stream.Close ();
client.Close ();

return image;
}

This will read your image and return it to the caller. As you can see you
do not need to worry about the length of the buffer, because the image
loader will read the correct number of bytes.

Note however, that I did not do any error checking above.

Another way to solve the problem is to not send just the image onto the
network stream, rather first the size (say an Int32) and then the contents
of the buffer. On the receiving end you would then always read an Int32
(the length), allocate a buffer that fits the data, and then receive into
that buffer. That way you allocate just as much space as you need.

Hope this helps

-Lenard


el***********@g mail.com wrote:

>I'm using TCP/IP to send a Bitmap object over Sockets. This is my first
time using C# at all so I don't know if this is the "right" way to do
it. I've already found out several times the way I was doing something
was really inefficient and could reduce 10 lines of code with 2, etc.

For reading, I am using a TcpClient and I call

NetworkStrea m ns = client.GetStrea m(); to get a stream

stream.Read(bu ffer, 0, buffer.Length);

now already my question is, how do I make buffer so that I don't have
to arbitrarily make it 1 MB? What if my Bitmap is larger than 1 MB? Do
I need to read multiple times and then "join" the buffers? How would I
do that?

MemoryStream ms = new MemoryStream(bu ffer);

Bitmap = new Bitmap(ms);

Does this seem like the correct way to send the Bitmap over my Socket?

I also found that saving the Bitmap as a PNG before sending makes it
smaller. Is this a good idea, and can I compress it even more?
bm.Save(ms, System.Drawing. Imaging.ImageFo rmat.Png);
Thanks so much for reading a question from a newbie. I know this might
not make sense to some of you, or seem trivial.

[Lenard Gunda]

Hi Dave,

My understanding is that ToArray() would create a copy of the buffer,
while GetBuffer() would return the buffer itself. For big buffers
(although they do get cleaned up by GC) I think this would waste memory.

While it is true that there might be unused space at the end, this is
the reason why I used the MemoryStream instance's Length property, and
not the length of the byte[] itself. This way the correct number of
bytes would be sent over the network.

-Lenard

Dave Sexton wrote:

Hi Lenard,

I like your idea of saving the bitmap directly to the stream. I used a
BinaryFormatter in my example, but it seems unnecessary now :)

However, you shouldn't use the GetBuffer method since it might return the
stream + empty buffer bytes. Use ToArray() instead.

"MemoryStream.T oArray Method"
http://msdn2.microsoft.com/en-us/lib...m.toarray.aspx

[Dave Sexton]

Hi Lenard,

I can see how that might be preferable.

--
Dave Sexton

"Lenard Gunda" <ms**@frenzy.hu wrote in message
news:%2******** *******@TK2MSFT NGP02.phx.gbl.. .

Hi Dave,

My understanding is that ToArray() would create a copy of the buffer,
while GetBuffer() would return the buffer itself. For big buffers
(although they do get cleaned up by GC) I think this would waste memory.

While it is true that there might be unused space at the end, this is the
reason why I used the MemoryStream instance's Length property, and not the
length of the byte[] itself. This way the correct number of bytes would be
sent over the network.

-Lenard

Dave Sexton wrote:

>Hi Lenard,

I like your idea of saving the bitmap directly to the stream. I used a
BinaryFormatte r in my example, but it seems unnecessary now :)

However, you shouldn't use the GetBuffer method since it might return the
stream + empty buffer bytes. Use ToArray() instead.

"MemoryStream. ToArray Method"
http://msdn2.microsoft.com/en-us/lib...m.toarray.aspx

[eliss.carmine]

Hi Lenarf,

Thanks for the quick response.

I am trying to get the ReceiveBitmap part working using your example. I
had a working solution and in mine, I replaced

byte[] buffer = new byte[1000000];
stream.Read(buf fer, 0, buffer.Length);
MemoryStream ms = new MemoryStream(bu ffer);
ShownWindow.Bac kgroundImage = Bitmap.FromStre am(ms);

with

ShownWindow.Bac kgroundImage = Bitmap.FromStre am(stream);

in order to cut out two middlemen, but then it stops working. Any idea
why?
Lenard Gunda wrote:

Hi,

I played a little with this problem, and came up with the following
solution.

For sending, you could use:

TcpListener listener = new TcpListener ( 9998 );
listener.Start ();
TcpClient client = listener.Accept TcpClient ();
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromFile ( @"..file.." );
using ( MemoryStream ms = new MemoryStream () )
{
image.Save ( ms, ImageFormat.Png );
byte[] imageBuffer = ms.GetBuffer ();
stream.Write ( imageBuffer, 0, (int)ms.Length );
}

stream.Close ( 500 );
client.Close ();
listener.Stop ();

Here you don't have to worry about the buffer, because MemoryStream will
handle it for you. For some reason you cannot use the NetworkStream
directly (to save the image into that). GDI+ throws an exception if you
try that. I guess it has something to do with network streams not being
searchable (but that is just a guess).

On the receiving end, you can however read directly from the
NetworkStream. So you could create a method like:

private Image ReceiveBitmap ()
{
TcpClient client = new TcpClient ();
client.Connect ( "127.0.0.1" , 9998 );
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromStrea m ( stream );

stream.Close ();
client.Close ();

return image;
}

This will read your image and return it to the caller. As you can see
you do not need to worry about the length of the buffer, because the
image loader will read the correct number of bytes.

Note however, that I did not do any error checking above.

Another way to solve the problem is to not send just the image onto the
network stream, rather first the size (say an Int32) and then the
contents of the buffer. On the receiving end you would then always read
an Int32 (the length), allocate a buffer that fits the data, and then
receive into that buffer. That way you allocate just as much space as
you need.

Hope this helps

-Lenard


el***********@g mail.com wrote:

I'm using TCP/IP to send a Bitmap object over Sockets. This is my first
time using C# at all so I don't know if this is the "right" way to do
it. I've already found out several times the way I was doing something
was really inefficient and could reduce 10 lines of code with 2, etc.

For reading, I am using a TcpClient and I call

NetworkStream ns = client.GetStrea m(); to get a stream

stream.Read(buf fer, 0, buffer.Length);

now already my question is, how do I make buffer so that I don't have
to arbitrarily make it 1 MB? What if my Bitmap is larger than 1 MB? Do
I need to read multiple times and then "join" the buffers? How would I
do that?

MemoryStream ms = new MemoryStream(bu ffer);

Bitmap = new Bitmap(ms);

Does this seem like the correct way to send the Bitmap over my Socket?

I also found that saving the Bitmap as a PNG before sending makes it
smaller. Is this a good idea, and can I compress it even more?
bm.Save(ms, System.Drawing. Imaging.ImageFo rmat.Png);
Thanks so much for reading a question from a newbie. I know this might
not make sense to some of you, or seem trivial.

[eliss.carmine]

Sorry, Lenard,

stream is a NetworkStream by the way

el***********@g mail.com wrote:

Hi Lenarf,

Thanks for the quick response.

I am trying to get the ReceiveBitmap part working using your example. I
had a working solution and in mine, I replaced

byte[] buffer = new byte[1000000];
stream.Read(buf fer, 0, buffer.Length);
MemoryStream ms = new MemoryStream(bu ffer);
ShownWindow.Bac kgroundImage = Bitmap.FromStre am(ms);

with

ShownWindow.Bac kgroundImage = Bitmap.FromStre am(stream);

in order to cut out two middlemen, but then it stops working. Any idea
why?
Lenard Gunda wrote:

Hi,

I played a little with this problem, and came up with the following
solution.

For sending, you could use:

TcpListener listener = new TcpListener ( 9998 );
listener.Start ();
TcpClient client = listener.Accept TcpClient ();
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromFile ( @"..file.." );
using ( MemoryStream ms = new MemoryStream () )
{
image.Save ( ms, ImageFormat.Png );
byte[] imageBuffer = ms.GetBuffer ();
stream.Write ( imageBuffer, 0, (int)ms.Length );
}

stream.Close ( 500 );
client.Close ();
listener.Stop ();

Here you don't have to worry about the buffer, because MemoryStream will
handle it for you. For some reason you cannot use the NetworkStream
directly (to save the image into that). GDI+ throws an exception if you
try that. I guess it has something to do with network streams not being
searchable (but that is just a guess).

On the receiving end, you can however read directly from the
NetworkStream. So you could create a method like:

private Image ReceiveBitmap ()
{
TcpClient client = new TcpClient ();
client.Connect ( "127.0.0.1" , 9998 );
NetworkStream stream = client.GetStrea m ();

Image image = Image.FromStrea m ( stream );

stream.Close ();
client.Close ();

return image;
}

This will read your image and return it to the caller. As you can see
you do not need to worry about the length of the buffer, because the
image loader will read the correct number of bytes.

Note however, that I did not do any error checking above.

Another way to solve the problem is to not send just the image onto the
network stream, rather first the size (say an Int32) and then the
contents of the buffer. On the receiving end you would then always read
an Int32 (the length), allocate a buffer that fits the data, and then
receive into that buffer. That way you allocate just as much space as
you need.

Hope this helps

-Lenard


el***********@g mail.com wrote:

I'm using TCP/IP to send a Bitmap object over Sockets. This is my first
time using C# at all so I don't know if this is the "right" way to do
it. I've already found out several times the way I was doing something
was really inefficient and could reduce 10 lines of code with 2, etc.
>
For reading, I am using a TcpClient and I call
>
NetworkStream ns = client.GetStrea m(); to get a stream
>
stream.Read(buf fer, 0, buffer.Length);
>
now already my question is, how do I make buffer so that I don't have
to arbitrarily make it 1 MB? What if my Bitmap is larger than 1 MB? Do
I need to read multiple times and then "join" the buffers? How would I
do that?
>
MemoryStream ms = new MemoryStream(bu ffer);
>
Bitmap = new Bitmap(ms);
>
Does this seem like the correct way to send the Bitmap over my Socket?
>
I also found that saving the Bitmap as a PNG before sending makes it
smaller. Is this a good idea, and can I compress it even more?
bm.Save(ms, System.Drawing. Imaging.ImageFo rmat.Png);
>
>
Thanks so much for reading a question from a newbie. I know this might
not make sense to some of you, or seem trivial.
>