Errata

Chapter 1 Part 1 in the Table 1-2

It shows that the default is anycpu, which is not correct since in VS 2013 the default is anycpu32bitprefered.

Reference http://blogs.microsoft.co.il/blogs/sasha/archive/2012/04/04/what-anycpu-really-means-as-of-net-4-5-and-visual-studio-11.aspx

"Unfortunately, this is not possible. At run time, the CLR requires access to the assembly?s metadata... this requires that the assemblies that contain IL and metadata be shipped."

Starting with .NET version 2.0, the native image generator includes the IL code and metadata in the native image together with native code. The justification provided in the book holds only in .NET 1.0 and 1.1. It should something like "Unfortunately, this is not possible because the IL code is still included in the native image".

It's not a mistake, I just want to note something.

Quoted from the book:
"Metadata Reference Table Name: TypeRef
Description: Contains one entry for each type referenced by the module. Each entry includes the type?s name and a reference to where the type can be found. [...] If the type is implemented in the same module, the reference will indicate a ModuleDef entry. [...]"

According the ECMA-335, 6th edition, section II.22.38 "TypeRef : 0x01" at informative text section 1.d describing the ResolutionScope index, the ModuleDef table should not be referenced by the TypeRef table.
"a Module token, if the target type is defined in the current module - this should not occur in a CLI (?compressed metadata?) module [WARNING]"

The book states that "the reference will indicate a ModuleDef entry", but the CLR isn't, and shouldn't support that (valid somehow) option according the CLI standard.

"In addition, the assemblies in the compiler/CLR directory are machine agnostic. That is, these assemblies contain only metadata in them."

However, when opening an assembly from the compiler/CLR directory using ildasm.exe, we can clearly see that this assembly contains the IL code in it, not only metadata.

"The runtime ensures that the file being referenced is, in fact,
in the assembly?s ModuleRef table of the current assembly?s manifest"

Instead of "assembly?s manifest" it should be "assembly?s metadata" as the ModuleRef is defined at the metadata and not at the manifest.

"When searching the GAC for an assembly, the CLR figures out that type of process the application is currently running in: 32-bit x86 (possibly using the WoW64 technology), 64-bit x64, or 32-bit ARM."

"32-bit x86" (the first type listed) process type isn't require the WoW64 as it should run naturally.
Maybe the author meant to "32-bit x64" where the WoW64 is used to run 32-bit process over x64 machine as mentioned at the parenthesis right after.

"Returns an instance of a Type-derived object that identifies the type..."

It should be"Returns an instance of a Type-derived type that identifies the type..."

on page 150 dynamic types

Error in TryInvokeMember method mistake is

Wrong:

MethodInfo method = FindMethod(binder.Name);

Correct:

MethodInfo method = FindMethod(binder.Name,args.Select(c=>c.GetType()).ToArray());

"Table 6-1 shows the six accessibility modifiers that can be applied to a member. The rows of the table are in order from most restrictive (Private) to least restrictive (Public)."

Firstly, "Family and Assembly" is more restrictive than "Family" and so they are not in the right order in the table. Secondly, "Family" and "Assembly" cannot be ordered because we cannot say that one is more restrictive than the other.

The definition of the extension method "Raise" is incomplete. If you try to compile it, you get following error: "The type 'TEventArgs' must be convertible to 'System.EventArgs' in order to use it as parameter in the generic delegate 'delegate void EventHandler<TEventArgs>(object sender, TEventArgs e)'."

In the previous part of the chapter it is said that it's only an convention:
"By convention, classes that hold event information to be passed to the event handler should be derived from System.EventArgs"

So when we want to use a generic version of EventHandler it is a must (where TEventArgs : System.EventArgs).

Code for add_NewMail & remove_NewMail methods uses "newMail != prevHandler" as the loop exit condition.

As the Delegate type redefines "==" & "!=" operators, this test will result in Delegate's "Equals(object)" (costly) override being called, whereas a simple call to object.ReferenceEquals(newMail,prevHandler) would be OK.

So dont' you think the loop should be rewritten like this?

do
{
}
while(!object.ReferenceEquals(newMail, prevHandler))

using System;
using System.Reflection;
using System.IO;

(snip)

// This callback method takes 1 String argument
private static Object Reverse(String s1) {
return new String(s1.Reverse().ToArray());
}

I think you missed to add "using System.Linq;".

The sample uses the reverse() Methord without specifying "using System.Linq" namespace. Thus, the following line should be added

the second overload is written as follows:
public static Boolean TryParse(String s, NumberStyles styles, IFormatProvider, provider, out Int32 result);

notice the comma after IFormatProvider. I believe it shouldn't be there: 'IFormatProvider' is a type of the parameter and 'provider' is its name.

IInputStream interface defined as follow.
But showed IOutputStream.

Correct is follow.
public interface IInputStream : ICloseable{
IAsyncOperationWithProgress<UInt32, UInt32> ReadAsync(IBuffer buffer, uint count, InputStreamOption options)
}

Kindle edition. Location 3032. "Chapter 5. Primitive, Reference, and Value Types"

The table 5-1 mentions that string, object and dynamic are primitive types.

According to the following code, string and object are not primitive types:

Console.WriteLine("Is {0} a primitive data type? {1}.", typeof(string).Name, typeof(string).IsPrimitive);
Console.WriteLine("Is {0} a primitive data type? {1}.", typeof(object).Name, typeof(object).IsPrimitive);

This MSDN page is listing the primitive types: http://msdn.microsoft.com/en-us/library/system.type.isprimitive(v=vs.110).aspx