我的代码中有热点,我pow()占用了大约10-20%的执行时间.
我的输入pow(x,y)是非常具体的,所以我想知道是否有办法滚动两个pow()近似值(每个指数一个)具有更高的性能:
float向量.如果可以利用平台细节,请立即使用!尽管我对全精度(for float)算法感兴趣,但最大错误率约为0.01%是理想的.
我已经在使用快速pow() 近似,但它没有考虑这些约束.有可能做得更好吗？
我正在尝试执行更新和选择......基本上,基于索引进行更新,然后选择已更新的行ID.
使用OUTPUT子句很简单:
UPDATE Foo
SET Bar = 1
OUTPUT INSERTED.Id
WHERE Baz = 2
但现在,我如何将其变为变量？
DECLARE @id INT
这三个不起作用:
UPDATE Foo
SET Bar = 1
OUTPUT @id = INSERTED.Id
WHERE Baz = 2
SET @id =
(UPDATE Foo
SET Bar = 1
OUTPUT INSERTED.Id
WHERE Baz = 2)
SET @id =
(SELECT Id FROM (UPDATE Foo
SET Bar = 1
OUTPUT INSERTED.Id Id
WHERE Baz = 2) z)
最后一个包括在内,因为当管理工作室中的所有红色波浪线消失时,它让我暂时兴奋.唉,我收到这个错误:
A nested INSERT, UPDATE, DELETE, or MERGE statement is not allowed …看看CancellationToken.None它的实现,它只是回归default(CancellationToken).但是,我在CancellationToken文档中看不到两者是等价的.
我想提供这样的API,但直到我确定它总能工作:
Task DoSomething(CancellationToken token = default(CancellationToken))
它定义的行为default(CancellationToken)是否相同CancellationToken.None,或者这只是一个实现细节？
我的应用程序需要将插件加载到单独的应用程序域中,然后异步执行其中的一些代码.我编写了一些代码来包装可Task编组类型:
static class RemoteTask
{
public static async Task<T> ClientComplete<T>(RemoteTask<T> remoteTask,
CancellationToken cancellationToken)
{
T result;
using (cancellationToken.Register(remoteTask.Cancel))
{
RemoteTaskCompletionSource<T> tcs = new RemoteTaskCompletionSource<T>();
remoteTask.Complete(tcs);
result = await tcs.Task;
}
await Task.Yield(); // HACK!!
return result;
}
public static RemoteTask<T> ServerStart<T>(Func<CancellationToken, Task<T>> func)
{
return new RemoteTask<T>(func);
}
}
class RemoteTask<T> : MarshalByRefObject
{
readonly CancellationTokenSource cts = new CancellationTokenSource();
readonly Task<T> task;
internal RemoteTask(Func<CancellationToken, Task<T>> starter)
{
this.task = starter(cts.Token);
}
internal void Complete(RemoteTaskCompletionSource<T> tcs)
{
task.ContinueWith(t …我收到了一些订单.
[a, b]
[a, b, c]
[a, b, c, d]
[a, b, c, d]
[b, c]
[c, d]
其中a,b,c和d是SKU,并且有大箱子.并且有数千个订单和数百个可能的SKU.
现在想象一下,在打包这些订单时,如果订单缺少先前订单中的商品,您必须将该SKU的包装盒放开(并且同样取出您没有的订单).
你如何对它进行排序,以便有最小数量的盒子更改？或者,在更多程序化术语中:如何最小化累积汉明距离/最大化集合中相邻项目之间的相交？
我真的不知道从哪里开始.是否已经有一些算法？有一个不错的近似值？
使用JSON.Net序列化/反序列化结构时,内置结构类型(如System.Drawing.Size)序列化为字符串,而自定义结构类型序列化为JSON对象.
例如:
using System;
using System.Drawing;
using Newtonsoft.Json;
namespace TestJsonNet
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(JsonConvert.SerializeObject(new Size(50, 50)));
Console.WriteLine(JsonConvert.SerializeObject(new Size2(50, 50)));
}
}
struct Size2
{
public int Width { get; set; }
public int Height { get; set; }
public Size2(int w, int h) : this()
{
Width = w; Height = h;
}
}
}
输出以下内容:
"50, 50"
{"Width":50,"Height":50}
我可以理解将结构序列化为字符串的想法,因为内存布局总是相同的; 但是,序列化自定义结构时出现差异的原因是什么？
另外,我会(因为内部遗留原因),喜欢让JSON.Net序列化结构像后一种情况(即作为JSON,而不是字符串).如果有可能,怎么能实现呢？
我需要转换从REST API获取的JSON数据,并将它们转换为CSV以进行某些分析.问题是JSON数据不一定遵循相同的内容,因此我无法定义映射类型.这已经成为一项挑战,占用了我太多的时间.我已经创建了一些代码,但当然它没有工作,因为它在这一行引发了异常
var data = JsonConvert.DeserializeObject<List<object>>(jsonData);
错误是:
附加信息:无法将当前JSON对象(例如{"name":"value"})反序列化为类型'System.Collections.Generic.List`1 [System.Object]',因为该类型需要JSON数组(例如[1] ,2,3])正确反序列化.
要修复此错误,请将JSON更改为JSON数组(例如[1,2,3])或更改反序列化类型,使其成为普通的.NET类型(例如,不是像整数这样的基本类型,而不是类似的集合类型可以从JSON对象反序列化的数组或List.JsonObjectAttribute也可以添加到类型中以强制它从JSON对象反序列化.
路径'数据',第2行,第10位.
请让我知道我能做些什么才能实现这一目标.
数据样本将是这样的,数据字段可以经常更改,例如可以在第二天添加新字段,因此我没有自由创建.Net类来映射数据.
{
"data": [
{
"ID": "5367ab140026875f70677ab277501bfa",
"name": "Happiness Initiatives - Flow of Communication/Process & Efficiency",
"objCode": "PROJ",
"percentComplete": 100.0,
"plannedCompletionDate": "2014-08-22T17:00:00:000-0400",
"plannedStartDate": "2014-05-05T09:00:00:000-0400",
"priority": 1,
"projectedCompletionDate": "2014-12-05T08:10:21:555-0500",
"status": "CPL"
},
{
"ID": "555f452900c8b845238716dd033cf71b",
"name": "UX Personalization Think Tank and Product Strategy",
"objCode": "PROJ",
"percentComplete": 0.0,
"plannedCompletionDate": "2015-12-01T09:00:00:000-0500",
"plannedStartDate": "2015-05-22T09:00:00:000-0400",
"priority": 1,
"projectedCompletionDate": "2016-01-04T09:00:00:000-0500",
"status": "APR"
},
{
"ID": "528b92020051ab208aef09a4740b1fe9",
"name": "SCL Health System - full Sitecore …我正在呼唤使用Windows身份验证的SOAP服务.这是我的配置:
new BasicHttpBinding
{
Security = new BasicHttpSecurity
{
Mode = BasicHttpSecurityMode.TransportCredentialOnly,
Transport = new HttpTransportSecurity
{
ClientCredentialType = HttpClientCredentialType.Windows
}
},
};
我在这里手动设置凭据,因为用户位于不同的域中:
client.ClientCredentials.Windows.ClientCredential.Domain = "...";
client.ClientCredentials.Windows.ClientCredential.UserName = "...";
client.ClientCredentials.Windows.ClientCredential.Password = "...";
我注意到我通过客户端代理进行的每次通话都会导致三次访问:
Request: POST /EndPoint (no auth)
Response: 401 Unauthorized, WWW-Authenticate: Negotiate
Request: POST /EndPoint, Authorization: Negotiate
Response: 401 Unauthorized, WWW-Authenticate: Negotiate <gunk>
Request: Post /EndPoint, Authorization: Negotiate <gunk>
Response: 200 OK
如果这只发生在第一次调用时它不会那么可怕,但它会发生在对同一客户端代理实例的所有后续调用中.
我呼叫的服务器不在我的控制之下,并且具有不可忽视的延迟,所以我很想找到一种方法来消除这些冗余的旅行.可能吗？
当我使用Assembly.LoadFile方法时,我没有外部访问加载到程序集中的文件,直到我的程序关闭.另一方面,StreamReader允许我在使用该StreamReader.Close()方法完成使用时关闭流.
在使用Assembly.Load时,有什么方法可以做同样的事情吗？
谢谢,
埃文
我正在尝试将一些TPL异步集成到更大的Rx链中Observable.FromAsync,就像在这个小例子中一样:
using System;
using System.Reactive.Linq;
using System.Threading.Tasks;
namespace rxtest
{
class Program
{
static void Main(string[] args)
{
MainAsync().Wait();
}
static async Task MainAsync()
{
await Observable.Generate(new Random(), x => true,
x => x, x => x.Next(250, 500))
.SelectMany((x, idx) => Observable.FromAsync(async ct =>
{
Console.WriteLine("start: " + idx.ToString());
await Task.Delay(x, ct);
Console.WriteLine("finish: " + idx.ToString());
return idx;
}))
.Take(10)
.LastOrDefaultAsync();
}
}
}
但是,我注意到这似乎同时启动所有异步任务,而不是一次启动它们,这会导致应用程序的内存使用量增加.在SelectMany似乎作用并不比不同Merge.
在这里,我看到这样的输出:
start: 0
start: 1
start: 2
...
我想看: …
RegEx从域\用户名获取域名.我尝试了这个,但它返回整个字符串.
/^(.*?)\.\\/
我做错了什么？最终结果应该是域名