Благодаря :) Какво прави това ?

    -->          teams.Values
                .Where(team => team.Members.Count == 0)
                .Select(team => team.Name)
                .OrderBy(name => name)
                .ToList()
        -->        .ForEach(Console.WriteLine);

teams.Values:

teams е Dictionary<string, Team>, и съответно teams.Values връща IEnumerable<Teams> - поток от всички тиймове в речника (представете си го като колекция - напр. List<Team>).

.ForEach(Console.WriteLine)

Съкратен запис на:

.ForEach(teamName => Console.WriteLine(teamName))

Изпълнява Console.WriteLine за всеки елемент. В случая елементите са имената на тийовете (string).

@Stancheva

Преработих още малко решението, като добавих допълнителен клас, в който се съхраняват отборите заедно с допълнителната логика по менажирането им.

Може да е една идея по-сложо от нивото на модула, но е по-близо до това, което се очаква да правите по-нататък в обучението и в работата:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApp1
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var teamsRegister = new TeamsRegister();

            var n = int.Parse(Console.ReadLine());


            for (var i = 0; i < n; i++)
            {
                var token = Console.ReadLine()
                    .Split("-".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                var creatorName = token[0];
                var teamName = token[1];

                try
                {
                    teamsRegister.Add(new Team(creatorName, teamName));
                    Console.WriteLine($"Team {teamName} has been created by {creatorName}!");
                }
                catch (ArgumentException e)
                {
                    Console.WriteLine(e.Message);
                }
            }

            string input;
            while ((input = Console.ReadLine()) != "end of assignment")
            {
                var token = input
                    .Split("->".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                var memberName = token[0];
                var teamName = token[1];

                try
                {
                    teamsRegister.AddMemberToTeam(memberName, teamName);
                }
                catch (ArgumentException e)
                {
                    Console.WriteLine(e.Message);
                }
            }

            Console.WriteLine(teamsRegister);
        }
    }

    internal class TeamsRegister
    {
        private readonly Dictionary<string, Team> _teams;

        public TeamsRegister()
        {
            _teams = new Dictionary<string, Team>();
        }

        public override string ToString()
        {
            var sb = new StringBuilder();

            _teams.Values
                .Where(team => team.Members.Count > 0)
                .OrderByDescending(team => team.Members.Count)
                .ThenBy(team => team.Name)
                .ToList()
                .ForEach(team => sb.Append(team).Append("\n"));

            sb.Append("Teams to disband:").Append("\n");

            _teams.Values
                .Where(team => team.Members.Count == 0)
                .Select(team => team.Name)
                .OrderBy(teamName => teamName)
                .ToList()
                .ForEach(teamName => sb.Append(teamName).Append("\n"));

            return sb.ToString();
        }

        private bool IsTeamCreator(string creatorName)
        {
            return _teams.Values.Any(team => team.Creator == creatorName);
        }

        private bool IsExistingTeam(string teamName)
        {
            return _teams.ContainsKey(teamName);
        }

        private bool IsExistingUser(string userName)
        {
            return _teams.Values.Any(team => team.Creator == userName || team.Members.Contains(userName));
        }

        public void Add(Team team)
        {
            if (IsExistingTeam(team.Name))
            {
                throw new ArgumentException($"Team {team.Name} was already created!");
            }

            if (IsTeamCreator(team.Creator))
            {
                throw new ArgumentException($"{team.Creator} cannot create another team!");
            }

            _teams.Add(team.Name, team);
        }

        public void AddMemberToTeam(string memberName, string teamName)
        {
            if (!IsExistingTeam(teamName))
            {
                throw new ArgumentException($"Team {teamName} does not exist!");
            }

            if (IsExistingUser(memberName))
            {
                throw new ArgumentException($"Member {memberName} cannot join team {teamName}!");
            }

            _teams[teamName].Add(memberName);
        }
    }

    internal class Team
    {
        public string Creator { get; }
        public string Name { get; }
        public List<string> Members { get; } = new List<string>();

        public Team(string creator, string name)
        {
            Creator = creator;
            Name = name;
        }

        public void Add(string user)
        {
            Members.Add(user);
        }

        public override string ToString()
        {
            var output = $"{Name}\n";
            output += $"- {Creator}\n";

            Members.OrderBy(name => name)
                .ToList()
                .ForEach(member => output += $"-- {member}\n");

            return output.Trim();
        }
    }
}