小编dal*_*lle的帖子

我有一个List,我想将它包装成IQueryable.

这可能吗？

我已经将两个类的公共属性分解为一个抽象基类,但是我有另一个模型需要引用其中一个类.不可能引用ABC,因为它实际上没有数据库表.

以下示例应说明我的问题:

class Answer(models.Model):
    ovramt = models.ForeignKey("Ovramt")
    question = models.ForeignKey("Question")
    answer = models.CharField(max_length=3, choices=(("yes","yes"),("no","no") ("NA","N/A"))
    likelihood = models.IntegerField(choices=LIKELY_CHOICES)
    consequence = models.IntegerField(choices=CONSEQUENCE_CHOICES)

    class Meta:
        abstract = True

class Answer_A(Answer):
    resident = models.ForeignKey("Resident")
    def __unicode__(self):
        return u"%s - %s - %s" %(self.ovramt.ssa.name, self.resident, self.question)    

class Answer_B(Answer):
    def __unicode__(self):
        return u"%s - %s" %(self.ovramt.ssa.name, self.question)    

class Answer_Risk(models.Model):
    answer = models.ForeignKey("Answer")
    risk = models.CharField(max_length=200)

    def __unicode__(self):
        return self.risk

Answer_A和Answer_B略有不同,Answer_A还需要与另一个表的FK关系.Answer_B以后可能还需要一些特定的属性.如果我将Answer_B作为超类 - 并且具有Answer_A子类或组成它,那么问题仍然存在.

无论是Answer_A还是Answer_B,'风险'都是相同的.我还有其他模型需要引用'答案'而不管它的子类型.如何才能做到这一点？无论它的子类型如何,您如何引用类型？

更新:
我试图避免加入操作但我不认为我能够.是否值得在所有'答案'中引用'Resident'并在必要时将其归零？或者这被认为是非常糟糕的做法？

WinRT有垃圾收集吗？

或者像COM一样引用计数？

为什么新的运算符存在于C#和Java等现代语言中？它纯粹是一个自我记录的代码功能,还是它可以用于任何实际目的？

例如以下示例:

Class1 obj = new Class1();

Class1 foo()
{
    return new Class1();
}

像Pythonesque写的那样容易阅读:

Class1 obj = Class1();

Class1 foo()
{
    return Class1();
}

编辑:考恩澄清问题:考恩为什么选择这种语法？

是否可以实现尊重开放/封闭原则的访客模式,但仍然能够添加新的可访问类？

开放/封闭原则规定"软件实体(类,模块,功能等)应该开放以进行扩展,但是关闭以进行修改".

struct ConcreteVisitable1;
struct ConcreteVisitable2;

struct AbstractVisitor
{
   virtual void visit(ConcreteVisitable1& concrete1) = 0;
   virtual void visit(ConcreteVisitable2& concrete2) = 0;
};

struct AbstractVisitable
{
   virtual void accept(AbstractVisitor& visitor) = 0;
};

struct ConcreteVisitable1 : AbstractVisitable
{
   virtual void accept(AbstractVisitor& visitor)
   {
      visitor.visit(*this);
   }
};

struct ConcreteVisitable2 : AbstractVisitable
{
   virtual void accept(AbstractVisitor& visitor)
   {
      visitor.visit(*this);
   }
};

您可以实现任意数量的派生自AbstractVisitor的类:它是可以扩展的.您无法添加新的可访问类,因为从AbstractVisitor派生的类将无法编译:它已关闭以进行修改.

AbstractVisitor类树遵循开放/封闭原则.AbstractVisitable类树不遵循开放/封闭原则,因为它无法扩展.

除了扩展AbstractVisitor和AbstractVisitable之外还有其他解决方案吗？

struct ConcreteVisitable3;

struct AbstractVisitor2 : AbstractVisitor
{
   virtual void visit(ConcreteVisitable3& concrete3) = 0;
};

struct …

我正在将类层次结构转换为存储在SQL数据库中.

原始伪代码:

abstract class Note
{
   int id;
   string message;
};

class TimeNote : public Note
{
   time_t time;
};

class TimeRangeNote : public Note
{
   time_t begin;
   time_t end;
};

class EventNote : public Note
{
   int event_id;
};

// More classes deriving from Note excluded.

目前我有几个想法如何将其存储在数据库中.

A.将所有笔记存储在一个宽表中

该表将包含派生自所有类所需的所有信息Note.

CREATE TABLE t_note(
   id INTEGER PRIMARY KEY,
   message TEXT,
   time DATETIME,
   begin DATETIME,
   end DATETIME,
   event_id INTEGER
);

未来的类派生自Note需要向此表添加新列.

B.将每个类映射到表

CREATE TABLE t_note(
   id …

在阅读对答案的评论时,我看到了以下构造来声明和初始化变量:

int variable = int.TryParse(stringValue, out variable) ? variable : 0;

在C#中这是允许的,正确的和明确定义的吗？引擎盖下会发生什么？以下是怎么回事？

1. 是variable第一初始化为零？
2. 然后传递给int.TryParse(赋值)？
3. 然后可选择阅读(如果int.TryParse返回true)？
4. 然后,再次分配/初始化？

是否有.NET库/教程可以让我告诉我如何为我的应用程序自定义Windows 7跳转列表？

枚举System.TypeCode定义如下:

public enum TypeCode
{
   Empty = 0,
   Object = 1,
   DBNull = 2,
   Boolean = 3,
   Char = 4,
   SByte = 5,
   Byte = 6,
   Int16 = 7,
   UInt16 = 8,
   Int32 = 9,
   UInt32 = 10,
   Int64 = 11,
   UInt64 = 12,
   Single = 13,
   Double = 14,
   Decimal = 15,
   DateTime = 16,
   String = 18,
}

出于好奇,TypeCode的价值17发生了什么？它曾经存在过吗？为什么TypeCode.String的值为18而不是17？

根据我的理解, C++/CX不使用垃圾收集,而是使用引用计数方法.

引用计数的问题在于它不能处理循环.循环通常使用弱引用来解决,例如标准C++中的weak_ptr.

但我无法在C++/CX中找到明确指定弱引用的方法.从那以后我会假设这是由C++/CX本身处理的.我想知道C++/CX将如何解决这个问题.

例如,查看以下代码:

ref class Foo
{
public:
    Bar^ bar;
};

ref class Bar
{
public:
    Foo^ foo;
};

ref class App
{
public:
    virtual void OnLaunched(LaunchActivatedEventArgs^ args)
    {
        Foo^ foo = ref new Foo();
        Bar^ bar = ref new Bar();
        foo.bar = bar;
        bar.foo = foo;
    }
};

C++/CX如何检测此循环？

C++/CX如何解决这个循环？

C++/CX如何决定这些对象中的哪一个应该是"根对象",哪一个应该是"弱引用"？