小编Ale*_*ill的帖子

我正在使用这里提到的模式 http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/implementing-the-repository-and-unit-of-work-patterns-in- AN-ASP净MVC应用程序

我正在使用下面的方法来查询EF

public virtual IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = "")
    {
        IQueryable<TEntity> query = dbSet;

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

现在我想创建动态Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>表达式来订购我的数据.

我只知道字段名称为字符串和顺序类型(升序,降序)为字符串(asc,desc)

我正在使用一个简单的Subject<object>方法在Web应用程序中实现Event Aggregator模式,如下所示:

public class EventAggregator
{
    private readonly ISubject<object, object> _subject = Subject.Synchronize(new Subject<object>());
    public IObservable<T> GetEvent<T>()
    {
        return _subject.AsObservable().OfType<T>();
    }

    public void Publish<TEvent>(TEvent sampleEvent)
    {
        _subject.OnNext(sampleEvent);
    }
}

当运营商或订户抛出异常时,我想记录它然后忽略它并继续发布事件 - 本质上我希望流在某些意外行为的情况下"继续",因为事件聚合器在单个生命周期中具有单个生命周期.申请的背景.

在这个问题中给出的答案是创建一个延迟的可观察和使用Retry(),但我不想在这里冷可观察.

我提出的解决方案是Catch在订阅者方法中使用和try-catch,我将其包含在扩展中:

public static IDisposable SubscribeSwallowExceptions<T>(this IObservable<T> source, Action<T> subscription, Action<Exception> log)
{
    source = source.Catch((Exception e) => { log(e); return source; });

    return source.Subscribe(x =>
    {
        try { subscription(x); }
        catch (Exception e) { log(e); }
    });
}

我知道"catch-all"异常处理通常是不受欢迎的,但在这种情况下,我不确定我有什么其他选项,因为我希望订阅保留,即使抛出异常.我不知道可能会发生什么类型的异常,因为我还不知道在处理流时会做什么工作. …

我理解如何使用类型提供程序从XML源检索数据.但是,我需要修改XML的特定部分并将其保存到磁盘.我已尝试使用<-该属性为只读属性,但该属性是只读的.

例如:

let doc = MyXml.load fileName
doc.ItemId.Id <- "newId" // doesn't work
doc |> saveXml

对于JSON,有一个类似的问题,其中建议是创建一个新对象,但这是专门针对XML的.

我对在IronPython中导入模块的两种方法感到困惑.

一方面,IronPython 2.7.4附带的教程文档声明您可以使用常规import语法来完成:

import System
from System import Xml

这可以像我期望的那样工作.

另一方面,互联网上的许多资源都表示导入模块的方法是使用如下clr模块:

import clr
clr.AddReference("System.Xml")

这两种方法有什么区别？

我正在寻找一种不间断动态合并数据源的方法.现实世界的情况是在不考虑冗余信息的情况下从多个来源获取数据.

为了简化代码,我用一个简单的数字生成器替换了更复杂的代码,它将持续生成数据.这可以比较来自多个外部服务器的连续数据流.

我希望能够合并两个源并将结果(在适当的时候)打印到控制台,这部分非常有用.当我们终止这两个源并在另一个源中合并时,事情就会按预期停止工作.在这种情况下,我们可以轻松地重新连接mergedStreamObserver,但是,在更大的应用程序中,我们必须关注数据中的差距以及跟踪Observers订阅的内容.

有没有解决的办法？

// imports
using System;
using System.Reactive.Linq;
using System.Threading;
using System.Threading.Tasks;

static void Main(string[] args) {
    // base "stream of results" as we will want to randomly add (and terminate other sources)
    IObservable<int> merged = Observable.Empty<int>();

    // source 1
    var tokenSource1 = new CancellationTokenSource();
    IObservable<int> xs = Generate(tokenSource1, "A");

    // to avoid generating the same numbers, which does happen,
    // sleep some amount of time before calling generate again
    Thread.Sleep(100);

    // source 2
    var tokenSource2 = new …

我已经配置了resolve几个路由的参数来返回一个promise,以便延迟控制器的实例化,直到解析了promise.目前我正在使用函数表示法,而不是指定要注入的字符串.

例如:

.when('/article/:id', {
    templateUrl: 'app/article/article.html',
    controller: 'ArticleController',
    resolve: {
        article: ['Content', '$route', function (Content, $route) {
            return Content.get({ contentId: $route.current.params.id }).$promise;
        }]
    }
})

该article参数是正确与解决承诺值注入.

但是,我想保持DRY并通过指定字符串来注入此值,如文档中所述.

当我设置工厂函数来提供这样的承诺时,实例只能正确注入一次(第一次).此后,使用相同的promise,因为AngularJS注入服务已缓存该实例.

.factory('contentPromise', ['Content', '$route', function (Content, $route) {
    return Content.get({ contentId: $route.current.params.id }).$promise;
}])

是否可以指定每次请求时都必须运行工厂功能？或者以其他方式实现我的目标？

我想应用一个常规函数,它接受一个元组的两个参数.我定义了一个辅助函数,如下所示:

let apply f (a, b) =
    f a b

但是我觉得这必须是一个相当常见的用例,并想知道它是否是标准库中的一个函数(我不确定要搜索的是什么术语)

我的Service类(在ASP.NET MVC应用程序中)中的当前检索模式如下所示:

public Client Get(int id)
{
    using (var repo = _repoFactory.Get<Client>())
    {
        return repo.Get(id);
    }
}

当_repoFactory.Get<T>()返回贮藏库,配置时,还部署了实体框架DbContext;

但是,当Get(int id)方法的使用者需要在Client对象上使用导航属性时,会抛出异常,因为已经处理了上下文.

我可以预见几种方法来协商这个问题:

• 不要在服务之外使用导航属性
• 不要使用延迟加载导航属性
• 找到一些在请求完成时处理上下文的方法

什么是"正确"(或最不正确)的方式以及如何实现？

我想将一个函数应用于同构元组的两个成员,从而产生另一个元组.继我之前的问题之后,我定义了一个对我来说似乎有意义的运算符:

let (||>>) (a,b) f = f a, f b

但是,我觉得这可能是一个常见的用例,但在标准库中找不到它.它存在吗？

我正在尝试使用Entity Framework MetadataWorkspace来计算导航属性的ID外键.我的模型看起来像这样:

public class Person
{
    [Key]
    public int PersonId { get; set; }

    public int AddressId { get; set; }
    public virtual Address Address { get; set; }
}

public class Address
{
    public Address()
    {
        People = new HashSet<Person>();
    }

    [Key]
    public int AddressId { get; set; }

    public virtual ICollection<Person> People { get; set; }
}

class PersonDbContext : DbContext
{
    public DbSet<Person> People { get; set; }
    public DbSet<Address> Addresses { get; set; } …