推荐的好的都有分噢

到www.sf.net上去找吧。

你指的是什么呢？完成什么工作的？
如果是网络编程的基础库，首选ACE ── windows／linux通用，C++，开源，工业级质量，
高效、稳定可靠。能开发windows服务端程序，内部是完成端口实现，也能用于客户端程序。
基本上日常网络编程工作的80%都做了，做东西又快又好，缺点是：难学，一般人都学不会。。。

──────────────────────
国内专业的ACE论坛开通：
www.acejoy.com 
www.acedevelop.com
涉及ACE使用和开发，服务器端软件的设计，P2P技术，
网络编程等内容。
欢迎加入，大家一起交流、学习成长！

包含一些网络服务器代码：比如sock代理服务器，一些协议的库，还有处理大规模网络连接的成功例子

给你一个就：

完成端口实现，发送数据效率3MB每秒

服务端头文件：


// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (C) 1993-1997  Microsoft Corporation.  All Rights Reserved.
//
//  MODULE:   socksrv.h
//
//  PURPOSE:  Definitions and prototypes for socksrv.c
//

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <wsipx.h>
#include "commdef.h"

#define MAXIMUM_NUMBER_OF_CLIENTS   64
#define MAXIMUM_NUMBER_OF_WORKERS   32
#define FILE_SIZE ((1024*1024*8)-CLIENT_OUTBOUND_BUFFER_MAX)

#define SIXTY_FOUR_K    (64*1024)
#define SIXTEEN_K       (16*1024)
DWORD InitialBuffer[SIXTY_FOUR_K/sizeof(DWORD)];
#define NUMBER_OF_WRITES ((FILE_SIZE+CLIENT_OUTBOUND_BUFFER_MAX)/SIXTY_FOUR_K)

#define CLIENT_CONNECTED    0x00000001
#define CLIENT_DONE         0x00000002

typedef struct _PER_CLIENT_DATA {
    SOCKET Socket;
    OVERLAPPED Overlapped;
    CLIENT_IO_BUFFER IoBuffer;
    CHAR OutboundBuffer[CLIENT_OUTBOUND_BUFFER_MAX];
    DWORD Flags;
    HANDLE hEvent;
} PER_CLIENT_DATA, *PPER_CLIENT_DATA;

typedef struct _PER_THREAD_DATA {
    DWORD TotalTransactions;
    DWORD TotalBytesTransferred;
} PER_THREAD_DATA, *PPER_THREAD_DATA;

PER_THREAD_DATA ThreadData[MAXIMUM_NUMBER_OF_WORKERS];
PER_CLIENT_DATA ClientData[MAXIMUM_NUMBER_OF_CLIENTS];
BOOL fVerbose;
BOOL fTcp;
DWORD dwNumberOfClients;
DWORD dwNumberOfWorkers;
DWORD dwConcurrency;
DWORD dwWorkIndex;
SYSTEM_INFO SystemInfo;
HANDLE CompletionPort;
DWORD dwActiveClientCount;
HANDLE hBenchmarkComplete;
HANDLE hBenchmarkStart;
DWORD StartTime;
DWORD EndTime;
HANDLE hFile;

DWORD
WINAPI
Random (
    DWORD nMaxValue
    );


VOID
WINAPI
ShowUsage(
    VOID
    );

VOID
WINAPI
ParseSwitch(
    CHAR chSwitch,
    int *pArgc,
    char **pArgv[]
    );

BOOL
WINAPI
CreateNetConnections(
    VOID
    );

BOOL
WINAPI
CreateWorkers(
    VOID
    );

DWORD
WINAPI
WorkerThread(
    LPVOID WorkContext
    );

VOID
WINAPI
CompleteBenchmark(
    VOID
    );

VOID
WINAPI
SortTheBuffer(
    LPDWORD Destination,
    LPDWORD Source,
    int DwordCount
    );

实现文件：

#include "socksrv.h"

int _CRTAPI1
main (
        int argc,
        char *argv[],
        char *envp[]
)
{

   char chChar, *pchChar;
   DWORD lc;
   BOOL b;
   int WriteCount;

   //
   // try to get timing more accurate... Avoid context
   // switch that could occur when threads are released
   //

   SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL);

   //
   // Figure out how many processors we have to size the minimum
   // number of worker threads and concurrency
   //

   GetSystemInfo (&SystemInfo);

   fVerbose = FALSE;
   dwNumberOfClients = 2;
   dwNumberOfWorkers = 2 * SystemInfo.dwNumberOfProcessors;
   dwConcurrency = SystemInfo.dwNumberOfProcessors;
   fTcp = TRUE;
   dwWorkIndex = 4;

   while (--argc)
   {
      pchChar = *++argv;
      if (*pchChar == '/' || *pchChar == '-')
      {
         while (chChar = *++pchChar)
         {
            ParseSwitch (chChar, &argc, &argv);
         }
      }
   }

   //
   // If we are doing file I/O, then create a large file that clients
   // can randomly seek and read from
   //

   srand (1);

   //
   // Create a new file and make it the correct size
   //

   DeleteFile ("socksrv.dat");

   hFile = CreateFile (
                         "socksrv.dat",
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_ALWAYS,
   FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
                         NULL
      );
   if (hFile == INVALID_HANDLE_VALUE)
   {
      fprintf (stderr, "SOCKSRV: Error opening file %d\n", GetLastError ());
      exit (1);
   }

   //
   // Initialize the file with random data
   //

   ClientData[0].Overlapped.Offset = 0;
   for (WriteCount = 0; WriteCount < NUMBER_OF_WRITES; WriteCount++)
   {

      for (lc = 0; lc < SIXTEEN_K; lc++)
      {
         InitialBuffer[lc] = (DWORD) rand ();
      }

      b = WriteFile (hFile, InitialBuffer, sizeof (InitialBuffer), &lc, &ClientData[0].Overlapped);

      if (!b && GetLastError () != ERROR_IO_PENDING)
      {
         fprintf (stderr, "SOCKSRV: Error in pre-write %d\n", GetLastError ());
         exit (1);
      }
      b = GetOverlappedResult (
                                 hFile,
                                 &ClientData[0].Overlapped,
                                 &lc,
                                 TRUE
         );
      if (!b || lc != sizeof (InitialBuffer))
      {
         fprintf (stderr, "SOCKSRV: Wait for pre-write failed %d\n", GetLastError ());
         exit (1);
      }
      ClientData[0].Overlapped.Offset += lc;
   }

   srand (1);
   fprintf (stdout, "SOCKSRV: %2d Clients %2d Workers Concurrency %d Using %s WorkIndex %d\n",
            dwNumberOfClients,
            dwNumberOfWorkers,
            dwConcurrency,
            fTcp ? "TCP" : "IPX",
            dwWorkIndex
      );

   if (!CreateNetConnections ())
   {
      exit (1);
   }

   if (!CreateWorkers ())
   {
      exit (1);
   }

   if (fVerbose)
   {
      fprintf (stdout, "Workers Created, Waiting for Clients to complete\n");
   }

   CompleteBenchmark ();

   exit (1);
   return 1;
}

VOID
WINAPI
CompleteBenchmark (
                     VOID
)
{
   DWORD LowestTicks;
   DWORD HighestTicks;
   DWORD TotalTicks;
   DWORD TotalIterations;
   DWORD TotalBytesTransferred;
   DWORD i;

   StartTime = GetTickCount ();
   SetEvent (hBenchmarkStart);
   WaitForSingleObject (hBenchmarkComplete, INFINITE);
   EndTime = GetTickCount ();

   LowestTicks = ClientData[0].IoBuffer.u.IAmDone.TotalTicks;
   HighestTicks = ClientData[0].IoBuffer.u.IAmDone.TotalTicks;
   TotalTicks = EndTime - StartTime;
   TotalIterations = 0;
   TotalBytesTransferred = 0;

   for (i = 0; i < dwNumberOfClients; i++)
   {
      TotalIterations += ClientData[i].IoBuffer.u.IAmDone.TotalIterations;
      TotalBytesTransferred += ClientData[i].IoBuffer.u.IAmDone.TotalBytesTransferred;

      //
      // find fastest client
      //
      if (LowestTicks > ClientData[i].IoBuffer.u.IAmDone.TotalTicks)
      {
         LowestTicks = ClientData[i].IoBuffer.u.IAmDone.TotalTicks;
      }

      //
      // find slowest client
      //
      if (HighestTicks < ClientData[i].IoBuffer.u.IAmDone.TotalTicks)
      {
         HighestTicks = ClientData[i].IoBuffer.u.IAmDone.TotalTicks;
      }
   }

   fprintf (stdout, "\nSOCKSRV:TPS, %ld (Fastest Client %dms Slowest Client %dms)\n",
            (TotalIterations * 1000) / TotalTicks,
            LowestTicks,
            HighestTicks
      );

   if (fVerbose)
   {
      fprintf (stdout, "\n%ld bytes transferred in %ld iterations, time = %ld ms\n",
               TotalBytesTransferred,
               TotalIterations,
               TotalTicks
         );

      for (i = 0; i < dwNumberOfWorkers; i++)
      {
         fprintf (stdout, "Thread[%2d] %d Transactions %d Bytes\n",
                  i,
                  ThreadData[i].TotalTransactions,
                  ThreadData[i].TotalBytesTransferred
            );
      }
   }
}

BOOL
WINAPI
CreateNetConnections (
                        void
)
{
   DWORD i;
   SOCKET listener;
   INT err;
   WSADATA WsaData;
   DWORD nbytes;
   BOOL b;

   err = WSAStartup (0x0101, &WsaData);
   if (err == SOCKET_ERROR)
   {
      fprintf (stdout, "WSAStartup Failed\n");
      return FALSE;
   }

   //
   // Open a socket to listen for incoming connections.
   //

   if (fTcp)
   {

      SOCKADDR_IN localAddr;

      listener = socket (AF_INET, SOCK_STREAM, 0);
      if (listener == INVALID_SOCKET)
      {
         fprintf (stdout, "Socket Create Failed\n");
         return FALSE;
      }

      //
      // Bind our server to the agreed upon port number.  See
      // commdef.h for the actual port number.
      //
      ZeroMemory (&localAddr, sizeof (localAddr));
      localAddr.sin_port = htons (SERVPORT);
      localAddr.sin_family = AF_INET;

      err = bind (listener, (PSOCKADDR) & localAddr, sizeof (localAddr));
      if (err == SOCKET_ERROR)
      {
         fprintf (stdout, "Socket Bind Failed\n");
         if (WSAGetLastError () == WSAEADDRINUSE)
            fprintf (stdout, "The port number may already be in use.\n");
         return FALSE;
      }

   }
   else
   {

      SOCKADDR_IPX localAddr;

      listener = socket (AF_IPX, SOCK_STREAM, NSPROTO_SPX);
      if (listener == INVALID_SOCKET)
      {
         fprintf (stdout, "Socket Create Failed\n");
         return FALSE;
      }

      ZeroMemory (&localAddr, sizeof (localAddr));
      localAddr.sa_socket = htons (7);
      localAddr.sa_family = AF_IPX;

      err = bind (listener, (PSOCKADDR) & localAddr, sizeof (localAddr));
      if (err == SOCKET_ERROR)
      {
         fprintf (stdout, "Socket Bind Failed\n");
         return FALSE;
      }
   }

   //
   // Prepare to accept client connections.  Allow up to 5 pending
   // connections.
   //
   err = listen (listener, 5);
   if (err == SOCKET_ERROR)
   {
      fprintf (stdout, "Socket Listen Failed\n");
      return FALSE;
   }


   //
   // Only Handle a single Queue
   //

   for (i = 0; i < dwNumberOfClients; i++)
   {

      //
      // Accept incoming connect requests and create wait events for each.
      //

      //
      // If we are doing file I/O, each client will need its own event
      // to use for async file I/O
      //

      if (hFile)
      {
         ClientData[i].hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
         if (!ClientData[i].hEvent)
         {
            fprintf (stdout, "Client Event Create Failed\n");
            return FALSE;
         }
      }

      ClientData[i].Socket = accept (listener, NULL, NULL);
      if (ClientData[i].Socket == INVALID_SOCKET)
      {
         fprintf (stdout, "Accept Failed\n");
         return FALSE;
      }

      if (fVerbose)
      {
         fprintf (stdout, "Client Connection Accepted\n");
      }

      //
      // note the 16 says how many concurrent cpu bound threads to allow thru
      // this should be tunable based on the requests. CPU bound requests will
      // really really honor this.
      //

      CompletionPort = CreateIoCompletionPort (
                                              (HANDLE) ClientData[i].Socket,
                                                 CompletionPort,
                                                 (DWORD) i,
                                                 dwConcurrency
         );

      if (!CompletionPort)
      {
         fprintf (stdout, "CompletionPort Create Failed\n");
         return FALSE;
      }

      ClientData[i].Flags = CLIENT_CONNECTED;

      //
      // Start off an asynchronous read on the socket.
      //

      ClientData[i].Overlapped.hEvent = NULL;

      b = ReadFile (
                      (HANDLE) ClientData[i].Socket,
                      &ClientData[i].IoBuffer,
                      sizeof (CLIENT_IO_BUFFER),
                      &nbytes,
                      &ClientData[i].Overlapped
         );

      if (!b && GetLastError () != ERROR_IO_PENDING)
      {
         fprintf (stdout, "ReadFile Failed\n");
         return FALSE;
      }
   }

   dwActiveClientCount = dwNumberOfClients;
   hBenchmarkComplete = CreateEvent (NULL, TRUE, FALSE, NULL);
   if (!hBenchmarkComplete)
   {
      fprintf (stdout, "Create Benchmark Complete Event Failed\n");
      return FALSE;
   }
   hBenchmarkStart = CreateEvent (NULL, TRUE, FALSE, NULL);
   if (!hBenchmarkStart)
   {
      fprintf (stdout, "Create Benchmark Start Event Failed\n");
      return FALSE;
   }

   return TRUE;
}

BOOL
WINAPI
CreateWorkers (
                 void
)
{
   DWORD ThreadId;
   HANDLE ThreadHandle;
   DWORD i;

   for (i = 0; i < dwNumberOfWorkers; i++)
   {

      ThreadHandle = CreateThread (
                                     NULL,
                                     0,
                                     WorkerThread,
                                     &ThreadData[i],
                                     0,
                                     &ThreadId
         );
      if (!ThreadHandle)
      {
         fprintf (stdout, "Create Worker Thread Failed\n");
         return FALSE;
      }

      CloseHandle (ThreadHandle);
   }

   return TRUE;
}