小编cor*_*ore的帖子

我不知道有多少次我不得不编写代码来验证字符串参数:

public RoomName(string name)
{
    if (string.IsNullOrEmpty(name))
    {
        throw new ArgumentException("Cannot be empty", "name");
    }
}

反正有没有避免这个？是否有一些属性或设计合同机制来避免这种情况？有没有办法说:

public RoomName(NotNullOrEmptyString name)
{

而不必实际创建该类型？

我有大约30名单<li>中<ul>.有没有办法,使用CSS,将这些分为三列十？

我还有点不清楚,什么时候可以锁定一些代码.我的一般经验法则是在读取或写入静态变量时将操作包装在锁中.但是当只读取静态变量时(例如,它是在类型初始化期间设置的只读),访问它不需要包含在锁定语句中,对吧？我最近看到一些代码看起来像下面的例子,它让我觉得我的多线程知识可能存在一些空白:

class Foo
{
    private static readonly string bar = "O_o";

    private bool TrySomething()
    {
        string bar;

        lock(Foo.objectToLockOn)
        {
            bar = Foo.bar;          
        }       

        // Do something with bar
    }
}

这对我来说没有意义 - 为什么会出现读取寄存器的并发问题？

此外,这个例子提出了另一个问题.其中一个比另一个好吗？(例如两个持有锁的时间较短？)我想我可以拆卸MSIL ......

class Foo
{
    private static string joke = "yo momma";

    private string GetJoke()
    {
        lock(Foo.objectToLockOn)
        {
            return Foo.joke;
        }
    }
}

与

class Foo
{
    private static string joke = "yo momma";

        private string GetJoke()
        {
            string joke;

            lock(Foo.objectToLockOn)
            {
                joke = Foo.joke; …

这是如何在作为范围兄弟姐妹的两个组件之间正确通信的吗？

1. Ctrl1将事件发送到Ctrl1和Ctrl2的父作用域.
2. 父作用域侦听来自Ctrl1的发出事件,然后将另一个事件向下广播到Ctrl2.
3. Ctrl2侦听来自父作用域的广播事件.

当我尝试使用泛型类时,this.value为T:

if (this.value.GetType() == typeof(int))
{
    ((int)this.value)++;
}
else
{
    throw new InvalidOperationException
            ("T must be an int to perform this operation");
}

我得到一个编译时错误:"无法将类型'T'转换为'int'"

当它是int时,我该怎么做才能对this.value执行整数运算？

请注意,这只是一个例子.代码用泛型键入转换,"int"只是T的一种类型的示例.

我正在尝试通过编写一些简单的扩展方法来刷新我的LINQ.有没有更好的方法来编写如下函数从字符串中删除给定的字符列表(使用LINQ)？

它帮助我思考LINQ首先依赖的扩展方法:

public static string Remove(this string s, IEnumerable<char> chars)
{
    string removeChars = string.Concat(chars);

    return new string(s.ToCharArray().Where(c => !removeChars.Contains(c)).ToArray());
}

但那很难看.Ergo LINQ.

我在LINQ语句中注意到的差异是我必须使用'select'而使用扩展方法,我不必这样做.

/// <summary>Strip characters out of a string.</summary>
/// <param name="chars">The characters to remove.</param>
public static string Remove(this string s, IEnumerable<char> chars)
{
    string removeChars = string.Concat(chars);

    var stripped = from c in s.ToCharArray()
                   where !removeChars.Contains(c)
                   select c;

    return new string(stripped.ToArray());
}

所以我想知道这个(上面的最后一个片段)是否是用于完成字符删除的最简洁的LINQ语句.

假设我有两个字符串:a和b.为了比较a和被忽略大小写时是否具有相同的值,我总是使用:

// (Assume a and b have been verified not to be null)

if (a.ToLower() == b.ToLower())

但是,使用Reflector,我在.NET Framework中已经看过几次:

// (arg three is ignoreCase)

if (string.Compare(a, b, true) == 0)

我测试哪个更快,每次用我使用的字符串ToLower()节拍Compare().

是否有理由Compare()而不是ToLower()？有什么不同的CultureInfo？我在挠头.

这是一个带foreach循环的简单方法:

IEnumerable<XElement> FieldsToXElements(object instance)
{
    var fieldElements = new List<XElement>();

    foreach (var field in instance.GetType().GetFields(instance))
    {
        fieldElements.Add(new XElement(field.Name, field.GetValue(instance)));
    }

    return fieldElements;
}

有点难看.如果在LINQ中有一些运算符意味着"做某事"(例如Action对LINQ语句中选择的每一个执行一个),它会看起来更好,更简洁:

IEnumerable<XElement> FieldsToXElements(object instance)
{
    var fieldElements = new List<XElement>();

    from field in instance.GetType().GetFields(instance))
    let name = field.Name
    let value = field.GetValue(instance)
    do fieldElements.Add(new XElement(name, value));

    return fieldElements;
}

我意识到这是主观的,只是我的意见.对于一个只有一行调用方法的foreach循环do,在我看来," "运算符是有意义的.但我想知道MS的任何人是否也想过同样的事情.这样的LINQ运营商是否计划在任何即将发布的版本中(例如,与C#4.0首次亮相)？

这是另一个带谓词的例子,虚拟do运算符真正使代码看起来更清晰.这个:

IEnumerable<XElement> FieldsToXElements
    (object instance, Func<FieldInfo, bool> predicate)
{
    var fieldElements = new List<XElement>();

    foreach (var field …

假设我有这个对象(或这些对象的数组):

var person = {
    birth: {
        place: {
            country: 'USA'
        }
    }
};

我以为有一个lodash函数,我可以传入'birth.place.country'并获取值USA.

在lodasdh 3.x中有这样的功能,还是我想象这个？

我想知道如果在表中不存在记录,是否有更简单的方法来插入记录.我还在尝试构建我的LINQ to SQL技能.

这就是我所拥有的,但似乎应该有一种更简单的方法.

public static TEntity InsertIfNotExists<TEntity>
(
    DataContext db,
    Table<TEntity> table,
    Func<TEntity,bool> where,
    TEntity record
)
    where TEntity : class
{
    TEntity existing = table.SingleOrDefault<TEntity>(where);

    if (existing != null)
    {
        return existing; 
    }
    else
    {
        table.InsertOnSubmit(record);

        // Can't use table.Context.SubmitChanges()
        // 'cause it's read-only

        db.SubmitChanges();
    }

    return record;
}