Function to receive file in TcpSockets

I had this function on the server side to receive a file. However the file is too huge and can't read all of it. Is it any other way?

Server:

static void receiveFile(NetworkStream stream, TcpClient client, string op)
        {
            
            Console.WriteLine("Receiving file...");
            string file = receiveMessage(stream, client);

            //Create a new directory to store the files if it doesn't exist
            if (!Directory.Exists("files"))
            {
                Directory.CreateDirectory("files");
            }


            //save the data to a file in the current directory
            File.WriteAllText("./files/" + op.ToLower() + ".txt", file);
            Console.WriteLine("File received and saved to: " + Path.GetFullPath("./files/" + op.ToLower() + ".txt"));
        }

Client

static void sendFile(string filePath, NetworkStream stream)
        {
            //read the file
            byte[] fileData = File.ReadAllBytes(filePath);
            //send the file name
            string fileName = Path.GetFileName(filePath);
            //send the file size
            string fileSize = fileData.Length.ToString();
            //send the file
            stream.Write(fileData, 0, fileData.Length);
        }

I heard about FileStream. Is it a good solution?

You need to stream it. That is the answer to your question. The first iteration of our code may look like this:

    static void sendFile(string filePath, NetworkStream stream)
    {
        const int bufferSize = 8192;
        using var file = File.OpenRead(filePath);
        var buffer = new byte[bufferSize];
        while (true)
        {
            var read = file.Read(buffer, 0, bufferSize);
            if (read == 0)
            {
                break;
            }
            stream.Write(buffer, 0, read);
        }        
    }

    static void receiveFile(NetworkStream stream, string op)
    {
        //Create a new directory to store the files if it doesn't exist
        if (!Directory.Exists("files"))
        {
            Directory.CreateDirectory("files");
        }

        const int bufferSize = 8192;
        var filePath = Path.Combine("files", op.ToLower() + ".txt");
        using var file = File.OpenWrite(filePath);
        var buffer = new byte[bufferSize];
        while (true)
        {
            var read = stream.Read(buffer, 0, bufferSize);
            if (read == 0)
            {
                break;
            }
            file.Write(buffer, 0, read);
        }
    }

Both methods stream the file in 8192 chunks.

So sendFile will more or less stream the file correctly, however receiveFile will never finish, unless the client closes the socket. That's one issue. Another issue is that if you stream two files in a row, the server won't know where one ends and the other begins. So in order to stream this properly, you need to introduce some kind of protocol. One idea is to send the file size before sending the actual file. The second iteration of our code may look like this:

    static void sendFile(string filePath, NetworkStream stream)
    {
        const int bufferSize = 8192;
        using var file = File.OpenRead(filePath);
        var buffer = new byte[bufferSize];

        // Read the file size and write it to the socket
        // as a fixed sequence of 4 bytes
        var length = (int)file.Length;
        var tmpLength = length;
        for (var i = 0; i < 4; i++)
        {
            buffer[i] = (byte)(tmpLength & 0xFF);
            tmpLength >>= 8;
        }
        stream.Write(buffer, 0, 4);

        // Stream the rest of the file
        while (length > 0)
        {
            var read = file.Read(buffer, 0, bufferSize);
            stream.Write(buffer, 0, read);
            length -= read;
        }        
    }

    static void receiveFile(NetworkStream stream, string op)
    {
        //Create a new directory to store the files if it doesn't exist
        if (!Directory.Exists("files"))
        {
            Directory.CreateDirectory("files");
        }

        const int bufferSize = 8192;
        var filePath = Path.Combine("files", op.ToLower() + ".txt");
        using var file = File.OpenWrite(filePath);
        var buffer = new byte[bufferSize];

        // Read the fixed sequence of 4 bytes and 
        // retrieve the passed length from it.
        stream.ReadExactly(buffer, 0, 4);
        var length = 0;
        for (var i = 0; i < 4; i++)
        {
            length <<= 8;
            length += buffer[3-i];
        }

        // Use the retrieved length to stream the exact number
        // of bytes.
        while (length > 0)
        {
            var read = stream.Read(buffer, 0, bufferSize);
            file.Write(buffer, 0, read);
            length -= read;
        }
    }

Now this is a lot better, and may suit basic needs. There's still a lot to improve here, like for example authentication, passing file metadata like filename, etc. etc. Also note that the code itself can be improved, for example integer (de)serialization can be done through BitConverter. I'm leaving this raw example so that the reader understands better what is happening.

Things become only more difficult at this point, so I strongly suggest you actually use something widely used and well designed like HTTP protocol. Also with streaming big files you will encounter other issues, like for example single tcp connection might not be enough. Because if it dies then we need to restart the process. This is one of the reasons more sophisticated protocols like Torrent were designed.