小编sin*_*law的帖子

这看起来像是在通用结构上提升为操作数的null的错误.

考虑以下虚拟结构,它覆盖operator==:

struct MyStruct
{
    private readonly int _value;
    public MyStruct(int val) { this._value = val; }

    public override bool Equals(object obj) { return false; }
    public override int GetHashCode() { return base.GetHashCode(); }

    public static bool operator ==(MyStruct a, MyStruct b) { return false; }
    public static bool operator !=(MyStruct a, MyStruct b) { return false; }
}

现在考虑以下表达式:

Expression<Func<MyStruct, MyStruct, bool>> exprA   = 
    (valueA, valueB) => valueA == valueB;

Expression<Func<MyStruct?, MyStruct?, bool>> exprB = 
    (nullableValueA, nullableValueB) …

在以下代码中:

interface IGet { int Value { get; } }

interface ISet { int Value { set; } }

interface IBoth : IGet, ISet { }

class Test
{
    public void Bla(IBoth a)
    {
        var x = a.Value; // Error: Ambiguity between 'IGet.Value' and 'ISet.Value'
    }
}

我收到一个错误:

'IGet.Value'和'ISet.Value'之间的歧义

为什么编译器无法确定访问的属性必须来自IGet？

编辑 - 我猜测编译器首先尝试确定正在访问哪个属性,然后才检查它是get还是set.问题是 - 为什么？为什么不排除那些不提供吸气剂的候选人呢？为什么不解析实际的get/set方法并忽略它是属性的事实？

更新:使用方法而不是属性的更多代码,其中问题不存在.属性并不完全像一对方法.

看起来像[1,2,3]和[1..3]之间的奇怪区别.

在下面使用runghc打印出一个"True",然后永久挂起:为什么？(我正在使用ghc 7.8.3)

module Main where

import Data.Functor((<$>))
import Data.Time.Clock(DiffTime)
import Data.Binary(Binary(..), encode, decode, Get)
import Data.Int(Int64)

instance Binary DiffTime where
  put x = put (truncate (x * 10^12) :: Int64)
  get = ((/ 10^12) . fromIntegral) <$> (get :: Get Int64)

prop_getput_difftime :: DiffTime -> Bool
prop_getput_difftime x = x == ((decode . encode $ x) :: DiffTime)

explicit :: [DiffTime]
explicit = [1,2,3,4,5,6,7,8,9,10]

elipsis :: [DiffTime]
elipsis = [1..10]

main :: IO ()
main = do
  print $ …

您好,我需要使用进行IBAN验证检查javascript.

我需要遵循的规则是

验证IBAN 通过将IBAN转换为整数并对其执行基本mod-97操作(如ISO 7064中所述)来验证IBAN.如果IBAN有效,则余数等于1.

1.根据国家/地区检查总IBAN长度是否正确.如果不是,则IBAN无效

2.将四个初始字符移动到字符串的末尾

3.用两位数字替换字符串中的每个字母,从而扩展字符串,其中A = 10,B = 11,...,Z = 35

4.将字符串作为十进制整数进行解释,并在除以97时计算该数字的余数

我正在为白俄罗斯IBAN做这件事,所以它必须遵循以下格式

2C 31N -

RU1230000000000000000000000000000

如何修改以下内容以符合上述规则;

function validateIBAN(iban) {
    var newIban = iban.toUpperCase(),
        modulo = function (divident, divisor) {
            var cDivident = '';
            var cRest = '';

            for (var i in divident ) {
                var cChar = divident[i];
                var cOperator = cRest + '' + cDivident + '' + cChar;

                if ( cOperator < parseInt(divisor) ) {
                        cDivident …

首先,请不要试图争论我做出的热切负载 - 遍历对象图并导致(通过延迟加载)甚至超过一次往返数据库只是不是一种选择.

我有一个大的对象图.我想获取根对象,以及它的子,孙子,曾孙等的子集.目前我通过创建多个Future对象(使用Criteria)来执行此操作,并且在每个对象中,我这样做SetFetchMode("...", FetchMode.Eager)- 请参阅Ayende的帖子和Sam的第3条评论在这里.有两个问题:

1. NHibernate在同一个往返中执行多个选择查询 - 从根到叶子(A.B.C.D)的每个路径一个,这很好,但使用join而不是subselect我真正想要它做的事情.使用join意味着需要从数据库发送大量数据,需要进行解析,并且nhibernate需要做更多的工作而不是必要的.

2. 问题1的结果 - 在某些情况下,对象的重复嵌套多于一层.

第二个问题我通过将我的集合设置为Set来"解决",但后来我失去了排序能力 - 因为我必须指定ISet为接口,我的代码无法知道该集合是否真的是一个OrderedSet.

有没有人知道如何执行,在一次往返,急切加载一个对象加上几个深层嵌套的集合,但不使用连接？

我非常感激!我已经在网上搜索了答案,显然我不是第一个打到这堵墙的人.

考虑以下类型:

class A { }
class B { }
interface IC { }

A a = null; // the value doesn't matter - null or anything else, for all three
B b = null;
IC c = null;

以下就不能编译:

var x = a == b;

但下面不会编译(我很惊讶地发现):

var x = a == c;

据我所知,编译器回退到使用default ==运算符,它在对象上定义,因此接受任何类型的参数.IL看起来像这样(忽略细节ldfld):

ldarg.0
ldfld class A a
ldarg.0
ldfld class IC c
ceq
stloc.0

换句话说,它使用引用相等.

我的问题:

1. 在语言设计方面,为什么这有意义？对我而言,它没有,我认为这是一个很大的陷阱.

2. 如果这确实是一个陷阱,代码分析不应警告我们吗？(不 - 它没有).顺便说一句, …

考虑：

#define TEST(x) x
int arr[2] = TEST({1, 2});

我希望它可以被预处理成 int arr[2] = {1, 2};

相反，gcc和clang都抱怨。gcc 7.3.0：

./test.c:2:25: error: macro "TEST" passed 2 arguments, but takes just 1
 int arr[2] = TEST({1, 2});

铛3.8.1：

./test.c:2:23: error: too many arguments provided to function-like macro invocation
int arr[2] = TEST({1, 2});

我找不到在宏的C语言标准部分（6.10）中特别对待大括号的内容。

为什么会这样？

考虑这个界面:

interface Test<out T> where T : struct { }

它编译时没有错误或警告.

如本问题所述,并在协方差和反演法常见问题中提到:

仅当类型参数是引用类型时才支持差异.

那么为什么上面的接口编译？对"out"关键字失败(或至少警告)是有意义的.我想这个问题归结为 - out在上面的例子中使用关键字是否有任何区别？

更新:这是一个误导性行为的例子,对于看不到上面接口的不知情的开发人员来说可能会漏掉:

typeof(IDummy).IsAssignableFrom(typeof(MyStruct)); // should return true
typeof(ITest<IDummy>).IsAssignableFrom(typeof(ITest<MyStruct>)); // returns false

如果编码器不知道方差不适用于值类型,他们会期望第二行返回true- 因为out关键字 - 但它永远不会.这正是促使我提出这个问题的错误......

另一个可编译但产生意外结果的代码示例:

ITest<MyStruct> foo = ...;
var casted = (ITest<IDummy>)foo;

我希望这可以工作(不知道协方差对引用类型的限制),但它会导致System.InvalidCastException.

考虑

U8 foo(U8 x, U8 y) {
    return x % y;
}

如果U8(x和y的类型是char或unsigned char),GCC的-Wconversion表现不同:

gcc -Wconversion -c test.c -DU8='unsigned char'

(没有警告)

gcc -Wconversion -c test.c -DU8=char
test.c: In function ‘foo’:
test.c:2:14: warning: conversion to ‘char’ from ‘int’ may alter its value [-Wconversion]
     return x % y;
            ~~^~~

但是根据我的理解,在两种情况下x,y都经历整数提升(到int或unsigned int),因此在两种情况下它都将从int转换为返回类型(char或unsigned char).

为什么会有区别？

额外问题:如果你启用了ubsan(-fsanitize = undefined),那么GCC会在两种情况下都发出-Wconversion.

编辑:

没有论证x,y经历整数提升然后需要转换为结果类型,因此无需解释.

这里唯一的问题是为什么GCC对不同类型的行为不同.答案将涉及对GCC内部的一些见解.

我正在编写一个单元测试套件来测试TCP/IP通信库.

当我使用BeginAcceptClient和EndAcceptClient时,消息在后台线程中接收.

收到消息后,我对它执行一些断言,但如果任何断言失败,则VSTestHost.exe崩溃.

我用Google搜索了一下,发现Assert异常是在后台线程中引发的.

编辑:我正在做的示例代码,只是为了说明:

public void TestFooMessage() {
    Server.OnReceive += (s, e) => {
        Assert.IsInstanceOfType(e.Message, typeof(Foo));
    };

    var message = new Foo();
    Client.Send(message);
}

有谁知道如何让它按预期工作:记录断言并继续正常运行？