小编use*_*127的帖子

我正在实现一个应该支持跨域请求的REST API.使用CORS我想实现这一目标.几乎所有的请求都是"不简单",这意味着对于所有非GET请求,浏览器必须发送预检请求.

为了限制预检/ OPTIONS请求的数量,我尝试让浏览器缓存OPTIONS请求.这似乎适用于Firefox和Safari,但不适用于Chrome.我知道Chrome只会将预检请求缓存10分钟,但就我而言,似乎根本没有缓存.

这些是Chrome发送/接收的HTTP请求和响应:

请求:

OPTIONS /api/v1/sessions HTTP/1.1
Host: xxxxxxx
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache
Access-Control-Request-Method: POST
Origin: http://localhost:8000
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36
Access-Control-Request-Headers: content-type
Accept: */*
Referer: http://localhost:8000/
Accept-Encoding: gzip, deflate, sdch
Accept-Language: nl-NL,nl;q=0.8,en-US;q=0.6,en;q=0.4

响应:

HTTP/1.1 200 OK
Date: Sun, 26 Jul 2015 09:33:27 GMT
Server: Apache/2.4.7 (Ubuntu)
X-Powered-By: PHP/5.5.9-1ubuntu4.9
Cache-Control: private, max-age=1440, pre-check=1440
Access-Control-Allow-Origin: http://localhost:8000
Access-Control-Allow-Methods: GET,POST,PATCH,DELETE
Access-Control-Max-Age: 86400
Access-Control-Allow-Headers: content-type
Content-Length: 0
Keep-Alive: timeout=5, max=100 …

当我遇到一个奇怪的结果时,我正在做一些关于对象分配的性能测试.我有以下java代码:

public static long TestMethod(){
    int len = 10000000;
    Object[] obs = new Object[len];
    long t = System.nanoTime();
    for (int i = 0; i < len; i++) {
        obs[i] = new Object();
    }
    return System.nanoTime() - t;
}

public static void main(String... args) throws InterruptedException {
    for(int i = 0; i < 10; i++){
        System.gc();
        System.gc();//Wait for the gc to be finished
        Thread.sleep(1000);
        System.out.println(TestMethod());
    }
}

期望:由于请求操作系统和热点增强的更大内存空间,第一次调用将比第二次调用慢.但第二和第三将几乎相同.

观察结果:

11284734000
799837000
682304000
304736000
380770000
392786000
374279000
381611000
379174000
407256000 …

假设我在课堂上有一些事件:

 class SomeClass{
     event ChangedEventHandler SomeDoubleChanged;
     double SomeDouble;
 }

有:

 delegate void ChangedEventHandler(double d);

现在假设我想在SomeDouble上侦听更改事件,但只想触发大于的更改delta.现在我可以做点什么

 SomeObject.SomeDoubleChanged += (d) => {if(abs(d-old_d) > delta){
                                  //do something     
                                 };

但我希望我的活动能够解决这个问题,所以在最好的情况下我想做的事情如下:

 SomeObject.SomeDoubleChange += (delta, (d) => {});

仍然允许:

 SomeObject.SomeDoubleChange += (d) => {};

我只想实现它的唯一方法是删除整个事件关键字并使用+ =和 - =运算符实现一个容器,对指定的委托进行操作.但在我看来,这不是一个非常优雅的解决方案,因为它为SomeClass的用户提供了SomeDoubleChanged不是事件的想法.

这个问题最优雅的解决方案是什么？