小编CSJ*_*CSJ的帖子

为什么匿名类型没有属性设置者？

var a = new { Text = "Hello" };
a.Text = "World"; //error

F#教程包括以下代码段:

/// A record for a person's first and last name
type Person = {     
    First : string
    Last  : string
}

/// define a discriminated union of 3 different kinds of employees
type Employee = 
    | Engineer  of Person
    | Manager   of Person * list<Employee>            // manager has list of reports
    | Executive of Person * list<Employee> * Employee // executive also has an assistant

经理和执行官被描述为元组的事实冒犯了我的感情(我很容易被冒犯).它让我觉得不那么富有表现力.我试着按如下方式修改它们:

/// define a discriminated union of 3 different kinds of employees
type Employee …

我知道如何强制类型参数成为另一种类型的子类型:

public interface IMapping<T2> 
{
    public void Serialize<T3>(T3 obj) 
        where T3 : T2;
}
...

var mapping = MapManager.Find<Truck>();
mapping.Serialize(new TonkaTruck());

有没有办法强制类型参数成为另一种类型的超类型？

public interface IMapping<T2>
{
    public void IncludeMappingOf<T1>() 
        where T2 : T1;   // <== doesn't work
}
...

var mapping = MapManager.Find<Truck>();

// Truck inherits Vehicle    
// Would like compiler safety here:
mapping.IncludeMappingOf<Vehicle>(); 

mapping.Serialize(new TonkaTruck());

目前,我不得不在运行时使用IsSubclassOf内部比较T1和T2 IncludeMappingOf.编译安全的解决方案更可取.有任何想法吗？

编辑: 改变示例,以减少设计臭.

注意:链接的问题非常相似,但没有给出合适的答案.希望这个问题也会对这个问题有所了解.

编辑#2:

更简单的例子:

public class Holder<T2>
{
    public T2 Data { get; …

假设我有两个班:

public class Triangle {
    public float Base { get; set; }
    public float Height { get; set; }

    public float CalcArea() { return Base * Height / 2.0; }
}

public class Cylinder {
    public float Radius { get; set; }
    public float Height { get; set; }

    public float CalcVolume() { return Radius * Radius * Math.PI * Height }
}

我们在这里有两个几何形状的描述以及两者中的操作.

这是我在F#中的尝试:

type Triangle = { Base: float; Height: float }
module TriangleStuff = 
    let CalcArea t …

这段代码:

IEnumerable<IEnumerable<int>> numbas = new[] {new[] {0, 1}, new[] {2}, new[] {3, 4, 5}};
var flattened = numbas.SelectMany(a => a);

从多个来源中提取单个扁平的可枚举数字列表.Resharper警告说,有可能a(第二个)被多次枚举 - 但这很愚蠢; 每个源只被枚举一次.是的,符号a将被多次枚举,但每次都会有不同的来源.

我错过了什么,或者这是来自Resharper的错误警告？

在C#中,我有以下代码:

public class SomeKindaWorker
{
    public double Work(Strategy strat)
    {
        int i = 4;
        // some code ...
        var s = strat.Step1(i);
        // some more code ...
        var d = strat.Step2(s);
        // yet more code ...
        return d;
    }
}

这是一段代码,可以通过使用提供的策略对象来填充部分实现来完成某种工作.注意:一般来说,策略对象不包含状态; 它们只是多态地提供各个步骤的实现.

策略类如下所示:

public abstract class Strategy
{
    public abstract string Step1(int i);
    public abstract double Step2(string s);
}

public class StrategyA : Strategy
{
    public override string Step1(int i) { return "whatever"; }
    public override double Step2(string …

我有一个应用程序,我监视和控制一堆计算机(可能是3到35左右,可能是本地的).

我监控的一件事是正常运行时间/ ping状态.应用程序的目的之一是重新启动框,有时它们会因其他原因重新启动.

我希望能够快速获取pingable/non-pingable更改.

我在一个线程上有一个旋转循环.

在我看来,阻止ping可以防止它更新一点,即使你并行运行它(防止一个盒子的ping阻塞另一个)

(并行实现示例,请注意以下内容仅仅是我的头脑并没有实现,可能包含错误)

var startTime = DateTime.Now;
var period = TimeSpan.FromSeconds();
Parallel.ForEach(boxes, (box) => 
{
    var now = DateTime.Now;
    var remainingTime = (now - startTime) - period;
    while(remainingTime > TimeSpan.Zero)
    {
        box.CanPing.TryUpdate();
    }
});

其中TryUpdate就是这样的

using(ping = new Ping())
{
    var reply = ping.Send (IP);
    bool upStatus = (reply.Status == IPStatus.Success);
    this.Value = upStatus;
}

或者,我尝试使用多个SendAsync(一次多个异步ping)在SendAsync回调中使用双重检查锁定尽快发现正常运行时间

if(upStatus != this.Value)
{
    lock(_lock)//is it safe to have a non static readonly lock object, all the examples seem to …

我想设置两个值,彼此保持不可变的引用.例:

data class Person(val other: Person)
val jack = Person(jill), jill = Person(jack)   // doesn't compile

注意:lateinit似乎不适用于数据类主构造函数.

有任何想法吗？

我有一个有大约20个属性的类,但我会为这个问题简化它:

public class Product
{
   public int Id { get; set; }
   public string Name { get; set; }
}

我想要一个班级或财产,以确定我的班级是否脏.我的意思是确定它的任何值是否已经改变？

我可以采取3种设计方法:

1)在类中设置属性时,我检查属性是否为IsDirty.

public string Name 
{
    get { return this._name; }
    set { if (this._name != value) { this.IsDirty = true; this._name = value; }
}

2)当从类外部设置属性时,我检查属性IsDirty.

例如

if (p.Name != newName)
{
 p.IsDirty = true;
 p.Name = newName; 
}

这种方法迫使我在客户端类中添加大量ifs.有些属性甚至是集合甚至是引用对象,因此行数甚至会增加.

3)当对象准备好保存时,我通过获取克隆对象并检查相等性来检查是否有任何属性IsDirty.

这会有较差的性能,因为我必须克隆或再次加载原始对象,然后逐个比较属性.

哪一个是最好的设计？或者是否有任何其他设计模式可以帮助解决这个问题？

这两个问题几乎可以回答我自己的问题,但并不完全.考虑这是对这些问题的后续问题.

• 我是否需要考虑处理我使用的任何IEnumerable <T>？
• 了解迭代器块和处理方法

我理解一个枚举器的foreach循环将Dispose在它完成时完成.

我的问题是:

如果有问题的枚举器实际上GetEnumerator()/yield是一个IEnumerable<T>自己实现的类的ac#iterator块(即)IDisposable,我可以确定该对象本身是否会被处理？或者我是否需要GetEnumerator()/MoveNext()/Current在using块内明确调用？

编辑: 这个片段演示@ JonSkeet的答案.

编辑#2: 此片段基于@ JonSkeet的评论,展示了理想的用法.迭代器块负责所需资源的生命周期,而不是可枚举对象本身.这样,如果需要,可以多次枚举枚举 - 每个枚举都有自己的资源可供使用.