Question

我在C＃（2.0）中编写一个必须返回简单对象集合的方法。通常我会做这样的事情：

class MyWidget
{
    struct LittleThing
    {
        int foo;
        DateTime bar;
    }

    public IList<LittleThing> LookupThings()
    {
        // etc.
    }
}

但是，我必须在接口中声明此方法。调用者无法看到MyWidget，只能看到IWidget接口。上述设置在这种情况下不起作用，因为C＃不允许在接口内定义类型。做这种声明的正确或最佳方式是什么？

我想到的直接的事情是简单地在界面之外声明LittleThing。出于几个原因，这看起来并不好。一：它只用于那个单一类中的那个单一方法，所以LittleThing似乎不应该只是一个独立的类型。二：如果为其他类编写类似的方法，它们将返回不同类型的数据（出于良好的设计原因），并且我不希望使用大量相似命名的结构来混淆名称空间来自彼此。

如果我们可以升级我们的.Net版本，我只会返回一个Tuple<>，但这在一段时间内不会是一个选项。

[编辑添加：小对象确实需要包含两个以上的字段，因此KeyValuePair<K,V>不会完全删除它。]

[已编辑进一步添加：IWidget仅由一个类Widget实现。我认为只有一个类的接口很奇怪，但这样做是为了满足旧的编码策略，该策略要求契约始终与实现分开。所述政策现已消失，但我们没有资源重构整个应用程序并删除所有不必要的接口。]

最佳做法是什么？

Answer 1

如果“LittleThing”只有两个值，您可以返回KeyValuePair<TKey,TValue>。

如果有两个以上，你可以随时制作自己的Tuple类，并在最终转移到.NET 4时将其替换为.NET 4。

否则，我只是用接口定义结构，并将其作为API的一部分包含在内。命名空间负责命名问题......

Answer 2

为什么要使用结构？为什么不使用类呢？
单独声明该类，作为公共类。

Answer 3

您可以在struct之外声明interface，但在嵌套namespace内声明。

Answer 4

如果我们可以升级我们的.Net版本，我只会返回一个Tuple＆lt;＆gt;，但这已经不是一段时间了。

为什么要等？它不像元组是一件复杂的事情。这是3元组的代码。

public struct Tuple<TItem1, TItem2, TItem3>
{
    public Tuple(TItem1 item1, TItem2 item2, TItem3 item3)
    {
        this = new Tuple<TItem1, TItem2, TItem3>();
        Item1 = item1;
        Item2 = item2;
        Item3 = item3;
    }

    public static bool operator !=(Tuple<TItem1, TItem2, TItem3> left, Tuple<TItem1, TItem2, TItem3> right)
    { return left.Equals(right); }

    public static bool operator ==(Tuple<TItem1, TItem2, TItem3> left, Tuple<TItem1, TItem2, TItem3> right)
    { return !left.Equals(right); }

    public TItem1 Item1 { get; private set; }
    public TItem2 Item2 { get; private set; }
    public TItem3 Item3 { get; private set; }

    public override bool Equals(object obj)
    {
        if (obj is Tuple<TItem1, TItem2, TItem3>)
        {
            var other = (Tuple<TItem1, TItem2, TItem3>)obj;
            return Object.Equals(Item1, other.Item1)
                && Object.Equals(Item2, other.Item2)
                && Object.Equals(Item3, other.Item3);
        }
        return false;
    }

    public override int GetHashCode()
    {
        return ((this.Item1 != null) ? this.Item1.GetHashCode() : 0)
             ^ ((this.Item2 != null) ? this.Item2.GetHashCode() : 0)
             ^ ((this.Item3 != null) ? this.Item3.GetHashCode() : 0);
    }
}

正如你所看到的，这没什么大不了的。我在当前项目中所做的是实现2,3和4元组，以及带有Tuple方法的静态Create类，它完全反映了.NET 4元组类型。如果你真的是偏执狂，你可以使用反射器来查看.NET 4元组的反汇编源代码，并逐字复制

当我们最终升级到.NET 4时，我们只会删除这些类，或者#ifdef将它们删除

Answer 5

在此处忽略结构名称的含义，您可以使用KeyValuePair的通用版本。

Answer 6

接口只定义了可以在另一个类上实现的内容，这就是为什么你不能在它们内部给出任何定义的原因。包括类和结构。

也就是说，通常用于解决此限制的一种模式是定义具有相同名称的类（不包括“I”前缀）以提供任何相关定义，例如：

public interface IWidget
{
    IList<Widget.LittleThing> LookupThings();
}

// For definitions used by IWidget
public class Widget
{
    public struct LittleThing
    {
        int foo;
        DateTime bar;
    }
}

此模式的示例可以在BCL中找到，特别是使用泛型和扩展方法，但也可以使用默认值（例如EqualityComparer<T>.Default）甚至是默认实现（例如IList<T>和List<T> ）。以上只是另一种情况。

Answer 7

所以，阅读你所评论的所有内容就是我的想法：

如果所有实现IWidget的类型都返回LittleThing：

然后我认为LittleThing的最佳实践与IWidget处于相同的命名空间级别，最好是在Widgets命名空间上。但是你真的应该考虑让LittleThing成为一个类。通过你对问题的描述，似乎它可能不会那么少，因为每次实现IWidget的课程都会使用某些字段而不是其他字段。

如果实现IWidget的所有类型都需要返回稍微不同的值，但行为类似：

考虑建立IThing界面。然后每个IThing实现都完全依赖于返回它的类，那么你就可以在实现IWidget的类中声明实现IThing的结构或类，如下所示：

interface IWidget
{
    IList<IThing> LookupThings()
    {
        …
    }
}

interface IThing
{
    …
}

class MyWidget : IWidget
{
    IList<IThing> IWidget.LookupThings()
    {
         …
    }

    private class MyWidgetThings : IThing
    {
         …
    }
}

声明从接口方法返回的结构

7 个答案: