BeginAccept не вызывает мою функцию, которая вызывает EndAccept

В вашем коде много ошибок:

• BeginAccept и т. д. — это устарело. Используйте новые функции Async с await.
• Используйте TcpListener и TcpClient вместо необработанных сокетов.
• Не привязывайтесь к 127.0.0.1, если вы не хотите только слушать запросы локального хоста (а затем просто используйте IPAddress.Loopback), в противном случае просто используйте IPAddress.Any.

public static async Task Main()
{
    int ServerPort = 1234;
    var listener = new TcpListener(IPAddress.Any, ServerPort);
    listener.Start(5);
    Console.WriteLine("Server is listening for connections");

    while (true)
    {
        var client = await listener.AcceptTcpClientAsync();
        Console.WriteLine("Client connected!");
        // hand off client so we can carry on listening
        Task.Run(() => HandleClient(client));
    }
}    

public static async Task HandleClient(TcpClient client)
{
    using var _ = client;
    using var stream = client.GetStream();
    //setup a array called temp to store the clients data, set what you recieve from clientSocket to be put into an int called ClientBytes
    //convert the bytes from clientbytes to string to read it 
    byte[] temp = new byte[1024];
    do
    {
        int bytesRead = await stream.ReadAsync(temp);
        if (bytesRead == 0)
            return;

        string ClientMessage = Encoding.ASCII.GetString(temp, 0, ClientBytes);
        Console.WriteLine("Recieved data from client: " + ClientMessage);

        //Convert the message to bytes, store it in a array then send it down the client socket
        string ServerMessage = Console.ReadLine();
        if (ServerMessage is not { Length : > 0 })
            return;
    
        byte[] temp2 = Encoding.ASCII.GetBytes(ServerMessage);
        await stream.WriteAsync(temp2);
    } while (Console.ReadKey(true).Key != ConsoleKey.F10);  // how to end this loop??
}

Дальнейшие примечания:

• Вам нужно какое-то оформление сообщения, иначе у вас нет гарантии относительно того, какой объем данных проходит при каждом чтении. TCP — это непрерывный поток, и любое чтение/запись может быть разбито или объединено.
  Таким образом, вы будете читать, пока не достигнете конечной точки сообщения, проанализировать то, что у вас есть, а затем вернуться обратно. Альтернативно, каждое сообщение может иметь префикс длины.
• Encoding.ASCII довольно ограничивает.
• Рассмотрите возможность использования какого-либо CancellationTokenSource, возможно, в сочетании с Console.CancelKeyPress, чтобы отключить прослушиватель и сокеты.

Вашему AcceptCallback() скорее всего звонят, просто вы ничего с него не сообщаете. Ваш основной код ведет журналирование, но он никогда не сообщит о подключении клиента, поскольку ищет для этого неправильное условие. Вы запускаете цикл занятости, который просто вызывает ServerSocket.BeginAccept() снова и снова бесконечно, чего ServerSocket.Connected никогда не будет true - прослушивающий TCP-сокет никогда не сможет войти в состояние Connected, не говоря уже о выполнении операций чтения/отправки ввода-вывода. Принятие TCP-клиента создает новый Socket, для которого вы должны выполнить ввод-вывод, но вы его игнорируете.

Как описывает ответ @Charlieface, есть лучшие способы добиться того, чего вы хотите. Но если вы хотите, чтобы ваш существующий код работал, попробуйте реструктурировать его примерно так:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Collections.Generic;

public class Server
{
    private class ClientInfo
    {
        Socket clientSocket; 
        byte[] readBuffer;
        List<byte[]> sendBuffers;
        byte[] currSendBuffer;
        int sendTotal;
        int sentSoFar;

        public ClientInfo(Socket ClientSocket)
        {
            clientSocket = ClientSocket; 
            readBuffer = new byte[102];
            sendBuffers = new List<byte[]>();
            currSendBuffer = null;
            sendTotal = 0;
            sentSoFar = 0;
        }

        public void BeginReceive()
        {
            clientSocket.BeginReceive(readBuffer, 0, readBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), this);
        }

        private void ReceiveCallback(IAsyncResult ar)
        {
            int numRead = clientSocket.EndReceive(ar);
            if (numRead > 0)
            {
                string ClientMessage = Encoding.ASCII.GetString(readBuffer, 0, numRead);
                Console.WriteLine("Received data from client: " + ClientMessage);
                BeginSendMsg("I GOT IT!");
                BeginReceive();
            }
            else
            {
                clientSocket.Close();
                Console.WriteLine("Client disconnected!");
            }
        }

        private BeginSendMsg(string Message)
        {
            byte[] buffer = Encoding.ASCII.GetBytes(Message);
            sendBuffers.Add(buffer);
            if (sendBuffers.Count == 1)
                BeginSendFirstBuffer();
        }

        private void BeginSendFirstBuffer()
        {
            currSendBuffer = sendBuffers[0];
            sendTotal = currSendBuffer.Length;
            sentSoFar = 0;
            BeginSendNextChunk();
        }

        private void BeginSendNextChunk()
        {
            clientSocket.BeginSend(currSendBuffer, sentSoFar, sendTotal - sentSoFar, SocketFlags.None, new AsyncCallback(SendCallback), this);
        }

        private void SendCallback(IAsyncResult ar)
        {
            int numSent = clientSocket.EndSend(ar);
            if (numSent <= 0)
            {
                clientSocket.Close();
                return;
            }
            sentSoFar += numSent;
            if (sentSoFar < sendTotal)
            {
                BeginSendNextChunk();
                return;
            }
            sendBuffers.RemoveAt(0);
            if (sendBuffers.Count == 0)
            {
                currSendBuffer = null;
                sendTotal = 0;
                sentSoFar = 0;
                return;
            }
            BeginSendFirstBuffer();
        }
    }

    public static void Main()
    {
        IPAddress ServerAddress = IPAddress.Loopback; // or IPAddress.Any
        int ServerPort = 1234;

        Socket ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        ServerSocket.Bind(new IPEndPoint(ServerAddress, ServerPort));
        ServerSocket.Listen(5);
        Console.WriteLine("Server is listening for connections");

        ServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), ServerSocket);
            
        while (Console.ReadKey().Key != ConsoleKey.F10) {}

        ServerSocket.Close();
    }

    private static void AcceptCallback(IAsyncResult ar)
    {
        Socket ServerSocket = (Socket)ar.AsyncState;
        Socket ClientSocket = ServerSocket.EndAccept(ar);
        Console.WriteLine("Client connected!");
        ClientInfo client = new ClientInfo(ClientSocket);
        client.BeginReceive();
        ServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), ServerSocket);
    }
}