The use of TcpClient and TcpListener just means a few less lines of code. As you say it&#39;s just a wrapper over the Socket class so there is no performance difference between them it&#39;s purely a style choice.

**Update:** Since this answer was posted the .Net source code has become available. It does indeed show that [TcpClient][1] is a very light wrapper over the [Socket][2] class which is itself a wrapper on top of the native [WinSock2 API][3]*.

* On Windows. Will be different for .Net Standard/Core etc. on other platforms. 


  [1]: https://referencesource.microsoft.com/#System/net/System/Net/Sockets/TCPClient.cs
  [2]: https://referencesource.microsoft.com/#System/net/System/Net/Sockets/Socket.cs
  [3]: https://docs.microsoft.com/en-us/windows/win32/api/_winsock/

Also, you can access the socket directly from the `TCPClient` object, it&#39;s under the property `Client` - so there is no performance difference.

Where can I find a **well-respected reference** that details the proper handling of PID files on Unix?

On Unix operating systems, it is common practice to “lock” a program (often a daemon) by use of a special lock file: the PID file.

This is a file in a predictable location, often ‘/var/run/foo.pid’. The program is supposed to check when it starts up whether the PID file exists and, if the file does exist, exit with an error. So it&#39;s a kind of advisory, collaborative locking mechanism.

The file contains a single line of text, being the numeric process ID (hence the name “PID file”) of the process that currently holds the lock; this allows an easy way to automate sending a signal to the process that holds the lock.

What I can&#39;t find is a good reference on expected or “best practice” behaviour for handling PID files. There are various nuances: how to actually lock the file (don&#39;t bother? use the kernel? what about platform incompatibilities?), handling stale locks (silently delete them? when to check?), when exactly to acquire and release the lock, and so forth.

Where can I find a **respected, most-authoritative reference** (ideally on the level of W. Richard Stevens) for this small topic?


Reference for proper handling of PID file on Unix

I am basing my question and example on Jason&#39;s answer in [this][1] question

I am trying to avoid using an `eventListener`, and just to call `handleClick` `onsubmit`, when the submit button is clicked.

Absolutely nothing happens with the code I have.

Why is `handleClick` not being called?

    &lt;html&gt;
      &lt;head&gt;
        &lt;script type=&quot;text/javascript&quot;&gt;
          function getRadioButtonValue(rbutton)
          {
            for (var i = 0; i &lt; rbutton.length; ++i)
            { 
              if (rbutton[i].checked)
                return rbutton[i].value;
            }
            return null;
          }
    
          function handleClick(event)
          {
            alert(&quot;Favorite weird creature: &quot;+getRadioButtonValue(this[&quot;whichThing&quot;]));
            event.preventDefault(); // disable normal form submit behavior
            return false; // prevent further bubbling of event
          }
        &lt;/script&gt;
      &lt;/head&gt;
    &lt;body&gt;
        &lt;form name=&quot;myform&quot; onSubmit=&quot;JavaScript:handleClick()&quot;&gt;
          &lt;input name=&quot;Submit&quot;  type=&quot;submit&quot; value=&quot;Update&quot; onClick=&quot;JavaScript:handleClick()&quot;/&gt;
          Which of the following do you like best?
          &lt;p&gt;&lt;input type=&quot;radio&quot; name=&quot;whichThing&quot; value=&quot;slithy toves&quot; /&gt;Slithy toves&lt;/p&gt;
          &lt;p&gt;&lt;input type=&quot;radio&quot; name=&quot;whichThing&quot; value=&quot;borogoves&quot; /&gt;Borogoves&lt;/p&gt;
          &lt;p&gt;&lt;input type=&quot;radio&quot; name=&quot;whichThing&quot; value=&quot;mome raths&quot; /&gt;Mome raths&lt;/p&gt;
        &lt;/form&gt;
    &lt;/body&gt;
    &lt;/html&gt;



  [1]: https://stackoverflow.com/questions/662630/javascript-form-bypassing-default-behaviour-for-ajax/664938#664938

edit:

Please do not suggest a framework as a solution.

Here are the relevant changes I have made to the code, which results in the same behavior.

          function handleClick()
          {
            alert(&quot;Favorite weird creature: &quot;+getRadioButtonValue(document.myform[&#39;whichThing&#39;])));
            event.preventDefault(); // disable normal form submit behavior
            return false; // prevent further bubbling of event
          }
        &lt;/script&gt;
      &lt;/head&gt;
    &lt;body&gt;
    &lt;form name=&quot;aye&quot;&gt;;
          &lt;input name=&quot;Submit&quot;  type=&quot;submit&quot; value=&quot;Update&quot; action=&quot;JavaScript:handleClick()&quot;/&gt;
          Which of the following do you like best?
          &lt;p&gt;&lt;input type=&quot;radio&quot; name=&quot;whichThing&quot; value=&quot;slithy toves&quot; /&gt;Slithy toves&lt;/p&gt;
          &lt;p&gt;&lt;input type=&quot;radio&quot; name=&quot;whichThing&quot; value=&quot;borogoves&quot; /&gt;Borogoves&lt;/p&gt;
          &lt;p&gt;&lt;input type=&quot;radio&quot; name=&quot;whichThing&quot; value=&quot;mome raths&quot; /&gt;Mome raths&lt;/p&gt;
        &lt;/form&gt;

Calling Javascript from a html form

I don&#39;t see much use of `TCPClient`, yet there is a lot of `Socket`? What is the major difference between them and when would you use each?

I understand that .NET `Socket` is written on top of WINSOCK, and `TCPClient` is a wrapper over `Socket` class. Thus `TCPClient` is way up the chain, and possibly inefficient. Correct me if I am wrong. 


TCPClient vs Socket in C#

<p>I don't see much use of <code>TCPClient</code>, yet there is a lot of <code>Socket</code>? What is the major difference between them and when would you use each?</p>
<p>I understand that .NET <code>Socket</code> is written on top of WINSOCK, and <code>TCPClient</code> is a wrapper over <code>Socket</code> class. Thus <code>TCPClient</code> is way up the chain, and possibly inefficient. Correct me if I am wrong.</p>


I have a program that requires fast performance.  Within one of its inner loops, I need to test the type of an object to see whether it inherits from a certain interface.

One way to do this would be with the CLR&#39;s built-in type-checking functionality.  The most elegant method there probably being the &#39;is&#39; keyword:

    if (obj is ISpecialType)

Another approach would be to give the base class my own virtual GetType() function which returns a pre-defined enum value (in my case, actually, i only need a bool).  That method would be fast, but less elegant.

I have heard that there is an IL instruction specifically for the &#39;is&#39; keyword, but that doesn&#39;t mean it executes fast when translated into native assembly.  Can anyone share some insight into the performance of &#39;is&#39; versus the other method?

**UPDATE:**  Thanks for all the informed answers!  It seem a couple helpful points are spread out among the answers:  Andrew&#39;s point about &#39;is&#39; automatically performing a cast is essential, but the performance data gathered by Binary Worrier and Ian is also extremely useful.  It would be great if one of the answers were edited to include *all* of this information.

C# &#39;is&#39; operator performance

I&#39;m finding massive performance differences between similar code in C and C#.

The C code is:

    #include &lt;stdio.h&gt;
    #include &lt;time.h&gt;
    #include &lt;math.h&gt;
    
    main()
    {
    	int i;
    	double root;
    	
    	clock_t start = clock();
    	for (i = 0 ; i &lt;= 100000000; i++){
    		root = sqrt(i);
    	}
    	printf(&quot;Time elapsed: %f\n&quot;, ((double)clock() - start) / CLOCKS_PER_SEC);	
    
    }

And the C# (console app) is:

    using System;
    using System.Collections.Generic;
    using System.Text;
    
    namespace ConsoleApplication2
    {
        class Program
        {
            static void Main(string[] args)
            {
                DateTime startTime = DateTime.Now;
                double root;
                for (int i = 0; i &lt;= 100000000; i++)
                {
                    root = Math.Sqrt(i);
                }
                TimeSpan runTime = DateTime.Now - startTime;
                Console.WriteLine(&quot;Time elapsed: &quot; + Convert.ToString(runTime.TotalMilliseconds/1000));
            }
        }
    }

With the above code, the C# completes in 0.328125 seconds (release version) and the C takes 11.14 seconds to run.

The C is being compiled to a Windows executable using mingw.

I&#39;ve always been under the assumption that C/C++ were faster or at least comparable to C#.net. What exactly is causing the C code to run over 30 times slower?

EDIT:
It does appear that the C# optimizer was removing the root as it wasn&#39;t being used.
I changed the root assignment to `root +=` and printed out the total at the end.
I&#39;ve also compiled the C using cl.exe with the /O2 flag set for max speed.

The results are now:
3.75 seconds for the C
2.61 seconds for the C#

The C is still taking longer, but this is acceptable.


C# vs C - Big performance difference

The C#/.NET application I am working on is suffering from a slow memory leak.  I have used CDB with SOS to try to determine what is happening but the data does not seem to make any sense so I was hoping one of you may have experienced this before.

The application is running on the 64 bit framework.  It is continuously calculating and serialising data to a remote host and is hitting the Large Object Heap (LOH) a fair bit.  However, most of the LOH objects I expect to be transient: once the calculation is complete and has been sent to the remote host, the memory should be freed.  What I am seeing, however, is a large number of (live) object arrays interleaved with free blocks of memory, e.g., taking a random segment from the LOH:

    0:000&gt; !DumpHeap 000000005b5b1000  000000006351da10
             Address               MT     Size
    ...
    000000005d4f92e0 0000064280c7c970 16147872
    000000005e45f880 00000000001661d0  1901752 Free
    000000005e62fd38 00000642788d8ba8     1056       &lt;--
    000000005e630158 00000000001661d0  5988848 Free
    000000005ebe6348 00000642788d8ba8     1056
    000000005ebe6768 00000000001661d0  6481336 Free
    000000005f214d20 00000642788d8ba8     1056
    000000005f215140 00000000001661d0  7346016 Free
    000000005f9168a0 00000642788d8ba8     1056
    000000005f916cc0 00000000001661d0  7611648 Free
    00000000600591c0 00000642788d8ba8     1056
    00000000600595e0 00000000001661d0   264808 Free
    ...

Obviously I would expect this to be the case if my application were creating long-lived, large objects during each calculation.  (It does do this and I accept there will be a degree of LOH fragmentation but that is not the problem here.)  The problem is the very small (1056 byte) object arrays you can see in the above dump which I cannot see in code being created and which are remaining rooted somehow.

Also note that CDB is not reporting the type when the heap segment is dumped: I am not sure if this is related or not.  If I dump the marked (&lt;--) object, CDB/SOS reports it fine:

    0:015&gt; !DumpObj 000000005e62fd38
    Name: System.Object[]
    MethodTable: 00000642788d8ba8
    EEClass: 00000642789d7660
    Size: 1056(0x420) bytes
    Array: Rank 1, Number of elements 128, Type CLASS
    Element Type: System.Object
    Fields:
    None

The elements of the object array are all strings and the strings are recognisable as from our application code.

Also, I am unable to find their GC roots as the !GCRoot command hangs and never comes back (I have even tried leaving it overnight).

So, I would very much appreciate it if anyone could shed any light as to why these small (&lt;85k) object arrays are ending up on the LOH: what situations will .NET put a small object array in there?  Also, does anyone happen to know of an alternative way of ascertaining the roots of these objects?

---

Update 1

Another theory I came up with late yesterday is that these object arrays started out large but have been shrunk leaving the blocks of free memory that are evident in the memory dumps.  What makes me suspicious is that the object arrays always appear to be 1056 bytes long (128 elements), 128 * 8 for the references and 32 bytes of overhead.

The idea is that perhaps some unsafe code in a library or in the CLR is corrupting the number of elements field in the array header.  Bit of a long shot I know...

---

Update 2

Thanks to Brian Rasmussen (see accepted answer) the problem has been identified as fragmentation of the LOH caused by the string intern table!  I wrote a quick test application to confirm this:

    static void Main()
    {
        const int ITERATIONS = 100000;

        for (int index = 0; index &lt; ITERATIONS; ++index)
        {
            string str = &quot;NonInterned&quot; + index;
            Console.Out.WriteLine(str);
        }

        Console.Out.WriteLine(&quot;Continue.&quot;);
        Console.In.ReadLine();

        for (int index = 0; index &lt; ITERATIONS; ++index)
        {
            string str = string.Intern(&quot;Interned&quot; + index);
            Console.Out.WriteLine(str);
        }

        Console.Out.WriteLine(&quot;Continue?&quot;);
        Console.In.ReadLine();
    }

The application first creates and dereferences unique strings in a loop.  This is just to prove that the memory does not leak in this scenario.  Obviously it should not and it does not.

In the second loop, unique strings are created and interned.  This action roots them in the intern table.  What I did not realise is how the intern table is represented.  It appears it consists of a set of pages -- object arrays of 128 string elements -- that are created in the LOH.  This is more evident in CDB/SOS:

    0:000&gt; .loadby sos mscorwks
    0:000&gt; !EEHeap -gc
    Number of GC Heaps: 1
    generation 0 starts at 0x00f7a9b0
    generation 1 starts at 0x00e79c3c
    generation 2 starts at 0x00b21000
    ephemeral segment allocation context: none
     segment    begin allocated     size
    00b20000 00b21000  010029bc 0x004e19bc(5118396)
    Large object heap starts at 0x01b21000
     segment    begin allocated     size
    01b20000 01b21000  01b8ade0 0x00069de0(433632)
    Total Size  0x54b79c(5552028)
    ------------------------------
    GC Heap Size  0x54b79c(5552028)

Taking a dump of the LOH segment reveals the pattern I saw in the leaking application:

    0:000&gt; !DumpHeap 01b21000 01b8ade0
    ...
    01b8a120 793040bc      528
    01b8a330 00175e88       16 Free
    01b8a340 793040bc      528
    01b8a550 00175e88       16 Free
    01b8a560 793040bc      528
    01b8a770 00175e88       16 Free
    01b8a780 793040bc      528
    01b8a990 00175e88       16 Free
    01b8a9a0 793040bc      528
    01b8abb0 00175e88       16 Free
    01b8abc0 793040bc      528
    01b8add0 00175e88       16 Free    total 1568 objects
    Statistics:
          MT    Count    TotalSize Class Name
    00175e88      784        12544      Free
    793040bc      784       421088 System.Object[]
    Total 1568 objects

Note that the object array size is 528 (rather than 1056) because my workstation is 32 bit and the application server is 64 bit.  The object arrays are still 128 elements long.

So the moral to this story is to be very careful interning.  If the string you are interning is not known to be a member of a finite set then your application will leak due to fragmentation of the LOH, at least in version 2 of the CLR.

In our application&#39;s case, there is general code in the deserialisation code path that interns entity identifiers during unmarshalling: I now strongly suspect this is the culprit.  However, the developer&#39;s intentions were obviously good as they wanted to make sure that if the same entity is deserialised multiple times then only one instance of the identifier string will be maintained in memory.

Large Object Heap Fragmentation

I&#39;m trying to hold a list of items in a collection with a key of my choice. In Java, I would simply use Map&lt;Key,Value&gt; as follows:

    class Test {
      Map&lt;Integer,String&gt; entities;
    
      public String getEntity(Integer code) {
        return this.entities.get(code);
      }
    }

Is there an equivalent way of doing this in C#?
`System.Collections.Generic.Hashset` doesn&#39;t uses hash and I cannot define a custom type key
`System.Collections.Hashtable` isn&#39;t a generic class  
`System.Collections.Generic.Dictionary` doesn&#39;t have a `get(Key)` method


Java Map equivalent in C#

All of a sudden I keep getting a `MetadataException` on instantiating my generated `ObjectContext` class. The connection string in App.Config looks correct - hasn&#39;t changed since last it worked - and I&#39;ve tried regenerating a new model (edmx-file) from the underlying database with no change.

Anyone have any ideas?

Further details: I haven&#39;t changed any properties, I haven&#39;t changed the name of any output assemblies, I haven&#39;t tried to embed the EDMX in the assembly. I&#39;ve merely waited 10 hours from leaving work until I got back. And then it wasn&#39;t working anymore.

I&#39;ve tried recreating the EDMX. I&#39;ve tried recreating the project. I&#39;ve even tried recreating the database, from scratch. No luck, whatsoever.

MetadataException: Unable to load the specified metadata resource

&gt; **Possible Duplicate:**  
&gt; [Interface defining a constructor signature?](https://stackoverflow.com/questions/619856/interface-defining-a-constructor-signature)  

&lt;!-- End of automatically inserted text --&gt;

I know that you cannot specify a constructor in an interface in .Net, but why can we not?

It would be really useful for my current project to be able to specify that an &#39;engine&#39; must be passed in with the constructor, but as I cant, I have to suffice with an XML comment on the class.

Why are we not allowed to specify a constructor in an interface?

If I have the option of using `.Net` and can do data `transformations` just fine in .Net, when would I need `SSIS`?  Is there a certain task that `SSIS` would be better for?  Are the added benefits of transparency worth it?  Is it just what I am more comfortable with?  What are the best practices for determining this?

.Net vs SSIS: What should SSIS be used for?

Frequently I need to create a .Net class library that requires an app.config for things such as database connection strings. However, these settings must be in the calling application&#39;s app.config or web.config. If I want to distribute the DLL across multiple applications it becomes a pain because I have to copy these settings into each the application&#39;s app.config.

I have considered manually reading the config settings via code from inside the class library, but that is also a major pain. Does anyone have any suggestions for the best way to load app.config settings inside a class library?

Using app.config with a class library

How can I detect that a client has disconnected from my server?

I have the following code in my `AcceptCallBack` method

    static Socket handler = null;
    public static void AcceptCallback(IAsyncResult ar)
    {
      //Accept incoming connection
      Socket listener = (Socket)ar.AsyncState;
      handler = listener.EndAccept(ar);
    }

I need to find a way to discover as soon as possible that the client has disconnected from the `handler` Socket.

I&#39;ve tried:

 1. `handler.Available;`
 2. `handler.Send(new byte[1], 0,
    SocketFlags.None);`
 3. `handler.Receive(new byte[1], 0,
    SocketFlags.None);`

The above approaches work when you are connecting to a server and want to detect when the server disconnects but they do not work *when you are the server and want to detect client disconnection.*

Any help will be appreciated.

Instantly detect client disconnection from server socket

I just had to re-install mysql and I am having a problem starting it up.  It cannot find the socket (mysql.sock).  The problem is that neither can I.  In my Mac OS X 10.4 terminal, I type: `locate mysql.sock`, and I get back `/private/tmp/mysql.sock`.  It makes sense that the socket file exist in that location, but it actually does not.

1. How can I find the socket file?

2. If locate is returning a false location, it must have some sort of memory and probably indexes.  How can I refresh that index?

Cannot find mysql.sock

I have two components that that communicate via TCP/IP.  Component A acts as a server/listener and Component B is the client.  The two should communicate as quickly as possible.  There can only ever be one connection at any time (though that is aside to this question).  A senior developer at my company has said I need to use application level heartbeats between the two components to ensure the connection stays open.  

I thought the connection stays open with TCP/IP but I&#39;ve read a number of blogs/sites saying it&#39;s pretty standard practice to heartbeat between these applications.  

I know part of the reason component A heartbeats component B is so it can inform support if there are communications problems with component B (either the link is down or component B is not running).  Are heartbeats needed for any other reason? Such as to ensure there is frequently something &quot;in the pipe&quot; to keep it open?

Component A currently heartbeats component B every 20 seconds and closes the connection if nothing is received back from component B in 120 seconds.  It then resumes listening for connections under the assumption that component B will periodically try a reconnect if the link is broken.  This works successfully.  

To reiterate my question:  Are heartbeats necessary to keep a TCP/IP connection alive?

Do I need to heartbeat to keep a TCP connection open?

I am working on a school project where I had to write a multi-threaded server, and now I am comparing it to apache by running some tests against it. I am using autobench to help with that, but after I run a few tests, or if I give it too high of a rate (around 600+) to make the connections,  I get a &quot;Too many open files&quot; error. 

After I am done with dealing with request, I always do a `close()` on the socket. I have tried to use the `shutdown()` function as well, but nothing seems to help. Any way around this?

Socket accept - &quot;Too many open files&quot;

I&#39;ve been playing with message queues (System V, but POSIX should be ok too) in Linux recently and they seem perfect for my application, but after reading The Art of Unix Programming I&#39;m not sure if they are really a good choice.

[http://www.faqs.org/docs/artu/ch07s02.html#id2922148][1]
&gt; The upper, message-passing layer of System V IPC has largely fallen out of use. The lower layer, which consists of shared memory and semaphores, still has significant applications under circumstances in which one needs to do mutual-exclusion locking and some global data sharing among processes running on the same machine. These System V shared memory facilities evolved into the POSIX shared-memory API, supported under Linux, the BSDs, MacOS X and Windows, but not classic MacOS.

[http://www.faqs.org/docs/artu/ch07s03.html#id2923376][2]
&gt;The System V IPC facilities are present in Linux and other modern Unixes. However, as they are a legacy feature, they are not exercised very often. The Linux version is still known to have bugs as of mid-2003. Nobody seems to care enough to fix them.

Are the System V message queues still buggy in more recent Linux versions? I&#39;m not sure if the author means that POSIX message queues should be ok?

It seems that sockets are the preferred IPC for almost anything(?), but I cannot see how it would be very simple to implement message queues with sockets or something else. Or am I thinking too complexly?

I don&#39;t know if it&#39;s relevant that I&#39;m working with embedded Linux?

  [1]: http://www.faqs.org/docs/artu/ch07s02.html#id2922148
  [2]: http://www.faqs.org/docs/artu/ch07s03.html#id2923376

Are message queues obsolete in linux?

What are the advantages (or limitations) of one over the other for transferring files over the Internet?

(I am aware of secure forms of both protocols. I&#39;d like to hear comparisons through personal experiences in terms of performance, reliability, file size limitations etc.)

Comparing HTTP and FTP for transferring files

How to simulating two client-controlled vehicles colliding (sensibly) in a typical client/server setup for a network game? I did read [this eminent blog post][1] on how to do distributed network physics in general (without traditional client prediction), but this question is specifically on how to handle collisions of owned objects.

&lt;h3&gt;Example&lt;/h3&gt;
Say client A is 20 ms ahead of server, client B 300 ms ahead of server (counting both latency and maximum jitter). This means that when the two vehicles collide, both clients will see the other as 320 ms behind - in the opposite direction of the velocity of the other vehicle. Head-to-head on a Swedish highway means a difference of 16 meters/17.5 yards!

&lt;h3&gt;What not to try&lt;/h3&gt;
It is virtually impossible to extrapolate the positions, since I also have very complex vehicles with joints and bodies all over, which in turn have linear and angular positions, velocities and accelerations, not to mention states from user input.


  [1]: https://web.archive.org/web/20181107181430/https://gafferongames.com/post/networked_physics_2004/

Game network physics collision

In every example and discussion I run across in the context of BSD socket programming, it seems that the recommended way to set a file descriptor to nonblocking I/O mode is using the `O_NONBLOCK` flag to `fcntl()`, e.g.

    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);

I&#39;ve been doing network programming in UNIX for over ten years, and have always used the `FIONBIO ioctl()` call to do this:

    int opt = 1;
    ioctl(fd, FIONBIO, &amp;opt);

Never really gave much thought to why.  Just learned it that way.  

Does anyone have any commentary on the possible respective merits of one or the other?  I imagine the portability locus differs somewhat, but do not know to what extent as `ioctl_list(2)` doesn&#39;t speak to that aspect of individual `ioctl` methods.  

UNIX nonblocking I/O: O_NONBLOCK vs. FIONBIO

I am going to develop an instant messaging application that runs in the browser.

What browsers support the [WebSocket API][1]?

[1]: http://en.wikipedia.org/wiki/WebSocket

What browsers support HTML5 WebSocket API?

Say if I was to get shared, virtual or dedicated hosting, I read somewhere a server/machine can only handle 64,000 TCP connections at one time, is this true? How many could any type of hosting handle regardless of bandwidth? I&#39;m assuming HTTP works over TCP.

Would this mean only 64,000 users could connect to the website, and if I wanted to serve more I&#39;d have to move to a web farm?

Content Type	Original Author	Original Content on Stackoverflow
Question	Sasha	View Question on Stackoverflow
Solution 1 - C#	sipsorcery	View Answer on Stackoverflow
Solution 2 - C#	John Rasch	View Answer on Stackoverflow

TCPClient vs Socket in C#

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Calling Javascript from a html form

Reference for proper handling of PID file on Unix

Attributions