小编Rys*_*gan的帖子

我一直在讨论关于DRY(不要重复自己)的原则,也称为DIE(Duplication Is Evil),并且有投票,任何简单的代码重复总是邪恶的.我想听听你对以下几点的看法:

1. 不确定的未来.让我们说,我们在两个地方有相同的代码.关键是,这两个地方只有偶然的内涵.有可能,它们将来会有所不同,因为它们的上下文和语义不同.从这些地方抽象并不便宜,如果其中一个地方发生变化,从抽象中解开将更加昂贵.
2. 可读性.存在涉及若干变量或步骤的复杂计算.在代码的其他地方还有另一个代码,它们有一些相同的部分.问题是,如果我们取出公共部分,计算的可读性会降低,创建抽象将很难给它一个描述性的名称.更糟糕的是,如果算法的某些部分将来会像第1点那样发生变化.

上述情况是否是放弃抽象过程的好理由,只留下重复的代码以支持未来变更的风险或只是可读性？

有一个:

enum SomeEnum
{
    A = 0,
    B = 1,
    C = 2
}

现在编译器允许我写:

SomeEnum x = SomeEnum.A;
switch(x)
{
    case 0: // <--- Considered SomeEnum.A
        break;
    case SomeEnum.B:
        break;
    case SomeEnum.C:
        break;
    default:
        break;
}

0被认为SomeItems.A.但我写不出来:

SomeEnum x = SomeEnum.A;
switch(x)
{
    case 0:
        break;
    case 1: // <--- Here is a compilation error.
        break;
    case SomeEnum.C:
        break;
    default:
        break;
}

为什么只存在隐式转换0？

假设我有桌子#Foo:

Id Color
-- ----
1  Red
2  Green
3  Blue
4  NULL

和表#Bar:

Value
-----
1
2.5

我想创建表Result使用简单的语句来获取:

Id Color   Value
-- ----   -----
1  Red    1
2  Green  2.5
3  Blue   NULL
4  NULL   NULL

到目前为止我发明的是:

WITH cte1
AS
(
    SELECT [Id], [Color], ROW_NUMBER() OVER (ORDER BY [Id]) AS 'No'
    FROM #Foo
),
cte2
AS
(
    SELECT [Value], ROW_NUMBER() OVER (ORDER BY [Value]) AS 'No'
    FROM #Bar
)
SELECT [Id], [Color], [Value]
FROM cte1 c1
FULL OUTER JOIN …

我需要一个解决方案来执行任意暂停.延迟准确性无关紧要.WaitHandle.WaitOne方法(TimeSpan)和Thread.Sleep方法之间的这种情况有什么实际区别.还有更好的解决方案吗？

我有以下代码,它有效:

public DataTemplate ItemTemplate
{
    get { return _list.ItemTemplate; }
    set { _list.ItemTemplate = value; }
}

我有代码,我想拥有,但它不起作用.甚至从不调用setter:

public static readonly DependencyProperty ItemTemplateProperty = DependencyProperty.Register("ItemTemplate", typeof(DataTemplate), typeof(MyUserControl));
public DataTemplate ItemTemplate
{
    get { return (DataTemplate)GetValue(ItemTemplateProperty); }
    set
    {
        _list.ItemTemplate = value;
        SetValue(ItemTemplateProperty, value);
    }
}

使用它在XAML中:

<Window.Resources>
    <DataTemplate x:Key="ItemTemplate">
        <TextBlock Text="{Binding Path=Name}"/>
    </DataTemplate>
</Window.Resources>

<local:MyUserControl ItemTemplate="{StaticResource ItemTemplate}"/>

为什么标准属性工作而依赖属性不起作用？

为了简单说明我的困境,让我说我有以下代码:

class A
{
    // May be set by a code or by an user.
    public string Property
    {
        set { PropertyChanged(this, EventArgs.Empty); }
    }

    public EventHandler PropertyChanged;
}

class B
{
    private A _a;

    public B(A a)
    {
        _a = a;
        _a.PropertyChanged += Handler;
    }

    void Handler(object s, EventArgs e)
    {
        // Who changed the Property?
    }

    public void MakeProblem()
    {
        _a.Property = "make a problem";
    }
}

为了履行其职责,B级必须对A的PropertyChanged事件作出反应,但在某些情况下也能够自行交替该属性.不幸的是,其他对象也可以与Property进行交互.

我需要一个顺序流的解决方案.也许我可以使用一个变量来禁用一个动作:

bool _dontDoThis;

void Handler(object s, EventArgs e)
{
    if …

在某些情况下，我手动或自动覆盖文件，但没有提前检查它，因此在 p4v 中我将其视为没有红色小鸟的蓝色图标。此类文件未显示在待处理列表中，我需要在工作区树中查找它。

如何过滤掉p4v中覆盖但未签出的文件？

我想知道是否有一种简单的方式来处理C#中的某种事务.我们假设我们有两个属性,我们想更新它们的值.我们可以写:

A = GetA();
B = GetB();

问题是,如果在分配B时抛出异常,那么对象将处于不一致状态,因为A已被更新.我们可以通过存储A的当前值并在处理B时捕获异常来解决这个问题:

var tempA = A;
A = GetA(); // A is up to date
try { B = GetB(); } catch { A = tempA; } // B is up to date also or A is reverted

即使上面的解决方案也不是保存,因为在还原A时可以抛出异常,但关键是,如果.NET中有内置机制来完成这样的操作？

我可以想象如下的声明:

transaction { A = GetA(); B = GetB(); }

或代码构造如:

Transaction.Enter();
A = GetA();
B = GetB();
Transaction.Leave();

在交易之前,将存储机器状态,并且在交易之后,如果发生异常,它将被还原.在.NET中有类似的东西吗？

尽管它看起来像是基于主要意见的问题，但并非绝对如此。

我想知道在 SQL 中创建约束的每个可能约定的优缺点是什么。由于我使用 SQL Server，因此我将展示三个我熟悉的创建主键约束的示例：

1. CREATE TABLE Persons (Id int NOT NULL PRIMARY KEY);
   • +：简洁
   • -: 生成半随机名称
   • -: 不能覆盖超过一栏
2. CREATE TABLE Persons (Id int NOT NULL, CONSTRAINT PK_Persons_Id PRIMARY KEY(Id));
   • +：简洁的中间
   • +：可以覆盖多列
   • +：开发者事先知道什么是主键，什么是pk的名字
   • -：降低创建语句的可重用性
3. CREATE TABLE Persons (Id int NOT NULL); ALTER TABLE Persons ADD CONSTRAINT PK_Persons_Id PRIMARY KEY (Id);
   • +：将表创建语句与其约束分开，这可能会增加一些好处，例如代码可重用性
   • -: 也许它掩盖了表模式，因为开发人员事先不知道什么是主键

这些都是优点和缺点，这是我目前发现的。也许更有经验的开发人员可以指出在开发和生产环境中创建主键和其他约束时可以帮助做出最佳决策的其他因素。例如：

• 开发人员并不总是事先知道将来会使用什么工具。也许有一些不支持某些语法的常用工具。
• 如果我们可以在不同的数据库上使用它，代码就可以重用。这可能是使用一种语法而不是另一种语法的论据。
• 也许有人遇到过这样的情况，他想要在其中定义没有约束的表创建语句以及出于什么原因。

我相信我们可以分享关于一种语法何时比另一种语法具有实际优势的知识。

在.NET Framework 4.5的Monitor文档中,我找到了一个句子,它表示lock关键字使用Monitor的Enter(Object,Boolean)方法:

Enter和Exit方法提供的功能与C#lock语句(Visual Basic中的SyncLock)提供的功能相同,只是lock和SyncLock在尝试中包装Enter(Object,Boolean)方法重载和Exit方法... finally阻止(尝试...最后在Visual Basic中)以确保释放监视器.

另一方面,在监视器的重叠中,有:

Visual Basic SyncLock和C#锁定语句使用MonitorEnter获取锁定,MonitorExit使用它来释放它.

上面的MonitorEnter指的是比以前不同版本的Enter方法,即:Enter(Object)

在Visual Studio 2012的线程同步(C#和Visual Basic)中,有一个示例锁定如何包装Monitor:

System.Object obj = (System.Object)x;
System.Threading.Monitor.Enter(obj);
try
{
    DoSomething();
}
finally
{
    System.Threading.Monitor.Exit(obj);
}

还有Enter(对象)版本.

什么是真的？lock语句是调用Enter(Object,Boolean)还是Enter(Object)？它是如何真正完成的？