小编Dav*_*ier的帖子

在应用Scrum时，产品待办事项是用户案例。我在TFS上创建了一个示例故事，如下所示：

作为用户，我可以注册系统。

然后，我创建了以下任务：

1. 应该准备一个登录表格。
2. 用户应填写表格上的所有字段。
3. 用户应输入有效的格式化电子邮件。
4. 用户密码之间必须匹配。
5. 如果用户成功填写表格，请发送验证电子邮件。

有些任务是前端（HTML，CSS等），有些是后端（发送电子邮件等）。

1. 我应该将前端任务和后端任务彼此分开吗？我应该将它们分为不同的用户故事吗？
2. 任务可以由不同的开发人员执行吗？

我想知道是否可以同时在多个功能分支上处理 Maven 项目，并避免不断覆盖 Nexus 中其他功能分支产生的工件。

我正在一个跨国项目中工作，该项目使用 gitflow 工作流来开发多个组件（30+）。每个组件都有一个 git 存储库，因此 gitflow 工作流应用于每个组件。所以每个组件都有一个开发和几个功能分支。通常，每个组件产生至少一种由其 GAV 识别的人工制品。

假设我们有组件 A（带有特征分支 feature/A-foo 和 feature/A-bar）和 B（带有特征分支 feature/B-foo）

Component A:
A:develop
A:feature/A-foo
A:feature/A-bar

Component B:
B:develop
B:feature/B-foo

A:feature/A-foo 和 B:feature/B-foo 工作在同一个主题上，需要交换快照版本以测试它们的交互（例如客户端/服务器功能）。组件 A 和 B 只能通过 Nexus 交换工件（无法访问其他组件的源代码）。因此，A:feature/A-foo 必须部署其快照工件以使其可用于 B:feature/B-foo，反之亦然。

但是当 A:feature/A-bar（适用于完全不同的主题）之后部署时，由于相同的 GAV 和更新的时间戳，它会“覆盖”Nexus 中的快照工件，并且 B:feature/B-foo 将导入在其下一个构建中出现错误的工件。

一种解决方案是使用功能名称（例如 foo）扩展 GAV：

some.company.componentA-1.2.3-foo.jar
some.company.componentA-1.2.3-bar.jar
some.company.componentB-3.2.1-foo.jar

通过这种方式，您可以避免 A:feature/A-foo 覆盖 A:feature/B-bar 的工件，因为它们具有不同的 GAV。但这非常容易出错（在分支时重命名 GAV，再次合并到开发时将其重命名；如果有人忘记重命名，它会搞乱构建）。

有没有更好的解决办法？还是应该禁止在功能分支上部署？

我目前正在重构一些代码以使其更易于测试.具体来说,我正在提取几个类的接口,以便轻松创建测试双精度.

我想保持公共接口与此代码相同,在原始类之后命名接口.

然而,这给我留下了什么称为原始类的问题.

我正在使用C++.

如果我的界面是:

class ServiceClient;

我应该怎么称呼这个版本,我想出了一些我不相信的选择:

class ConcreteServiceClient;
class ServiceClientImpl;
class StandardServiceClient;
class BasicServiceClient;

人们使用哪些约定？

我想创建一个插件架构,我可以将程序集API限制为非常有限的东西,即只允许函数白名单.是否可以限制插件组件可以调用的功能/方法？我可以使用AppDomains吗？

有没有人有一个简单的例子？

我正在尝试使用stl算法for_each而不会在我的代码中扩散模板.std :: for_each想要按值实例化MyFunctor类,但它不能自抽象.我已经创建了一个functor适配器类,它传递一个指针,然后在适当时将其转发.

我的问题:

STL或Boost是否已经有这样的适配器类？我不想重新发明轮子!

 struct MyFunctor  {
     virtual ~MyFunctor() {}
     virtual void operator()(int a) = 0; 
 }

 namespace {
     template<typename FunctorType, typename OperandType> struct
 FunctorAdapter
     {
         FunctorAdapter(FunctorType* functor) : mFunctor(functor) {}
         void operator()(OperandType& subject)
         {
             (*mFunctor)(subject);
         }

         FunctorType* mFunctor;
     }; }

 void applyToAll(MyFunctor &f) {
     FunctorHelper<MyFunctor, int> tmp(&f);
     std::for_each(myvector.begin(), myvector.end(), tmp); }

干杯,

戴夫

我正在开发一个项目,该项目使用代码生成来使用基于文本的描述中的命令行工具生成C#类.我们将开始使用这些javascript描述.

目前生成这些类然后签入,但是,我希望能够自动生成代码,以便将任何更改传播到两个版本.

手动运行的步骤是:

servicegen.exe -i:MyService.txt -o:MyService.cs

当我构建时,我希望MSBuild/VS首先生成CS文件然后编译它.可以通过修改csproj,或许使用MSBuild任务来实现这一点Exec,DependentUpon&AutoGen？

我有一个发送GET请求的方法,如下所示:

private JArray GetRESTData(string uri)
{
    try
    {
        var webRequest = (HttpWebRequest)WebRequest.Create(uri);
        var webResponse = (HttpWebResponse)webRequest.GetResponse();
        var reader = new StreamReader(webResponse.GetResponseStream());
        string s = reader.ReadToEnd();
        return JsonConvert.DeserializeObject<JArray>(s);
    }
    catch // This method crashes if only one json "record" is found - try this:
    {
        try
        {
            MessageBox.Show(GetScalarVal(uri));
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }
    return null;
}

...我通过在webRequest和webResponse的赋值之间加入来修改它来处理POST请求:

if (uri.ToUpper().Contains("POST"))
{
    webRequest.Method = "POST";
    webRequest.ContentLength = 0;
}

...并将其重命名为GetOrPostRESTData()

但这违反了单一责任原则.

然而,如果我将它变成两个方法,POST方法与GET方法相同,除了条件中另外两行代码("if Post")之外,我违反了DRY,大部分代码都是一样的.

还有第三种方式吗？中途？或者我必须在这两种违规行为中做出选择 我被困在DRY和SOLID之间.

我正在尝试用C#实现一个消费者.有许多发布者可以同时执行.我创建了三个示例,一个使用Rx和subject,一个使用BlockingCollection,第三个使用BlockingCollection中的ToObservable.在这个简单的例子中,它们都做同样的事情,我希望它们与多个生产者一起工作.

每种方法有哪些不同的特质？

我已经在使用Rx,所以我更喜欢这种方法.但我担心OnNext没有线程安全保证,我不知道排队语义是什么主题和默认调度程序.

有线程安全主题吗？

是否要处理所有消息？

当这不起作用时还有其他任何情况吗？是同时处理？

void SubjectOnDefaultScheduler()
{
    var observable = new Subject<long>();
    observable.
        ObserveOn(Scheduler.Default).
        Subscribe(i => { DoWork(i); });
    observable.OnNext(1);
    observable.OnNext(2);
    observable.OnNext(3);
}

不是Rx,但很容易适应使用/订阅它.它需要一个项目然后处理它.这应该是连续发生的.

void BlockingCollectionAndConsumingTask()
{
    var blockingCollection = new BlockingCollection<long>();
    var taskFactory = new TaskFactory();
    taskFactory.StartNew(() =>
    {
        foreach (var i in blockingCollection.GetConsumingEnumerable())
        {
            DoWork(i);
        }
    });
    blockingCollection.Add(1);
    blockingCollection.Add(2);
    blockingCollection.Add(3);
}

使用阻塞集合有点像主题似乎是一个很好的妥协.我猜是隐式地会安排到任务,所以我可以使用async/await,这是正确的吗？

void BlockingCollectionToObservable()
{
    var blockingCollection = new BlockingCollection<long>();
    blockingCollection.
        GetConsumingEnumerable().
        ToObservable(Scheduler.Default).
        Subscribe(i => { DoWork(i); });
    blockingCollection.Add(1);
    blockingCollection.Add(2);
    blockingCollection.Add(3);
}

如何从List<T>C#中删除对象并返回删除的对象？

是否RemoveAt会破坏物体？我是否需要首先制作对象的深层副本然后调用RemoveAt？

我正在尝试将 Javascript 项目移植到 Typescript。我有一个名为如下的依赖项：@myscope/utils

来自此的文件被导入到 ts 文件中，如下所示：

import date = require('@myscope/utils/date');

当我尝试编译它时，出现以下错误：

src/subfolder/something.ts(12,23): error TS2307: Cannot find module '@myscope/utils/date'.

如何为这样的私有模块添加自己的类型？

今天我在使用参考文献时看到了非常奇怪的事情.

只是一个简单的例子:

#include <iostream>

struct Base {
  enum Type {
    FOO = 0,
    BAR = 1
  };
  virtual ~Base() {}
  virtual Type type() const = 0;
  int value_;
};

struct Foo : Base { 
    Foo() { value_ = 33; }
    virtual Type type() const { return FOO; }
};

struct Bar : Base { 
    Bar() { value_ = 44; }
    virtual Type type() const { return BAR; }
};

int main() {
    Foo foo;
    Bar bar;
    Base & b = …

我有3个代码文件,我想从构造函数中打印"刚刚创建的山脉".你能告诉我我错在哪里以及我必须做什么吗？

Mountains.h

#ifndef MOUNTAINS_H
#define MOUNTAINS_H

class Mountains{
    public:
        Mountains();
        ~Mountains();
};
#endif

Mountains.cpp

#include <cstdlib>
#include <iostream>
#include "Mountains.h"

Mountains::Mountains()
{
    cout<<"Mountains were just created"<<endl;
}

Mountains::~Mountains()
{
    cout<<"Mountains are about to be destroyed"<<endl;
}

main.cpp中

#include <cstdlib>
#include <iostream>
#include "Mountains.h"


int main(int argc, char *argv[])
{

    Mountains m();

    system("PAUSE");
    return EXIT_SUCCESS;
}

我希望,"山脉刚刚被创建",当我打电话时写入控制台Mountains m();这不会发生.