TCP connection and reconnection
A couple of comments:


Shortening code is not a goal - readability and maintainability is (which may, but not neccessarily, shorten it).
The code mixes net code, graphics code, encoder code and UI code. Separating these into separate functions/classes will be very good. Just remember that (as a general rule), one function should do one thing.
Always use braces, even when it's for a single statement where it's not required.

if (!tcp.Connected)
{
    tcp.Connect(adress);
}

Similarly, I'd suggest putting brackets around the !xxx in the if statement. Not needed, but can aid understandability.

while ((!tcp.Connected) &amp;&amp; (!CTS.IsCancellationRequested))

What does 13369376 represent?  Define the set of constants (SRCCOPY etc) that you're using and then use those.
TcpClient.Connect is a blocking call - depending on your use, you may want to consider rewriting using BeginConnect instead. One problem is that when in the middle of a connect, you can not check CTSSend for a cancellation.
You need to rethink your exception handling. At the moment, your code puts up a message box, requiring a response. You do not want to mix UI and non-UI code like this
The exception-catching occurs in the middle of a loop, so if it happens once, it's likely to happen again and again...each time requiring acknowledgement of the message box.
Catch specific exceptions (SocketException) rather than general ones (Exception). You can have multiple catches if you need them.
If you're using bsize to determine if the screen has changed, it'll be unreliable. You might end up with two images that have the same size even if the images are different.
The code grabs images as quickly as possible, possibly discarding most of them (if my understanding is correct) - this seems uneccessary. Why not grab an image (say) every 1 second? In which case you can set up something like a System.Timers.Timer instance and get the image when that is triggered.
You should probably allocate a new MemoryStream, rather than reusing it. If you're doing that to "save time", it 'probably' doesn't matter compared with the speed of network traffic and image conversion.
What happens when the window size changes/minimized etc, or is it guaranteed to have a fixed size?
In regards to your edit: Rather than a void return, either return a bool or (preferably) define an enum (CancelRequested, Connected) and return that.


Edit in response to (first) comment:


If you have 10 stacked braces at the end of the method, the method is too long. Break it up rather than remove the braces.
re MemoryStream - it'll gain readability. One thing though that you may want to do is to set an initial capacity (say, rc.Width*rc.Height) - MemoryStream itself reallocates memory/copies data on resizing.
Have you tried using a different image format, say png, rather than jpeg. It may be quicker to compress or smaller, depending on the type of image.
You could also try spliting the image up into quandrants/etc, compressing &amp; sending those and reassembling them at the other side. It may be overall quicker.
And of course, if you want 'quicker', always base it on actual timings rather than feelings :)