标签: factory

我有ac#struct,我需要禁止在其上调用no args构造函数.

MyStruct a;
/// init a by members   // OK
MyStruct b = MyStruct.Fact(args); // OK, inits by memebers

MyStruct s = new MyStruct(); // can't have that

我这样做主要是为所有成员强制explicet值,因为没有有效的默认值,并且所有成员必须具有有效值.

在C++中,这很容易,添加一个私有构造函数,但c#不允许这样做.

有没有办法防止上述情况？

我真的需要强制使用工厂,因此阻止所有公共构造函数调用也会起作用.

完整的披露:为了避免单声道依赖,c#app会被自动转换为D,new Struct()从而产生一个指针,这对我来说很糟糕.然而,这个问题是相关的,尽管如此,请忽略它.

我有"工厂"设计模式实现的以下代码.

class Pen{
public:
     virtual void Draw() = 0;
};

class RedPen : public Pen{
public:
     virtual void Draw(){
         cout << "Drawing with red pen" << endl;
     }
};

class BluePen : public Pen{
public:
     virtual void Draw(){
         cout << "Drawing with blue pen" << endl;
     }
};

auto_ptr<Pen> createPen(const std::string color){
     if(color == "red")
         return auto_ptr<Pen>(new RedPen);
     else if(color == "blue")
         return auto_ptr<Pen>(new BluePen);
}

但我听说可以使用"C++模板"以更好的方式完成.任何人都可以帮助它如何完成以及模板方法如何比这更好？

有什么想法吗

所以,谈到工厂的主题,我想知道他们是如何建立的.

从我的立场,我可以看到3种类型的工厂:

一体

一个工厂,基本上包含应用程序中使用的所有类.感觉它只是为了拥有一个工厂而拥有一个工厂,而且并不真正感觉有条理.

示例(其中ClassA,Class B和ClassC没有任何共同之处,除非在同一个App中):

class Factory
{
 public static function buildClassA()
 public static function buildClassB()
 public static function buildClassC()
}

^{提供的代码示例使用PHP.但是,这个问题与语言无关.}

内置工厂

下一个是将静态函数与常规函数混合,以便创建特殊的创建模式(请参阅此问题)

例:

class ClassA
{
 public static function buildClass()
 public function __construct()
}

工厂在旁边

我能想到的最后一个是为个别班级或个别班级设立工厂.这似乎可变,以统一的方式使用.

示例(其中ClassA,B和C相关,并且1,2和3相关):

class FactoryAlpha
{
 public static function buildClassA()
 public static function buildClassB()
 public static function buildClassC()
}

class FactoryNumeric
{
 public static function buildClass1()
 public static function buildClass2()
 public static function buildClass3()
}

我的问题是:所有这些糟糕的想法,其中任何一个都是坏主意吗？还有其他创建工厂的方法吗？这些中的任何一个都是好主意吗？什么是创建工厂的好/最佳方式.

任何人都可以指点我如何使用ANSI C实现工厂模式？如果覆盖更多的模式,那将只是一个奖励.在C++中这样做对我来说是微不足道的,但由于C没有类和多态,我不太清楚如何做到这一点.我正在考虑使用所有常见数据类型的"基础"结构,然后使用void指针,并按照与顶部基础结构相同的顺序定义结构的所有公共部分？或者不能保证它们在内存中以相同的方式结束？

我有一个奇怪的问题.我正在使用工厂注册模式,它在内部引用std :: map.我正在将这种方法用于多个组件,并且在不同的编译单元(即.cpp文件)中的多个点处进行注册.这发生在静态变量初始化时(在调用'main'之前).出于一些奇怪的原因,我指的是一个段错误

map[key] = value;

(基本上当我注册一个特定的pfn时).现在,如果我在同一个编译单元中移动特定麻烦组件的注册,一切正常.再说一遍,如果我只撤回一个组件的注册,我会得到一个段错误.

我不得不说,这不是我第一次使用这种模式,它适用于其他组件的相同可执行文件(即,在初始化时没有问题的情况下,在另一个工厂类型的多个.cpp上传播的组件使用基本相似的源代码) .

我该怎么办？现在我已经将组件的注册保留在同一个.cpp中(并且它可以完美地工作).我怎样才能更好地调查？

我正在使用g ++(Ubuntu/Linaro 4.4.4-14ubuntu5)4.4.5

在stacktrace下面

0x00007ffff793da1a in std::_Rb_tree_decrement(std::_Rb_tree_node_base*) () from /usr/lib/libstdc++.so.6
(gdb) bt
#0  0x00007ffff793da1a in std::_Rb_tree_decrement(std::_Rb_tree_node_base*) () from /usr/lib/libstdc++.so.6
#1  0x0000000000413fe9 in std::_Rb_tree_iterator, std::allocator > const, http::servlet* (*)()> >::operator-- (
    this=0x7fffffffdff0) at /usr/include/c++/4.4/bits/stl_tree.h:199
#2  0x000000000041379d in std::_Rb_tree, std::allocator >, std::pair, std::allocator > const, http::servlet* (*)()>, std::_Select1st, std::allocator > const, http::servlet* (*)()> >, std::less, std::allocator > >, std::allocator, std::allocator > const, http::servlet* (*)()> > >::_M_insert_unique (this=0x632a20, __v=...) at /usr/include/c++/4.4/bits/stl_tree.h:1179
#3  0x00000000004125f2 in std::_Rb_tree, std::allocator >, std::pair, …

我有3个班B,C,D,从一个基类派生A:

class A
{
// body
};

class B : public A
{
// body
};

class C : public A
{
// body
};

class D : public A
{
// body
};

我想创建一个工厂函数,让我创建特定类型(B,C或D)的对象,并将其作为指向A类的指针返回:

typedef std::shared_ptr<A> a_ptr;

a_ptr createObject(int type)
{
    switch(type)
    {
    case 0:
        return a_ptr(new B());
    break;
    case 1:
        return a_ptr(new C());
    break;
    case 2:
        return a_ptr(new D());
    break;
    }
} …

在过去的几周里,我一遍又一遍地遇到同样的问题.归结为它的核心,我构建了一个(有向无环)对象层次结构,如:

• a -> c
• b -> c
• b -> d

一个实例可以有多个父项和多个子项.c可能是读者和作家之间共享的价值.b可能是一个复合值.层次结构很容易由工厂创建 - 例如a.setChild(new C()).后来,客户只关心根,对她称getValue()或setValue().

我的问题是:谁清理了层次结构？谁负责调用delete上b还是c？

1. 选项 - 工厂创建节点,工厂必须删除节点: 我不喜欢这个选项,因为我理解工厂作为替代new.保持工厂直到它创建的实例可以被销毁,这感觉很奇怪.

2. 选项 - "智能"指针: 不太好,因为它污染了界面,并为诸如指针之类的简单事物引入了很多复杂性.

3. 选项-任何内存管理的曲线状类: 该类收集的所有节点a,b,c,d,...,并提供访问根.节点本身相互引用,但不删除子节点或父节点.如果"图形"或复合管理器被销毁,它将销毁所有节点.

我更喜欢最后一个选项.然而,它使层次结构的构造复杂化.您可以在外部构建层次结构,并告诉图表每个节点,或者在图形内部构建层次结构,这类似于选项1.图表只能删除,它知道什么.因此,如果必须将节点传递给图形,则设计中会出现内存泄漏.

有这个问题的模式吗？您更喜欢哪种策略？

编辑1 - 2014年9月1日:抱歉,对于智能指针没有特别说明.我试图避免另一个"何时使用智能指针问题",而是将问题集中在替代解决方案上.但是,我愿意使用智能指针,如果它们确实是最好的选择(或者如果必要的话).

在我看来,签名setChild(C* child)应该是首选,setChild(std::shared_ptr<C> child)原因与每个循环应优先于迭代器相同.但是,我必须承认,像std:string共享指针一样,它的语义更具体.

就复杂性而言,现在节点内的每个操作都必须处理共享指针.std::vector<C*>变得std::vector< std::shared_ptr<C> >,...此外,每个指针都带有一个引用计数,如果有其他选项可以避免.

我应该补充一点,我开发了一个实时系统的低级部分.它不是固件而是关闭.

编辑2 - 2014年9月1日: 感谢您的所有意见.我的具体问题是:我得到一个字节数组,让我们说传感器数据.在某些时候,我被告知哪个值写在该数组中的哪个位置.一方面,我想要从数组中的位置到原始值(int32,double,...)的映射.另一方面,我想将原始值合并到复杂类型(结构,向量,......).不幸的是,并非所有映射都是双向的.例如.我可以读取值之间的比较,但我不能根据比较结果写入值.因此,我将读者和作者分开,并在必要时让他们访问相同的值.

我正在使用angularjs,在后端我检查每个api身份验证.每个请求都应该检查参数access_token.

$provide.factory('MyHttpInterceptor', function($q, $location, $localStorage) {
    return {
        request : function(config) {
            config.params = config.params || {};
            if ($localStorage.access_token) {
                config.params.access_token = $localStorage.access_token;
            }
            return config || $q.when(config);
        },
    };
});

// Add the interceptor to the $httpProvider.
$httpProvider.interceptors.push('MyHttpInterceptor'); 

我用这个代码.它工作得很好,但我在开发工具(网络)中看到html,css,js文件也添加了参数.喜欢.

http://localhost/webapp/views/template/left-menu.html?access_token=xxxxxxxxxxxxxxxxx
http://localhost/webapp/css/index.css?access_token=xxxxxxxxxxxxxxxxx

但我不喜欢将access_token发送到所有http请求(html,css,js).

我喜欢发送带有前缀api的access_token

http://localhost:9090/api/user/get?access_token=xxxxxxxxxxxxxxxxxxxxxx

//I think the solution is find the http url and grep the text api, if found means add the parameter. Don't konw this is good approach.

Please me the good approach.

我只期望只有后端api请求.另外,我不希望每个严格的http请求添加参数.

可以在config中添加常见的一个位置吗？

假设您具有以下相关的Django模型：

class Service:
   restaurant = models.ForeignKey(Restaurant)
   hist_day_period = models.ForeignKey(DayPeriod)

class DayPeriod:
   restaurant = models.ForeignKey(Restaurant)

我想Service使用Factory 创建一个对象。它应该创建所有3个模型，但使用同一家餐厅。

使用此代码：

class ServiceFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Service

    restaurant = factory.SubFactory('restaurants.factories.RestaurantFactory')

    hist_day_period = factory.SubFactory(
        'day_periods.factories.DayPeriodFactory', restaurant=restaurant)

工厂男孩将创建2家不同的餐厅：

s1 = ServiceFactory.create()
s1.restaurant == s1.hist_day_period.restaurant
>>> False

关于如何执行此操作的任何想法？我不清楚我是否应该使用related factors而不是SubFactory完成此操作。

Laravel 5.7工厂发生了什么？当我在工厂上运行php artisan tinker它工作正常.但是当我在单元测试中使用它时会抛出一个错误:

Unable to locate factory with name [default] [App\User]

这是我的单元测试

<?php

namespace Tests\Unit;

use Tests\TestCase;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use \App\User;

class UserTest extends TestCase
{
    use DatabaseTransactions;

    public function setUp()
    {
        $this->user = factory(User::class, 1)->create()->first();
    }

    /**
     * @test
     */
    public function a_sample_test()
    {
        $this->assertTrue(!empty($this->user));

    }
}

并且UserFactory是通过运行生成的 php artisan make:factory UserFactory --model=User

这是我的用户/数据库/工厂的工​​厂

<?php

use Faker\Generator as Faker;

$factory->define(\App\User::class, function (Faker $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail, …