标签: generic-programming

我正在研究如何提高我正在处理的应用程序中某些代码的一致性,简洁性和可读性.起始代码看起来像这样:

context.GetGraphType<Bar>().Subscribe<Fizz>(
     (instance, evt) => evt.Execute((Bar)instance.Instance)
);

如上所述,有许多几乎相同的代码行.我想重写它看起来像这样:

typeof(Bar).SubscribeTo<Fizz>(context);

首先,这将使我能够利用已经成为非正式会议的形式化.此外,我希望它现在会读取类似"bar在订阅上下文中订阅fizz事件",而不是"上下文获取条形码并订阅fizz然后做一些事情."我认为流程是更好,我询问同事的同事.

我开始将其作为扩展方法实现.为了实现上述目的,我想为事件类型使用抽象通用基类,所以Fizz也是如此Event<T>.这意味着扩展方法的泛型类型参数必须被约束为调用扩展方法的类型.因此,对于上面的例子,Fizz必须是类型Event<Bar>.

这可能吗？我在同一时间采用了替代解决方案,但我仍然很好奇是否可以实现.其他建议也是受欢迎的.

谢谢!

编辑#1:为了清楚,我意识到我可以使用一个额外的类型参数,但我正在寻找避免这种情况的方法.

编辑#2:我想我会接受一个接受答案的微小变化,因为它与我的情景不符合100%.底线是可以使用通用静态类而不是Type的扩展方法来实现我的目标.谢谢dss539!

更新代码(因为我在飞行中这样做可能会出现错别字):

public class Bar { }

public class Event<TSubscriber>
{
    public abstract void Execute(TSubscriber source);
}

public class Fizz : Event<Bar>
{
    public override void Execute(Bar bar)
    {
        // respond to event
    }
}

public class Context { }

public static class ForType<TSubscriber>
{
    public static void SubscribeTo<TEvent>(Context context)
        where TEvent : Event<TSubscriber>
    {
        context.GetType<TSubscriber>().Subscribe<TEvent>(
            (evt, args) …

假设您有一些目标类,其中包含一些方法:

class Subject
{
public:
  void voidReturn() { std::cout<<__FUNCTION__<<std::endl; }
  int  intReturn()  { std::cout<<__FUNCTION__<<std::endl; return 137; }
};

和Value类(概念类似于Boost.Any):

struct Value
{
  Value() {}
  Value( Value const & orig ) {}
  template< typename T > Value( T const & val ) {}
};

我想使用Subject类中的方法生成一个Value对象:

Subject subject;
Value intval( subject.intReturn() );
Value voidVal( subject.voidReturn() );  // compilation error

我在VC++ 2008中遇到以下错误:

error C2664: 'Value::Value(const Value &)' : cannot convert parameter 1 from 'void' to 'const Value &'
Expressions of type void cannot …

如何在Agda中编写arity-generic函数？是否可以编写完全依赖和Universe多态的arity-generic函数？

我正在尝试构造某种"泛型类型别名",这意味着我想要定义一个类型int,例如,但是使用泛型类型参数,然后使其与其他类型的实例不兼容.

我尝试使用别名模板执行此操作:

template <typename T>
using NumberWithSemantics = int;

但问题是所有实例化,无论类型如何T,都被认为是相同的,例如:

struct A {};
struct B {};

NumberWithSemantics<A> getThing() {
    return 14;
}

int processDifferentThing(NumberWithSemantics<B> b) {
    return b * 3;
}

int main() {
    auto a = getThing();
    return processDifferentThing(a); // unfortunately compiles just fine
}

有没有办法定义某种不允许混合不同模板实例的泛型类型别名？

我也跟着上通用的存储库模式教程与ASP.NET核心与EF CORE， 这里 例如

   public class Repository<T> : IRepository<T> where T : class
   {
    protected readonly DbContext _dbContext;
    protected readonly DbSet<T> _dbSet;

    public Repository(DbContext context)
    {
        _dbContext = context ?? throw new 
         ArgumentException(nameof(context));
        _dbSet = _dbContext.Set<T>();
    }

    public void Add(T entity)
    {
       _dbSet.Add(entity);
    }
   }

由于这是使用EF Core，我们只能使用预定义的方法通过Add方法插入数据，但是当涉及dapper时，它需要sql查询，那么我如何才能创建适合Dapper的通用接口？

我注意到我遇到的一些“困难” 组合问题可以用某种类型的树搜索来表示，例如 alpha-beta 剪枝、波束搜索或类似的算法。然而，对它们进行编程似乎是重复编码相同的东西，而且也很容易出错。在我看来应该有一个库来实现这些算法，而我应该被要求写的是

1. 解决方案的编码，即如何从不完整的解决方案中获得更具体的解决方案。这将给出树/图结构。
2. 给定部分解决方案，如何获得最大/最小成本，以及可能的成本估计。
3. 初始解决方案/部分解决方案。
4. 也许是某种验证解决方案。

很抱歉我没有给出任何具体的代码，但我想我已经解释了这个问题。如果我可以为上述函数编写代码，我是否应该能够轻松运行许多树/图搜索算法？是否有任何用户友好的库/框架可以轻松支持这一点？我希望它能用 Python 或 C/C++ 编写，但也有兴趣听到任何建议。

编辑：更准确地说，我正在谈论知情树搜索算法。

如何在通用条件"where"中编写正确的Linq表达式

public static class ConStr
{
    public static MySqlConnection Conn()
    {
        return new MySqlConnection(ConfigurationManager.ConnectionStrings["DBCN"].ConnectionString);
    }

}

Repositor.cs

private IDbConnection cn;

public IEnumerable<TEntity> FilterBy(Expression<Func<TEntity, bool>> expression)
{
     using(cn = ConStr.Conn())
     {
        return cn.GetAll<TEntity>(null).Where(expression); <--error does not contain definition of where
     }

 }

但这与Linq表达式将运行

using (IDbConnection cn = ConStr.Conn()) 
{
    var que = cn.GetAll<Cause>(null).Where(x=>x.cause_id == 1);            
    bool dbIE = Utils.IsAny<Cause>(que);
    if (dbIE == true)
    {
        DGRID.DataSource = que;
    }
    else 
    {
        MessageBox.Show("Sorry No Value");
    }
}  

在这段代码中,T可以是A,B,C或D,但Eclipse显示它是D.

static class A { }
static class B extends A { }
static class C extends B { }
static class D extends C { }
static <T> void copy(List<? super T> dst, List<? extends T> src) {
    for (T t : src)
        dst.add(t);
}
public static void main(String[] args) {
    List<A> dst = new ArrayList<>();
    List<D> src = new ArrayList<>();
    copy(dst, src); // Eclipse shows T is D
}

是否有关于类型推断如何完成以及为什么选择D的规则？

给定一对case类,Source并且Target,它们具有嵌套的case类,并且在每个嵌套级别,其中的字段Target都是未对齐的子集Source,是否有办法将通用的无Shape转换变换Source为Target？

例如,给定以下Internal和External类:

object Internal {
  case class User(
    firstName: String,
    lastName: String,
    isAdmin: Boolean,
    address: Address
  )

  case class Address(
    street: String,
    country: String,
    blacklisted: Boolean
  )
}

object External {
  // Note that isAdmin is missing and the fields are jumbled
  case class User(
    lastName: String,
    firstName: String,
    address: Address
  )

  // blacklisted is gone
  case class Address(
    street: String,
    country: String
  ) …

我正在构建一个简单的 2D 游戏引擎，它变得越来越大，暴露 Lua 中的所有功能将是不可能的：所以我试图自动化一点这个过程，有没有办法获取所有 n 个参数（不同类型）立即从堆栈中取出并直接注入到 C++ 函数中。我已经自动化了函数参数检查。仍然是函数绑定，这有点棘手

例如：我有用于更改精灵位置的正常代码：

int LuaSprite::SetSpritePosition(lua_State* L)
{
    Drawable* sprt = (Drawable*)lua_touserdata(L, 1);
    int x = (int)lua_tonumber(L, 2);
    int y = (int)lua_tonumber(L, 3);
    sprt->setPosition(Vec2i(x, y));
    return 0;
}

我想要实现的概念更像是这样：

int LuaSprite::SetSpritePosition(lua_State* L)
{   
    LOAD_ARGS(Sprite*, int, int)
    GET_ARG(1)->setPosition(Vec2i(GET_ARGS_FROM(1)));
    LOAD_RETURN(true, x, y, 3);
    return 3;
}

所以

• LOAD_ARGS将从堆栈中分别获取给定的类型。
  
• GET_ARG(i) 将获取索引 i 处的 arg。
  
• GET_ARGS_FROM(i) 将执行类似 x,y,z,type 的操作
  

我并不是要求相同的行为，因为它可能是不可能做的，但至少有类似的行为，
而且我确信仅使用“普通”C++ 是无法实现的，而且我还需要一些“神奇”宏。
我没有使用现成的自动 Lua 绑定“库”，因为有自定义结构，并且一些函数正在使用复杂的结构和类，我已经做了很多搜索，但我感到真的迷失了。