小编Pet*_*nks的帖子

尽管这样的问题被多次询问,我仍在努力理解存储库和工作单元模式之间的关系.基本上我还是不明白哪个部分会保存/提交数据更改 - 存储库或工作单元？

由于我看到的每个例子都与使用这些和数据库/ OR映射器有关,所以让我们做一个更有趣的例子 - 让数据保存在数据文件中的文件系统中; 根据模式,我应该能够做到这一点,因为数据的去向与此无关.

所以对于一个基本实体:

public class Account
{
    public int Id { get; set; }
    public string Name { get; set; }
}

我想会使用以下接口:

public interface IAccountRepository
{
     Account Get(int id);
     void Add(Account account);
     void Update(Account account);
     void Remove(Account account);
}

public interface IUnitOfWork
{
    void Save();
}

我认为在使用方面它看起来像这样:

IUnitOfWork unitOfWork = // Create concrete implementation here
IAccountRepository repository = // Create concrete implementation here

// Add a new account
Account account = new Account() …

我想知道我是否可以this在C#lambda中使用关键字,虽然实际上我知道我可以,但我想确保这不是一件坏事或稍后会产生微妙的问题.

阅读了关于lambda的变量范围的规则,我可以看到:

在引用它的委托超出范围之前,捕获的变量不会被垃圾收集.

所以这导致我假设this也会捕获一个对象实例().为了测试这个,我编写了这个人为的例子,这是我想要在我的真实代码中实现的目标 - 用LINQPad编写,因此为什么我有Dump()方法调用:

void Main()
{
    Repository repo = new Repository();
    Person person = repo.GetPerson(1);

    person.ID.Dump("Person ID - Value Assigned");
    person.Name.Dump("Person Name - Lazily Created");
}

class Person
{
    public Person(Lazy<string> name)
    {
        this.name = name;
    }

    public int ID { get; set; }

    private Lazy<string> name;
    public string Name
    {
        get { return name.Value; }
    }
}

class Repository
{
    public Person GetPerson(int id)
    {
        // …

我正在研究任务并行库的用法,用于我正在做的工作项目,并希望了解长时间运行任务的优点/缺点.我还没有现实生活中的例子,只想了解这背后的理论.

从MSDN页面所说的任务调度程序和这个SO问题来看,似乎最好尽可能避免长时间运行的任务,这样你就不会在ThreadPool之外创建线程.但是说你确实有一项任务需要很长时间才能完成,而不是这样:

Task.Factory.StartNew(() => DoTimeConsumingWork(), TaskCreationOptions.LongRunning)

您是否可以尝试将您的工作分成更小,更快的工作单元并使用任务延续,如下所示:

Task.Factory
    .StartNew(() => DoWorkPart1())
    .ContinueWith(t => DoWorkPart2())
    .ContinueWith(t => DoWorkPart3())
    //...etc

这种方法是否会更有益,或者它试图实现的目标是否过度？

我即将开始一个项目,我们有一个后端服务来进行冗长的处理,以便我们的ASP.NET网站可以自由地做更快的请求.因此,我一直在阅读WCF和Web API等服务,以了解他们的工作.由于这种后端服务实际上将由几个彼此通信的服务组成,并且不会公开给我们的客户,因此WCF似乎是这种情况的理想技术.

但经过大量的研究后,我仍然对WCF和Web API之间的好处和差异感到困惑.一般来说,似乎:

• 如果您需要公共和/或RESTful API,那么Web API是最好的
• WCF可以支持比HTTP更多的传输,因此您可以对它们进行更多的控制
• 由于WCF的附加功能/复杂性,Web API开发似乎比WCF更容易

但也许我的问题归结为以下几点:

1. 为什么REST服务会更有益？一个完整的WCF服务是否会成为公共API的好主意？或者,Web API无法提供WCF服务可以提供的任何内容吗？
2. 相反,如果我有许多内部服务需要相互通信并且乐于使用HTTP作为传输,那么Web API是否会突然成为可行的选择？

我正在使用.resx文件本地化WPF应用程序.我创建了Resources.en-US.resx或Resources.cs-CZ.resx等主要资源文件的副本.适用于字符串.但是,我无法弄清楚如何在资源文件中本地化其他文件,如图像或文档.

当我向Resources文件(Resources.en-US.resx或Resources.cs-CZ.resx)添加新图像时,该文件的副本始终复制到/ Resources目录.因此,对于多种语言,一个文件不能有多个版本,因为在一个目录中只能有一个具有相同名称的文件.

理想的解决方案是,如果来自本地化资源的图像将被复制到像/ Resources/en-Us这样的子目录中.在当前条件下,我无法使用.resx文件本地化图像和文档.我有什么想法可以达到这个目的吗？谢谢.

我最近有一种情况,我有一个ASP.NET WebAPI控制器,需要在其action方法中对另一个REST服务执行两个Web请求.我编写了我的代码,将功能完全分离为单独的方法,看起来有点像这个例子:

public class FooController : ApiController
{

    public IHttpActionResult Post(string value)
    {
        var results = PerformWebRequests();
        // Do something else here...
    }

    private IEnumerable<string> PerformWebRequests()
    {
        var result1 = PerformWebRequest("service1/api/foo");
        var result = PerformWebRequest("service2/api/foo");

        return new string[] { result1, result2 };
    }

    private string PerformWebRequest(string api)
    {
        using (HttpClient client = new HttpClient())
        {
            // Call other web API and return value here...
        }
    }

}

因为我使用的HttpClient所有Web请求都必须是异步的.我之前从未使用async/await,因此我开始天真地添加关键字.首先,我将async关键字添加到PerformWebRequest(string api)方法中,然后调用者抱怨该PerformWebRequests()方法必须async也是为了使用await …

我有一个场景来优化我的Web应用程序如何在会话中存储数据并检索它.我应该指出我使用SQL Server作为我的会话存储.

我的场景是我需要存储一个映射到用户会话中字符串值的唯一ID列表供以后使用.我继承的当前代码是使用List<T>带有自定义对象的代码,但我已经可以看到某种字典对于性能来说要好得多.

我已经测试了两个替代方案的想法:

1. Dictionary<int, string>在会话中存储.当我需要返回字符串时,我从会话中获取字典一次,并可以测试字典对象上的每个ID.

2. 由于会话基本上类似于字典本身,因此使用唯一的会话密钥将字符串直接存储在会话中Session["MyString_<id>"] = stringValue".从会话中获取值基本上是反向操作.

我的测试结果显示以下基于我需要做的操作并使用100个字符串:

• 字典 - 4552字节,0.1071秒做操作
• 会话直接 - 4441字节,0.0845秒做操作

从这些结果中我看到我在会话中节省了一些空间(可能是因为我没有得到序列化字典对象的开销)并且从会话中获取值时似乎更快,可能因为字符串更快到反序列化比对象.

所以我的问题是,在会话中存储大量较小的对象而不是一个大的对象是否更好？存储大量较小的物体与一个我没见过的较大物体有什么不利之处吗？

我试图了解多播如何在MSMQ中工作,但我甚至无法接收消息,即使是在同一台机器上也是如此.我显然做错了什么但看不清楚是什么.

这是我在的地方:

我手动创建了一个非事务性专用队列MulticastTest,然后将多播地址设置为234.1.1.1:8001.然后我的测试发送应用程序这样做:

MessageQueue queue = new MessageQueue("FormatName:MULTICAST=234.1.1.1:8001");
queue.Send("Hello World");

这工作,它至少似乎发送我在同一台机器上的传出队列中看到的消息.至少我认为这是正确的,如果不是,请告诉我.

所以现在我尝试运行我的接收应用程序(在同一台机器上或配置为相同多播地址的不同机器上),我无法让它工作.如果我试试这个:

MessageQueue queue = new MessageQueue("FormatName:MULTICAST=234.1.1.1:8001");
var message = queue.Receive();

它根本不起作用,该Receive()方法抛出异常说:

指定的格式名称不支持请求的操作.例如,无法删除直接队列格式名称

如果我尝试设置接收队列,因为.\private$\MulticastTest它至少等待消息但没有任何反应,所有消息仍然保留在传出队列中.

那么我做错了什么？是否需要运行某种服务以便MSMQ从传出队列发送消息？

我也试过根据这个问题向ANONYMOUS USER提供完全权限,但这没有任何影响.

我正在从我们的ASP.NET站点删除我们的电子邮件系统,该站点过去常常通过系统发送电子邮件来处理单独服务中的请求,以减少网站上的工作量.我正在尝试围绕一组接口进行设计,以便我可以根据需要交换实现,但最初它将基于消息队列(MSMQ)将请求发送到队列,让服务接收传入请求然后处理它们.我目前大致定义了以下接口:

// Sends one or more requests to be processed somehow
public interface IRequestSender
{
    void Send(IEnumerable<Request> requests);
}

// Listens for incoming requests and passes them to an observer to do the real work
public interface IRequestListener : IObservable<Request>
{
    void Start();
    void Stop();
}

// Processes a request given to it by a IRequestListener
public interface IRequestProcessor : IObserver<Request>
{
}

您会注意到监听器和处理器使用可观察的模式,因为这是我认为最适合的.

我的问题是弄清楚如何编写IRequestListener从MSMQ接收的实现,基本上我该如何创建一个合适的IObservable<T>？

我找到的第一个选项是IObservable<T>根据MSDN文档给出的示例从头开始创建,但这似乎需要做很多管道工作.

另一个选择是使用Reactive Extensions,因为它似乎旨在使创建observable更容易.我发现最接近使用Rx和MSMQ的是这些页面:

• 使用异步模式(queue.BeginReceive,queue.EndReceive)使用Reactive扩展(Rx)进行MSMQ消息接收
• MSMQ使用Rx - 用于MSMQ的代码片段接收超时问题 …

我正在尝试使用MSMQ,并且可以让发送器/接收器在本地计算机上工作.现在我正在尝试让发件人从另一台机器上工作并将消息发送到远程专用队列,但现在我的发送者说它已经发送了一条消息但是没有收到任何消息 - 或者看起来它已经被发送到了我可以告诉.

我确保它连接到删除专用队列,如下所示:

FormatName:Direct=TCP:ipaddress\private$\TestQueue

其中ipaddress是我的远程机器的正确地址.然后,我可以在计算机管理中看到为此队列创建了传出队列.然而,当我使用Send()方法时,它完成并且什么都不做.传出队列中没有任何内容,并且肯定不会出现在远程计算机上.它也没有任何错误地做到这一点 - 它什么都不做,继续.

我尝试使用这篇文章http://beaucrawford.net/post/MSMQ-ndash3b-Sending-Messages-to-Remote-Queues.aspx添加确认代码但是它确实抛出一个异常,说明找不到请求的消息在确认队列中.

有任何想法吗？在我可以进行分布式消息队列之前是否需要配置？

更新:

发现它与我发送的队列的权限有关.使用下面的答案,我打开了死信排队,找出消息的去向,发现消息被发送到远程专用队列,但访问被拒绝.

String ntohl(int i)
{
    int i1 = i % (256);
    int i2 = (i %(65536))/(256);
    int i3 = (i %(16777216))/(65536);
    int i4 = (i)/(16777216);

    int i5 = i % (2^8);
    int i6 = (i %(2^16))/(2^8);
    int i7 = (i %(2^24))/(2^16);
    int i8 = i/(2^24);

    Log.d(TAG, "i:"+i+"   "+i1+"."+i2+"."+i3+"."+i4);
    Log.d(TAG, "i:"+i+"   "+i5+"."+i6+"."+i7+"."+i8);
    return ""+i1+"."+i2+"."+i3+"."+i4;
}

嗨,

我有一个上面列出的方法,它返回一个ipv4地址.我已经完成了计算,但i5 i6 i7 i8与i1 i2 i3 i4不同.