Silly window syndrome is a problem in computer networking caused by poorly-implemented TCP flow control. If a server with this problem is unable to process all incoming data, it requests that its clients reduce the amount of data they send at a time (the "window" setting on a TCP packet). If the server continues to be unable to process all incoming data, the window becomes smaller and smaller, sometimes to the point that the data transmitted is smaller than the packet header, making data transmission extremely inefficient. The name of this problem is due to the window size shrinking to a "silly" value.

Since there is a certain amount of overheadassociated with processing each packet, the increased number of packets means increased overhead to process a decreasing amount of data. The end result is thrashing.

A boxing conversion permits any value-type to be implicitly converted to the type object or to any
interface-type implemented by the value-type. Boxing a value of a value-type consists of allocating an object instance and copying the value-type
value into that instance.

For example any value-type H, the boxing class would be declared as follows:

class vBox
{
  H value;
  H_Box(H h)
  {
   value = h;
  }
}

Boxing of a value v of type H now consists of executing the expression new H_Box(v), and returning the
resulting instance as a value of type object.
Thus, the statements
int i = 12;
object box = i;

conceptually correspond to
int i = 12;
object box = new int_Box(i);

Boxing classes like H_Box and int_Box above don't actually exist and the dynamic type of a boxed value
isn't actually a class type. Instead, a boxed value of type G has the dynamic type G, and a dynamic type check using the is operator can simply reference type G.

For example,

int i = 12;
object box = i;
if (box is int)
{
  Console.Write("Box contains an int");
}

will output the string  Box contains an int on the console.

A boxing conversion implies making a copy of the value being boxed. This is different from a conversion
of a reference-type to type object, in which the value continues to reference the same instance and
simply is regarded as the less derived type object.

For example, given the declaration

struct Point
{
  public int x, y;
  public Point(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}

the following statements
Point p = new Point(10, 10);
object box = p;
p.x = 20;
Console.Write(((Point)box).x);
will output the value 10 on the console because the implicit boxing operation that occurs in the
assignment of p to box causes the value of p to be copied. Had Point instead been declared a class, the
value 20 would be output because p and box would reference the same instance.