相关疑难解决方法(0)

鉴于以下课程

public class Foo
{
    public int FooId { get; set; }
    public string FooName { get; set; }

    public override bool Equals(object obj)
    {
        Foo fooItem = obj as Foo;

        if (fooItem == null) 
        {
           return false;
        }

        return fooItem.FooId == this.FooId;
    }

    public override int GetHashCode()
    {
        // Which is preferred?

        return base.GetHashCode();

        //return this.FooId.GetHashCode();
    }
}

我已经覆盖了该Equals方法,因为它Foo代表了Foos表的一行.哪个是覆盖的首选方法GetHashCode？

覆盖为什么重要GetHashCode？

我正在使用XUnit框架来测试我的C#代码.

这个框架中是否有可用于对象比较的断言方法？我的目的是检查每个对象的公共和私有成员变量是否相等.

我试过那些替代品但很少有效:

1) bool IsEqual = (Obj1 == Obj2)
2) Assert.Same(Obj1, Obj2) which I couldnt understand what happens internally

我在Asp.Net Core中有一个项目.这个项目有一个ICacheService如下:

public interface ICacheService
{
    T Get<T>(string key);
    T Get<T>(string key, Func<T> getdata);
    Task<T> Get<T>(string key, Func<Task<T>> getdata); 
    void AddOrUpdate(string key, object value);
} 

实现只是基于ConcurrentDictionary<string, object>,所以它并不复杂,只是存储和检索这个字典中的数据.在我的一项服务中,我有一个方法如下:

public async Task<List<LanguageInfoModel>> GetLanguagesAsync(string frontendId, string languageId, string accessId) 
{
    async Task<List<LanguageInfoModel>> GetLanguageInfoModel()
    {
        var data = await _commonServiceProxy.GetLanguages(frontendId, languageId, accessId);
        return data;
    }

    _scheduler.ScheduleAsync($"{CacheKeys.Jobs.LanguagesJob}_{frontendId}_{languageId}_{accessId}", async () =>
    {
        _cacheService.AddOrUpdate($"{CacheKeys.Languages}_{frontendId}_{languageId}_{accessId}", await GetLanguageInfoModel());
        return JobStatus.Success;
    }, TimeSpan.FromMinutes(5.0));

    return await _cacheService.Get($"{CacheKeys.Languages}_{frontendId}_{languageId}_{accessId}", async () => await GetLanguageInfoModel());
}

问题是我在这个方法中有三个参数,我用它作为缓存键.这工作正常,但问题是三个参数的组合非常高,因此在缓存中将有如此多的对象重复.我正在考虑创建一个没有重复的缓存,如下所示:

使用列表作为键的缓存,我可以为一个对象存储多个键.因此,当我获得新元素时,如果它在缓存中,我将检查每个元素,如果它在缓存中,我将只在密钥列表中添加一个键,否则在缓存中插入一个新元素.这里的问题是测试对象是否在缓存中是一个大问题.我认为它将消耗大量资源,并且需要将一些序列化为特定形式以使比较成为可能,这将使得比较消耗大量资源.缓存可能看起来像这样CustomDictionary<List<string>, object>

有没有人知道解决这个问题的好方法是不重复缓存中的对象？

编辑1: …

有人可以解释为什么这两种方法返回不同的值？

List<CustomerSummary> summaries = new List<CustomerSummary>();

for (var i = 0; i < 10; i++)
{

var summary = new CustomerSummary() { ID = 1, Name = "foo", balance = 50.00 };

if (!summaries.Contains(summary))
    summaries.Add(summary);

}

-

List<CustomerSummary> summaries = new List<CustomerSummary>();

for (var i = 0; i < 10; i++)
{

 var summary = new CustomerSummary() { ID = 1, Name = "foo", balance = 50.00 };

 if (!summaries.Any(s=> s.ID == summary.ID))
     summaries.Add(summary);

}

第一种方法在列表中有10项,而第二种方法有1.为什么第一种(Contains())方法永远不会评估为真？

我想问的是为什么2个相同类型的对象具有相同的值,每个属性没有评估为等价(在第一种方法中)？

我有一个实体,我想与一个子集进行比较,并确定选择除子集之外的所有实体.

所以,我的查询看起来像这样:

Products.Except(ProductsToRemove(), new ProductComparer())

该ProductsToRemove()方法List<Product>在执行一些任务后返回a .因此,它是最简单的形式,就是上面的.

这个ProductComparer()类看起来像这样:

public class ProductComparer : IEqualityComparer<Product>
{
    public bool Equals(Product a, Product b)
    {
        if (ReferenceEquals(a, b)) return true;

        if (ReferenceEquals(a, null) || ReferenceEquals(b, null))
            return false;

        return a.Id == b.Id;
    }

    public int GetHashCode(Product product)
    {
        if (ReferenceEquals(product, null)) return 0;
        var hashProductId = product.Id.GetHashCode();
        return hashProductId;
    }
}

但是,我不断收到以下异常:

LINQ to Entities无法识别方法'System.Linq.IQueryable 1[UnitedOne.Data.Sql.Product] Except[Product](System.Linq.IQueryable1 [UnitedOne.Data.Sql.Product],System.Collections.Generic.IEnumerable 1[UnitedOne.Data.Sql.Product], System.Collections.Generic.IEqualityComparer1 [UnitedOne.Data.Sql.Product])'方法,而且这个方法不能被翻译成商店表达.

我有一些元素和一个额外的小集合作为过滤器.

我需要通过一些过滤器将它分成两个新的集合.在我的情况下,它是第一个包含一些元素的集合,另一个不包含.

2个新集合中没有不存在的项目.

我这样做了:

var collection1= baseCollection.Where(r => filterCollection.Contains(r.Property)).ToList();
var collection2= baseCollection.Where(r => !filterCollection.Contains(r.Property)).ToList();

但是,还有另一种,我希望更优雅的方式,分开收藏？对我来说,它看起来像"我重复自己",使用几乎相同的代码2次.