В тексте все слова заданной длины заменить указанной подстрокой, длина которой может не совпадать с длиной заменяемого слова

using System.Collections;
using System.Collections.Generic;
using System;
using System.Linq;
 
namespace ConsoleApplication1
{
    /// <summary>
    /// Слово
    /// </summary>
    public interface IWord : IComparable<IWord>, IComparable
    {
        /// <summary>
        ///[readonly] Свойство на чтение что бы получить слово
        /// </summary>
        String GetWord { get; }
 
        /// <summary>
        ///[readonly] Возвращает длину слова
        /// </summary>
        Int32 Lenght { get; }
 
        String ToString();
 
    }
 
    public interface ISentence : IEnumerable<IWord>
    {
        /// <summary>
        ///[readonly] Возвращает разделитель слов
        /// </summary>
        Char Separator { get; }
        /// <summary>
        ///[readonly] Возвращает колличество слов
        /// </summary>
        Int32 Count { get; }
        String ToString();
 
        /// <summary>
        /// Производит замену одного слова на другое
        /// </summary>
        /// <param name="what">Какое слово</param>
        /// <param name="then">Чем меняем</param>
        /// <returns>Новое предложение</returns>
        Sentence Replace(Word what, Word then);
 
        /// <summary>
        /// Производит замену слова по  длине на другое
        /// </summary>
        /// <param name="wordLenght">Длинна меняемых слов</param>
        /// <param name="then">Чем меняем</param>
        /// <returns>Новое предложение</returns>
        Sentence Replace(Int32 wordLenght, IWord then);
    }
 
    /// <summary>
    /// Слово
    /// </summary>
    public class Word : IWord // IComparable<Word>,IComparable можно сравнивать компоратором один объект типа слова с другим
    {
        /// <summary>
        /// Слово, доступно только в нутри класса, и не изменяемое после инициализации объекта
        /// </summary>
        private readonly String _word;
        /// <summary>
        /// Длинна слова
        /// </summary>
        private readonly Int32 _lenght;
 
        /// <summary>
        ///[readonly] Свойство на чтение что бы получить слово
        /// </summary>
        public String GetWord
        {
            get { return _word; }
        }
 
        /// <summary>
        /// Конструктор принимающие слово
        /// </summary>
        /// <param name="word"></param>
        public Word(String word)
        {
            _word = word;
            _lenght = word.Length;
        }
 
        /// <summary>
        ///[readonly] Возвращает длину слова
        /// </summary>
        public Int32 Lenght
        {
            get { return _lenght; }
        }
        public override String ToString()
        {
            return _word;
        }
        #region Реализация IComparable<Word>, IComparable
        /// <summary>
        /// Компаратор
        /// </summary>
        /// <param name="other">Объект с которым сравниваем</param>
        /// <returns>-1 0 1</returns>
        public Int32 CompareTo(IWord other)
        {
            return _lenght == other.Lenght ? String.Compare(other.GetWord, _word, StringComparison.Ordinal) : other.Lenght.CompareTo(_lenght);
        }
 
        public Int32 CompareTo(object obj)
        {
            if (obj is Word)
            {
                return CompareTo(obj as Word);
            }
            throw new ArgumentException("Некорректный тип аргумента, сравнение недопустимо!");
        }
        #endregion
    }
 
    /// <summary>
    /// Предложение
    /// </summary>
    public class Sentence : ISentence
    {
        /// <summary>
        /// Слова в предложении
        /// </summary>
        private readonly IList<IWord> _wordList;
 
        /// <summary>
        ///[readonly] Возвращает разделитель слов
        /// </summary>
        public Char Separator
        {
            get { return _separator; }
        }
        /// <summary>
        ///[readonly] Возвращает колличество слов
        /// </summary>
        public Int32 Count
        {
            get { return _wordList.Count; }
        }
        /// <summary>
        ///[readonly] разделитель слов в предложении
        /// </summary>
        private readonly Char _separator;
 
        /// <summary>
        /// Конструктор инициализируется строчкой слова разделяются указанным разделителем по умолчанию это пробел
        /// </summary>
        /// <param name="sentence">Строчка предложение</param>
        /// <param name="separator">Разделитель слов в предложении</param>
        public Sentence(String sentence, Char separator = ' ')
        {
            _wordList = new List<IWord>();
            _separator = separator;
            foreach (var item in sentence.Split(separator))
                _wordList.Add(new Word(item));
        }
        /// <summary>
        /// Конструктор инициализируется любой коллекцией Слов (в том числе массивом)
        /// </summary>
        /// <param name="collection">Коллекция Слов</param>
        /// <param name="separator">Разделитель по умолчанию пробел</param>
        public Sentence(IEnumerable<IWord> collection, Char separator = ' ')
        {
            _wordList = new List<IWord>();
            _separator = separator;
            foreach (var item in collection)
                _wordList.Add(item);
        }
 
        public override String ToString()
        {
            return _wordList.Aggregate("", (current, item) => current + item.GetWord + _separator);
        }
 
        /// <summary>
        /// Производит замену одного слова на другое
        /// </summary>
        /// <param name="what">Какое слово</param>
        /// <param name="then">Чем меняем</param>
        /// <returns>Новое предложение</returns>
        public Sentence Replace(Word what, Word then)
        {
            var temp = this.Select(item => what.CompareTo(item) == 0 ? then : item);
            return new Sentence(temp, _separator);
        }
        /// <summary>
        /// Производит замену слова по  длине на другое
        /// </summary>
        /// <param name="wordLenght">Длинна меняемых слов</param>
        /// <param name="then">Чем меняем</param>
        /// <returns>Новое предложение</returns>
        public Sentence Replace(Int32 wordLenght, IWord then)
        {
            var temp = this.Select(item => wordLenght == item.Lenght ? then : item);
            return new Sentence(temp, _separator);
        }
 
        #region Реализация IEnumerable для поддержки foreach
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        public IEnumerator<IWord> GetEnumerator()
        {
            return _wordList.GetEnumerator();
        }
        #endregion
    }
 
    public class Program
    {
        private static void Main(string[] args)
        {
            Console.WriteLine("Input sentence, separator space: ");
            var inputText = Console.ReadLine();
            Int32 length;
            do
            {
                Console.WriteLine("Input length: ");
            } while (!Int32.TryParse(Console.ReadLine(), out length));
            Console.WriteLine("Input new world: ");
            IWord world = new Word(Console.ReadLine());
 
            ISentence sentence = new Sentence(inputText);
            Console.WriteLine("The original text.: ");
            Console.WriteLine(sentence.ToString());
            Console.WriteLine("The modificated text.: ");
            Console.WriteLine(sentence.Replace(length, world).ToString());
            Console.ReadLine();
        }
    }
}