Question

这是IEnumerable接口，在其中添加一些单词并返回最后两个方法

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

namespace Thesaurus {

    /// <summary>
    /// Represents a thesaurus.
    /// </summary>
    public interface IThesaurus {
        /// <summary>
        /// Adds the given synonyms to the thesaurus
        /// </summary>
        /// <param name="synonyms">The synonyms to add.</param>
        void AddSynonyms(IEnumerable < string > synonyms);

        /// <summary>
        /// Gets the synonyms for a given word.
        /// </summary>
        /// <param name="word">The word the synonyms of which to get.</param>
        /// <returns>A <see cref="string"/> with all synonyms for the given word.</returns>
        IEnumerable < string > GetSynonyms(string word);

        /// <summary>
        /// Gets all words from the thesaurus.
        /// </summary>
        /// <returns>An <see cref="IEnumerable<string>"/> containing
        /// all the words in the thesaurus.</returns>
        IEnumerable < string > GetWords();
    }
}

这是我的代码，当我调用AddSynonyms和GetSynonyms方法时，我的问题是GetWords方法中的参数，我不知道如何解决它。< / p>

public class Thesaurus {

    public void AddSynonyms(IEnumerable < string > synonyms) {
        synonyms = new List < string > () {
            "one", "two", "three"
        };
    }

    public IEnumerable < string > GetSynonyms(string word) {
        foreach(String s in AddSynonyms()) {
            if (s == word) {
                yield return s;
            }
        }
    }

    public IEnumerable < string > GetWords() {
        foreach(String s in AddSynonyms()) {
            yield return s;
        }
    }
}

Answer 1

AddSynonyms（IEnumerable synonyms）是一种不会从GetSynonyms（）或GetWords（）调用的方法。

实现IThesaurus的类应该维护一个看起来像这样的受保护属性：

protected List<ISynonyms> Synonyms {get; set;}

GetSynonyms(string word) and GetWords() should be returning Items from that Property.

AddSynonym(IEnumerable<string> synonyms) will be adding items to that Property.

ISynonyms是一个继承自IDictionary<string, List<string>>的接口，其中字符串是您存储的Word同义词，List是Word的同义词。您也可以放弃ISynonyms接口，只需这样：

protected IDictionary<string, List<string>> {get; set;}

然后在构造函数中将其设置为新的Dictionary＆gt;（）。

Answer 2

首先，我认为您的意图是在add synonums方法中返回IEnumerable，因为您的输入参数甚至没有被使用过。所以我认为你打算这样做：

public interface IThesaurus
{

        IEnumerable<string> AddSynonyms();
        IEnumerable<string> GetSynonyms(string word);

        IEnumerable<string> GetWords();

}

您的问题不明确，但您需要在类上实现您的界面，现在您不会收到AddSynonyms错误消息。

现在您可以实现界面：

public class Thesaurus : IThesaurus
{
       public IEnumerable<string> AddSynonyms()
       {
          return new List<string>() {"one", "two", "three"};
       }

       public IEnumerable<string> GetSynonyms(string word)
       {
           return AddSynonyms().Where(s => s == word);
       }

       public IEnumerable<string> GetWords()
       {
           return AddSynonyms();
       }
}

请注意，GetWords和AddSynonyms本身就是“同义词”:)你应该让其中一个方法有不同的用途。

Answer 3

这是我如何实现该界面的最好的客人。请注意，您可能希望根据放入同义词库的数据量使用不同的内部数据结构，或者您是否需要AddSynonyms比GetSynonyms更具信息性。此外，还有一些错误检查和极端情况可能不会在这里处理，但我希望这至少可以让您了解如何实现接口。

public class Thesaurus : IThesaurus
{
    private Dictionary<string, List<string>> lookup = 
        new Dictionary<string, List<string>>(); 

    public void AddSynonyms(IEnumerable<string> synonyms)
    {
        var words = synonyms.Distinct().ToList();
        foreach (var word in words)
        {
            var currentWordSynonyms = words.Where(w => w ! == word).ToList();
            if (lookup.ContainsKey(word))
            {
                foreach (var synonym in currentWordSynonyms)
                {
                    if(!lookup[word].Contains(synonym))
                        lookup[word].Add(synonym);
                }
            }
            else
            {
                lookup.Add(word, currentWordSynonyms);
            }
        }
    }

    public IEnumerable<string> GetSynonyms(string word)
    {
        if(lookup.ContainsKey(word))
            return lookup[word];
        return Enumerable.Empty<string>();
        // Or throw an exception.
    }

    public IEnumerable<string> GetWords()
    {
        return lookup.Keys();
    }
}

修改

这里的想法是，您有一个Dicitionary，它会将每个单词与List个同义词相关联。 AddSynonyms方法将枚举同义词，并首先创建一个唯一单词列表，以防有任何重复。然后它会遍历每个单词并检查它是否已被添加。如果有，则它会遍历该单词的所有同义词（words列表减去word），并检查它们是否在与该单词相关联的List中。如果不是，则将同义词添加到列表中。如果该单词不在Dicitionary中，则会将其与List个同义词一起添加（同样是words列表减去word）。

GetSynonymns方法只返回与给定List相关联的word。如果单词不在同义词库中，则会返回一个空的枚举（如果需要，可以将其更改为抛出异常）。

GetWords方法只返回Dicitionary的所有键，这些键将是添加的每个单词。

此代码会产生大量重复，因为每个单词都会引用Dicitionary中的同义词列表。但这会导致GetSynonyms和GetWords方法相当快。但是，随着内部AddSynonyms的增长，Dicitionary会变慢。

这不会验证发送到方法的参数不为null。它还允许您关联诸如＆＃34之类的内容;这是一个句子＆＃34;作为＆＃34; 123456＆＃34;的同义词，所以基本上任何字符串都可以是任何其他字符串的同义词。

Answer 4

你需要写：

public class Thesaurus :  IThesaurus
{
public void AddSynonyms(IEnumerable<string> synonyms){

 synonyms = new List<string>() { "one", "two", "three"};

}

public IEnumerable<string> GetSynonyms(string word){

foreach(String s in AddSynonyms()){

     if(s == word)
        {
         yield return s;
}
  }

public IEnumerable<string> GetWords(){

foreach(String s in AddSynonyms()){

         yield return s;
}
}
}

我正在尝试实现此接口，但需要一些帮助：

4 个答案: