小编Jes*_*ter的帖子

我正在使用Entity Framework 6处理一些Web API,我的一个控制器方法是"Get All",它希望从我的数据库接收表的内容IQueryable<Entity>.在我的存储库中,我想知道是否有任何有利的理由以异步方式执行此操作,因为我不熟悉使用EF与异步.

基本上归结为

 public async Task<IQueryable<URL>> GetAllUrlsAsync()
 {
    var urls = await context.Urls.ToListAsync();
    return urls.AsQueryable();
 }

VS

 public IQueryable<URL> GetAllUrls()
 {
    return context.Urls.AsQueryable();
 }

异步版本实际上是否会在这里产生性能优势,或者我是通过首先投射到List(使用async mind you)然后转向IQueryable而产生不必要的开销？

我想知道是否有一种简洁而准确的方法来提取十进制值中的小数位数(作为int),可以安全地在不同的文化信息中使用？

例如:
19.0应该返回
1,27.5999应该返回4,19.12
应该返回2,
等等.

我写了一个查询,在一个句点上执行字符串拆分以查找小数位:

int priceDecimalPlaces = price.ToString().Split('.').Count() > 1 
                  ? price.ToString().Split('.').ToList().ElementAt(1).Length 
                  : 0;

但我发现这只适用于使用'.'的地区.作为小数分隔符,因此在不同系统中非常脆弱.

我想知道是否有人可以向我解释一下编译器可能正在为我做些什么来观察一个简单方法的性能差异.

 public static uint CalculateCheckSum(string str) { 
    char[] charArray = str.ToCharArray();
    uint checkSum = 0;
    foreach (char c in charArray) {
        checkSum += c;
    }
    return checkSum % 256;
 }

我正在与一位同事一起为消息处理应用程序做一些基准测试/优化.在Visual Studio 2012中使用相同的输入字符串执行此功能的1000万次迭代大约需要25秒,但是当使用"优化代码"选项构建项目时,打开相同的代码,在7秒内执行相同的1000万次迭代.

我非常有兴趣了解编译器在幕后做了什么,以便能够看到像这样看似无辜的代码块的性能提升超过3倍.

根据要求,这是一个完整的控制台应用程序,演示我所看到的.

class Program
{
    public static uint CalculateCheckSum(string str)
    {
        char[] charArray = str.ToCharArray();
        uint checkSum = 0;
        foreach (char c in charArray)
        {
            checkSum += c;
        }
        return checkSum % 256;
    }

    static void Main(string[] args)
    {
        string stringToCount = "8=FIX.4.29=15135=D49=SFS56=TOMW34=11752=20101201-03:03:03.2321=DEMO=DG00121=155=IBM54=138=10040=160=20101201-03:03:03.23244=10.059=0100=ARCA10=246";
        Stopwatch stopwatch = Stopwatch.StartNew(); …

我是AutoFac的新手,目前我在app app中使用自定义模块来启动一些核心F#系统.我正在使用的代码是

var builder = new ContainerBuilder();
builder.RegisterType<DefaultLogger>().As<IDefaultLogger>();
builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
builder.Build();

在我的app配置中,我有适当的逻辑来启动相关系统.我想访问我的模块中的DefaultLogger.Module基类的元数据有以下选项可供我使用:

protected virtual void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration);

protected virtual void AttachToRegistrationSource(IComponentRegistry componentRegistry, IRegistrationSource registrationSource);

public void Configure(IComponentRegistry componentRegistry);

protected virtual void Load(ContainerBuilder builder);

到目前为止我只使用Load,我在构建器上看不到任何允许我进入日志记录服务的方法.

我在今天之前从未遇到过这个问题,并且想知道实现这种行为的惯例/最佳实践是什么.

基本设置是这样的:

public interface IDispatch {
    void Dispatch();
}

public class Foo : IDispatch {
    void IDispatch.Dispatch() {
        DoSomething();
    }
}

public class Bar : Foo {
     ...
}

Bar需要子类化Foo,因为它与Bar共享所有相同的属性,并引入了我需要遇到的2个新属性.我遇到的问题是Foo还需要稍微不同的Dispatch()实现.通常它会被覆盖,但这对于接口方法无效,所以只需要Bar实现IDispatch就可以了,所以我的类定义如下所示:

public class Bar : Foo, IDispatch { .... }

然后只是在Bar中明确实现该接口方法？当我尝试这样做时,我的编译器似乎没有抱怨,但我不确定它是否会导致任何运行时问题,从而解决在未来使用哪种实现或者是否有更好的方法来完成这样的事情.

另外值得一提的是,在我的工作场所,我们使用UML模型中的代码生成,强制所有类设计必须首先从模型完成.代码生成工具是导致接口方法被明确实现的原因(不想辩论它的优点和缺点,这正是我现在被迫处理的事情,因此隐式实现不是一个选项)

我最近在Reactive Framework上做了一些工作,到目前为止我一直非常喜欢它.我正在寻找用一些过滤的IObservable替换传统的轮询消息队列来清理我的服务器操作.以旧的方式,我处理进入服务器的消息,如下所示:

// Start spinning the process message loop
   Task.Factory.StartNew(() =>
   {
       while (true)
       {
           Command command = m_CommandQueue.Take();
           ProcessMessage(command);
       }
   }, TaskCreationOptions.LongRunning);

这导致连续轮询线程将命令从客户端委托给ProcessMessage方法,其中我有一系列if/else-if语句,用于确定命令的类型并根据其类型委派工作

我用一个使用Reactive的事件驱动系统替换它,我已经编写了以下代码:

 private BlockingCollection<BesiegedMessage> m_MessageQueue = new BlockingCollection<BesiegedMessage>();
 private IObservable<BesiegedMessage> m_MessagePublisher;

 m_MessagePublisher = m_MessageQueue
       .GetConsumingEnumerable()
       .ToObservable(TaskPoolScheduler.Default);

        // All generic Server messages (containing no properties) will be processed here
 IDisposable genericServerMessageSubscriber = m_MessagePublisher
       .Where(message => message is GenericServerMessage)
       .Subscribe(message =>
       {
           // do something with the generic server message here
       }

我的问题是,虽然这有效,但是使用阻塞集合作为这样的IObservable的支持是一种好习惯吗？我没有看到Take()被称为这样的方式,这让我觉得消息将在队列中堆积而不会在处理后被删除？

将Subjects作为支持集合来驱动过滤后的IObservables来获取这些消息会更有效吗？还有什么我在这里缺少可能有益于这个系统架构的东西吗？

晚安，我正在与 ag-grid 合作开发一个 React 项目。我创建了一个用户可以启用列可见性的组件，到目前为止一切顺利，运行完美。但是，当运行函数设置所有列的可见性时，会出现标题中提到的错误。执行此操作的函数如下。但另一点是，只有在启用了reactUi={true}时才会发生这种情况，如果禁用它则可以正常工作。

 const handleOnChange = (e, i) => {
    var columnApi = props.columnApi;
    columnApi.setColumnVisible(e.target.value, e.target.checked);
  };

  const handleAllChange = (e) => {
    var columnApi = props.columnApi;
    for (let index = 0; index < columns.length; index++) {
      columnApi.setColumnVisible(columns[index].colId, e.target.checked);
    }
  };

我正在开发一个Web API项目,该项目使用Azure的托管缓存服务将数据库结果缓存到内存中,以缩短响应时间并减轻数据库的重复流量.尝试在缓存中放入新项时,有时会抛出特定于缓存的异常,代码为DataCacheErrorCode.RetryLater.当然,为了以后重试而不需要阻止这种方法,我做了它async并await Task.Delay在稍后再试一次.以前,开发人员已经Thread.Sleep在那里硬编码,这确实会损害应用程序性能.

方法签名看起来与此类似:

public static async Task Put(string cacheKey, object obj)

在此更改之后,我从应用程序中的所有其他位置获得~75个编译器警告,这些警告调用以前的同步版本Put指示:

因为不等待该调用,所以在调用完成之前继续执行当前方法.考虑将'await'运算符应用于调用的结果.

在这种情况下,由于Put没有返回任何内容,因此我有理由让这个操作发生故障,因为我没有看到任何理由阻止执行调用它的方法.我只是想知道是否存在任何危险或陷阱,Task因为Put可以经常调用在后台运行许多这些即发即弃的操作.或者我应该等待,因为99%的时间我不会得到重试错误,并且Task几乎立即完成.我只是想确保我没有因为有太多线程(或类似的东西)而受到任何处罚.

我正在一个执行一系列验证检查的方法内部工作,如果这些检查中的任何一个检查失败,它会调用Action<string>运行一些常见的拒绝代码.设置类似于:

public void ValidationMethod() {
    Action<string> rejectionRoutine = (rejectionDescription) => {
        // do something with the reject description
        // other common code
    };

    if (condition != requiredValue) {
        rejectionRoutine("Condition check failed");
        // I currently have to put `return` here following every failed check
    }

    // many more checks following this
}

在这个系统中,一旦检查验证失败,我就不需要验证其余部分,我只想在Action中运行公共拒绝代码并退出方法.目前为了做到这一点,我只是return在接下来的一行电话之后rejectionRoutine.我想知道是否有一种方法可以合并从内部返回或终止父方法执行的能力Action？

我知道这有点挑剔,但我觉得如果其他人需要添加额外的验证检查(他们不必担心将回报全部放在地方),那么在未来的路上可扩展性会更好作为封装在这些情况下应该是常见的代码内部结束执行的常见行为.

我正在编写一个简单的方法来计算小数值中的小数位数.该方法如下所示:

public int GetDecimalPlaces(decimal decimalNumber) { 
try {
    int decimalPlaces = 1;
    double powers = 10.0;
    if (decimalNumber > 0.0m) {
        while (((double)decimalNumber * powers) % 1 != 0.0) {
            powers *= 10.0;
            ++decimalPlaces;
        }
    }
    return decimalPlaces;

我已经针对一些测试值运行它以确保一切正常但是在最后一个上得到了一些非常奇怪的行为:

int test = GetDecimalPlaces(0.1m);
int test2 = GetDecimalPlaces(0.01m);
int test3 = GetDecimalPlaces(0.001m);
int test4 = GetDecimalPlaces(0.0000000001m);
int test5 = GetDecimalPlaces(0.00000000010000000001m);
int test6 = GetDecimalPlaces(0.0000000001000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001m);

测试1-5工作正常,但test6返回23.我知道传入的值超过了最大小数精度,但为什么23？我发现奇怪的另一件事是当我在来自test6的调用之后在GetDecimalPlaces方法中放置一个断点时,方法中的decimalNumber的值来自test5(20个小数位)的相同值,即使该值传入有20个小数位23返回.

也许只是因为我传递了一个数字,这个数字有太多的小数位并且事情变得不稳定但我想确保我不会遗漏一些根本错误的东西,这可能会导致其他值的计算失败路.