小编Dav*_* S.的帖子

可以[assembly: InternalsVisibleTo("NameOfOtherAssembly")]在 AssemblyInfo.cs 中指定。

但是是否可以将其限制为特定的内部功能？

例如，是否有可以应用于每个功能的属性？

[InternalVisibleTo("NameOfOtherAssembly")]
internal void ShouldBeVisible()
{}

internal void ShouldNotBeVisible()
{}

如果没有，有没有其他方法可以做到这一点？

我有一个List<Thing> things,其中一些Thing需要通过看两个变量的组合经常检索小号T1 f1和T2 f2,这是值类型.我现在这样做的方式很简单things.Where(t => t.Field1 == f1 && t.Field2 == f2).但是,我经常进行极其多的查找,并且需要更有效的方法.

幸运的是,things不需要删除或添加元素,所以我想在构造中解析列表并添加到Dictionary<T1, Lookup<T2, Thing>>.但是,这感觉很麻烦,特别是添加了解析.如果我需要查找更多字段,它会变得非常毛茸茸.三个字段看起来像Dictionary<T1, Dictionary<T2, Lookup<T3, Thing>>>.

我的下一个想法是做一个Lookup<Tuple<T1,T2,T3,...>,Thing>.但在这种情况下,我不确定密钥是否真的有效,因为Tuple是一个引用类型.

即使我做了一个Lookup<ValueType<T1,T2,T3,...>,Thing> things,查找语句将things[new ValueType<T1,T2,T3,...>(f1, f2, f3, ...)]是非常难看的(我仍然不确定我是否可以信任这些键).

有没有更优雅的解决方案,这保持哈希表的性能优势,我可以简单地输入类似的东西IEnumerable<Thing> found = things[f1, f2, f3, ...];？

我ILookup<TKey,TElement> lookup经常从中获取元素并使用LINQ或者迭代它们foreach.我看起来像这样IEnumerable<TElement> results = lookup[key];.

因此,results每次使用查找结果时都需要至少枚举一次(如果我先不使用.ToList(),那么如果我多次迭代则更多).

即使它不是"干净",使用a也不是更好(性能方面)Dictionary<TKey,List<TElement>>,所以一个键的所有结果只在字典的构造中枚举？ToList()有多累赘？

我有一个多线程应用程序,在某段代码中我用a Stopwatch来衡量一个操作的时间:

MatchCollection matches = regex.Matches(text); //lazy evaluation
Int32 matchCount;
//inside this bracket program should not context switch
{
    //start timer
    MyStopwatch matchDuration = MyStopwatch.StartNew();
    //actually evaluate regex
    matchCount = matches.Count;
    //adds the time regex took to a list
    durations.AddDuration(matchDuration.Stop());
}

现在,问题是如果程序在秒表启动时将控制切换到另一个其他线程,那么定时持续时间将是错误的.在上下文切换回此部分之前,另一个线程可以完成任何工作量.

请注意,我不是在询问锁定,这些都是局部变量,因此不需要这样做.我只想让定时部分连续执行.

编辑:另一个解决方案可能是减去上下文切换时间,以获得在定时部分完成工作的实际时间.不知道是否可能.

我在lambda语法中有以下linq表达式:

var myValue = 6;
var from = 2;
var to = 8;

var res = MyList.Where(m => m.person.Id == person.Id
                         && IsBetween(myValue, from, to))
                .Select(x => new Person { blah blah blah })
                .ToList());

IsBetween是一个简单的通用助手方法,看看我之间是否有东西:

public bool IsBetween<T>(T element, T start, T end)
{
    return Comparer<T>.Default.Compare(element, start) >= 0
        && Comparer<T>.Default.Compare(element, end) <= 0;
}

现在我收到了这个错误,我不知道如何解决它:

LINQ to Entities无法识别方法'Boolean IsBetween [Decimal](System.Decimal,System.Decimal,System.Decimal)'方法,并且此方法无法转换为商店表达式.

我有一个类型的集合,我想过滤掉每个不具体的类型.

我可以看到我可以检查isAbstract和isInterface以捕获大多数非混凝土,但这会错过任何东西吗？

是否有"isConcrete"属性？

执行语句时如何比较字符串switch？线程/计算机的当前文化是否会影响switch评估？我养成了在比较字符串时总是指定比较器的习惯，因此如果能够确认这一点那就太好了。

我怀疑是这样StringComparer.Ordinal，但我找不到任何相关文档。

我在背景工作者身上做了一些繁重的工作,所以它不会影响我的Silverlight UI线程.但是,在DoWork函数中,我遇到了这个异常:

UnauthorizedAccessException "无效的跨线程访问".

我知道我无法从BackgroundWorker访问UI线程,但是,此行发生此异常:

  ListBoxItem insert = new ListBoxItem();

怎么访问我的ui线程？

这是我将其缩小到的实际代码段.我基本上正在创建listboxitems,我想插入sourceList列表框:

void FillSourceList()
{
    busyIndicator.IsBusy = true;
    BackgroundWorker bw = new BackgroundWorker();
    bw.DoWork += (sender, args) =>
        {
            List<ListBoxItem> x = new List<ListBoxItem>();
            for (int i = 0; i < 25; i++ )
            {
                ListBoxItem insert = new ListBoxItem(); //<---Getting exception here
                insert.Content = "whatever";
                x.Add(insert);
            }
            args.Result = x;
        };
    bw.RunWorkerCompleted += (sender, args) =>
        {
            foreach (ListBoxItem insert in (List<ListBoxItem>)(args.Result))
                sourceList.Items.Add(insert);
            busyIndicator.IsBusy = false;
        }; …

我从一个IEnumerable<Task> tasks我无法控制的地方得到一个.我不知道,如果使用手动创建的任务new Task,Task.Run或者如果他们是一个异步方法调用的结果async Task DoSomethingAsync().

如果我这样做await Task.WhenAll(tasks),我冒着无限期的风险,因为可能没有启动一个或多个任务.

我不能这样做tasks.ForEach(t => t.Start()),因为那样我将得到一个InvalidOperationException"如果它来自一个异步方法调用(已经启动),则可能无法在promise风格的任务上调用".

我不能这样做,await Task.WhenAll(tasks.Select(t => Task.Run(async () => await t)))因为每个人t仍然只是等待它才开始.

我假设解决方案与检查每个任务Status并Start()基于此有关,但我也认为它可能很棘手,因为状态可能随时改变,对吧？如果这仍然是要走的路,那么检查哪些状态是正确的,我应该担心哪些线程问题？

非工作案例:

//making an IEnumerable as an example, remember I don't control this part
Task t = new Task( () => Console.WriteLine("started"));
IEnumerable<Task> tasks = new[] {t};

//here I receive the tasks
await Task.WhenAll(tasks);//waits forever because t is not started

工作案例示例:

//calls …

我想用一些元数据将一些属性包装在 JSON 对象中，无论它是否为空。但是，JsonConverter.WriteJson如果属性为 ，则不会调用我的自定义覆盖null。

当属性不为空时我得到什么：

{"Prop":{"Version":1, "Object":{"Content":"abc"}}}

当它为空时我得到什么：

{"Prop":null}

当它为空时我想要什么：

{"Prop":{"Version":1, "Object":null}}

由于WriteJson从未被要求提供空值，我没有机会控制这种行为。有什么办法可以强制这样做吗？

请注意，我想知道这是否可以与转换器或合约解析器等一起使用，我不能/不想更改MyContent或Wrap类（见下文）。

class VersioningJsonConverter : JsonConverter
{
    //Does not get called if value is null !!
    public override void WriteJson(JsonWriter writer, Object value, JsonSerializer serializer)
    {
        writer.WriteStartObject();
        writer.WritePropertyName("v");
        writer.WriteValue(1);
        writer.WritePropertyName("o");
        if(value == null)
        {
            //never happens
            writer.WriteNull();
        }
        else
        {
            writer.WriteStartObject();
            writer.WritePropertyName("Content");
            writer.WriteValue((value as MyContent).Content);                
            writer.WriteEndObject();
        }
        writer.WriteEndObject();
    }
    public override Object ReadJson(JsonReader reader, Type objectType, …