Q:  My C# application crashes on start with an exception CLR20R2 mentioning System.Security.Security

Q:  In C#, can I write a generic that inherits from one of it's type arguments, so I can specialize it's behavior, as in:

    class Demostration<T> : T

Q:  How can I inline a C# method?

        Employee employee = new Employee("Cool Guy", 65);
        IPromotion p = employee;
        Console.WriteLine(employee);
        p.promote();
        Console.WriteLine(employee);

        public void SetVariableValueOldOk<Tvalue>( int variableStorageElementNo, Tvalue newValue )
        {
            if (typeof(Tvalue) == typeof(double))
                variableStorageDouble[variableStorageElementNo] = (double) (object) newValue;
            else if (typeof(Tvalue) == typeof(int))
                variableStorageInt[variableStorageElementNo] = (int) (object) newValue;
            // Handle other types ...

        }

2. Use pointers to take the address of the generic parameters
    This functions as above, but manually pins the generic parameter by using a little-known trick of obtaining a second GC handle to an existing object.  It is then possible to get the address of the object, bypassing the compiler's limitation on doing so for managed types.  This has only been tested for value-types.  Unfortunately, the overhead of the GCHandle calls render this method no faster than the above.

        public unsafe void SetVariableValue<Tvalue>( int variableStorageElementNo, Tvalue newValue )
        {
            IntPtr valuePointer;
            double* valuePointerDouble;
            int* valuePointerInt;
            System.Runtime.InteropServices.GCHandle genericObjectHandle;
            genericObjectHandle = System.Runtime.InteropServices.GCHandle.Alloc(newValue, System.Runtime.InteropServices.GCHandleType.Pinned);
            valuePointer = genericObjectHandle.AddrOfPinnedObject();
 
            if (typeof(Tvalue) == typeof(double))
            {
                valuePointerDouble = (double*) valuePointer;
                variableStorageDouble[variableStorageElementNo] = *valuePointerDouble;
            }
            else if (typeof(Tvalue) == typeof(int))
            {
                valuePointerInt = (int*) valuePointer;
                variableStorageInt[variableStorageElementNo] = *valuePointerInt;
            }
            genericObjectHandle.Free();
        }

Q:  For performance sensitive code, how expensive is typeof()?
A:  A call to typeof is approximately 14x more expensive than setting a value in a single-dimensional array.
Q:  In C#/NET, can I use the Shadow Copy feature to update an assembly used by an AppDomain?
A:  Not in the way that is intended by this question - unfortunately, the MSDN description of shadow copy is vague.  AppDomain shadow copy does NOT permit the in-memory assembly used in an AppDomain to be updated.  What it does instead is permit the install fileset to be modified, by making a copy of nearly all an application's assemblies to a temp directory at app startup, assuming the author follows a specific pattern in the application design.  At least one assembly must provide the support for this, and consequently cannot be updated.  The Shadow Copy feature is intended for use by service-oriented programs such as servers, where the server core is hosted in a separate replaceable assembly and run in a child AppDomain.  The program must include a shell with three responsibilities:
Run the server core in a child AppDomain with ShadowCopy enabled for a specified directory containing the core assembly(ies).
Route client requests to the appropriate AppDomain and server responses back to those clients.  Nearly always, this is accomplished by  holding a reference to the current child AppDomain to use and routing all new client connections to it.
Monitor the special directory containing the core assembly(ies), and when it sees updates, create a new AppDomain using the new assemblies.
For reference, see this old but authoritative MSDN blog that clearly spells this out at the end.

Q:  Can I write unmanaged code in C#?
A:  No, the Microsoft C# compiler only generates managed code.  It cannot generate code that does not require the NET runtime services to operate.  However, you can write methods that use pointers.  This is called unsafe code.  You can also pass a pointer to a managed delegate to an unmanaged function, such as a Win32 API like EnumWindows.  The NET runtime will automatically lock the method code and marshal the method pointer to a native pointer.  Doing this introduces the unobvious problem that the delegate may be cleaned up unexpectedly.  This happens when you pass a delegate that must remain registered past the lifespan of the current method call or context.  Resolving this is easy:  store a reference to the delegate in an object with sufficient lifespan.

Q:  I need a high-speed 128-bit integer (Int128) library/assembly for C#.  What should I use?
A:  It depends.
Using only a few thousand values at a time:  Use System.Numerics.BigInteger.  This has the best performance of any extended-length integer I have tested, C# and C++.
Using hundreds of thousands or more values at a time:  It depends again:
Performance of multiply/divide not that important:  Use the Softfluent Int128 class.  It is posted on CodePlex and it's license is commercial-friendly (Microsoft Public License).
Need high-speed multiply/divide:  Roll your own.  Easiest way to do is to either fix the multiply/divide in the Softfluent class.  See the Mono source for a good-speed BigInteger whose operations are nearly as fast as the Microsoft implementation.
There are significant performance differences between implementations.  A key issue is that most Int128 implementations are really arbitrarily-long integer classes originating from cryptography or game programming, which hurts their performance in this case.  Here's a performance comparison of several extended-size integer libraries for 128-bit (16 byte) integers versus int64 operations.  The table shows the time of the operation in multiples of the time for the same operation implemented using int64s.  All operations used the same 4-digit numbers.  This test was not extremely rigorous, but it is accurate enough for the differences it encountered.
Package
Add
Subtract
Multiply
Divide
ToDouble
FromDouble
Microsoft System.Numerics.BigInteger
 7.1
 7.1
 6.8
 4.6
 2.143
 3.5
Mono System.Numerics.BigInteger
 9.9
 14
 7.8
 7.7
 327.4*
 6.3
CodeProject BigInteger
 11
 40
 9.1
 9.5
 4681*
 8.8
SoftFluent
 4.1
 18
 73
 56
 855.1*
 4.4
GNU GPM (MIPR Windows distribution)***
 33.8
 36
 69
 15
 **
 **
XInt***
 1793
 4413
 3276
 388
 **
 **
*None of these libraries actually implement this function - they all convert the big integer to a number, then use a double string parsing routine to get the double, thus the extreme slowness
**Unsupported, you must create your own
***No significant difference when using different memory allocators, internal APIs, or provided classes implementations

Q:  How do I write a managed C++/CLI method in native assembly?
A:  You can't in Windows 7 and previous.  All CLR types are actually compiled to IL, not native code.  The Visual C++ IDE/debugger goes to considerable effort to make everything appear native, but it is not.  You can partially workaround this by calling an assembly function.  The CLR will automatically perform a managed/unmanaged transition at the CALL instruction - the Visual Studio IDE will not indicate that this is done or allow you to trace through it.  Consequently, the expense of this transition is hidden.  The overhead is quite low and only significant if the execution time of your method is on the order of 1-10 function calls, as in the case of the x86 assembly instructions to perform 128-bit operations.  In this case, the overhead may exceed the time of your method by several times and is unavoidable.
C++/CLI actually compiles to CIL #1
C++/CLI actually compiles to CIL #2

In Windows 8 and above, however, you can accomplish this by writing a Windows Runtime Component that can be projected into .NET and used from there.  This is not a feature of the .NET framework, it is a feature of the new Windows Runtime API in Windows 8.  Consequently, it is unlikely to be backported to Windows 7 or older OS's.  One reference, though not the best, on this is here. 

Q:  How do I eliminate the CLR overhead when calling a high-performance/very short time assembly routine from a managed C++/CLI method?
A:  You can't, and Visual Studio will hide the transition from you as you trace through the code in the debugger.  For example, if you enable disassembly while stepping through a function, a single-step at the assembly CALL instruction will go directly to the code for that function.  The only indication that a managed->native transition took place is the addition of a [Managed-to-native] item at the top of the call stack.  Consider re-implementing the routine using only C++ code that is supported by the CLR - this means no compiler intrinsics either.  While slower, the total time will likely be less than the less efficient implement + managed->unmanaged transition time.

Q:  How do I determine the byte ordering (endianness) of the C# CLR/CIL virtual machine?
A:  Call System.BitConverter.IsLittleEndian.  This assumes memory is byte-addressable, which is normally the case.  However, some memory is word-addressable, which can result in unexpected byte orderings, such as little-endian 16-bit.

Q:  How do I get my XmlSerializer to qualify XML element and attribute names with the namespace abbreviation?
A:  Do the following:
1.  Create an XmlSerializerNamespaces object and add all needed prefix/namespace mappings.
2.  Set the Namespace attribute of the XmlRoot used for your class to the namespace it exists in (not the prefix)

Q:  How do I serialize data with XmlSerializer?  Specifically, configure classes using it's attributes to serialize/deserialize XML?
A:  In general, it is better to use DataContractSerializer than XmlSerializer.  The XmlSerializer class should only be used when you need exact control of the XML generated or processed.  This can be complicated by limitations of XmlSerializer, particularly in regard to custom collection types.  The following rules illustrate how to map C# classes to XML via XmlSerializer.  These rules should not be considered the only way to do things, particularly in the case of collections, but are the simplest approach most of the time.
1. Model each XML complex type or structure-like element as a class.  A structure-like element is an element whose child elements store either primitive values or collections of primitive values.
2. Decorate the class members stored as an XML element with XmlElement.  If necessary, use a more descriptive or meaningful name in the C# class and specify the ElementName attribute of XmlElement to connect it to the element name in the XML.
3. Decorate the class members stored as XML attributes with XmlAttribute.  If necessary, use a more descriptive or meaningful name in the C# class and specify the AttributeName attribute of XmlElement to connect it to the element name in the XML.
4. To capture all attributes of an element not mapped by members decorated with XmlAttribute, create a single member of type XmlAttribute[] decorated with XmlAnyAttribute.  If you need only the attribute values, this member can a string collection type instead, such as string[] or List<string>.  This is not recommended if the class will be serialized as well due to the lack of attribute names.
5. To capture all child elements of an element not mapped by members decorated with XmlElement, create a single member of type XmlElement[] decorated with XmlAnyElement.  Note that empty child elements with no attributes are ignored.
6. To capture the value (inner text) of an element that represents a primitive value and also has an attribute, create a class for the element with two members:  one for the attribute decorated with XmlAttribute and one for the element contents decorated with XmlText.
7. There are many ways to map collections from XML to the class.
    a.  If the XML uses a plural/singular pattern, such as a <books> element that contains multiple <book> elements, create a class for the item, book in this case, then map the collection by creating a class member decorated with XmlArray("books") and XmlArrayItem("book").  For example, for the following XML:
        <root>
            <books>
                <book>
                    <title>The Hitchhiker's Guide To The Galaxy</title>
                    <author>Douglas Adams</author>
                </book>
                <book>
                    <title>The C Programming Language</title>
                    <author>Brian Kerningham and Dennis Ritchie</author>
                </book>
            </books>
        </root>
    This can be mapped via the following C#:
    [XmlType("root")]
    public class Root
    {
        [XmlArray("books")]
        [XmlArrayItem("book")]
        public Book[] theBooks;
    }

    public class Book
    {
        [XmlElement(ElementName="title"))
        public string title;
        [XmlElement(ElementName="author"))
        public string author;
    }
    This XML can also be modeled using the method in B, but it requires three classes instead of two:  one for root, one for books, and one for book.  That approach is not recommended.  

    b.  If the XML uses a list of elements of the same type, map the collection by creating a class member of any valid collection type.  For example, given the following XML:
        <common_properties somethingcustom="zzz">
            <e name="NCName" desc="String" type="string" lang="en-us" ro="false" unit="String" unit_ref="String" ci="0">text</e>
            <e name="blub" ci="1" desc="Blubber factor">17</e>
        </common_properties>
        This can be modeled using the following C# code:  This class also captures any other attributes not specifically mapped via XmlAttribute.
public class CommonProperties
{
    [XmlElement(ElementName="e")]
    public CommonPropertiesExtensionValue[]     values;
}

public class CommonPropertiesExtensionValue
{
    [XmlAttribute(AttributeName="name")]
    public string                               name;
    [XmlAttribute(AttributeName="desc")]
    public string                               description;
    [XmlAttribute(AttributeName="type")]
    public string                               type;
    [XmlAttribute(AttributeName="lang")]
    public string                               language;
    [XmlAttribute(AttributeName="ro")]
    public string                               isReadOnly;
    [XmlAttribute(AttributeName="unit")]
    public string                               unit;
    [XmlAttribute(AttributeName="unit_ref")]
    public string                               unitReference;
    [XmlAttribute(AttributeName="ci")]
    public string                               creatorId;
    [XmlAnyAttribute]
    public System.Xml.XmlAttribute[]            customAttributes;
    [XmlText]
            public string                               value;
}
8.  You must designate a single class as the root element for your file.  Decorate this class with XmlRoot.  The data type of this class is the type you specify when creating the XmlSerializer.
9.  If the root element and all subelements exist within a namespace, specify this namespace via XmlRoot's Namespace attribute.  If a subelement exists in a different namespace, specify that namespace by setting the Namespace property of the XmlElement attribute on the c# class member for that subelement.  For example, in the example in 7b, if the e element existed in a namespace different from it's parent common_properties, this should be specified by modifying the XmlElement attribute on CommonProperties.values to add Namespace="http://whatever".

Q:  My XmlSerializer XML class does not write back out the namespace prefixes that were defined in the document.  It does deserialize correctly, but the resultant XML does not use prefixes and looks different.  How do I preserve the prefixes?
A:  Add a XmlSerializerNamespaces member to the element marked [XmlRoot] and decorate the member with [XmlNamespaceDelcarations].  This will persist the namespace prefixes defined at the document root and normally resolves the issue.  However, it is possible to define a namespace prefix or current namespace at any element of an XML file.  To persist this information for serialization, it must be captured during deserialization.  To do so, modify every class corresponding to an XML element by adding a XmlAttribute[] member decorated with [XmlAnyAttribute].  This will ensure that any element custom attributes are persisted and written back out at serialization time

Q:  When writing XML via XmlWriter, XmlWriter does not use my document/pre-defined namespace prefixes.  How do I fix this?
A:  Call XmlWriter.LookupPrefix, and if non-null, supply the prefix in the WriteAttributeString call.  For example:
    namespacePrefix = targetWriter.LookupPrefix(currCustomAttribute.NamespaceURI);
    if (namespacePrefix != null)
        targetWriter.WriteAttributeString(namespacePrefix, currCustomAttribute.LocalName, currCustomAttribute.NamespaceURI, currCustomAttribute.Value);
    else
        targetWriter.WriteAttributeString(currCustomAttribute.LocalName, currCustomAttribute.NamespaceURI, currCustomAttribute.Value);

Q:  What's the fastest way to do XPath queries in C#?
A:  Use an XPathDocument to get an XPathNavigator.  This is approximately 30x faster than an XmlDocument's XPathNavigator.  See this link for an illustrative study.

Q:  The XmlReader throws an XmlSchemaValidationException from Create with the message "The 'http://www.w3.org/XML/1998/namespace:lang' attribute is not declared."  How do I fix this?
A:  Get a copy of that schema and provide it to the reader in the XmlReader.Create call.  To do so, specify an XmlReaderSettings object in the XmlReader.Create call and manually load the xml schema into that settings object, as in:
schemaStream = new FileStream(System.IO.Path.Combine(Path.GetDirectoryName(schemaName), "xml.xsd"), FileMode.Open, FileAccess.Read);
newSchema = XmlSchema.Read(schemaStream, null);
schemaStream.Dispose();
readerSettings.Schemas.Add(newSchema);
The MSDN documentation for XmlReader also suggests that the the XmlSchemaValidationFlag.AllowXmlAttributes will resolve this as well.  In my testing, it did not, regardless of whether or not the "xml" namespace was declared by the XSD.

Q:  How do I embed a file in a C# .resx file?
A:  You don't.  You can create a RESX element with a base64-'d copy of the file data, however.  A RESX file is completely self-contained, with no references to other files, unlike the RC format.  To achieve an effect similar to adding a binary resource stored in a file to an RC file, add the file to the Visual Studio project as an existing item, then set the Build Action to Embedded Resource.  If this is a WPF project, the Build Action Resource can be used as well.  The method used to load the file from resources varies slightly based on this type.  For an example of loading an embedded resource, see this MSDN example.

Q:  How do I specify the name used for an embedded resource?
A:  Edit the *proj file directly and add a LogicalName element to the EmbeddedResource element whose name you want to customize.  Set the element content to the name to use.  For example:
    <EmbeddedResource Include="XSD\xml.xsd">
      <SubType>Designer</SubType>
      <LogicalName>xsd\xml.xsd</LogicalName>
    </EmbeddedResource>

Q:  Is there a way to automatically determine the namespace used for automatically generated embedded resource names?
A:  No.  The string used for the namespace is actually simply a prefix for embedded resource names.  There are no actual namespaces used for embedded resources.  The prefix is generated from the Visual Studio default namespace project setting.  You can, however, specify names for the resources instead of using automatically generated names.  See the question above for more information.

Q:  Can I debug the XmlSerializer's serialization/deserialization process?
A:  Yes.  The XmlSerializer functions by dynamically creating an assembly at runtime and then executing that assembly.  To debug the dynamically-generated assembly, add the following to your app.config:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    ...
   <system.diagnostics>
      <switches>
         <add name="XmlSerialization.Compilation" value="1" />
      </switches>
   </system.diagnostics>
    ...
</configuration>
Then you will be able to step into the Serialize/Deserialize calls.  I've seen this many places on the web, most recently on Dominic Zukiewicz's blog.

Q:  Is there a free tool to determine the dependencies of a NET assembly?
A:  Yes.  Use the IL Disassembler installed with .NET.  They will be listed under the MANIFEST element, normally at the top of the list.  However, note that you must double-click the element to get the assembly list.  The text window at the bottom of ILDisasm does NOT show the value of the selected item.

Q:  SGen fails with the error "An attempt was made to load an assembly with an incorrect format"  How do I fix this?
A:  Use the .NET 4.0 version of SGen, located in "C:\Program Files\Microsoft SDKs\Windows\v7.0A\bin\NETFX 4.0 Tools".  Visual Studio 2010 includes several versions of SGen, some of which are better than others.  Credit this stackoverflow answer.

Q:  When the XmlSerializer calls my ValidationEventHandler, it does not provide a schema object.  The ValidationEventArgs SourceSchemaObject field is always null, and the XmlReader's SchemaInfo is also null.  How do I determine what schema rule was violated, causing my ValidationEventHandler to be called?
A:  Use reflection to extract the "validator" field from the XmlReader.  Cast this to System.Xml.Schema.XmlSchemaValidator, then call GetExpectedParticles().

Q:  Is there a way to set the StreamingContext argument for DataContextSerializer?
A:  No.  This argument is used only by NetDataContractSerializer.  DataContractSerializer doesn't even have an instance of StreamingContext.  See the DataContractSerializer source code.

Q:  Does Windows 8 support Windows Runtime (WinRT) desktop applications using XAML/WPF?
A:  No.  There is currently no clarification on when or if such support may be available from Microsoft.  Note that some, reportedly about half, of WinRT APIs can be called from a desktop app in some way, though.

Paul Spiteri's Blog With References to MSDN Discussions
MSDN Channel 9

Q:  How do I ensure a class static field/property is initialized before I reference it via Reflection?
A:  Call System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(targetType.TypeHandle).  Static field and property initializers are run before the class static constructor.  This method ensures the class constructor is run only once.  Note if you reference a class static directly, from code, the runtime of course ensures it is initialized for you.
References:  Slashdot discussion, C# language specification section 10.5.5.1.

Q:  How do I pass an object as an argument to an attribute constructor?
A:  You can't, but you can achieve the same effect via reflection.  Change the argument to a Type object and add a string property/field name argument.  You may also want an argument to clarify if a field or property is being referenced.  Then use reflection to get the static field/property.  Make sure to call RunClassConstructor first to ensure the target's initializer has run, or this is useless.

Q:  How do I specify a surrogate using the NetDataContractSerializer?
A:  You don't.  The NetDataContractSerializer has support that sounds very similar to DataContractSerializer's surrogates, but is effectively useless for most surrogates due to it's limitations.  For example, you can't solve the problem of remoting an unserializable system type such as System.Type or XmlSchemaObject.  In particular, the DataContractSerializer allows a caller to provide a substitute fully-built object to be serialized in place of another, and perform the reverse.  This encapsulates three important capabilities:
1.  The DataContractSerializer allows the caller to arbitrarily specify the type of object to substitute for the unserializable object X.  Other instances of the same class as X can use different types for the surrogate if needed.
2.  The surrogate is serialized and deserialized using the standard DataContractSerializer methods.
3.  The DataContractSerializer permits the surrogate specifier/unwrapper to initialize the surrogate and reconstruct the original via user specified code.

The NetDataContractSerializer does support an interface called ISerializationSurrogate, but this has many limitations:
1.  It cannot change the type of the object serialized in the stream/deserialized from the stream.
2.  The surrogate must implement ISerializable-style serialization.
3.  It requires a parameterless constructor, because the NetDataContractSerializer owns object construction.

The type of object can only be changed at deserialization time.  This is done by specifying a Binder and overriding BindToType.  However, only the type of object created can be changed - the binder cannot supply the object itself.  Consequently, this requires the type specified to support deserialization, and if it were capable of that, there would be no point in many cases.

See this MSDN article for examples of NetDataContractSerializer surrogates.

Q:  How do I receive service control events in a C# service?