Question

我有一个有趣的问题，一个我在寻找答案时遇到困难。

我有两个IEnumerable对象集合。底层对象是完全独立的，但我可以识别应该匹配的共享密钥。集合很重要，因为我的“左”对象是“记录系统”，而“正确”对象代表我需要确保与记录系统匹配的系统。

匹配后，我需要在一侧执行CRUD操作，使右侧与左侧对齐。例如，它会在右侧创建一个新项目，如果一个项目不存在，或者更新值，或者如果该项目在左侧缺失，则删除，但不是右侧。

问题是，我有数百个这些集合要匹配，实际的CRUD代码是不同的。

我想介绍一些共享代码，我可以在其中传递集合，集合类型（可能是泛型），某种比较器，以及为CRUD执行的操作的一些委托。

如果此代码确实存在，它可能看起来像这样

class Stuff
{
   string Id {get; set;}
   string Name {get; set;}
}

class Junk
{
    string Id {get; set;}
    string ShortName {get; set;}
}

IEnumerable<Stuff> myStuff = GetStuff();
IEnumerable<Junk> myJunk = GetJunk();

CrudComparer cc = new CrudComparer<Stuff, Junk>(myStuff, myJunk);
cc.Comparer = (leftObject, rightObject) => {
    leftObject.Name == rightObject.Name
}

cc.CreateOperation = (newObject, rightCollection) => {
    Junk j = new Junk();
    j.Shortname = newObject.Name;
    rightCollection.Add(j);
} 

cc.UpdateOperation = (leftObject, rightObject) => {
    rightObject.Shortname = leftObject.Name;
}

cc.DeleteOperation = (rightCollection, rightObject) => {
    rightCollection.Remove(rightObject);
}

cc.Compare();

有没有人见过像这样的代码？如果我能抓住已经完成的东西，我不想重新发明轮子。

感谢您的帮助！ - 迈克尔

Answer 1

我更多地考虑了这一点，并意识到我对delgates和generics的了解应该足以解决这个问题，所以我进入LinqPad并获得了一些乐趣。我还没有编写任何单元测试，所以请自行承担风险，但希望如果你想使用它，你就能理解基本概念。

class Blah
{
    public int ID { get; set; }
    public string BlahName { get; set;}
}

class Bleh
{
    public int ID { get; set; }
    public string BlehName { get; set;}
}

class CrudComparer<TLeft, TRight>
{

    private readonly ICollection<TLeft> _leftCollection;
    private readonly ICollection<TRight> _rightCollection;
    private readonly Comparer _compareOperation;
    private readonly CreateOperation _createOperation;
    private readonly UpdateOperation _updateOperation;
    private readonly DeleteOperation _deleteOperation;

    public delegate bool Comparer(TLeft leftItem, TRight rightItem);
    public delegate void CreateOperation(TLeft leftItem, ICollection<TRight> rightCollection);
    public delegate void UpdateOperation(TLeft leftItem, TRight rightItem);
    public delegate void DeleteOperation(TRight rightItem, ICollection<TRight> rightCollection);

    public CrudComparer(ICollection<TLeft> leftCollection, ICollection<TRight> rightCollection, Comparer compareOperation, CreateOperation createOperation, UpdateOperation updateOperation, DeleteOperation deleteOperation)
    {
        _leftCollection = leftCollection;
        _rightCollection = rightCollection;
        _compareOperation = compareOperation;
        _createOperation = createOperation;
        _updateOperation = updateOperation;
        _deleteOperation = deleteOperation;
    }

    public void Compare()
    {
        foreach (TLeft leftItem in _leftCollection)
        {
            bool foundItem = false;
            foreach (TRight rightItem in _rightCollection)
            {
                if (_compareOperation(leftItem, rightItem))
                {
                    //these equal
                    foundItem = true;
                }
            }

            if (foundItem == false)
            {
                _createOperation(leftItem, _rightCollection);
            }
        }


        List<TRight> itemsToDelete = new List<TRight>();
        foreach (TRight rightItem in _rightCollection)
        {
            bool foundItem = false;

            foreach (TLeft leftItem in _leftCollection)
            {
                if (_compareOperation(leftItem, rightItem))
                {
                    foundItem = true;
                    _updateOperation(leftItem, rightItem);
                    break;          
                }
            }

            if (!foundItem)
            {
                itemsToDelete.Add(rightItem);
            }
        }

        foreach (TRight itemToDelete in itemsToDelete)
        {
            _deleteOperation(itemToDelete, _rightCollection);
        }
    }
}

void Main()
{
    List<Blah> blahItems = new List<Blah>();
    blahItems.Add(new Blah() { ID = 1, BlahName = "Blah" });
    blahItems.Add(new Blah() { ID = 2, BlahName = "ABC" });
    blahItems.Add(new Blah() { ID = 34, BlahName = "XYZ" });
    blahItems.Add(new Blah() { ID = 6442, BlahName = "123" });

    List<Bleh> blehItems = new List<Bleh>();
    blehItems.Add(new Bleh() { ID = 2, BlehName = "12345"});
    blehItems.Add(new Bleh() { ID = 6, BlehName = "43232"});
    blehItems.Add(new Bleh() { ID = 77, BlehName = "BlahBlah"});
    blehItems.Add(new Bleh() { ID = 2334, BlehName = "ZYX"});

    CrudComparer<Blah, Bleh>.Comparer compareOperation = (leftObject, rightObject) => 
    { 
        return leftObject.ID == rightObject.ID; 
    };
    CrudComparer<Blah, Bleh>.CreateOperation createOperation = (leftObject, rightCollection) => 
    { 
        rightCollection.Add(new Bleh() { ID = leftObject.ID }); 
    };
    CrudComparer<Blah, Bleh>.UpdateOperation updateOperation = (leftObject, rightObject) =>
    {
        rightObject.BlehName = leftObject.BlahName;
    };
    CrudComparer<Blah, Bleh>.DeleteOperation deleteOperation = (rightObject, rightCollection) =>
    {
        rightCollection.Remove(rightObject);
    };

    CrudComparer<Blah, Bleh> cc = new CrudComparer<Blah, Bleh>(blahItems, blehItems, compareOperation, createOperation, updateOperation, deleteOperation);
    cc.Compare();
}

CRUD超过两个不同的POCO集合

1 个答案: