小编Dan*_*ner的帖子

我正在向对象上下文添加几个实体.

try
{
    forach (var document in documents)
    {
        this.Validate(document); // May throw a ValidationException.

        this.objectContext.AddToDocuments(document);
    }

    this.objectContext.SaveChanges();
}
catch
{
    // How to clean-up the object context here?

    throw;
}

如果某些文档通过了验证而一个文档失败,则所有通过验证的文档仍会添加到对象上下文中.我必须清理对象上下文,因为它可能会被重用,并且可能发生以下情况.

var documentA = new Document { Id = 1, Data = "ValidData" };
var documentB = new Document { Id = 2, Data = "InvalidData" };
var documentC = new Document { Id = 3, Data = "ValidData" };

try
{
    // Adding document B will cause a …

我经常读到structs应该是不可变的 - 根据定义它们不是吗？

你认为int是不可改变的吗？

int i = 0;
i = i + 123;

似乎没关系 - 我们得到一个新的int并将其分配给i.那这个呢？

i++;

好的,我们可以把它想象成一条捷径.

i = i + 1;

怎么样struct Point？

Point p = new Point(1, 2);
p.Offset(3, 4);

这真的改变了这一点(1, 2)吗？我们难道不应该将它视为Point.Offset()返回新点的下列捷径吗？

p = p.Offset(3, 4);

这种想法的背景是这样的 - 没有身份的价值类型怎么可能是可变的？您必须至少查看两次以确定它是否发生了变化.但是如果没有身份,你怎么能这样做呢？

我不想通过考虑ref参数和拳击来使这个推理复杂化.我也知道,p = p.Offset(3, 4);表达不变性比做得好p.Offset(3, 4);.但问题仍然存在 - 根据定义,值不是不可变的值吗？

UPDATE

我认为至少涉及两个概念 - 变量或字段的可变性以及变量值的可变性.

public class Foo
{
    private Point point; …

简单的问题 - 给定一个IList<T>如何在不自己编写方法的情况下执行二进制搜索,而不将数据复制到具有内置二进制搜索支持的类型.我目前的状况如下.

• List<T>.BinarySearch() 不是会员 IList<T>
• 没有相应的ArrayList.Adapter()方法List<T>
• IList<T>不继承IList,因此使用ArrayList.Adapter()是不可能的

我倾向于认为使用内置方法是不可能的,但我无法相信BCL/FCL中缺少这样的基本方法.

如果不可能,谁可以提供最短,最快,最智能或最美丽的二进制搜索实现IList<T>？

UPDATE

我们都知道在使用二进制搜索之前必须对列表进行排序,因此您可以假设它是.但我认为(但没有验证)排序是同样的问题 - 你如何排序IList<T>？

结论

似乎没有内置二进制搜索IList<T>.可以使用First()和OrderBy()LINQ方法进行搜索和排序,但它可能会受到性能影响.自己实现它(作为扩展方法)似乎是你能做到的最好的.

为什么List<T>将容量增加2倍？

private void EnsureCapacity(int min)
{
    if (this._items.Length < min)
    {
        int num = (this._items.Length == 0) ? 4 : (this._items.Length * 2);
        if (num < min)
        {
            num = min;
        }
        this.Capacity = num;
    }
}

为什么Dictionary<K,V>使用素数作为容量？

private void Resize()
{
    int prime = HashHelpers.GetPrime(this.count * 2);
    int[] numArray = new int[prime];
    for (int i = 0; i < numArray.Length; i++)
    {
        numArray[i] = -1;
    }
    Entry<TKey, TValue>[] destinationArray = new Entry<TKey, TValue>[prime];
    Array.Copy(this.entries, 0, …

我尝试使用.NET Int64.Parse方法解析数字,它不会接受像"0x3039"这样的字符串,即使这是你在C#中编写常量的方式.该文档特别禁止字符串具有"0x"前缀,并且尾随"h"似乎也不起作用.

要解析十六进制数,我必须使用该System.Globalization.NumberStyles.HexNumber选项.

如果有人知道那些Int64.Parse()无法接受带有"0x"前缀的字符串,请告诉我.

我正在尝试使用"联盟"合并2个列表,因此我摆脱了重复.以下是示例代码:

public class SomeDetail
{
    public string SomeValue1 { get; set; }
    public string SomeValue2  { get; set; }
    public string SomeDate { get; set; }
}

public class SomeDetailComparer : IEqualityComparer<SomeDetail>
{
    bool IEqualityComparer<SomeDetail>.Equals(SomeDetail x, SomeDetail y)
    {
        // Check whether the compared objects reference the same data.        
        if (Object.ReferenceEquals(x, y))
            return true;
        // Check whether any of the compared objects is null.        
        if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
            return false;
        return x.SomeValue1 == y.SomeValue1 && x.SomeValue2 == y.SomeValue2; …

我需要调试我没有源代码的Java应用程序.它在Jetty服务器上本地运行.使用JD-GUI进行反编译工作正常.通过套接字连接或共享内存附加JDB也可以正常工作.

我失败的地方是将各个部分加在一起.我主要使用JD-Eclipse插件和远程调试来尝试Eclipse.我找不到将调试器成功附加到正在运行的进程的方法.一切似乎都假设我至少有部分应用程序可用作项目中的源代码,但我没有.它是一个相当大的应用程序(200多个MiB的JAR文件和500多个MiB的其他东西)所以试图从所有反编译的类构建一个项目并让它运行不是一个选项,除非它很容易自动化.

我真正需要的是能够将调试器附加到正在运行的进程,查看和导航反编译代码,设置断点并检查变量和对象.是否可以重新编译代码并不重要.有条件的断点和表达式评估会很好.

我的输入是三个数字 - 一个数字s以及一个范围的开头b和结尾.任务是找到范围内的最小Levenstein距离和范围内的所有数字.没有必要找到最小化距离的数字,最小距离就足够了.e0 <= s,b,e <= 10^1000s[b, e]

显然我必须将数字作为字符串读取,因为标准C++类型不会处理如此大的数字.计算可能在很大范围内的每个数字的Levenstein距离是不可行的.

有任何想法吗？

我有两个IQueryable实例 - objIQuerableA而且objIQueryableB我想只获取存在于objIQuerableA和不存在的元素objIQuerableB.

一种方法是使用foreach循环,但我想知道是否有更好的方法.

我有方法将私有集合返回给调用者,我想阻止调用者修改返回的集合.

private readonly Foo[] foos;

public IEnumerable<Foo> GetFoos()
{
    return this.foos;
}

目前,私有集合是一个固定数组,但如果需要在运行时添加新项目,集合可能会成为一个列表.

有几种解决方案可以防止调用者修改集合.返回IEnumerable<T>是最简单的解决方案,但调用者仍然可以将返回值向上转换IList<T>并修改集合.

((IList<Foo>)GetFoos())[0] = otherFoo;

克隆集合的明显缺点是有两个集合可以独立发展.到目前为止,我已经考虑了以下选项.

1. 将收藏包装进去ReadOnlyCollection<T>.
2. Enumerable通过执行类似的虚拟投影返回由类定义的LINQ迭代器之一list.Select(item => item).实际上我考虑使用Where(item => true)因为返回的迭代器似乎更轻量级.
3. 编写自定义包装器.

我不喜欢使用ReadOnlyCollection<T>它是它实现IList<T>和调用Add()或访问索引器将导致异常.虽然这在理论上是绝对正确的,但几乎没有真正的代码检查IList<T>.IsReadOnly或IList<T>.IsFixedSize.

使用LINQ迭代器 - 我将代码包装在扩展方法中MakeReadOnly()- 防止这种情况,但它有一个黑客的味道.

编写自定义包装器？重新发明轮子？

有任何想法,考虑或其他解决方案吗？

在标记这个问题时,我发现了之前没有注意到的Stack Overflow问题.Jon Skeet也建议使用"LINQ hack",但使用效率更高Skip(0).