我应该使用什么数据结构将三个“旧”值映射到三个“新”值？

Question

我试图找出什么样的数据结构才有意义代表我的数据。 我正在使用一种C＃工具，它将更新一组特定类别的名称，SubCategories和SubSubCategories。 以下是一些示例数据：

OldCategory | OldSubCategory | OldSubSubCategory | NewCategory           | NewSubCategory | NewSubSubCategory
-------------------------------------------------------------------------------------------------------------
Hardware    | Display        | Broken            | HD-Hardware           | Display        |
Hardware    | Display        | Request upgrade   | Requests              | Hardware       | Display 
Software    | Excel          | Error message     | HD-Software           | Excel          | General Error
Software    | Excel          | How Do I          | HD-Software           | Excel          | Training
Software    | Excel          | Plug-in           | HD-SoftwareExtensions | Excel          |

如您所见，我不能简单地将每个OldCategory更新为相应的NewCategory 。 该数据是建立使每个组合Category ， SubCategory ，和SubSubCategory是一个独特的价值。 例如， Hardware | Display | Request upgrade Hardware | Display | Request upgrade Hardware | Display | Request upgrade将映射到Requests | Hardware | Display Requests | Hardware | Display Requests | Hardware | Display 。

如何将三个旧值的组合映射到三个新值的组合？

我当时正在考虑使用Dictionary<Tuple<string, string, string>, Tuple<string, string, string>>结构，但这似乎太冗长，并且可能使其他开发人员或我未来的自己感到困惑。 有什么建议可以更清楚地表示我的数据吗？

Answer 1

我建议你走同样的路线，即

Dictionary<Tuple<string, string, string>, Tuple<string, string, string>>

使用新的ValueTuple ，您可以使用更简洁的语法来完成此操作

var tbl = new Dictionary<(string, string, string), (string, string, string)>();
var newVal = tbl[("Hardware", "Display", "Request upgrade")];

您还可以为元组字段使用名称，如下所示

var tbl = new Dictionary<(string Cat, string SubCat, string SubSubCat), (string Cat, string SubCat, string SubSubCat)>();

如果您需要更多的灵活性，控件或功能，可以为此使用一个类，如下所示

class CatInfo : Tuple<string, string, string> {
    public string Category => Item1;
    public string SubCategory => Item2;
    public string SubSubCategory => Item3;

    public CatInfo(string cat, string subCat, string subSubCat) : base(cat, subCat, subSubCat) { }
}

如果出于某种原因，您不能从Tuple子类，或者想要稍微好一点的性能，则可以仅创建如下所示的不可变结构

struct CatInfo {
    public string Category { get; }
    public string SubCategory { get; } 
    public string SubSubCatergory { get; }

    public CatInfo(string cat, string subCat, string subSubCat) {
        Category = cat;
        SubCategory = subCat;
        SubSubCatergory = subSubCat;
    }

    public bool Equals(CatInfo other) {
        return string.Equals(Category, other.Category) && string.Equals(SubCategory, other.SubCategory) && string.Equals(SubSubCatergory, other.SubSubCatergory);
    }

    public override bool Equals(object obj) {
        if (obj is null)
            return false;
        return obj is CatInfo info && Equals(info);
    }

    public override int GetHashCode() {
        unchecked {
            int hashCode = (Category != null ? Category.GetHashCode() : 0);
            hashCode = (hashCode * 397) ^ (SubCategory != null ? SubCategory.GetHashCode() : 0);
            hashCode = (hashCode * 397) ^ (SubSubCatergory != null ? SubSubCatergory.GetHashCode() : 0);
            return hashCode;
        }
    }

    public static bool operator ==(CatInfo info1, CatInfo info2) {
        return info1.Equals(info2);
    }

    public static bool operator !=(CatInfo info1, CatInfo info2) {
        return !(info1 == info2);
    }
}

Answer 2

这是我在评论中一直在谈论的一个示例：

public class Category : IEquatable<Category>
{
    public string MainCategory { get; set; }
    public string SubCategory { get; set; }
    public string SubSubCategory { get; set; }


    private string GetCharacterizer()
    {
        return $"{MainCategory}#{SubCategory}#{SubSubCategory}";
    }

    public override int GetHashCode()
    {
        return GetCharacterizer().GetHashCode();
    }

    public bool Equals(Category other)
    {
        if (other == null)
        {
            return false;
        }
        return GetCharacterizer().Equals(other.GetCharacterizer());
    }

    public override bool Equals(object other)
    {
        if (!(other is Category catOther))
        {
            return false;
        }

        return Equals(catOther);
    }
}

然后您将创建一个Dictionary<Category, Category>

Answer 3

创建课程对我来说似乎是最好的选择。 这样，您可以创建构造函数并拥有方法。 例如

public CategoryClass{
    string category;
    string subCategory;
    string subSubCategory;
}

然后可以将它们放入字典中：

static void Main(string[] args)
{
    CategoryClass oldCategory = new CategoryClass();
    CategoryClass newCategory = new CategoryClass();
    Dictionary<CategoryClass, CategoryClass> dict = new Dictionary<CategoryClass, CategoryClass>();
}

...或其他物体。