Merge pull request #298 from leecow/master

Preview 1 content updates and API diff

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff.md

@@ -0,0 +1,20 @@
+# API Difference .NET Core App 1.0 (ref) vs .NET Core App 1.1 (ref)
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System](1.0-1.1-api-diff_System.md)
+* [System.Composition](1.0-1.1-api-diff_System.Composition.md)
+* [System.Composition.Convention](1.0-1.1-api-diff_System.Composition.Convention.md)
+* [System.Composition.Hosting](1.0-1.1-api-diff_System.Composition.Hosting.md)
+* [System.Composition.Hosting.Core](1.0-1.1-api-diff_System.Composition.Hosting.Core.md)
+* [System.IO.Pipes](1.0-1.1-api-diff_System.IO.Pipes.md)
+* [System.Reflection.Metadata](1.0-1.1-api-diff_System.Reflection.Metadata.md)
+* [System.Reflection.Metadata.Ecma335](1.0-1.1-api-diff_System.Reflection.Metadata.Ecma335.md)
+* [System.Reflection.PortableExecutable](1.0-1.1-api-diff_System.Reflection.PortableExecutable.md)
+* [System.Runtime.CompilerServices](1.0-1.1-api-diff_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](1.0-1.1-api-diff_System.Runtime.InteropServices.md)
+* [System.Text.RegularExpressions](1.0-1.1-api-diff_System.Text.RegularExpressions.md)
+* [System.Threading.Tasks](1.0-1.1-api-diff_System.Threading.Tasks.md)
+* [System.Xml](1.0-1.1-api-diff_System.Xml.md)
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Composition.Convention.md

@@ -0,0 +1,80 @@
+# System.Composition.Convention
+
+``` diff
++namespace System.Composition.Convention {
++    public abstract class AttributedModelProvider {
++        protected AttributedModelProvider();
++        public abstract IEnumerable<Attribute> GetCustomAttributes(Type reflectedType, MemberInfo member);
++        public abstract IEnumerable<Attribute> GetCustomAttributes(Type reflectedType, ParameterInfo parameter);
++    }
++    public class ConventionBuilder : AttributedModelProvider {
++        public ConventionBuilder();
++        public PartConventionBuilder ForType(Type type);
++        public PartConventionBuilder<T> ForType<T>();
++        public PartConventionBuilder ForTypesDerivedFrom(Type type);
++        public PartConventionBuilder<T> ForTypesDerivedFrom<T>();
++        public PartConventionBuilder ForTypesMatching(Predicate<Type> typeFilter);
++        public PartConventionBuilder<T> ForTypesMatching<T>(Predicate<Type> typeFilter);
++        public override IEnumerable<Attribute> GetCustomAttributes(Type reflectedType, MemberInfo member);
++        public override IEnumerable<Attribute> GetCustomAttributes(Type reflectedType, ParameterInfo parameter);
++    }
++    public sealed class ExportConventionBuilder {
++        public ExportConventionBuilder AddMetadata(string name, Func<Type, object> getValueFromPartType);
++        public ExportConventionBuilder AddMetadata(string name, object value);
++        public ExportConventionBuilder AsContractName(Func<Type, string> getContractNameFromPartType);
++        public ExportConventionBuilder AsContractName(string contractName);
++        public ExportConventionBuilder AsContractType(Type type);
++        public ExportConventionBuilder AsContractType<T>();
++    }
++    public sealed class ImportConventionBuilder {
++        public ImportConventionBuilder AddMetadataConstraint(string name, Func<Type, object> getConstraintValueFromPartType);
++        public ImportConventionBuilder AddMetadataConstraint(string name, object value);
++        public ImportConventionBuilder AllowDefault();
++        public ImportConventionBuilder AsContractName(Func<Type, string> getContractNameFromPartType);
++        public ImportConventionBuilder AsContractName(string contractName);
++        public ImportConventionBuilder AsMany();
++        public ImportConventionBuilder AsMany(bool isMany);
++    }
++    public abstract class ParameterImportConventionBuilder {
++        public T Import<T>();
++        public T Import<T>(Action<ImportConventionBuilder> configure);
++    }
++    public class PartConventionBuilder {
++        public PartConventionBuilder AddPartMetadata(string name, Func<Type, object> getValueFromPartType);
++        public PartConventionBuilder AddPartMetadata(string name, object value);
++        public PartConventionBuilder Export();
++        public PartConventionBuilder Export(Action<ExportConventionBuilder> exportConfiguration);
++        public PartConventionBuilder Export<T>();
++        public PartConventionBuilder Export<T>(Action<ExportConventionBuilder> exportConfiguration);
++        public PartConventionBuilder ExportInterfaces();
++        public PartConventionBuilder ExportInterfaces(Predicate<Type> interfaceFilter);
++        public PartConventionBuilder ExportInterfaces(Predicate<Type> interfaceFilter, Action<Type, ExportConventionBuilder> exportConfiguration);
++        public PartConventionBuilder ExportProperties(Predicate<PropertyInfo> propertyFilter);
++        public PartConventionBuilder ExportProperties(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ExportConventionBuilder> exportConfiguration);
++        public PartConventionBuilder ExportProperties<T>(Predicate<PropertyInfo> propertyFilter);
++        public PartConventionBuilder ExportProperties<T>(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ExportConventionBuilder> exportConfiguration);
++        public PartConventionBuilder ImportProperties(Predicate<PropertyInfo> propertyFilter);
++        public PartConventionBuilder ImportProperties(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ImportConventionBuilder> importConfiguration);
++        public PartConventionBuilder ImportProperties<T>(Predicate<PropertyInfo> propertyFilter);
++        public PartConventionBuilder ImportProperties<T>(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ImportConventionBuilder> importConfiguration);
++        public PartConventionBuilder NotifyImportsSatisfied(Predicate<MethodInfo> methodFilter);
++        public PartConventionBuilder SelectConstructor(Func<IEnumerable<ConstructorInfo>, ConstructorInfo> constructorSelector);
++        public PartConventionBuilder SelectConstructor(Func<IEnumerable<ConstructorInfo>, ConstructorInfo> constructorSelector, Action<ParameterInfo, ImportConventionBuilder> importConfiguration);
++        public PartConventionBuilder Shared();
++        public PartConventionBuilder Shared(string sharingBoundary);
++    }
++    public class PartConventionBuilder<T> : PartConventionBuilder {
++        public PartConventionBuilder<T> ExportProperty(Expression<Func<T, object>> propertySelector);
++        public PartConventionBuilder<T> ExportProperty(Expression<Func<T, object>> propertySelector, Action<ExportConventionBuilder> exportConfiguration);
++        public PartConventionBuilder<T> ExportProperty<TContract>(Expression<Func<T, object>> propertySelector);
++        public PartConventionBuilder<T> ExportProperty<TContract>(Expression<Func<T, object>> propertySelector, Action<ExportConventionBuilder> exportConfiguration);
++        public PartConventionBuilder<T> ImportProperty(Expression<Func<T, object>> propertySelector);
++        public PartConventionBuilder<T> ImportProperty(Expression<Func<T, object>> propertySelector, Action<ImportConventionBuilder> importConfiguration);
++        public PartConventionBuilder<T> ImportProperty<TContract>(Expression<Func<T, object>> propertySelector);
++        public PartConventionBuilder<T> ImportProperty<TContract>(Expression<Func<T, object>> propertySelector, Action<ImportConventionBuilder> importConfiguration);
++        public PartConventionBuilder<T> NotifyImportsSatisfied(Expression<Action<T>> methodSelector);
++        public PartConventionBuilder<T> SelectConstructor(Expression<Func<ParameterImportConventionBuilder, T>> constructorSelector);
++    }
++}
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Composition.Hosting.Core.md

@@ -0,0 +1,75 @@
+# System.Composition.Hosting.Core
+
+``` diff
++namespace System.Composition.Hosting.Core {
++    public delegate object CompositeActivator(LifetimeContext context, CompositionOperation operation);
++    public sealed class CompositionContract {
++        public CompositionContract(Type contractType);
++        public CompositionContract(Type contractType, string contractName);
++        public CompositionContract(Type contractType, string contractName, IDictionary<string, object> metadataConstraints);
++        public string ContractName { get; }
++        public Type ContractType { get; }
++        public IEnumerable<KeyValuePair<string, object>> MetadataConstraints { get; }
++        public CompositionContract ChangeType(Type newContractType);
++        public override bool Equals(object obj);
++        public override int GetHashCode();
++        public override string ToString();
++        public bool TryUnwrapMetadataConstraint<T>(string constraintName, out T constraintValue, out CompositionContract remainingContract);
++    }
++    public class CompositionDependency {
++        public CompositionContract Contract { get; }
++        public bool IsPrerequisite { get; }
++        public object Site { get; }
++        public ExportDescriptorPromise Target { get; }
++        public static CompositionDependency Missing(CompositionContract contract, object site);
++        public static CompositionDependency Oversupplied(CompositionContract contract, IEnumerable<ExportDescriptorPromise> targets, object site);
++        public static CompositionDependency Satisfied(CompositionContract contract, ExportDescriptorPromise target, bool isPrerequisite, object site);
++        public override string ToString();
++    }
++    public sealed class CompositionOperation : IDisposable {
++        public void AddNonPrerequisiteAction(Action action);
++        public void AddPostCompositionAction(Action action);
++        public void Dispose();
++        public static object Run(LifetimeContext outermostLifetimeContext, CompositeActivator compositionRootActivator);
++    }
++    public abstract class DependencyAccessor {
++        protected DependencyAccessor();
++        protected abstract IEnumerable<ExportDescriptorPromise> GetPromises(CompositionContract exportKey);
++        public IEnumerable<CompositionDependency> ResolveDependencies(object site, CompositionContract contract, bool isPrerequisite);
++        public CompositionDependency ResolveRequiredDependency(object site, CompositionContract contract, bool isPrerequisite);
++        public bool TryResolveOptionalDependency(object site, CompositionContract contract, bool isPrerequisite, out CompositionDependency dependency);
++    }
++    public abstract class ExportDescriptor {
++        protected ExportDescriptor();
++        public abstract CompositeActivator Activator { get; }
++        public abstract IDictionary<string, object> Metadata { get; }
++        public static ExportDescriptor Create(CompositeActivator activator, IDictionary<string, object> metadata);
++    }
++    public class ExportDescriptorPromise {
++        public ExportDescriptorPromise(CompositionContract contract, string origin, bool isShared, Func<IEnumerable<CompositionDependency>> dependencies, Func<IEnumerable<CompositionDependency>, ExportDescriptor> getDescriptor);
++        public CompositionContract Contract { get; }
++        public ReadOnlyCollection<CompositionDependency> Dependencies { get; }
++        public bool IsShared { get; }
++        public string Origin { get; }
++        public ExportDescriptor GetDescriptor();
++        public override string ToString();
++    }
++    public abstract class ExportDescriptorProvider {
++        protected static readonly IDictionary<string, object> NoMetadata;
++        protected static readonly IEnumerable<ExportDescriptorPromise> NoExportDescriptors;
++        protected static readonly Func<IEnumerable<CompositionDependency>> NoDependencies;
++        protected ExportDescriptorProvider();
++        public abstract IEnumerable<ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor);
++    }
++    public sealed class LifetimeContext : CompositionContext, IDisposable {
++        public void AddBoundInstance(IDisposable instance);
++        public static int AllocateSharingId();
++        public void Dispose();
++        public LifetimeContext FindContextWithin(string sharingBoundary);
++        public object GetOrCreate(int sharingId, CompositionOperation operation, CompositeActivator creator);
++        public override string ToString();
++        public override bool TryGetExport(CompositionContract contract, out object export);
++    }
++}
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Composition.Hosting.md

@@ -0,0 +1,35 @@
+# System.Composition.Hosting
+
+``` diff
++namespace System.Composition.Hosting {
++    public class CompositionFailedException : Exception {
++        public CompositionFailedException();
++        public CompositionFailedException(string message);
++        public CompositionFailedException(string message, Exception innerException);
++    }
++    public sealed class CompositionHost : CompositionContext, IDisposable {
++        public static CompositionHost CreateCompositionHost(IEnumerable<ExportDescriptorProvider> providers);
++        public static CompositionHost CreateCompositionHost(params ExportDescriptorProvider[] providers);
++        public void Dispose();
++        public override bool TryGetExport(CompositionContract contract, out object export);
++    }
++    public class ContainerConfiguration {
++        public ContainerConfiguration();
++        public CompositionHost CreateContainer();
++        public ContainerConfiguration WithAssemblies(IEnumerable<Assembly> assemblies);
++        public ContainerConfiguration WithAssemblies(IEnumerable<Assembly> assemblies, AttributedModelProvider conventions);
++        public ContainerConfiguration WithAssembly(Assembly assembly);
++        public ContainerConfiguration WithAssembly(Assembly assembly, AttributedModelProvider conventions);
++        public ContainerConfiguration WithDefaultConventions(AttributedModelProvider conventions);
++        public ContainerConfiguration WithPart(Type partType);
++        public ContainerConfiguration WithPart(Type partType, AttributedModelProvider conventions);
++        public ContainerConfiguration WithPart<TPart>();
++        public ContainerConfiguration WithPart<TPart>(AttributedModelProvider conventions);
++        public ContainerConfiguration WithParts(IEnumerable<Type> partTypes);
++        public ContainerConfiguration WithParts(IEnumerable<Type> partTypes, AttributedModelProvider conventions);
++        public ContainerConfiguration WithParts(params Type[] partTypes);
++        public ContainerConfiguration WithProvider(ExportDescriptorProvider exportDescriptorProvider);
++    }
++}
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Composition.md

@@ -0,0 +1,96 @@
+# System.Composition
+
+``` diff
++namespace System.Composition {
++    public abstract class CompositionContext {
++        protected CompositionContext();
++        public object GetExport(CompositionContract contract);
++        public object GetExport(Type exportType);
++        public object GetExport(Type exportType, string contractName);
++        public TExport GetExport<TExport>();
++        public TExport GetExport<TExport>(string contractName);
++        public IEnumerable<object> GetExports(Type exportType);
++        public IEnumerable<object> GetExports(Type exportType, string contractName);
++        public IEnumerable<TExport> GetExports<TExport>();
++        public IEnumerable<TExport> GetExports<TExport>(string contractName);
++        public abstract bool TryGetExport(CompositionContract contract, out object export);
++        public bool TryGetExport(Type exportType, out object export);
++        public bool TryGetExport(Type exportType, string contractName, out object export);
++        public bool TryGetExport<TExport>(string contractName, out TExport export);
++        public bool TryGetExport<TExport>(out TExport export);
++    }
++    public static class CompositionContextExtensions {
++        public static void SatisfyImports(this CompositionContext compositionContext, object objectWithLooseImports);
++        public static void SatisfyImports(this CompositionContext compositionContext, object objectWithLooseImports, AttributedModelProvider conventions);
++    }
++    public sealed class Export<T> : IDisposable {
++        public Export(T value, Action disposeAction);
++        public T Value { get; }
++        public void Dispose();
++    }
++    public class ExportAttribute : Attribute {
++        public ExportAttribute();
++        public ExportAttribute(string contractName);
++        public ExportAttribute(string contractName, Type contractType);
++        public ExportAttribute(Type contractType);
++        public string ContractName { get; private set; }
++        public Type ContractType { get; private set; }
++    }
++    public class ExportFactory<T> {
++        public ExportFactory(Func<Tuple<T, Action>> exportCreator);
++        public Export<T> CreateExport();
++    }
++    public class ExportFactory<T, TMetadata> : ExportFactory<T> {
++        public ExportFactory(Func<Tuple<T, Action>> exportCreator, TMetadata metadata);
++        public TMetadata Metadata { get; }
++    }
++    public sealed class ExportMetadataAttribute : Attribute {
++        public ExportMetadataAttribute(string name, object value);
++        public string Name { get; private set; }
++        public object Value { get; private set; }
++    }
++    public class ImportAttribute : Attribute {
++        public ImportAttribute();
++        public ImportAttribute(string contractName);
++        public bool AllowDefault { get; set; }
++        public string ContractName { get; private set; }
++    }
++    public sealed class ImportingConstructorAttribute : Attribute {
++        public ImportingConstructorAttribute();
++    }
++    public class ImportManyAttribute : Attribute {
++        public ImportManyAttribute();
++        public ImportManyAttribute(string contractName);
++        public string ContractName { get; private set; }
++    }
++    public sealed class ImportMetadataConstraintAttribute : Attribute {
++        public ImportMetadataConstraintAttribute(string name, object value);
++        public string Name { get; }
++        public object Value { get; }
++    }
++    public sealed class MetadataAttributeAttribute : Attribute {
++        public MetadataAttributeAttribute();
++    }
++    public sealed class OnImportsSatisfiedAttribute : Attribute {
++        public OnImportsSatisfiedAttribute();
++    }
++    public class PartMetadataAttribute : Attribute {
++        public PartMetadataAttribute(string name, object value);
++        public string Name { get; private set; }
++        public object Value { get; private set; }
++    }
++    public sealed class PartNotDiscoverableAttribute : Attribute {
++        public PartNotDiscoverableAttribute();
++    }
++    public class SharedAttribute : PartMetadataAttribute {
++        public SharedAttribute();
++        public SharedAttribute(string sharingBoundaryName);
++        public string SharingBoundary { get; }
++    }
++    public sealed class SharingBoundaryAttribute : Attribute {
++        public SharingBoundaryAttribute(params string[] sharingBoundaryNames);
++        public ReadOnlyCollection<string> SharingBoundaryNames { get; }
++    }
++}
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.IO.Pipes.md

@@ -0,0 +1,60 @@
+# System.IO.Pipes
+
+``` diff
+ namespace System.IO.Pipes {
++    public enum PipeAccessRights {
++        AccessSystemSecurity = 16777216,
++        ChangePermissions = 262144,
++        CreateNewInstance = 4,
++        Delete = 65536,
++        FullControl = 2032031,
++        Read = 131209,
++        ReadAttributes = 128,
++        ReadData = 1,
++        ReadExtendedAttributes = 8,
++        ReadPermissions = 131072,
++        ReadWrite = 131483,
++        Synchronize = 1048576,
++        TakeOwnership = 524288,
++        Write = 274,
++        WriteAttributes = 256,
++        WriteData = 2,
++        WriteExtendedAttributes = 16,
++    }
++    public sealed class PipeAccessRule : AccessRule {
++        public PipeAccessRule(IdentityReference identity, PipeAccessRights rights, AccessControlType type);
++        public PipeAccessRule(string identity, PipeAccessRights rights, AccessControlType type);
++        public PipeAccessRights PipeAccessRights { get; }
++    }
++    public sealed class PipeAuditRule : AuditRule {
++        public PipeAuditRule(IdentityReference identity, PipeAccessRights rights, AuditFlags flags);
++        public PipeAuditRule(string identity, PipeAccessRights rights, AuditFlags flags);
++        public PipeAccessRights PipeAccessRights { get; }
++    }
++    public static class PipesAclExtensions {
++        public static PipeSecurity GetAccessControl(this PipeStream stream);
++        public static void SetAccessControl(this PipeStream stream, PipeSecurity pipeSecurity);
++    }
++    public class PipeSecurity : NativeObjectSecurity {
++        public PipeSecurity();
++        public override Type AccessRightType { get; }
++        public override Type AccessRuleType { get; }
++        public override Type AuditRuleType { get; }
++        public override AccessRule AccessRuleFactory(IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
++        public void AddAccessRule(PipeAccessRule rule);
++        public void AddAuditRule(PipeAuditRule rule);
++        public sealed override AuditRule AuditRuleFactory(IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
++        protected internal void Persist(SafeHandle handle);
++        protected internal void Persist(string name);
++        public bool RemoveAccessRule(PipeAccessRule rule);
++        public void RemoveAccessRuleSpecific(PipeAccessRule rule);
++        public bool RemoveAuditRule(PipeAuditRule rule);
++        public void RemoveAuditRuleAll(PipeAuditRule rule);
++        public void RemoveAuditRuleSpecific(PipeAuditRule rule);
++        public void ResetAccessRule(PipeAccessRule rule);
++        public void SetAccessRule(PipeAccessRule rule);
++        public void SetAuditRule(PipeAuditRule rule);
++    }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Reflection.Metadata.Ecma335.md

@@ -0,0 +1,388 @@
+# System.Reflection.Metadata.Ecma335
+
+``` diff
+ namespace System.Reflection.Metadata.Ecma335 {
++    public struct ArrayShapeEncoder {
++        public ArrayShapeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void Shape(int rank, ImmutableArray<int> sizes, ImmutableArray<int> lowerBounds);
++    }
++    public struct BlobEncoder {
++        public BlobEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void CustomAttributeSignature(Action<FixedArgumentsEncoder> fixedArguments, Action<CustomAttributeNamedArgumentsEncoder> namedArguments);
++        public void CustomAttributeSignature(out FixedArgumentsEncoder fixedArguments, out CustomAttributeNamedArgumentsEncoder namedArguments);
++        public SignatureTypeEncoder FieldSignature();
++        public LocalVariablesEncoder LocalVariableSignature(int variableCount);
++        public MethodSignatureEncoder MethodSignature(SignatureCallingConvention convention=(SignatureCallingConvention)(0), int genericParameterCount=0, bool isInstanceMethod=false);
++        public GenericTypeArgumentsEncoder MethodSpecificationSignature(int genericArgumentCount);
++        public NamedArgumentsEncoder PermissionSetArguments(int argumentCount);
++        public PermissionSetEncoder PermissionSetBlob(int attributeCount);
++        public MethodSignatureEncoder PropertySignature(bool isInstanceProperty=false);
++        public SignatureTypeEncoder TypeSpecificationSignature();
++    }
++    public static class CodedIndex {
++        public static int CustomAttributeType(EntityHandle handle);
++        public static int HasConstant(EntityHandle handle);
++        public static int HasCustomAttribute(EntityHandle handle);
++        public static int HasCustomDebugInformation(EntityHandle handle);
++        public static int HasDeclSecurity(EntityHandle handle);
++        public static int HasFieldMarshal(EntityHandle handle);
++        public static int HasSemantics(EntityHandle handle);
++        public static int Implementation(EntityHandle handle);
++        public static int MemberForwarded(EntityHandle handle);
++        public static int MemberRefParent(EntityHandle handle);
++        public static int MethodDefOrRef(EntityHandle handle);
++        public static int ResolutionScope(EntityHandle handle);
++        public static int TypeDefOrRef(EntityHandle handle);
++        public static int TypeDefOrRefOrSpec(EntityHandle handle);
++        public static int TypeOrMethodDef(EntityHandle handle);
++    }
++    public sealed class ControlFlowBuilder {
++        public ControlFlowBuilder();
++        public void AddCatchRegion(LabelHandle tryStart, LabelHandle tryEnd, LabelHandle handlerStart, LabelHandle handlerEnd, EntityHandle catchType);
++        public void AddFaultRegion(LabelHandle tryStart, LabelHandle tryEnd, LabelHandle handlerStart, LabelHandle handlerEnd);
++        public void AddFilterRegion(LabelHandle tryStart, LabelHandle tryEnd, LabelHandle handlerStart, LabelHandle handlerEnd, LabelHandle filterStart);
++        public void AddFinallyRegion(LabelHandle tryStart, LabelHandle tryEnd, LabelHandle handlerStart, LabelHandle handlerEnd);
++    }
++    public struct CustomAttributeArrayTypeEncoder {
++        public CustomAttributeArrayTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public CustomAttributeElementTypeEncoder ElementType();
++        public void ObjectArray();
++    }
++    public struct CustomAttributeElementTypeEncoder {
++        public CustomAttributeElementTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void Boolean();
++        public void Byte();
++        public void Char();
++        public void Double();
++        public void Enum(string enumTypeName);
++        public void Int16();
++        public void Int32();
++        public void Int64();
++        public void PrimitiveType(PrimitiveSerializationTypeCode type);
++        public void SByte();
++        public void Single();
++        public void String();
++        public void SystemType();
++        public void UInt16();
++        public void UInt32();
++        public void UInt64();
++    }
++    public struct CustomAttributeNamedArgumentsEncoder {
++        public CustomAttributeNamedArgumentsEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public NamedArgumentsEncoder Count(int count);
++    }
++    public struct CustomModifiersEncoder {
++        public CustomModifiersEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public CustomModifiersEncoder AddModifier(EntityHandle type, bool isOptional);
++    }
++    public struct ExceptionRegionEncoder {
++        public BlobBuilder Builder { get; }
++        public bool HasSmallFormat { get; }
++        public ExceptionRegionEncoder Add(ExceptionRegionKind kind, int tryOffset, int tryLength, int handlerOffset, int handlerLength, EntityHandle catchType=null, int filterOffset=0);
++        public ExceptionRegionEncoder AddCatch(int tryOffset, int tryLength, int handlerOffset, int handlerLength, EntityHandle catchType);
++        public ExceptionRegionEncoder AddFault(int tryOffset, int tryLength, int handlerOffset, int handlerLength);
++        public ExceptionRegionEncoder AddFilter(int tryOffset, int tryLength, int handlerOffset, int handlerLength, int filterOffset);
++        public ExceptionRegionEncoder AddFinally(int tryOffset, int tryLength, int handlerOffset, int handlerLength);
++        public static bool IsSmallExceptionRegion(int startOffset, int length);
++        public static bool IsSmallRegionCount(int exceptionRegionCount);
++    }
++    public struct FixedArgumentsEncoder {
++        public FixedArgumentsEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public LiteralEncoder AddArgument();
++    }
++    public enum FunctionPointerAttributes {
++        HasExplicitThis = 96,
++        HasThis = 32,
++        None = 0,
++    }
++    public struct GenericTypeArgumentsEncoder {
++        public GenericTypeArgumentsEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public SignatureTypeEncoder AddArgument();
++    }
++    public struct InstructionEncoder {
++        public InstructionEncoder(BlobBuilder codeBuilder, ControlFlowBuilder controlFlowBuilder=null);
++        public BlobBuilder CodeBuilder { get; }
++        public ControlFlowBuilder ControlFlowBuilder { get; }
++        public int Offset { get; }
++        public void Branch(ILOpCode code, LabelHandle label);
++        public void Call(EntityHandle methodHandle);
++        public void Call(MemberReferenceHandle methodHandle);
++        public void Call(MethodDefinitionHandle methodHandle);
++        public void Call(MethodSpecificationHandle methodHandle);
++        public void CallIndirect(StandaloneSignatureHandle signature);
++        public LabelHandle DefineLabel();
++        public void LoadArgument(int argumentIndex);
++        public void LoadArgumentAddress(int argumentIndex);
++        public void LoadConstantI4(int value);
++        public void LoadConstantI8(long value);
++        public void LoadConstantR4(float value);
++        public void LoadConstantR8(double value);
++        public void LoadLocal(int slotIndex);
++        public void LoadLocalAddress(int slotIndex);
++        public void LoadString(UserStringHandle handle);
++        public void MarkLabel(LabelHandle label);
++        public void OpCode(ILOpCode code);
++        public void StoreArgument(int argumentIndex);
++        public void StoreLocal(int slotIndex);
++        public void Token(int token);
++        public void Token(EntityHandle handle);
++    }
++    public struct LabelHandle : IEquatable<LabelHandle> {
++        public int Id { get; }
++        public bool IsNil { get; }
++        public override bool Equals(object obj);
++        public bool Equals(LabelHandle other);
++        public override int GetHashCode();
++        public static bool operator ==(LabelHandle left, LabelHandle right);
++        public static bool operator !=(LabelHandle left, LabelHandle right);
++    }
++    public struct LiteralEncoder {
++        public LiteralEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public ScalarEncoder Scalar();
++        public void TaggedScalar(Action<CustomAttributeElementTypeEncoder> type, Action<ScalarEncoder> scalar);
++        public void TaggedScalar(out CustomAttributeElementTypeEncoder type, out ScalarEncoder scalar);
++        public void TaggedVector(Action<CustomAttributeArrayTypeEncoder> arrayType, Action<VectorEncoder> vector);
++        public void TaggedVector(out CustomAttributeArrayTypeEncoder arrayType, out VectorEncoder vector);
++        public VectorEncoder Vector();
++    }
++    public struct LiteralsEncoder {
++        public LiteralsEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public LiteralEncoder AddLiteral();
++    }
++    public struct LocalVariablesEncoder {
++        public LocalVariablesEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public LocalVariableTypeEncoder AddVariable();
++    }
++    public struct LocalVariableTypeEncoder {
++        public LocalVariableTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public CustomModifiersEncoder CustomModifiers();
++        public SignatureTypeEncoder Type(bool isByRef=false, bool isPinned=false);
++        public void TypedReference();
++    }
++    public sealed class MetadataBuilder {
++        public MetadataBuilder(int userStringHeapStartOffset=0, int stringHeapStartOffset=0, int blobHeapStartOffset=0, int guidHeapStartOffset=0);
++        public AssemblyDefinitionHandle AddAssembly(StringHandle name, Version version, StringHandle culture, BlobHandle publicKey, AssemblyFlags flags, AssemblyHashAlgorithm hashAlgorithm);
++        public AssemblyFileHandle AddAssemblyFile(StringHandle name, BlobHandle hashValue, bool containsMetadata);
++        public AssemblyReferenceHandle AddAssemblyReference(StringHandle name, Version version, StringHandle culture, BlobHandle publicKeyOrToken, AssemblyFlags flags, BlobHandle hashValue);
++        public ConstantHandle AddConstant(EntityHandle parent, object value);
++        public CustomAttributeHandle AddCustomAttribute(EntityHandle parent, EntityHandle constructor, BlobHandle value);
++        public CustomDebugInformationHandle AddCustomDebugInformation(EntityHandle parent, GuidHandle kind, BlobHandle value);
++        public DeclarativeSecurityAttributeHandle AddDeclarativeSecurityAttribute(EntityHandle parent, DeclarativeSecurityAction action, BlobHandle permissionSet);
++        public DocumentHandle AddDocument(BlobHandle name, GuidHandle hashAlgorithm, BlobHandle hash, GuidHandle language);
++        public void AddEncLogEntry(EntityHandle entity, EditAndContinueOperation code);
++        public void AddEncMapEntry(EntityHandle entity);
++        public EventDefinitionHandle AddEvent(EventAttributes attributes, StringHandle name, EntityHandle type);
++        public void AddEventMap(TypeDefinitionHandle declaringType, EventDefinitionHandle eventList);
++        public ExportedTypeHandle AddExportedType(TypeAttributes attributes, StringHandle @namespace, StringHandle name, EntityHandle implementation, int typeDefinitionId);
++        public FieldDefinitionHandle AddFieldDefinition(FieldAttributes attributes, StringHandle name, BlobHandle signature);
++        public void AddFieldLayout(FieldDefinitionHandle field, int offset);
++        public void AddFieldRelativeVirtualAddress(FieldDefinitionHandle field, int offset);
++        public GenericParameterHandle AddGenericParameter(EntityHandle parent, GenericParameterAttributes attributes, StringHandle name, int index);
++        public GenericParameterConstraintHandle AddGenericParameterConstraint(GenericParameterHandle genericParameter, EntityHandle constraint);
++        public ImportScopeHandle AddImportScope(ImportScopeHandle parentScope, BlobHandle imports);
++        public InterfaceImplementationHandle AddInterfaceImplementation(TypeDefinitionHandle type, EntityHandle implementedInterface);
++        public LocalConstantHandle AddLocalConstant(StringHandle name, BlobHandle signature);
++        public LocalScopeHandle AddLocalScope(MethodDefinitionHandle method, ImportScopeHandle importScope, LocalVariableHandle variableList, LocalConstantHandle constantList, int startOffset, int length);
++        public LocalVariableHandle AddLocalVariable(LocalVariableAttributes attributes, int index, StringHandle name);
++        public ManifestResourceHandle AddManifestResource(ManifestResourceAttributes attributes, StringHandle name, EntityHandle implementation, uint offset);
++        public void AddMarshallingDescriptor(EntityHandle parent, BlobHandle descriptor);
++        public MemberReferenceHandle AddMemberReference(EntityHandle parent, StringHandle name, BlobHandle signature);
++        public MethodDebugInformationHandle AddMethodDebugInformation(DocumentHandle document, BlobHandle sequencePoints);
++        public MethodDefinitionHandle AddMethodDefinition(MethodAttributes attributes, MethodImplAttributes implAttributes, StringHandle name, BlobHandle signature, int bodyOffset, ParameterHandle parameterList);
++        public MethodImplementationHandle AddMethodImplementation(TypeDefinitionHandle type, EntityHandle methodBody, EntityHandle methodDeclaration);
++        public void AddMethodImport(MethodDefinitionHandle method, MethodImportAttributes attributes, StringHandle name, ModuleReferenceHandle module);
++        public void AddMethodSemantics(EntityHandle association, MethodSemanticsAttributes semantics, MethodDefinitionHandle methodDefinition);
++        public MethodSpecificationHandle AddMethodSpecification(EntityHandle method, BlobHandle instantiation);
++        public ModuleDefinitionHandle AddModule(int generation, StringHandle moduleName, GuidHandle mvid, GuidHandle encId, GuidHandle encBaseId);
++        public ModuleReferenceHandle AddModuleReference(StringHandle moduleName);
++        public void AddNestedType(TypeDefinitionHandle type, TypeDefinitionHandle enclosingType);
++        public ParameterHandle AddParameter(ParameterAttributes attributes, StringHandle name, int sequenceNumber);
++        public PropertyDefinitionHandle AddProperty(PropertyAttributes attributes, StringHandle name, BlobHandle signature);
++        public void AddPropertyMap(TypeDefinitionHandle declaringType, PropertyDefinitionHandle propertyList);
++        public StandaloneSignatureHandle AddStandaloneSignature(BlobHandle signature);
++        public void AddStateMachineMethod(MethodDefinitionHandle moveNextMethod, MethodDefinitionHandle kickoffMethod);
++        public TypeDefinitionHandle AddTypeDefinition(TypeAttributes attributes, StringHandle @namespace, StringHandle name, EntityHandle baseType, FieldDefinitionHandle fieldList, MethodDefinitionHandle methodList);
++        public void AddTypeLayout(TypeDefinitionHandle type, ushort packingSize, uint size);
++        public TypeReferenceHandle AddTypeReference(EntityHandle resolutionScope, StringHandle @namespace, StringHandle name);
++        public TypeSpecificationHandle AddTypeSpecification(BlobHandle signature);
++        public BlobHandle GetOrAddBlob(byte[] value);
++        public BlobHandle GetOrAddBlob(ImmutableArray<byte> value);
++        public BlobHandle GetOrAddBlob(BlobBuilder value);
++        public BlobHandle GetOrAddBlobUTF16(string value);
++        public BlobHandle GetOrAddBlobUTF8(string value, bool allowUnpairedSurrogates=true);
++        public BlobHandle GetOrAddConstantBlob(object value);
++        public BlobHandle GetOrAddDocumentName(string value);
++        public GuidHandle GetOrAddGuid(Guid guid);
++        public StringHandle GetOrAddString(string value);
++        public UserStringHandle GetOrAddUserString(string value);
++        public int GetRowCount(TableIndex table);
++        public ImmutableArray<int> GetRowCounts();
++        public ReservedBlob<GuidHandle> ReserveGuid();
++        public ReservedBlob<UserStringHandle> ReserveUserString(int length);
++        public void SetCapacity(HeapIndex heap, int byteCount);
++        public void SetCapacity(TableIndex table, int rowCount);
++    }
+     public static class MetadataReaderExtensions {
++        public static SignatureTypeKind ResolveSignatureTypeKind(this MetadataReader reader, EntityHandle typeHandle, byte rawTypeKind);
+     }
++    public sealed class MetadataRootBuilder {
++        public MetadataRootBuilder(MetadataBuilder tablesAndHeaps, string metadataVersion=null, bool suppressValidation=false);
++        public string MetadataVersion { get; }
++        public MetadataSizes Sizes { get; }
++        public bool SuppressValidation { get; }
++        public void Serialize(BlobBuilder builder, int methodBodyStreamRva, int mappedFieldDataStreamRva);
++    }
++    public sealed class MetadataSizes {
++        public ImmutableArray<int> ExternalRowCounts { get; }
++        public ImmutableArray<int> HeapSizes { get; }
++        public ImmutableArray<int> RowCounts { get; }
++        public int GetAlignedHeapSize(HeapIndex index);
++    }
+     public static class MetadataTokens {
++        public static int GetHeapOffset(BlobHandle handle);
++        public static int GetHeapOffset(GuidHandle handle);
++        public static int GetHeapOffset(StringHandle handle);
++        public static int GetHeapOffset(UserStringHandle handle);
+     }
++    public enum MethodBodyAttributes {
++        InitLocals = 1,
++        None = 0,
++    }
++    public struct MethodBodyStreamEncoder {
++        public MethodBodyStreamEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public MethodBodyStreamEncoder.MethodBody AddMethodBody(int codeSize, int maxStack=8, int exceptionRegionCount=0, bool hasSmallExceptionRegions=true, StandaloneSignatureHandle localVariablesSignature=null, MethodBodyAttributes attributes=(MethodBodyAttributes)(1));
++        public int AddMethodBody(InstructionEncoder instructionEncoder, int maxStack=8, StandaloneSignatureHandle localVariablesSignature=null, MethodBodyAttributes attributes=(MethodBodyAttributes)(1));
++        public struct MethodBody {
++            public ExceptionRegionEncoder ExceptionRegions { get; }
++            public Blob Instructions { get; }
++            public int Offset { get; }
++        }
++    }
++    public struct MethodSignatureEncoder {
++        public MethodSignatureEncoder(BlobBuilder builder, bool hasVarArgs);
++        public BlobBuilder Builder { get; }
++        public bool HasVarArgs { get; }
++        public void Parameters(int parameterCount, Action<ReturnTypeEncoder> returnType, Action<ParametersEncoder> parameters);
++        public void Parameters(int parameterCount, out ReturnTypeEncoder returnType, out ParametersEncoder parameters);
++    }
++    public struct NamedArgumentsEncoder {
++        public NamedArgumentsEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void AddArgument(bool isField, Action<NamedArgumentTypeEncoder> type, Action<NameEncoder> name, Action<LiteralEncoder> literal);
++        public void AddArgument(bool isField, out NamedArgumentTypeEncoder type, out NameEncoder name, out LiteralEncoder literal);
++    }
++    public struct NamedArgumentTypeEncoder {
++        public NamedArgumentTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void Object();
++        public CustomAttributeElementTypeEncoder ScalarType();
++        public CustomAttributeArrayTypeEncoder SZArray();
++    }
++    public struct NameEncoder {
++        public NameEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void Name(string name);
++    }
++    public struct ParametersEncoder {
++        public ParametersEncoder(BlobBuilder builder, bool hasVarArgs=false);
++        public BlobBuilder Builder { get; }
++        public bool HasVarArgs { get; }
++        public ParameterTypeEncoder AddParameter();
++        public ParametersEncoder StartVarArgs();
++    }
++    public struct ParameterTypeEncoder {
++        public ParameterTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public CustomModifiersEncoder CustomModifiers();
++        public SignatureTypeEncoder Type(bool isByRef=false);
++        public void TypedReference();
++    }
++    public struct PermissionSetEncoder {
++        public PermissionSetEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public PermissionSetEncoder AddPermission(string typeName, ImmutableArray<byte> encodedArguments);
++        public PermissionSetEncoder AddPermission(string typeName, BlobBuilder encodedArguments);
++    }
++    public sealed class PortablePdbBuilder {
++        public PortablePdbBuilder(MetadataBuilder tablesAndHeaps, ImmutableArray<int> typeSystemRowCounts, MethodDefinitionHandle entryPoint, Func<IEnumerable<Blob>, BlobContentId> idProvider=null);
++        public ushort FormatVersion { get; }
++        public Func<IEnumerable<Blob>, BlobContentId> IdProvider { get; }
++        public string MetadataVersion { get; }
++        public BlobContentId Serialize(BlobBuilder builder);
++    }
++    public struct ReturnTypeEncoder {
++        public ReturnTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public CustomModifiersEncoder CustomModifiers();
++        public SignatureTypeEncoder Type(bool isByRef=false);
++        public void TypedReference();
++        public void Void();
++    }
++    public struct ScalarEncoder {
++        public ScalarEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void Constant(object value);
++        public void NullArray();
++        public void SystemType(string serializedTypeName);
++    }
++    public struct SignatureDecoder<TType> {
++        public SignatureDecoder(ISignatureTypeProvider<TType> provider, MetadataReader metadataReader=null);
++        public TType DecodeFieldSignature(ref BlobReader blobReader);
++        public ImmutableArray<TType> DecodeLocalSignature(ref BlobReader blobReader);
++        public MethodSignature<TType> DecodeMethodSignature(ref BlobReader blobReader);
++        public ImmutableArray<TType> DecodeMethodSpecificationSignature(ref BlobReader blobReader);
++        public TType DecodeType(ref BlobReader blobReader, bool allowTypeSpecifications=false);
++    }
++    public struct SignatureTypeEncoder {
++        public SignatureTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public void Array(Action<SignatureTypeEncoder> elementType, Action<ArrayShapeEncoder> arrayShape);
++        public void Array(out SignatureTypeEncoder elementType, out ArrayShapeEncoder arrayShape);
++        public void Boolean();
++        public void Byte();
++        public void Char();
++        public CustomModifiersEncoder CustomModifiers();
++        public void Double();
++        public MethodSignatureEncoder FunctionPointer(SignatureCallingConvention convention=(SignatureCallingConvention)(0), FunctionPointerAttributes attributes=(FunctionPointerAttributes)(0), int genericParameterCount=0);
++        public GenericTypeArgumentsEncoder GenericInstantiation(EntityHandle genericType, int genericArgumentCount, bool isValueType);
++        public void GenericMethodTypeParameter(int parameterIndex);
++        public void GenericTypeParameter(int parameterIndex);
++        public void Int16();
++        public void Int32();
++        public void Int64();
++        public void IntPtr();
++        public void Object();
++        public SignatureTypeEncoder Pointer();
++        public void PrimitiveType(PrimitiveTypeCode type);
++        public void SByte();
++        public void Single();
++        public void String();
++        public SignatureTypeEncoder SZArray();
++        public void Type(EntityHandle type, bool isValueType);
++        public void UInt16();
++        public void UInt32();
++        public void UInt64();
++        public void UIntPtr();
++        public void VoidPointer();
++    }
++    public struct VectorEncoder {
++        public VectorEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public LiteralsEncoder Count(int count);
++    }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Reflection.Metadata.md

@@ -0,0 +1,526 @@
+# System.Reflection.Metadata
+
+``` diff
+ namespace System.Reflection.Metadata {
++    public struct ArrayShape {
++        public ArrayShape(int rank, ImmutableArray<int> sizes, ImmutableArray<int> lowerBounds);
++        public ImmutableArray<int> LowerBounds { get; }
++        public int Rank { get; }
++        public ImmutableArray<int> Sizes { get; }
++    }
++    public struct Blob {
++        public bool IsDefault { get; }
++        public int Length { get; }
++        public ArraySegment<byte> GetBytes();
++    }
++    public class BlobBuilder {
++        public BlobBuilder(int capacity=256);
++        protected internal int ChunkCapacity { get; }
++        public int Count { get; }
++        protected int FreeBytes { get; }
++        public void Align(int alignment);
++        protected virtual BlobBuilder AllocateChunk(int minimalSize);
++        public void Clear();
++        public bool ContentEquals(BlobBuilder other);
++        protected void Free();
++        protected virtual void FreeChunk();
++        public BlobBuilder.Blobs GetBlobs();
++        public void LinkPrefix(BlobBuilder prefix);
++        public void LinkSuffix(BlobBuilder suffix);
++        public void PadTo(int position);
++        public Blob ReserveBytes(int byteCount);
++        public byte[] ToArray();
++        public byte[] ToArray(int start, int byteCount);
++        public ImmutableArray<byte> ToImmutableArray();
++        public ImmutableArray<byte> ToImmutableArray(int start, int byteCount);
++        public int TryWriteBytes(Stream source, int byteCount);
++        public void WriteBoolean(bool value);
++        public void WriteByte(byte value);
++        public unsafe void WriteBytes(byte* buffer, int byteCount);
++        public void WriteBytes(byte value, int byteCount);
++        public void WriteBytes(byte[] buffer);
++        public void WriteBytes(byte[] buffer, int start, int byteCount);
++        public void WriteBytes(ImmutableArray<byte> buffer);
++        public void WriteBytes(ImmutableArray<byte> buffer, int start, int byteCount);
++        public void WriteCompressedInteger(int value);
++        public void WriteCompressedSignedInteger(int value);
++        public void WriteConstant(object value);
++        public void WriteContentTo(Stream destination);
++        public void WriteContentTo(BlobBuilder destination);
++        public void WriteContentTo(ref BlobWriter destination);
++        public void WriteDateTime(DateTime value);
++        public void WriteDecimal(decimal value);
++        public void WriteDouble(double value);
++        public void WriteGuid(Guid value);
++        public void WriteInt16(short value);
++        public void WriteInt16BE(short value);
++        public void WriteInt32(int value);
++        public void WriteInt32BE(int value);
++        public void WriteInt64(long value);
++        public void WriteReference(int reference, bool isSmall);
++        public void WriteSByte(sbyte value);
++        public void WriteSerializedString(string value);
++        public void WriteSingle(float value);
++        public void WriteUInt16(ushort value);
++        public void WriteUInt16BE(ushort value);
++        public void WriteUInt32(uint value);
++        public void WriteUInt32BE(uint value);
++        public void WriteUInt64(ulong value);
++        public void WriteUserString(string value);
++        public void WriteUTF16(char[] value);
++        public void WriteUTF16(string value);
++        public void WriteUTF8(string value, bool allowUnpairedSurrogates=true);
++        public struct Blobs : IDisposable, IEnumerable, IEnumerable<Blob>, IEnumerator, IEnumerator<Blob> {
++            public Blob Current { get; }
++            object System.Collections.IEnumerator.Current { get; }
++            public BlobBuilder.Blobs GetEnumerator();
++            public bool MoveNext();
++            public void Reset();
++            IEnumerator<Blob> System.Collections.Generic.IEnumerable<System.Reflection.Metadata.Blob>.GetEnumerator();
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++            void System.IDisposable.Dispose();
++        }
++    }
++    public struct BlobContentId : IEquatable<BlobContentId> {
++        public BlobContentId(byte[] id);
++        public BlobContentId(ImmutableArray<byte> id);
++        public BlobContentId(Guid guid, uint stamp);
++        public Guid Guid { get; }
++        public bool IsDefault { get; }
++        public uint Stamp { get; }
++        public override bool Equals(object obj);
++        public bool Equals(BlobContentId other);
++        public static BlobContentId FromHash(byte[] hashCode);
++        public static BlobContentId FromHash(ImmutableArray<byte> hashCode);
++        public override int GetHashCode();
++        public static Func<IEnumerable<Blob>, BlobContentId> GetTimeBasedProvider();
++        public static bool operator ==(BlobContentId left, BlobContentId right);
++        public static bool operator !=(BlobContentId left, BlobContentId right);
++    }
+     public struct BlobReader {
++        public unsafe byte* CurrentPointer { get; }
++        public unsafe byte* StartPointer { get; }
++        public void Align(byte alignment);
++        public void ReadBytes(int byteCount, byte[] buffer, int bufferOffset);
++        public void SeekOffset(int offset);
++        public void SkipBytes(int count);
+     }
++    public struct BlobWriter {
++        public BlobWriter(byte[] buffer);
++        public BlobWriter(byte[] buffer, int start, int count);
++        public BlobWriter(int size);
++        public BlobWriter(Blob blob);
++        public Blob Blob { get; }
++        public int Length { get; }
++        public int Offset { get; set; }
++        public int RemainingBytes { get; }
++        public void Align(int alignment);
++        public void Clear();
++        public bool ContentEquals(BlobWriter other);
++        public void PadTo(int offset);
++        public byte[] ToArray();
++        public byte[] ToArray(int start, int byteCount);
++        public ImmutableArray<byte> ToImmutableArray();
++        public ImmutableArray<byte> ToImmutableArray(int start, int byteCount);
++        public void WriteBoolean(bool value);
++        public void WriteByte(byte value);
++        public unsafe void WriteBytes(byte* buffer, int byteCount);
++        public void WriteBytes(byte value, int byteCount);
++        public void WriteBytes(byte[] buffer);
++        public void WriteBytes(byte[] buffer, int start, int byteCount);
++        public void WriteBytes(ImmutableArray<byte> buffer);
++        public void WriteBytes(ImmutableArray<byte> buffer, int start, int byteCount);
++        public int WriteBytes(Stream source, int byteCount);
++        public void WriteBytes(BlobBuilder source);
++        public void WriteCompressedInteger(int value);
++        public void WriteCompressedSignedInteger(int value);
++        public void WriteConstant(object value);
++        public void WriteDateTime(DateTime value);
++        public void WriteDecimal(decimal value);
++        public void WriteDouble(double value);
++        public void WriteGuid(Guid value);
++        public void WriteInt16(short value);
++        public void WriteInt16BE(short value);
++        public void WriteInt32(int value);
++        public void WriteInt32BE(int value);
++        public void WriteInt64(long value);
++        public void WriteReference(int reference, bool isSmall);
++        public void WriteSByte(sbyte value);
++        public void WriteSerializedString(string str);
++        public void WriteSingle(float value);
++        public void WriteUInt16(ushort value);
++        public void WriteUInt16BE(ushort value);
++        public void WriteUInt32(uint value);
++        public void WriteUInt32BE(uint value);
++        public void WriteUInt64(ulong value);
++        public void WriteUserString(string value);
++        public void WriteUTF16(char[] value);
++        public void WriteUTF16(string value);
++        public void WriteUTF8(string value, bool allowUnpairedSurrogates);
++    }
+     public struct CustomAttribute {
++        public CustomAttributeValue<TType> DecodeValue<TType>(ICustomAttributeTypeProvider<TType> provider);
+     }
++    public struct CustomAttributeNamedArgument<TType> {
++        public CustomAttributeNamedArgument(string name, CustomAttributeNamedArgumentKind kind, TType type, object value);
++        public CustomAttributeNamedArgumentKind Kind { get; }
++        public string Name { get; }
++        public TType Type { get; }
++        public object Value { get; }
++    }
++    public struct CustomAttributeTypedArgument<TType> {
++        public CustomAttributeTypedArgument(TType type, object value);
++        public TType Type { get; }
++        public object Value { get; }
++    }
++    public struct CustomAttributeValue<TType> {
++        public CustomAttributeValue(ImmutableArray<CustomAttributeTypedArgument<TType>> fixedArguments, ImmutableArray<CustomAttributeNamedArgument<TType>> namedArguments);
++        public ImmutableArray<CustomAttributeTypedArgument<TType>> FixedArguments { get; }
++        public ImmutableArray<CustomAttributeNamedArgument<TType>> NamedArguments { get; }
++    }
+     public struct FieldDefinition {
++        public TType DecodeSignature<TType>(ISignatureTypeProvider<TType> provider);
+     }
++    public interface IConstructedTypeProvider<TType> : ISZArrayTypeProvider<TType> {
++        TType GetArrayType(TType elementType, ArrayShape shape);
++        TType GetByReferenceType(TType elementType);
++        TType GetGenericInstance(TType genericType, ImmutableArray<TType> typeArguments);
++        TType GetPointerType(TType elementType);
++    }
++    public interface ICustomAttributeTypeProvider<TType> : IPrimitiveTypeProvider<TType>, ISZArrayTypeProvider<TType>, ITypeProvider<TType> {
++        TType GetSystemType();
++        TType GetTypeFromSerializedName(string name);
++        PrimitiveTypeCode GetUnderlyingEnumType(TType type);
++        bool IsSystemType(TType type);
++    }
++    public enum ILOpCode : ushort {
++        Add = (ushort)88,
++        Add_ovf = (ushort)214,
++        Add_ovf_un = (ushort)215,
++        And = (ushort)95,
++        Arglist = (ushort)65024,
++        Beq = (ushort)59,
++        Beq_s = (ushort)46,
++        Bge = (ushort)60,
++        Bge_s = (ushort)47,
++        Bge_un = (ushort)65,
++        Bge_un_s = (ushort)52,
++        Bgt = (ushort)61,
++        Bgt_s = (ushort)48,
++        Bgt_un = (ushort)66,
++        Bgt_un_s = (ushort)53,
++        Ble = (ushort)62,
++        Ble_s = (ushort)49,
++        Ble_un = (ushort)67,
++        Ble_un_s = (ushort)54,
++        Blt = (ushort)63,
++        Blt_s = (ushort)50,
++        Blt_un = (ushort)68,
++        Blt_un_s = (ushort)55,
++        Bne_un = (ushort)64,
++        Bne_un_s = (ushort)51,
++        Box = (ushort)140,
++        Br = (ushort)56,
++        Br_s = (ushort)43,
++        Break = (ushort)1,
++        Brfalse = (ushort)57,
++        Brfalse_s = (ushort)44,
++        Brtrue = (ushort)58,
++        Brtrue_s = (ushort)45,
++        Call = (ushort)40,
++        Calli = (ushort)41,
++        Callvirt = (ushort)111,
++        Castclass = (ushort)116,
++        Ceq = (ushort)65025,
++        Cgt = (ushort)65026,
++        Cgt_un = (ushort)65027,
++        Ckfinite = (ushort)195,
++        Clt = (ushort)65028,
++        Clt_un = (ushort)65029,
++        Constrained = (ushort)65046,
++        Conv_i = (ushort)211,
++        Conv_i1 = (ushort)103,
++        Conv_i2 = (ushort)104,
++        Conv_i4 = (ushort)105,
++        Conv_i8 = (ushort)106,
++        Conv_ovf_i = (ushort)212,
++        Conv_ovf_i_un = (ushort)138,
++        Conv_ovf_i1 = (ushort)179,
++        Conv_ovf_i1_un = (ushort)130,
++        Conv_ovf_i2 = (ushort)181,
++        Conv_ovf_i2_un = (ushort)131,
++        Conv_ovf_i4 = (ushort)183,
++        Conv_ovf_i4_un = (ushort)132,
++        Conv_ovf_i8 = (ushort)185,
++        Conv_ovf_i8_un = (ushort)133,
++        Conv_ovf_u = (ushort)213,
++        Conv_ovf_u_un = (ushort)139,
++        Conv_ovf_u1 = (ushort)180,
++        Conv_ovf_u1_un = (ushort)134,
++        Conv_ovf_u2 = (ushort)182,
++        Conv_ovf_u2_un = (ushort)135,
++        Conv_ovf_u4 = (ushort)184,
++        Conv_ovf_u4_un = (ushort)136,
++        Conv_ovf_u8 = (ushort)186,
++        Conv_ovf_u8_un = (ushort)137,
++        Conv_r_un = (ushort)118,
++        Conv_r4 = (ushort)107,
++        Conv_r8 = (ushort)108,
++        Conv_u = (ushort)224,
++        Conv_u1 = (ushort)210,
++        Conv_u2 = (ushort)209,
++        Conv_u4 = (ushort)109,
++        Conv_u8 = (ushort)110,
++        Cpblk = (ushort)65047,
++        Cpobj = (ushort)112,
++        Div = (ushort)91,
++        Div_un = (ushort)92,
++        Dup = (ushort)37,
++        Endfilter = (ushort)65041,
++        Endfinally = (ushort)220,
++        Initblk = (ushort)65048,
++        Initobj = (ushort)65045,
++        Isinst = (ushort)117,
++        Jmp = (ushort)39,
++        Ldarg = (ushort)65033,
++        Ldarg_0 = (ushort)2,
++        Ldarg_1 = (ushort)3,
++        Ldarg_2 = (ushort)4,
++        Ldarg_3 = (ushort)5,
++        Ldarg_s = (ushort)14,
++        Ldarga = (ushort)65034,
++        Ldarga_s = (ushort)15,
++        Ldc_i4 = (ushort)32,
++        Ldc_i4_0 = (ushort)22,
++        Ldc_i4_1 = (ushort)23,
++        Ldc_i4_2 = (ushort)24,
++        Ldc_i4_3 = (ushort)25,
++        Ldc_i4_4 = (ushort)26,
++        Ldc_i4_5 = (ushort)27,
++        Ldc_i4_6 = (ushort)28,
++        Ldc_i4_7 = (ushort)29,
++        Ldc_i4_8 = (ushort)30,
++        Ldc_i4_m1 = (ushort)21,
++        Ldc_i4_s = (ushort)31,
++        Ldc_i8 = (ushort)33,
++        Ldc_r4 = (ushort)34,
++        Ldc_r8 = (ushort)35,
++        Ldelem = (ushort)163,
++        Ldelem_i = (ushort)151,
++        Ldelem_i1 = (ushort)144,
++        Ldelem_i2 = (ushort)146,
++        Ldelem_i4 = (ushort)148,
++        Ldelem_i8 = (ushort)150,
++        Ldelem_r4 = (ushort)152,
++        Ldelem_r8 = (ushort)153,
++        Ldelem_ref = (ushort)154,
++        Ldelem_u1 = (ushort)145,
++        Ldelem_u2 = (ushort)147,
++        Ldelem_u4 = (ushort)149,
++        Ldelema = (ushort)143,
++        Ldfld = (ushort)123,
++        Ldflda = (ushort)124,
++        Ldftn = (ushort)65030,
++        Ldind_i = (ushort)77,
++        Ldind_i1 = (ushort)70,
++        Ldind_i2 = (ushort)72,
++        Ldind_i4 = (ushort)74,
++        Ldind_i8 = (ushort)76,
++        Ldind_r4 = (ushort)78,
++        Ldind_r8 = (ushort)79,
++        Ldind_ref = (ushort)80,
++        Ldind_u1 = (ushort)71,
++        Ldind_u2 = (ushort)73,
++        Ldind_u4 = (ushort)75,
++        Ldlen = (ushort)142,
++        Ldloc = (ushort)65036,
++        Ldloc_0 = (ushort)6,
++        Ldloc_1 = (ushort)7,
++        Ldloc_2 = (ushort)8,
++        Ldloc_3 = (ushort)9,
++        Ldloc_s = (ushort)17,
++        Ldloca = (ushort)65037,
++        Ldloca_s = (ushort)18,
++        Ldnull = (ushort)20,
++        Ldobj = (ushort)113,
++        Ldsfld = (ushort)126,
++        Ldsflda = (ushort)127,
++        Ldstr = (ushort)114,
++        Ldtoken = (ushort)208,
++        Ldvirtftn = (ushort)65031,
++        Leave = (ushort)221,
++        Leave_s = (ushort)222,
++        Localloc = (ushort)65039,
++        Mkrefany = (ushort)198,
++        Mul = (ushort)90,
++        Mul_ovf = (ushort)216,
++        Mul_ovf_un = (ushort)217,
++        Neg = (ushort)101,
++        Newarr = (ushort)141,
++        Newobj = (ushort)115,
++        Nop = (ushort)0,
++        Not = (ushort)102,
++        Or = (ushort)96,
++        Pop = (ushort)38,
++        Readonly = (ushort)65054,
++        Refanytype = (ushort)65053,
++        Refanyval = (ushort)194,
++        Rem = (ushort)93,
++        Rem_un = (ushort)94,
++        Ret = (ushort)42,
++        Rethrow = (ushort)65050,
++        Shl = (ushort)98,
++        Shr = (ushort)99,
++        Shr_un = (ushort)100,
++        Sizeof = (ushort)65052,
++        Starg = (ushort)65035,
++        Starg_s = (ushort)16,
++        Stelem = (ushort)164,
++        Stelem_i = (ushort)155,
++        Stelem_i1 = (ushort)156,
++        Stelem_i2 = (ushort)157,
++        Stelem_i4 = (ushort)158,
++        Stelem_i8 = (ushort)159,
++        Stelem_r4 = (ushort)160,
++        Stelem_r8 = (ushort)161,
++        Stelem_ref = (ushort)162,
++        Stfld = (ushort)125,
++        Stind_i = (ushort)223,
++        Stind_i1 = (ushort)82,
++        Stind_i2 = (ushort)83,
++        Stind_i4 = (ushort)84,
++        Stind_i8 = (ushort)85,
++        Stind_r4 = (ushort)86,
++        Stind_r8 = (ushort)87,
++        Stind_ref = (ushort)81,
++        Stloc = (ushort)65038,
++        Stloc_0 = (ushort)10,
++        Stloc_1 = (ushort)11,
++        Stloc_2 = (ushort)12,
++        Stloc_3 = (ushort)13,
++        Stloc_s = (ushort)19,
++        Stobj = (ushort)129,
++        Stsfld = (ushort)128,
++        Sub = (ushort)89,
++        Sub_ovf = (ushort)218,
++        Sub_ovf_un = (ushort)219,
++        Switch = (ushort)69,
++        Tail = (ushort)65044,
++        Throw = (ushort)122,
++        Unaligned = (ushort)65042,
++        Unbox = (ushort)121,
++        Unbox_any = (ushort)165,
++        Volatile = (ushort)65043,
++        Xor = (ushort)97,
++    }
++    public static class ILOpCodeExtensions {
++        public static int GetBranchOperandSize(this ILOpCode opCode);
++        public static ILOpCode GetLongBranch(this ILOpCode opCode);
++        public static ILOpCode GetShortBranch(this ILOpCode opCode);
++        public static bool IsBranch(this ILOpCode opCode);
++    }
++    public class ImageFormatLimitationException : Exception {
++        public ImageFormatLimitationException();
++        public ImageFormatLimitationException(string message);
++        public ImageFormatLimitationException(string message, Exception innerException);
++    }
++    public interface IPrimitiveTypeProvider<TType> {
++        TType GetPrimitiveType(PrimitiveTypeCode typeCode);
++    }
++    public interface ISignatureTypeProvider<TType> : IConstructedTypeProvider<TType>, IPrimitiveTypeProvider<TType>, ISZArrayTypeProvider<TType>, ITypeProvider<TType> {
++        TType GetFunctionPointerType(MethodSignature<TType> signature);
++        TType GetGenericMethodParameter(int index);
++        TType GetGenericTypeParameter(int index);
++        TType GetModifiedType(MetadataReader reader, bool isRequired, TType modifier, TType unmodifiedType);
++        TType GetPinnedType(TType elementType);
++    }
++    public interface ISZArrayTypeProvider<TType> {
++        TType GetSZArrayType(TType elementType);
++    }
++    public interface ITypeProvider<TType> {
++        TType GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind);
++        TType GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind);
++        TType GetTypeFromSpecification(MetadataReader reader, TypeSpecificationHandle handle, byte rawTypeKind);
++    }
+     public struct MemberReference {
++        public TType DecodeFieldSignature<TType>(ISignatureTypeProvider<TType> provider);
++        public MethodSignature<TType> DecodeMethodSignature<TType>(ISignatureTypeProvider<TType> provider);
+     }
+     public sealed class MetadataReader {
++        public int MetadataLength { get; }
++        public unsafe byte* MetadataPointer { get; }
++        public MetadataStringDecoder UTF8Decoder { get; }
++        public BlobReader GetBlobReader(StringHandle handle);
+     }
+     public struct MethodDefinition {
++        public MethodSignature<TType> DecodeSignature<TType>(ISignatureTypeProvider<TType> provider);
+     }
++    public struct MethodSignature<TType> {
++        public MethodSignature(SignatureHeader header, TType returnType, int requiredParameterCount, int genericParameterCount, ImmutableArray<TType> parameterTypes);
++        public int GenericParameterCount { get; }
++        public SignatureHeader Header { get; }
++        public ImmutableArray<TType> ParameterTypes { get; }
++        public int RequiredParameterCount { get; }
++        public TType ReturnType { get; }
++    }
+     public struct MethodSpecification {
++        public ImmutableArray<TType> DecodeSignature<TType>(ISignatureTypeProvider<TType> provider);
+     }
++    public enum PrimitiveSerializationTypeCode : byte {
++        Boolean = (byte)2,
++        Byte = (byte)5,
++        Char = (byte)3,
++        Double = (byte)13,
++        Int16 = (byte)6,
++        Int32 = (byte)8,
++        Int64 = (byte)10,
++        SByte = (byte)4,
++        Single = (byte)12,
++        String = (byte)14,
++        UInt16 = (byte)7,
++        UInt32 = (byte)9,
++        UInt64 = (byte)11,
++    }
++    public enum PrimitiveTypeCode : byte {
++        Boolean = (byte)2,
++        Byte = (byte)5,
++        Char = (byte)3,
++        Double = (byte)13,
++        Int16 = (byte)6,
++        Int32 = (byte)8,
++        Int64 = (byte)10,
++        IntPtr = (byte)24,
++        Object = (byte)28,
++        SByte = (byte)4,
++        Single = (byte)12,
++        String = (byte)14,
++        TypedReference = (byte)22,
++        UInt16 = (byte)7,
++        UInt32 = (byte)9,
++        UInt64 = (byte)11,
++        UIntPtr = (byte)25,
++        Void = (byte)1,
++    }
+     public struct PropertyDefinition {
++        public MethodSignature<TType> DecodeSignature<TType>(ISignatureTypeProvider<TType> provider);
+     }
++    public struct ReservedBlob<THandle> where THandle : struct {
++        public Blob Content { get; }
++        public THandle Handle { get; }
++        public BlobWriter CreateWriter();
++    }
++    public enum SignatureTypeKind : byte {
++        Class = (byte)18,
++        Unknown = (byte)0,
++        ValueType = (byte)17,
++    }
+     public struct StandaloneSignature {
++        public ImmutableArray<TType> DecodeLocalSignature<TType>(ISignatureTypeProvider<TType> provider);
++        public MethodSignature<TType> DecodeMethodSignature<TType>(ISignatureTypeProvider<TType> provider);
+     }
+     public struct TypeSpecification {
++        public TType DecodeSignature<TType>(ISignatureTypeProvider<TType> provider);
+     }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Reflection.PortableExecutable.md

@@ -0,0 +1,113 @@
+# System.Reflection.PortableExecutable
+
+``` diff
+ namespace System.Reflection.PortableExecutable {
++    public sealed class DebugDirectoryBuilder {
++        public DebugDirectoryBuilder();
++        public void AddCodeViewEntry(string pdbPath, BlobContentId pdbContentId, ushort portablePdbVersion);
++        public void AddEmbeddedPortablePdbEntry(BlobBuilder debugMetadata, ushort portablePdbVersion);
++        public void AddReproducibleEntry();
++    }
+     public struct DebugDirectoryEntry {
++        public bool IsPortableCodeView { get; }
+     }
+     public enum DebugDirectoryEntryType {
++        EmbeddedPortablePdb = 17,
+     }
++    public class ManagedPEBuilder : PEBuilder {
++        public const int ManagedResourcesDataAlignment = 8;
++        public const int MappedFieldDataAlignment = 8;
++        public ManagedPEBuilder(PEHeaderBuilder header, MetadataRootBuilder metadataRootBuilder, BlobBuilder ilStream, BlobBuilder mappedFieldData=null, BlobBuilder managedResources=null, ResourceSectionBuilder nativeResources=null, DebugDirectoryBuilder debugDirectoryBuilder=null, int strongNameSignatureSize=128, MethodDefinitionHandle entryPoint=null, CorFlags flags=(CorFlags)(1), Func<IEnumerable<Blob>, BlobContentId> deterministicIdProvider=null);
++        protected override ImmutableArray<PEBuilder.Section> CreateSections();
++        protected internal override PEDirectoriesBuilder GetDirectories();
++        protected override BlobBuilder SerializeSection(string name, SectionLocation location);
++        public void Sign(BlobBuilder peImage, Func<IEnumerable<Blob>, byte[]> signatureProvider);
++    }
++    public abstract class PEBuilder {
++        protected PEBuilder(PEHeaderBuilder header, Func<IEnumerable<Blob>, BlobContentId> deterministicIdProvider);
++        public PEHeaderBuilder Header { get; }
++        public Func<IEnumerable<Blob>, BlobContentId> IdProvider { get; }
++        public bool IsDeterministic { get; }
++        protected abstract ImmutableArray<PEBuilder.Section> CreateSections();
++        protected internal abstract PEDirectoriesBuilder GetDirectories();
++        protected ImmutableArray<PEBuilder.Section> GetSections();
++        public BlobContentId Serialize(BlobBuilder builder);
++        protected abstract BlobBuilder SerializeSection(string name, SectionLocation location);
++        protected struct Section {
++            public readonly SectionCharacteristics Characteristics;
++            public readonly string Name;
++            public Section(string name, SectionCharacteristics characteristics);
++        }
++    }
++    public sealed class PEDirectoriesBuilder {
++        public PEDirectoriesBuilder();
++        public int AddressOfEntryPoint { get; set; }
++        public DirectoryEntry BaseRelocationTable { get; set; }
++        public DirectoryEntry BoundImportTable { get; set; }
++        public DirectoryEntry CopyrightTable { get; set; }
++        public DirectoryEntry CorHeaderTable { get; set; }
++        public DirectoryEntry DebugTable { get; set; }
++        public DirectoryEntry DelayImportTable { get; set; }
++        public DirectoryEntry ExceptionTable { get; set; }
++        public DirectoryEntry ExportTable { get; set; }
++        public DirectoryEntry GlobalPointerTable { get; set; }
++        public DirectoryEntry ImportAddressTable { get; set; }
++        public DirectoryEntry ImportTable { get; set; }
++        public DirectoryEntry LoadConfigTable { get; set; }
++        public DirectoryEntry ResourceTable { get; set; }
++        public DirectoryEntry ThreadLocalStorageTable { get; set; }
++    }
++    public sealed class PEHeaderBuilder {
++        public PEHeaderBuilder(Machine machine=(Machine)(0), int sectionAlignment=8192, int fileAlignment=512, ulong imageBase=(ulong)4194304, byte majorLinkerVersion=(byte)48, byte minorLinkerVersion=(byte)0, ushort majorOperatingSystemVersion=(ushort)4, ushort minorOperatingSystemVersion=(ushort)0, ushort majorImageVersion=(ushort)0, ushort minorImageVersion=(ushort)0, ushort majorSubsystemVersion=(ushort)4, ushort minorSubsystemVersion=(ushort)0, Subsystem subsystem=(Subsystem)(3), DllCharacteristics dllCharacteristics=(DllCharacteristics)(34112), Characteristics imageCharacteristics=(Characteristics)(8192), ulong sizeOfStackReserve=(ulong)1048576, ulong sizeOfStackCommit=(ulong)4096, ulong sizeOfHeapReserve=(ulong)1048576, ulong sizeOfHeapCommit=(ulong)4096);
++        public DllCharacteristics DllCharacteristics { get; }
++        public int FileAlignment { get; }
++        public ulong ImageBase { get; }
++        public Characteristics ImageCharacteristics { get; }
++        public Machine Machine { get; }
++        public ushort MajorImageVersion { get; }
++        public byte MajorLinkerVersion { get; }
++        public ushort MajorOperatingSystemVersion { get; }
++        public ushort MajorSubsystemVersion { get; }
++        public ushort MinorImageVersion { get; }
++        public byte MinorLinkerVersion { get; }
++        public ushort MinorOperatingSystemVersion { get; }
++        public ushort MinorSubsystemVersion { get; }
++        public int SectionAlignment { get; }
++        public ulong SizeOfHeapCommit { get; }
++        public ulong SizeOfHeapReserve { get; }
++        public ulong SizeOfStackCommit { get; }
++        public ulong SizeOfStackReserve { get; }
++        public Subsystem Subsystem { get; }
++        public static PEHeaderBuilder CreateExecutableHeader();
++        public static PEHeaderBuilder CreateLibraryHeader();
++    }
+     public sealed class PEHeaders {
++        public PEHeaders(Stream peStream, int size, bool isLoadedImage);
+     }
+     public struct PEMemoryBlock {
++        public ImmutableArray<byte> GetContent(int start, int length);
++        public BlobReader GetReader();
++        public BlobReader GetReader(int start, int length);
+     }
+     public sealed class PEReader : IDisposable {
++        public unsafe PEReader(byte* peImage, int size, bool isLoadedImage);
++        public bool IsLoadedImage { get; }
++        public PEMemoryBlock GetSectionData(string sectionName);
++        public MetadataReaderProvider ReadEmbeddedPortablePdbDebugDirectoryData(DebugDirectoryEntry entry);
++        public bool TryOpenAssociatedPortablePdb(string peImagePath, Func<string, Stream> pdbFileStreamProvider, out MetadataReaderProvider pdbReaderProvider, out string pdbPath);
+     }
+     public enum PEStreamOptions {
++        IsLoadedImage = 8,
+     }
++    public abstract class ResourceSectionBuilder {
++        protected ResourceSectionBuilder();
++        protected internal abstract void Serialize(BlobBuilder builder, SectionLocation location);
++    }
++    public struct SectionLocation {
++        public SectionLocation(int relativeVirtualAddress, int pointerToRawData);
++        public int PointerToRawData { get; }
++        public int RelativeVirtualAddress { get; }
++    }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Runtime.CompilerServices.md

@@ -0,0 +1,31 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
++    public sealed class AsyncMethodBuilderAttribute : Attribute {
++        public AsyncMethodBuilderAttribute(Type builderType);
++        public Type BuilderType { get; }
++    }
++    public struct AsyncValueTaskMethodBuilder<TResult> {
++        public ValueTask<TResult> Task { get; }
++        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public static AsyncValueTaskMethodBuilder<TResult> Create();
++        public void SetException(Exception exception);
++        public void SetResult(TResult result);
++        public void SetStateMachine(IAsyncStateMachine stateMachine);
++        public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine;
++    }
+     public sealed class TupleElementNamesAttribute : Attribute {
+-        public TupleElementNamesAttribute();
+
+     }
+     public static class Unsafe {
++        public static T Add<T>(ref T source, int elementOffset);
++        public static bool AreSame<T>(ref T left, ref T right);
++        public static TTo As<TFrom, TTo>(ref TFrom source);
++        public static T Subtract<T>(ref T source, int elementOffset);
+     }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Runtime.InteropServices.md

@@ -0,0 +1,16 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+     public static class Marshal {
++        public static string PtrToStringUTF8(IntPtr ptr);
++        public static string PtrToStringUTF8(IntPtr ptr, int byteLen);
++        public static IntPtr StringToCoTaskMemUTF8(string s);
++        public static void ZeroFreeCoTaskMemUTF8(IntPtr s);
+     }
+     public enum UnmanagedType {
++        LPUTF8Str = 48,
+     }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Text.RegularExpressions.md

@@ -0,0 +1,10 @@
+# System.Text.RegularExpressions
+
+``` diff
+ namespace System.Text.RegularExpressions {
+     public class Group : Capture {
++        public string Name { get; }
+     }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Threading.Tasks.md

@@ -0,0 +1,10 @@
+# System.Threading.Tasks
+
+``` diff
+ namespace System.Threading.Tasks {
+     public struct ValueTask<TResult> : IEquatable<ValueTask<TResult>> {
++        public static AsyncValueTaskMethodBuilder<TResult> CreateAsyncMethodBuilder();
+     }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.Xml.md

@@ -0,0 +1,10 @@
+# System.Xml
+
+``` diff
+ namespace System.Xml {
+     public abstract class XmlWriter : IDisposable {
++        public virtual void WriteValue(DateTime value);
+     }
+ }
+```
+

release-notes/1.1/1.0-1.1-api-diff/1.0-1.1-api-diff_System.md

@@ -0,0 +1,72 @@
+# System
+
+``` diff
+ namespace System {
++    public static class TupleExtensions {
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20, T21>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19, out T20 item20, out T21 item21);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19, out T20 item20);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7>(this Tuple<T1, T2, T3, T4, T5, T6, T7> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7);
++        public static void Deconstruct<T1, T2, T3, T4, T5, T6>(this Tuple<T1, T2, T3, T4, T5, T6> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6);
++        public static void Deconstruct<T1, T2, T3, T4, T5>(this Tuple<T1, T2, T3, T4, T5> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5);
++        public static void Deconstruct<T1, T2, T3, T4>(this Tuple<T1, T2, T3, T4> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4);
++        public static void Deconstruct<T1, T2, T3>(this Tuple<T1, T2, T3> value, out T1 item1, out T2 item2, out T3 item3);
++        public static void Deconstruct<T1, T2>(this Tuple<T1, T2> value, out T1 item1, out T2 item2);
++        public static void Deconstruct<T1>(this Tuple<T1> value, out T1 item1);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20, T21>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18, T19, T20, T21>>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18, T19, T20>>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18, T19>>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18>>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17>>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16>>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15>>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6, T7> ToTuple<T1, T2, T3, T4, T5, T6, T7>(this ValueTuple<T1, T2, T3, T4, T5, T6, T7> value);
++        public static Tuple<T1, T2, T3, T4, T5, T6> ToTuple<T1, T2, T3, T4, T5, T6>(this ValueTuple<T1, T2, T3, T4, T5, T6> value);
++        public static Tuple<T1, T2, T3, T4, T5> ToTuple<T1, T2, T3, T4, T5>(this ValueTuple<T1, T2, T3, T4, T5> value);
++        public static Tuple<T1, T2, T3, T4> ToTuple<T1, T2, T3, T4>(this ValueTuple<T1, T2, T3, T4> value);
++        public static Tuple<T1, T2, T3> ToTuple<T1, T2, T3>(this ValueTuple<T1, T2, T3> value);
++        public static Tuple<T1, T2> ToTuple<T1, T2>(this ValueTuple<T1, T2> value);
++        public static Tuple<T1> ToTuple<T1>(this ValueTuple<T1> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18, T19, T20, T21>>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20, T21>>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18, T19, T20>>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20>>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18, T19>>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19>>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17, T18>>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18>>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16, T17>>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17>>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15, T16>>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16>>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14, ValueTuple<T15>>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15>>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13, T14>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12, T13>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11, T12>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10, T11>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9, T10>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8, T9>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>> ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6, T7> ToValueTuple<T1, T2, T3, T4, T5, T6, T7>(this Tuple<T1, T2, T3, T4, T5, T6, T7> value);
++        public static ValueTuple<T1, T2, T3, T4, T5, T6> ToValueTuple<T1, T2, T3, T4, T5, T6>(this Tuple<T1, T2, T3, T4, T5, T6> value);
++        public static ValueTuple<T1, T2, T3, T4, T5> ToValueTuple<T1, T2, T3, T4, T5>(this Tuple<T1, T2, T3, T4, T5> value);
++        public static ValueTuple<T1, T2, T3, T4> ToValueTuple<T1, T2, T3, T4>(this Tuple<T1, T2, T3, T4> value);
++        public static ValueTuple<T1, T2, T3> ToValueTuple<T1, T2, T3>(this Tuple<T1, T2, T3> value);
++        public static ValueTuple<T1, T2> ToValueTuple<T1, T2>(this Tuple<T1, T2> value);
++        public static ValueTuple<T1> ToValueTuple<T1>(this Tuple<T1> value);
++    }
+ }
+```
+

release-notes/1.1/1.1.0-preview1.md

@@ -2,7 +2,6 @@
 
 ## .NET Core 1.1.0 Preview 1 released 10/24/2016
 
-
 There are a few issues to be aware of, which are described in the [.NET Core 1.1.0 Preview 1 Known Issues](1.1.0-preview1-known-issues.md) document.
 
 ### Linux Distros Added
@@ -21,6 +20,10 @@ Support has been added tofor the distros highlighted below.
 * Windows 7+ / Server 2012 R2+
 * Windows Nano Server TP5
 
+### .NET Core API
+
+Changes to the .NET Core API surface are can bee seen in the [1.0-1.1-api-diff](1.0-1.1-api-diff/1.0-1.1-api-diff.md)
+
 ### WCF
 
 XmlSerializer, DataContractSerializer, and DataContractJsonSerializer can now serialize or deserialize objects at runtime without using IL emit or code generation. Prior to this release, in Universal Windows Platform (UWP) applications, these serializers can only be generated at compile time by .NET Native toolchain. This new feature, therefore, is especially useful for UWP applications in scenarios where pre-generated serializers at compile time is hard to achieve when runtime information is required for seraization. For example, constructor XmlSerializer.ctor(Type, XmlRootAttribute) is now supported on UWP.