Почему моя маленькая программа продолжает использовать все больше и больше оперативной памяти и большую часть процессора?

Это плохой знак:

while(!task1.IsCompleted && !task2.IsCompleted)

Вы разработали собственное ожидание вращения, которое занимает все ядро ​​в бесконечном цикле ожидания ввода с клавиатуры. Трудно понять, чего вы хотите достичь здесь. Однако это был бы более разумный подход:

static async Task Main(string[] args)
{
   var ip = IPAddress.Parse("127.0.0.1");
   var client = new TcpClient();
   await client.ConnectAsync(ip, 23000);
   var stream = client.GetStream();
   var reader = new StreamReader(stream);
   var writer = new StreamWriter(stream);
   while (true)
   {
      await ReadAsync(reader);
      await WriteAsync(writer);
   }
}

private static async Task WriteAsync(StreamWriter wr)
{
   var str = Console.ReadLine();
   await wr.WriteAsync(str);
   await wr.FlushAsync();
}

private static async Task ReadAsync(StreamReader reader)
{
   var str = await reader.ReadLineAsync();
   Console.WriteLine(str);
}

Если вы хотите читать из потока асинхронно, вы можете попробовать что-то вроде этого

static async Task Main(string[] args)
{
   var ip = IPAddress.Parse("127.0.0.1");
   var client = new TcpClient();
   await client.ConnectAsync(ip, 23000);
   var stream = client.GetStream();
   using var reader = new StreamReader(stream);
   await using var writer = new StreamWriter(stream);
   using var cs = new CancellationTokenSource();

   var readTask = ReadAsync(reader,cs.Token);

   while (!cs.Token.IsCancellationRequested)
   {
      var str = Console.ReadLine();

      if (string.IsNullOrWhiteSpace(str))
      {
         cs.Cancel();
      }
      await writer.WriteAsync(str);
      await writer.FlushAsync();
   }

   await readTask;

   Console.WriteLine("Finished");
}

private static async Task ReadAsync(TextReader sr, CancellationToken token)
{
   while (!token.IsCancellationRequested)
   {
      var str = await sr.ReadLineAsync();
      Console.WriteLine(str);
   }
}

.net 7.3 совместимый

private static async Task Main(string[] args)
{
   var ip = IPAddress.Parse("127.0.0.1");
   var client = new TcpClient();
   await client.ConnectAsync(ip, 23000);
   var stream = client.GetStream();
   using (var reader = new StreamReader(stream))
   using (var writer = new StreamWriter(stream))
   using (var cs = new CancellationTokenSource())
   {
      // starts a task hot, does not await
      var readTask = ReadAsync(reader, cs.Token);

      // goes in to a loop
      while (!cs.Token.IsCancellationRequested)
      {
         var str = Console.ReadLine();

         if (string.IsNullOrWhiteSpace(str))
         {
            cs.Cancel();
         }

         await writer.WriteAsync(str);
         await writer.FlushAsync();
      }

      await readTask;

      Console.WriteLine("Finished");
   }

}

private static async Task ReadAsync(TextReader sr, CancellationToken token)
{
   // read loop
   while (!token.IsCancellationRequested)
   {
      var str = await sr.ReadLineAsync();
      Console.WriteLine(str);
   }
}

Ваши циклы while выглядят очень подозрительно. «While(statement){}» заставит ваш код проверять «оператор» настолько быстро, насколько ваш ЦП способен многократно проверять его, пока он окончательно не изменится. Это, скорее всего, и является причиной вашего странного поведения. Если вы хотите иметь такую ​​логику, может помочь задержка между каждой проверкой -

while (!task1.IsCompleted && !task2.IsCompleted)
{
     await Task.Delay(100);
}

Выполнение чего-то подобного решит вашу проблему, за исключением того, что это все еще ужасное кодирование, потому что вы используете цикл while, когда асинхронные задачи имеют встроенные методы ожидания.

Вместо этого вы можете использовать .Wait() для обхода всего цикла, что было бы правильным решением.

 while (true)
  {
      var task1 = Read(reader);
      var task2 = Write(writer);
      task1.Wait();
      task2.Wait();   
  }

Однако моим предпочтительным решением было бы сделать основной асинхронный метод и ждать задачи1 и задачи2.

 while (true)
  {
      var task1 = Read(reader);
      var task2 = Write(writer);
      await task1;
      await task2;   
  }

или если main не может быть асинхронным, то поместить весь код в Main во второй метод (то есть асинхронный), а затем в main вы просто вызовете свой второй метод с оператором .wait