Here, Microsoft uses the names “concurrent” and “background” to describe two versions of the GC it uses in .NET. In the .NET world, the “background collector” is an enhancement over the “concurrent collector” in that it has less restrictions on what application threads can do while the collector is running. A basic GC uses a … Read more
Once you map a file in memory, you cannot increase its size. This is a known limitation of memory mapped files. …you must calculate or estimate the size of the finished file because file mapping objects are static in size; once created, their size cannot be increased or decreased. One strategy would be to use … Read more
Good question – I was surprised that the first and third lines worked. However, they are supported in the C# language specification – in section 7.8.4, it talks about enumeration addition: Every enumeration type implicitly provides the following pre-defined operators, where E is the enum type and U is the underlying type of E: E … Read more
To workaround this .net bug, change all of the Solid Color Brushes in your code to be freezeable. For example <SolidColorBrush x:Key=”WindowBackground” Color=”Black” /> should be changed to: <SolidColorBrush po:Freeze=”True” x:Key=”WindowBackground” Color=”Black” />. For more detailed instructions see here: How can WPF objects deriving from Freezable be frozen in XAML?.
I remember reading something once from Microsoft that stated: “.NET 4.0 adds in-process side-by-side compatibility with earlier versions of the Framework. This feature allows an application process to simultaneously run part of its code using the .NET Common Language Runtime (CLR) 4 and other parts using older versions of the CLR.” So to answer your … Read more
I had a look at the code in ThreadLocal<T> to see what the current Dispose is doing and it appears to be a lot of voodoo. Obviously disposing of thread-related stuff. But it doesn’t dispose of the values if T itself is disposable. Now, I have a solution – a ThreadLocalDisposables<T> class, but before I … Read more
You are correct: in .NET 4, leaving the APTCA on there makes the assembly SecurityTransparent, and that may be what’s causing you grief. The MSDN article Migrating an APTCA Assembly to the .NET Framework 4 has a good discussion and explanation of the changes to the AllowPartiallyTrustedCallersAttribute in .NET 4. Specifically: The AllowPartiallyTrustedCallers attribute has … Read more
It is the UTF-8 BOM, which is actually discouraged by the Unicode standard: http://www.unicode.org/versions/Unicode5.0.0/ch02.pdf Use of a BOM is neither required nor recommended for UTF-8, but may be encountered in contexts where UTF-8 data is converted from other encoding forms that use a BOM or where the BOM is used as a UTF-8 signature You … Read more
IEnumerable<int> sequenceOfInts = new int[] { 1, 2, 3 }; IEnumerable<Foo> sequenceOfFoos = new Foo[] { new Foo() { Bar = “A” }, new Foo() { Bar = “B” } }; var serializer = new System.Web.Script.Serialization.JavaScriptSerializer(); string outputOfInts = serializer.Serialize(sequenceOfInts); string outputOfFoos = serializer.Serialize(sequenceOfFoos); Which produces the output [1,2,3] [{“Bar”:”A”},{“Bar”:”B”}] And then you can get … Read more
I haven’t tested this, but it seems like one possible workaround is to have multiple properties that all return the same thing. Conceivably you could then get 28 inlines per property. Note that the number of times a method is inlined most likely depends on the size of native code for that method (See http://blogs.msdn.com/b/vancem/archive/2008/08/19/to-inline-or-not-to-inline-that-is-the-question.aspx), … Read more