相关疑难解决方法(0)

是否可以在C#中创建多维arraylist？

StartDate   Qty   size
9/1/2010    10     15
9/1/2009    12     17
9/1/2008    11     19

StartDate,Qty和size是3周的ArrayLists.我需要把它们放在一个arraylist中.我还需要对这个arraylist进行排序StartDate.这可能吗？除了arraylist之外,还有更好的方法吗？

我发现允许修改值类型中的迭代器方法this.
但是,由于CLR的限制,调用方法看不到修改.(this按值传递)

因此,迭代器和非迭代器中的相同代码会产生不同的结果:

static void Main() {
    Mutable m1 = new Mutable();
    m1.MutateWrong().ToArray();     //Force the iterator to execute
    Console.WriteLine("After MutateWrong(): " + m1.Value);

    Console.WriteLine();

    Mutable m2 = new Mutable();
    m2.MutateRight();
    Console.WriteLine("After MutateRight(): " + m2.Value);
}

struct Mutable {
    public int Value;

    public IEnumerable<int> MutateWrong() {
        Value = 7;
        Console.WriteLine("Inside MutateWrong(): " + Value);
        yield break;
    }
    public IEnumerable<int> MutateRight() {
        Value = 7;
        Console.WriteLine("Inside MutateRight(): " + Value);
        return new int[0];
    }
}

输出:

Inside …

假设我们有以下struct使用泛型的定义:

public struct Foo<T>
{
    public T First; 
    public T Second;

    public Foo(T first)
    {
        this.First = first;
    }

}

编译说

在将控制权返回给调用者之前,必须完全分配'Foo.Second'

但是,如果Foo是一个类,那么它会成功编译.

public class Foo<T>
{
    public T First; 
    public T Second;

    public Foo(T first)
    {
        this.First = first;
    }

}

为什么？为什么编译器对它们的区别对待？此外,如果在第一个中没有定义构造函数,Foo那么它将编译.为什么会这样？

我的问题是:

• 我们什么时候应该使用值类型和引用类型？
• 一个优于其他的优点和缺点是什么？
• 如果在任何地方使用引用类型怎么办 它有什么危害吗？

还请讨论每个的优点和缺点.我也想了解这一点.

当使用f#3.0编译并且警告级别设置为5时,下面的第一个定义在标题中产生警告.第二个定义干净地编译.我想知道是否有人可以解释编译器担心我可能会意外改变的内容,或者如何使用let子句分割表达式有助于避免这种情况.非常感谢.

let ticks_with_warning () : int64 =
   System.DateTime.Now.Ticks 

let ticks_clean () : int64 =
   let t = System.DateTime.Now
   t.Ticks 

C#struct是否是线程安全的？

例如,如果有:

struct Data
{
    int _number;
    public int Number { get { return _number; } set { _number = value; } }

    public Data(int number) { _number = number; }
}

在另一种类型:

class DadData
{
    public Data TheData { get; set; }
}

是属性名为TheData,线程安全吗？

对此可能有一个非常合乎逻辑的解释,但我有一个问题.

假设我有一个名为_rect的Rectangle类型的变量.我现在可以说_rect.X = 50; 没有任何问题.

现在我有一个带有一个名为Rect的属性的类,它暴露了内部变量_rect.

然后,如果我尝试编写,Rect.X = 50;我得到以下编译错误:

无法修改'TestClass.Rect'的返回值,因为它不是变量.

我可以写Rect = new Rectangle( 50, Rect.Y, Rect.Width, Rect.Height)为不可变类型,但对于非不可变类型,还有其他方法吗？

我想为这个矩形字段使用自动属性,但它真的很烦人,无法在类本身内修改它.

是否有任何方法没有做出支持领域和放弃自动财产？

想象一下struct:

        struct Person
        {
             public string FirstName { get; set; }
             public string LastName { get; set; }
        }

以下代码:

        var list = new List<Person>();
        list.Add(new Person { FirstName = "F1", LastName = "L1" });
        list.Add(new Person { FirstName = "F2", LastName = "L2" });
        list.Add(new Person { FirstName = "F3", LastName = "L3" });

        // Can't modify the expression because it's not a variable
        list[1].FirstName = "F22";

当我想要更改Property它的值时,它会给我以下错误:

Can't modify the expression because it's not …

使用此代码:

struct Foo<T1>
{
    public T1 Item1 { get; private set; }

    public Foo(T1 item1)
    {
        Item1 = item1;
    }
}

我遇到这个错误:

在将控制权返回给调用者之前,必须完全分配自动实现的属性"Foo.Item1"的备份字段.考虑从构造函数初始化程序中调用默认构造函数.

我的问题是,为什么在Item1调用构造函数后属性没有完全赋值？

编辑:更改set为private set因为此问题与可变性无关.

好的,我们有一些代码:

//I complie nicely
ValueType[] good = new ValueType[1];
good[0].Name = "Robin";

//I don't compile: Cannot modify expression because its not a variable
IList<ValueType> bad = new ValueType[1];
bad[0].Name = "Jerome";

struct ValueType
{
    public string Name;
}

幕后究竟是什么导致编译器阻挠？

//Adding to watch the following
good.GetType().Name //Value = "ValueType[]" It's a ValueType array.
bad.GetType().Name  //Value = "ValueType[]" Also a ValueType array.

编译器阻止我修改我想要更改的对象副本的成员.但为什么要从这个阵列制作副本？

更多的研究投入:

var guess = (ValueType[]) bad;
guess[0].Name="Delilah";

现在,您的想法bad[0].Name是什么？没错,这是"Delilah".