标签: code-design

每次我写一个带有表示选项的布尔参数的方法时,我发现自己在想:"我应该用枚举来替换它,这会使读取方法调用变得更容易吗？".

考虑以下一个对象,它接受一个参数来判断实现是否应该使用它的线程安全版本(我不是在这里问这样做这样做是不是好的设计,只是使用了布尔值):

public void CreateSomeObject(bool makeThreadSafe);
CreateSomeObject(true);

当调用在声明旁边时,参数的目的当然显而易见.当它在一些你几乎不知道的第三方库中时,很难立即看到代码的作用,相比之下:

public enum CreationOptions { None, MakeThreadSafe }
public void CreateSomeObject(CreationOptions options);
CreateSomeObject(CreationOptions.MakeThreadSafe);

它更好地描述了意图.

当有两个表示选项的布尔参数时,情况变得更糟.看看ObjectContext.SaveChanges(bool)Framework 3.5和4.0之间发生了什么.它已被淘汰,因为已经引入了第二个选项,并且整个事物已经转换为枚举.

虽然在有三个或更多元素的情况下使用枚举似乎很明显,但在这些特定情况下,您对使用枚举而不是布尔值有什么看法和经验？

这个问题源自我在Grails应用程序上的工作,但它适用于几乎所有在层中开发的Web应用程序.这是一个简单的例子:

class OrderService {

    // Option 1
    def shipOrder(Order order) {
        order.status = OrderStatus.SHIPPED
        emailService.sendShipmentEmail(order)
        // ...
    }

    // Option 2
    def shipOrder(long orderId) {
        def order = Order.get(orderId)
        order.status = OrderStatus.SHIPPED
        emailService.sendShipmentEmail(order)
        // ...
    }

}

这些选项中的任何一个都记录为比另一个更好吗？

我想知道如何处理400多条路线.

我们目前根据它们所属的控制器命名空间将所有路由分成多个文件.

App/Http/Routes看起来像这样的结构:

- Auth.php
- Marketing.php
- Orders.php

我们所有的路线都被命名.但是这里出现了我们遇到的实际问题.

我们的路由使用填充了定义路径名称的常量的类来命名.

namespace App\Http\Controllers\Marketing;

class RouteConstants
{
    /**
     * MarketingController
     */
    const INDEX = 'marketing.index';
    const DISABLED = 'marketing.disabled';

这些常量类位于Controller名称空间中.然后在Marketing.php路由文件中使用它们,如下所示:

/**
 * Marketing Routes
 */
Route::group(['namespace' => 'App\Http\Controllers\Marketing'], function() {

    /**
     * MarketingController Routes
     */
    Route::get('marketing/overview', [
        'uses' => 'MarketingController@index',
        'as' => MarketingRoutes::INDEX
    ]);

    Route::get('marketing/disabled', [
        'uses' => 'MarketingController@showDisabled',
        'as' => MarketingRoutes::DISABLED
    ]);```

这样做是因为它允许我们使用PhpStorm自动完成功能,并查看每个路由的使用位置.

但问题是我们同时使用两个系统.Laravel的内部路由命名系统,同时我们使用自己的系统将名称定义为常量.

必须有一种更好的方法来管理这些路径,并有办法检查项目文件中的用法.

目前我们的观点也非常混乱:

<a href="{{ route(App\Http\Controllers\Marketing\RouteConstants::INDEX) }}">Marketing</a>

我已经为PhpStorm尝试了Laravel插件,但是当有一个包含自动加载到路径中的路径的文件夹时,这不能正常工作RouteServiceProvider.

我想创建一个可以使用四种算法之一的类(并且使用的算法仅在运行时才知道).我认为策略设计模式听起来合适,但我的问题是每个算法需要稍微不同的参数.使用策略是一个糟糕的设计,但是将相关参数传递给构造函数？

这是一个例子(为简单起见,假设只有两种可能的算法)......

class Foo
{
private:
   // At run-time the correct algorithm is used, e.g. a = new Algorithm1(1);
   AlgorithmInterface* a; 

};

class AlgorithmInterface
{
public:
   virtual void DoSomething() = 0;
};

class Algorithm1 : public AlgorithmInterface
{
public:
   Algorithm1( int i ) : value(i) {}
   virtual void DoSomething(){ // Does something with int value };
   int value;   
};

class Algorithm2 : public AlgorithmInterface
{
public:
   Algorithm2( bool b ) : value(b) {}
   virtual void DoSomething(){ // Do something with …

但我不知道我是否应该选择静态方法,只是标题,类或其他东西？

什么是最佳做法？但是,我不想拥有实用程序类的实例.

我想添加以下功能:

Uint32 MapRGB (int r, int g, int b);
const char* CopyString(const char* char);
// etc. You know: utility methods...

我一直在研究Option类型的使用.

这意味着转换功能如:

Customer GetCustomerById(Int32 customerID) {...}

Customer c = GetCustomerById(619);
DoStuff(c.FirstName, c.LastName);

返回选项Maybe类型:

Maybe<Customer> GetCustomerById(Int32 customerID) {...}

在我的非函数式语言中,我必须检查返回值是否存在:

Maybe<Customer> c = GetCustomerById(619);

if (c.HasValue)  
   DoStuff(c.Value.FirstName, c.Value.LastName);

这很好用:

• 你从函数签名中知道它是否可以返回null(而不是引发异常)
• 在盲目使用它之前,你会被检查检查返回的值

但是没有垃圾收集

但是我没有使用其RAII的C#,Java或C++.我在德尔福; 具有手动内存管理的本机语言.我将继续以类似C#的语言显示代码示例.

使用手动内存管理,我的原始代码:

Customer c = GetCustomerById(619);
if (c != nil) 
{
   try  
   {
      DoStuff(c.FirstName, c.LastName);
   }
   finally
   {
      c.Free();
   }
}   

转换为类似的东西:

Maybe<Customer> c = GetCustomerById(619);
if (c.HasValue)
{
   try  
   {
      DoStuff(c.Value.FirstName, c.Value.LastName);
   }
   finally
   {
      c.Value.Free();
   }
} …

我正在使用从嵌套类创建的Singleton实例.这个实例保存了一些静态集合,这些集合在处理Singleton时被清除,但问题是我得到了对非空闲处理的Singleton的引用,而这些处理没有被正确地垃圾收集.

我想知道WHEN和HOW如何完全处理和垃圾收集我的Singleton实例,以便在dispose(并设置为null)后再次查询实例时,会创建一个新的Instance.

我对Singleton实例使用以下嵌套模式:

public class SingletonClass : IDisposable
{
    private List<string> _collection;

    private SingletonClass()
    {
    }

    public static SingletonClass Instance
    {
        get
        {
            return Nested.Instance; //line 1 - this line returns the non-null instance after dispose and setting the Singleton instance to null which is causing problems
        }
    }

    private void Init()
    {
        _collection = new List<string>();
        //Add data to above collection
    }

    public void Dispose()
    {
        //Release collection
        _collection.Clear();
        _collection = null;
    }

    class Nested
    {
        static Nested()
        { …

想象一下,我有一个带有实例成员的类

String instanceMember;

此外,我有4个实例方法访问此成员.现在我想知道是否有任何真正的pro/con从实例方法直接访问实例成员或将实例成员作为参数传递给每个实例方法？

为什么这个 :

public <T> List<byte[]> getData(T data) {
    Location loc = (Location) data;
    // ...
}

在此期间不会生成任何警告:

public <T> List<byte[]> getData(T data) {
    List<ScanResult> scanRes = (List<ScanResult>) data;
    // ...
}

生成Type safety: Unchecked cast from T to List<ScanResult>？

我怎样才能安抚警告？
作为一种设计是这种方法声明一个气味？

public <T> List<byte[]> getData(T data)

是一个在不同类中使用不同数据类型实现的接口方法 - 所有实现的第一行都是这样的转换

给定后端基于 php 或 ruby​​ 的 Web 应用程序，并在前端使用 javascript 进行编程，有时我们需要在两侧定义值来处理通过 API 进行前端-后端通信的数据。

在javascript中会是这样的：

var options = {
        OPT_A : 1,
        OPT_B : 2,
        OPT_C : 3
    };

switch(data.type)
{
    case options.OPT_A:
        /* */
        break;
    case options.OPT_B:
        /* */
        break;
    case options.OPT_C:
        /* */
        break;
}

在 php 中是这样的：

const OPT_A = 1;
const OPT_B = 2;
const OPT_C = 3;

但问题是，你必须定义它们两次，每种语言一次。这可能会导致错误/不一致...

我想到的唯一方法是从服务器定义 javascript 部分，但我不喜欢 js 代码由 php/ruby 代码编写的想法。

所以我的问题是......有没有什么好的方法可以做到这一点？