标签: internals

在一个事件中,我想把重点放在ListViewItem模板中的特定TextBox上.XAML看起来像这样:

<ListView x:Name="myList" ItemsSource="{Binding SomeList}">
    <ListView.View>
        <GridView>
            <GridViewColumn>
                <GridViewColumn.CellTemplate>
                    <DataTemplate>
                        <!-- Focus this! -->
                        <TextBox x:Name="myBox"/>

我在后面的代码中尝试了以下内容:

(myList.FindName("myBox") as TextBox).Focus();

但我似乎误解了FindName()文档,因为它返回了null.

也ListView.Items没有帮助,因为(当然)包含我绑定的业务对象而没有ListViewItems.

也没有myList.ItemContainerGenerator.ContainerFromItem(item),也返回null.

(免责声明:我不知道C++标准对此有何看法......我知道,我很可怕)

在非常大的字符串上操作时,我注意到std :: string正在使用copy-on-write.我设法编写了可以重现观察到的行为的最小循环,例如,下面的循环运行得非常快:

#include <string>
using std::string;
int main(void) {
    string basestr(1024 * 1024 * 10, 'A');
    for (int i = 0; i < 100; i++) {
        string a_copy = basestr;
    }
}

当在循环体中添加写入时a_copy[1] = 'B';,显然发生了实际复制,程序以0.3s而不是几毫秒运行.100次写入减慢了大约100次.

但后来很奇怪.我的一些字符串没有被写入,只是从中读取,而这并没有反映在执行时间中,这几乎与字符串上的操作数成正比.通过一些挖掘,我发现只是从字符串读取仍然给我性能命中,所以它让我假设GNU STL字符串正在使用copy-on-read(？).

#include <string>
using std::string;
int main(void) {
    string basestr(1024 * 1024 * 10, 'A');
    for (int i = 0; i < 100; i++) {
        string a_copy = basestr;
        a_copy[99]; // this also ran in 0.3s!
    }
}

在我的发现中陶醉了一段时间之后,我发现从基础字符串中读取(带有operator [])对于整个玩具程序来说也需要0.3秒.我对此并不是100%舒服.STL字符串是否确实是可读写的,或者它们是否允许写入时复制？我被认为operator …

这可能是一个愚蠢的问题,但无论如何我都会问.我有一个生成器对象:

>>> def gen():
...     for i in range(10):
...         yield i
...         
>>> obj=gen()

我可以测量它的大小:

>>> obj.__sizeof__()
24

据说发电机被消耗掉了:

>>> for i in obj:
...     print i
...     
0
1
2
3
4
5
6
7
8
9
>>> obj.__sizeof__()
24

......但obj.__sizeof__()仍然是一样的.

使用字符串它按预期工作:

>>> 'longstring'.__sizeof__()
34
>>> 'str'.__sizeof__()
27

如果有人能够启发我,我将感激不尽.

WebKit浏览器具有内置的样式渲染优化技术,"甚至不必匹配页面上大约60%元素的样式."

但是,如果"在样式表中的任何地方遇到任何兄弟选择器......那么优化将完全关闭整个页面...这包括+选择器和选择器,如:first-child和:last-child."

有谁知道禁用此优化的选择器类型的完整列表？

-

更多信息

• Tali Garsiel关于浏览器内部的研究讨论了优化:浏览器如何工作.

• 以下是来自Dave Hyatt的兄弟选择器的完整报价,他显然是在编写浏览器代码:"必须没有使用兄弟选择器.当遇到任何兄弟选择器时,WebCore会抛出一个全局开关,并禁用整个文档的样式共享当它们存在时.这包括+选择器和选择器,如:first-child和:last-child."

• 这句话似乎来自于2005年凯悦写的一篇文章.下面他将更详细地讨论它(与之前相同的来源):
  
  "WebCore(在即将推出的Safari版本中)有一个非常酷的优化,我提出来避免甚至不得不计算应用于元素的声明集.这种优化在实践中甚至不必匹配页面上大约60%元素的样式.优化背后的想法是识别页面中的两个元素何时出现通过DOM(和其他状态)检查获得相同的样式,并尽可能简单地在这两个元素之间共享前端样式信息."

• Nate Koechley的这篇文章更详细地讨论了算法.他总结道:
  
  "在网络开发中,通常有6种不同的相似方式来做同样的事情.一个优秀的网络开发人员不断选择最好的几乎无法区分的路径.这些来自凯悦的内部提示让我们更完整了解浏览器的内容,并帮助我们选择最佳方法."

• Hyatt还讨论了此W3C邮件列表存档中的优化问题

• 在Ryan Kinal 的Stack聊天中也简要介绍了一下:"哇.哇哇.我永远不会再使用另一个兄弟选择器了."

我特别感兴趣的是:

• 子选择器是否也关闭优化

• Trident/IE是否使用任何类似的优化

• 是否存在任何测试表明它对渲染性能有多大差异

我使用std :: deque来存储大量的项目.
我知道deques是作为矢量列表实现的.这些矢量的大小无法设置,但我喜欢选择该大小的算法.

如果您反思过来,WindowsBase.dll > MS.Internal.DoubleUtil.AreClose(...)您将获得以下代码:

public static bool AreClose(double value1, double value2)
{
    if (value1 == value2)
    {
        return true;
    }
    double num2 = ((Math.Abs(value1) + Math.Abs(value2)) + 10.0) * 2.2204460492503131E-16;
    double num = value1 - value2;
    return ((-num2 < num) && (num2 > num));
}

我试图理解两件不同的事情:

1. 他们在哪里提出了num2的公式？我想我只是不明白第一次添加值的重要性,10.0其次将所有结果乘以这个数字2.2204460492503131E-16.任何人都知道为什么这是使用的公式？

2. 那里的退货声明有什么意义？似乎默认情况下,如果num2大于num而不是num2的否定值,则应小于num.也许我在这里遗漏了一些东西,但这似乎是多余的.对我而言,就像检查5是否大于3以及-5是否小于3(作为示例).

我在IDataReader上有两个扩展方法,具有以下签名:

internal static List<T> GetList<T>(this IDataReader reader, Func<string, T> del)

internal static double? GetDoubleOrNull(this IDataReader reader, string columnName)

GetDoubleOrNull 没有任何重载.

在其他地方,我能做到

Func<string, double?> del = reader.GetDoubleOrNull;

var x = reader.GetList(del);

要么

var x = reader.GetList<double?>(reader.GetDoubleOrNull);

或者只是传入一个类似的实例方法

public double? blah(string s)

var x = reader.GetList(blah);

但我不能这样做

var x = reader.GetList(reader.GetDoubleOrNull);

编译器给出错误

cannot convert from 'method group' to 'System.Func<string,double?>'

我不明白这一点.我认为既然没有重载GetDoubleOrNull,就不会有重载决策,它可以从方法签名推断出类型参数.

真正令人困惑的部分是它在传入时的工作方式blah.

另一个问题的答案说明了这一点

array.map(&:to_s)

比...更快

array.map { |n| n.to_s }

在第一个例子中,&变成:to_s了Proc.第二个例子使用一个块.

为什么Proc比基准中的块更快？这种技术允许解释器做一些优化吗？

从源代码scala/Equals.scala(这里):

package scala
trait Equals extends scala.Any {
  def canEqual(that: scala.Any): scala.Boolean
  def equals(that: scala.Any): scala.Boolean
}

在文档中,它说:

应该从每个设计良好的equals方法调用的方法,该方法在子类中被重写.

我随机挑选了一个扩展的类,这个类scala.Equals很容易理解.我选择了scala.Tuple2[+T1, +T2],这扩展了特性scala.Product[T1, T2],这反过来扩展了特征scala.Product,从而扩展了特征scala.Equals.

不幸的是,似乎因为scala.Tuple2是一个案例类,所以canEqual()和equals()方法是自动生成的,因此无法在源代码中找到scala/Tuple2.scala(这里).

我的问题是:

• 什么时候延长特质scala.Equals？
• 应该如何canEqual()实施？
• 使用的最佳实践(或样板)canEqual()是equals()什么？

提前致谢!

PS:万一重要,我使用的是Scala 2.11.7.

这个问题来自关于元组的讨论.

我开始考虑元组应该具有的哈希码.如果我们接受KeyValuePair类作为元组怎么办？它不会覆盖GetHashCode()方法,所以可能它不会知道它的"子"的哈希码...所以,运行时将调用Object.GetHashCode(),它不知道真实的对象结构.

然后我们可以创建一些引用类型的实例,它们实际上是Equal,因为重载的GetHashCode()和Equals().并使用它们作为元组中的"孩子"来"欺骗"字典.

但它不起作用!运行时以某种方式计算出我们元组的结构并调用我们类的重载GetHashCode!

它是如何工作的？Object.GetHashCode()的分析是什么？

当我们使用一些复杂的密钥时,它会在某些不好的情况下影响性能吗？(可能,不可能的情况......但仍然)

以此代码为例:

namespace csharp_tricks
{
    class Program
    {
        class MyClass
        {
            int keyValue;
            int someInfo;

            public MyClass(int key, int info)
            {
                keyValue = key;
                someInfo = info;
            }

            public override bool Equals(object obj)
            {
                MyClass other = obj as MyClass;
                if (other == null) return false;

                return keyValue.Equals(other.keyValue);
            }

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

        static void Main(string[] args)
        {
            Dictionary<object, object> dict = new Dictionary<object, object>();

            dict.Add(new KeyValuePair<MyClass,object>(new MyClass(1, …