InternetContent.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Binary;
using Waher.Events;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Runtime.Temporary;
 
namespace Waher.Content
{
    public static class InternetContent
    {
        public static readonly Encoding ISO_8859_1 = Encoding.GetEncoding("ISO-8859-1");
 
        private static string[] canEncodeContentTypes = null;
        private static string[] canEncodeFileExtensions = null;
        private static string[] canDecodeContentTypes = null;
        private static string[] canDecodeFileExtensions = null;
        private static string[] canGetUriSchemes = null;
        private static string[] canPostToUriSchemes = null;
        private static string[] canPutToUriSchemes = null;
        private static string[] canDeleteToUriSchemes = null;
        private static string[] canHeadUriSchemes = null;
        private static string[] canQueryUriSchemes = null;
        private static IContentEncoder[] encoders = null;
        private static IContentDecoder[] decoders = null;
        private static IContentConverter[] converters = null;
        private static IContentGetter[] getters = null;
        private static IContentPoster[] posters = null;
        private static IContentPutter[] putters = null;
        private static IContentDeleter[] deleters = null;
        private static IContentHeader[] headers = null;
        private static IContentQuery[] queries = null;
        private readonly static Dictionary<string, KeyValuePair<Grade, IContentDecoder>> decoderByContentType =
            new Dictionary<string, KeyValuePair<Grade, IContentDecoder>>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, KeyValuePair<Grade, IContentEncoder>> encodersByType =
            new Dictionary<string, KeyValuePair<Grade, IContentEncoder>>();
        private readonly static Dictionary<string, string> contentTypeByFileExtensions = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, string> fileExtensionsByContentType = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, IContentConverter> convertersByStep = new Dictionary<string, IContentConverter>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, ChunkedList<IContentConverter>> convertersByFrom = new Dictionary<string, ChunkedList<IContentConverter>>();
        private readonly static Dictionary<string, IContentGetter[]> gettersByScheme = new Dictionary<string, IContentGetter[]>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, IContentPoster[]> postersByScheme = new Dictionary<string, IContentPoster[]>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, IContentPutter[]> puttersByScheme = new Dictionary<string, IContentPutter[]>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, IContentDeleter[]> deletersByScheme = new Dictionary<string, IContentDeleter[]>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, IContentHeader[]> headersByScheme = new Dictionary<string, IContentHeader[]>(StringComparer.CurrentCultureIgnoreCase);
        private readonly static Dictionary<string, IContentQuery[]> queriesByScheme = new Dictionary<string, IContentQuery[]>(StringComparer.CurrentCultureIgnoreCase);
        private static int defaultTimeout = 60000;
        private static bool defaultTimeoutLocked = false;
 
        static InternetContent()
        {
            Types.OnInvalidated += Types_OnInvalidated;
        }
 
        private static void Types_OnInvalidated(object Sender, EventArgs e)
        {
            canEncodeContentTypes = null;
            canEncodeFileExtensions = null;
            canDecodeContentTypes = null;
            canDecodeFileExtensions = null;
            canGetUriSchemes = null;
            encoders = null;
            decoders = null;
            converters = null;
            getters = null;
            headers = null;
            posters = null;
            putters = null;
            deleters = null;
 
            lock (decoderByContentType)
            {
                decoderByContentType.Clear();
            }
 
            lock (encodersByType)
            {
                encodersByType.Clear();
            }
 
            lock (contentTypeByFileExtensions)
            {
                contentTypeByFileExtensions.Clear();
            }
 
            lock (fileExtensionsByContentType)
            {
                fileExtensionsByContentType.Clear();
            }
 
            lock (convertersByStep)
            {
                convertersByStep.Clear();
                convertersByFrom.Clear();
            }
 
            lock (gettersByScheme)
            {
                gettersByScheme.Clear();
            }
 
            lock (headersByScheme)
            {
                headersByScheme.Clear();
            }
 
            lock (postersByScheme)
            {
                postersByScheme.Clear();
            }
 
            lock (puttersByScheme)
            {
                puttersByScheme.Clear();
            }
 
            lock (deletersByScheme)
            {
                deletersByScheme.Clear();
            }
        }
 
        #region Default Timeout
 
        public static int DefaultTimeout => defaultTimeout;
 
        public static void SetDefaultTimeout(int Timeout, bool Lock)
        {
            if (Timeout <= 0)
                throw new ArgumentException("Timeout must be a positive number of milliseconds.", nameof(Timeout));
 
            if (defaultTimeoutLocked && defaultTimeout != Timeout)
                throw new InvalidOperationException("Default timeout is locked and cannot be changed.");
 
            defaultTimeout = Timeout;
            defaultTimeoutLocked |= Lock;
        }
 
        #endregion
 
        #region Encoding
 
        public static string[] CanEncodeContentTypes
        {
            get
            {
                if (canEncodeContentTypes is null)
                {
                    SortedDictionary<string, bool> ContentTypes = new SortedDictionary<string, bool>();
 
                    foreach (IContentEncoder Encoder in Encoders)
                    {
                        foreach (string ContentType in Encoder.ContentTypes)
                            ContentTypes[ContentType] = true;
                    }
 
                    string[] Types = new string[ContentTypes.Count];
                    ContentTypes.Keys.CopyTo(Types, 0);
 
                    canEncodeContentTypes = Types;
                }
 
                return canEncodeContentTypes;
            }
        }
 
        public static string[] CanEncodeFileExtensions
        {
            get
            {
                if (canEncodeFileExtensions is null)
                {
                    SortedDictionary<string, bool> FileExtensions = new SortedDictionary<string, bool>();
 
                    foreach (IContentEncoder Encoder in Encoders)
                    {
                        foreach (string FileExtension in Encoder.FileExtensions)
                            FileExtensions[FileExtension] = true;
                    }
 
                    string[] Types = new string[FileExtensions.Count];
                    FileExtensions.Keys.CopyTo(Types, 0);
 
                    canEncodeFileExtensions = Types;
                }
 
                return canEncodeFileExtensions;
            }
        }
 
        public static IContentEncoder[] Encoders
        {
            get
            {
                if (encoders is null)
                {
                    ChunkedList<IContentEncoder> Encoders = new ChunkedList<IContentEncoder>();
                    IContentEncoder Encoder;
                    Type[] EncoderTypes = Types.GetTypesImplementingInterface(typeof(IContentEncoder));
 
                    foreach (Type T in EncoderTypes)
                    {
                        ConstructorInfo CI = Types.GetDefaultConstructor(T);
                        if (CI is null)
                            continue;
 
                        try
                        {
                            Encoder = (IContentEncoder)CI.Invoke(Types.NoParameters);
                        }
                        catch (Exception)
                        {
                            continue;
                        }
 
                        Encoders.Add(Encoder);
                    }
 
                    encoders = Encoders.ToArray();
                }
 
                return encoders;
            }
        }
 
        public static bool Encodes(object Object, out Grade Grade, out IContentEncoder Encoder, params string[] AcceptedContentTypes)
        {
            string Key;
 
            if (!(AcceptedContentTypes is null) &&
                AcceptedContentTypes.Length == 1 &&
                AcceptedContentTypes[0] == "*")
            {
                AcceptedContentTypes = Array.Empty<string>();
                Key = Object.GetType().FullName;
            }
            else if (AcceptedContentTypes is null || AcceptedContentTypes.Length == 0)
                Key = Object.GetType().FullName;
            else
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append(Object.GetType().FullName);
 
                foreach (string Accepted in AcceptedContentTypes)
                {
                    sb.Append('|');
                    sb.Append(Accepted);
                }
 
                Key = sb.ToString();
            }
 
            lock (encodersByType)
            {
                if (encodersByType.TryGetValue(Key, out KeyValuePair<Grade, IContentEncoder> P))
                {
                    Grade = P.Key;
                    Encoder = P.Value;
 
                    if (!(Encoder is null))
                        return true;
 
                    if (Object is CustomEncoding)
                    {
                        Encoder = new CustomEncoder();
                        return true;
                    }
 
                    return false;
                }
            }
 
            Grade = Grade.NotAtAll;
            Encoder = null;
 
            foreach (IContentEncoder Encoder2 in Encoders)
            {
                if (Encoder2.Encodes(Object, out Grade Grade2, AcceptedContentTypes) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Encoder = Encoder2;
                }
            }
 
            lock (encodersByType)
            {
                encodersByType[Key] = new KeyValuePair<Grade, IContentEncoder>(Grade, Encoder);
            }
 
            if (!(Encoder is null))
                return true;
 
            if (Object is CustomEncoding)
            {
                Encoder = new CustomEncoder();
                return true;
            }
 
            return false;
        }
 
        [Obsolete("Use the EncodeAsync method for more efficient processing of content including asynchronous processing elements in parallel environments.")]
        public static ContentResponse Encode(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            return EncodeAsync(Object, Encoding, AcceptedContentTypes).Result;
        }
 
        public static Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            return EncodeAsync(Object, Encoding, null, AcceptedContentTypes);
        }
 
        public static Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding,
            ICodecProgress Progress, params string[] AcceptedContentTypes)
        {
            if (!Encodes(Object, out Grade _, out IContentEncoder Encoder, AcceptedContentTypes))
                return Task.FromResult(new ContentResponse(new ArgumentException("No encoder found to encode objects of type " + (Object?.GetType()?.FullName) + ".", nameof(Object))));
 
            return Encoder.EncodeAsync(Object, Encoding, Progress);
        }
 
        public static bool IsAccepted(string ContentType, params string[] AcceptedContentTypes)
        {
            if (AcceptedContentTypes.Length == 0)
                return true;
            else
                return Array.IndexOf(AcceptedContentTypes, ContentType) >= 0;
        }
 
        public static bool IsAccepted(string[] ContentTypes, params string[] AcceptedContentTypes)
        {
            return IsAccepted(ContentTypes, out string _, AcceptedContentTypes);
        }
 
        public static bool IsAccepted(string[] ContentTypes, out string ContentType, params string[] AcceptedContentTypes)
        {
            if (ContentTypes.Length == 0)
            {
                ContentType = null;
                return false;
            }
 
            if ((AcceptedContentTypes?.Length ?? 0) == 0)
            {
                ContentType = ContentTypes[0];
                return true;
            }
 
            foreach (string ContentType2 in ContentTypes)
            {
                if (IsAccepted(ContentType2, AcceptedContentTypes))
                {
                    ContentType = ContentType2;
                    return true;
                }
            }
 
            ContentType = null;
            return false;
        }
 
        #endregion
 
        #region Decoding
 
        public static string[] CanDecodeContentTypes
        {
            get
            {
                if (canDecodeContentTypes is null)
                {
                    SortedDictionary<string, bool> ContentTypes = new SortedDictionary<string, bool>();
 
                    foreach (IContentDecoder Decoder in Decoders)
                    {
                        foreach (string ContentType in Decoder.ContentTypes)
                            ContentTypes[ContentType] = true;
                    }
 
                    string[] Types = new string[ContentTypes.Count];
                    ContentTypes.Keys.CopyTo(Types, 0);
 
                    canDecodeContentTypes = Types;
                }
 
                return canDecodeContentTypes;
            }
        }
 
        public static string[] CanDecodeFileExtensions
        {
            get
            {
                if (canDecodeFileExtensions is null)
                {
                    SortedDictionary<string, bool> FileExtensions = new SortedDictionary<string, bool>();
 
                    foreach (IContentDecoder Decoder in Decoders)
                    {
                        foreach (string FileExtension in Decoder.FileExtensions)
                            FileExtensions[FileExtension] = true;
                    }
 
                    string[] Types = new string[FileExtensions.Count];
                    FileExtensions.Keys.CopyTo(Types, 0);
 
                    canDecodeFileExtensions = Types;
                }
 
                return canDecodeFileExtensions;
            }
        }
 
        public static IContentDecoder[] Decoders
        {
            get
            {
                if (decoders is null)
                {
                    ChunkedList<IContentDecoder> Decoders = new ChunkedList<IContentDecoder>();
                    IContentDecoder Decoder;
                    Type[] DecoderTypes = Types.GetTypesImplementingInterface(typeof(IContentDecoder));
 
                    foreach (Type T in DecoderTypes)
                    {
                        ConstructorInfo CI = Types.GetDefaultConstructor(T);
                        if (CI is null)
                            continue;
 
                        try
                        {
                            Decoder = (IContentDecoder)CI.Invoke(Types.NoParameters);
                        }
                        catch (Exception)
                        {
                            continue;
                        }
 
                        Decoders.Add(Decoder);
                    }
 
                    decoders = Decoders.ToArray();
                }
 
                return decoders;
            }
        }
 
        public static bool Decodes(string ContentType, out Grade Grade, out IContentDecoder Decoder)
        {
            lock (decoderByContentType)
            {
                if (decoderByContentType.TryGetValue(ContentType, out KeyValuePair<Grade, IContentDecoder> P))
                {
                    Grade = P.Key;
                    Decoder = P.Value;
 
                    return !(Decoder is null);
                }
            }
 
            Grade = Grade.NotAtAll;
            Decoder = null;
 
            foreach (IContentDecoder Decoder2 in Decoders)
            {
                if (Decoder2.Decodes(ContentType, out Grade Grade2) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Decoder = Decoder2;
                }
            }
 
            lock (decoderByContentType)
            {
                decoderByContentType[ContentType] = new KeyValuePair<Grade, IContentDecoder>(Grade, Decoder);
            }
 
            return !(Decoder is null);
        }
 
        [Obsolete("Use the DecoceAsync method for more efficient processing of content including asynchronous processing elements in parallel environments.")]
        public static ContentResponse Decode(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair<string, string>[] Fields, Uri BaseUri)
        {
            return DecodeAsync(ContentType, Data, Encoding, Fields, BaseUri).Result;
        }
 
        public static Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair<string, string>[] Fields, Uri BaseUri)
        {
            return DecodeAsync(ContentType, Data, Encoding, Fields, BaseUri, null);
        }
 
        public static Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding,
            KeyValuePair<string, string>[] Fields, Uri BaseUri, ICodecProgress Progress)
        {
            if (string.IsNullOrEmpty(ContentType))
            {
                if ((Data?.Length ?? 0) == 0)
                    return Task.FromResult(new ContentResponse(string.Empty, null, Data));
                else
                {
                    return Task.FromResult(new ContentResponse(BinaryCodec.DefaultContentType,
                        new CustomEncoding(BinaryCodec.DefaultContentType, Data), Data));
                }
            }
            else if (Decodes(ContentType, out Grade _, out IContentDecoder Decoder))
                return Decoder.DecodeAsync(ContentType, Data, Encoding, Fields, BaseUri, Progress);
            else
            {
                return Task.FromResult(new ContentResponse(ContentType,
                    new CustomEncoding(ContentType, Data), Data));
            }
        }
 
        [Obsolete("Use the DecoceAsync method for more efficient processing of content including asynchronous processing elements in parallel environments.")]
        public static ContentResponse Decode(string ContentType, byte[] Data, Uri BaseUri)
        {
            return DecodeAsync(ContentType, Data, BaseUri).Result;
        }
 
        public static Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Uri BaseUri)
        {
            return DecodeAsync(ContentType, Data, BaseUri, null);
        }
 
        public static Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Uri BaseUri,
            ICodecProgress Progress)
        {
            ParseContentType(ref ContentType, out Encoding Encoding,
                out KeyValuePair<string, string>[] Fields);
 
            return DecodeAsync(ContentType, Data, Encoding, Fields, BaseUri, Progress);
        }
 
        public static bool ParseContentType(ref string ContentType, out Encoding Encoding,
            out KeyValuePair<string, string>[] Fields)
        {
            int i;
            
            Encoding = null;
 
            i = ContentType.IndexOf(';');
            if (i > 0)
            {
                Fields = CommonTypes.ParseFieldValues(ContentType.Substring(i + 1).TrimStart());
                ContentType = ContentType.Substring(0, i).TrimEnd();
 
                foreach (KeyValuePair<string, string> Field in Fields)
                {
                    if (string.Compare(Field.Key, "CHARSET", true) == 0)
                        Encoding = GetEncoding(Field.Value);
                }
 
                return true;
            }
            else
            {
                Fields = Array.Empty<KeyValuePair<string, string>>();
                return false;
            }
        }
 
        public static Encoding GetEncoding(string CharacterSet)
        {
            if (string.IsNullOrEmpty(CharacterSet))
                return null;
 
            // Reference: http://www.iana.org/assignments/character-sets/character-sets.xhtml
            switch (CharacterSet.ToUpper())
            {
                case "ASCII":
                case "US-ASCII":
                    return Encoding.ASCII;
 
                case "UTF-16LE":
                case "UTF-16":
                    return Encoding.Unicode;
 
                case "UTF-16BE":
                    return Encoding.BigEndianUnicode;
 
                case "UTF-32":
                case "UTF-32LE":
                    return Encoding.UTF32;
 
                case "UNICODE-1-1-UTF-7":
                case "UTF-7":
                    return Encoding.UTF7;
 
                case "UTF-8":
                    return Encoding.UTF8;
 
                default:
                    return Encoding.GetEncoding(CharacterSet);
            }
        }
 
        #endregion
 
        #region File extensions
 
        public static string GetContentType(string FileExtension)
        {
            if (TryGetContentType(FileExtension, out string ContentType))
                return ContentType;
            else
                return BinaryCodec.DefaultContentType;
        }
 
        public static bool TryGetContentType(string FileExtension, out string ContentType)
        {
            FileExtension = FileExtension.ToLower();
            if (FileExtension.StartsWith("."))
                FileExtension = FileExtension.Substring(1);
 
            lock (contentTypeByFileExtensions)
            {
                if (contentTypeByFileExtensions.TryGetValue(FileExtension, out ContentType))
                    return true;
            }
 
            foreach (IContentDecoder Decoder in Decoders)
            {
                if (Decoder.TryGetContentType(FileExtension, out ContentType))
                {
                    lock (contentTypeByFileExtensions)
                    {
                        contentTypeByFileExtensions[FileExtension] = ContentType;
                    }
 
                    return true;
                }
            }
 
            foreach (IContentEncoder Encoder in Encoders)
            {
                if (Encoder.TryGetContentType(FileExtension, out ContentType))
                {
                    lock (contentTypeByFileExtensions)
                    {
                        contentTypeByFileExtensions[FileExtension] = ContentType;
                    }
 
                    return true;
                }
            }
 
            return false;
        }
 
        public static string GetFileExtension(string ContentType)
        {
            if (TryGetFileExtension(ContentType, out string FileExtension))
                return FileExtension;
            else
                return "bin";
        }
 
        public static bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            ContentType = ContentType.ToLower();
 
            lock (fileExtensionsByContentType)
            {
                if (fileExtensionsByContentType.TryGetValue(ContentType, out FileExtension))
                    return true;
            }
 
            foreach (IContentDecoder Decoder in Decoders)
            {
                if (Decoder.TryGetFileExtension(ContentType, out FileExtension))
                {
                    lock (fileExtensionsByContentType)
                    {
                        fileExtensionsByContentType[ContentType] = FileExtension;
                    }
 
                    return true;
                }
            }
 
            foreach (IContentEncoder Encoder in Encoders)
            {
                if (Encoder.TryGetFileExtension(ContentType, out FileExtension))
                {
                    lock (fileExtensionsByContentType)
                    {
                        fileExtensionsByContentType[ContentType] = FileExtension;
                    }
 
                    return true;
                }
            }
 
            return false;
        }
 
        #endregion
 
        #region Content Conversion
 
 
        public static IContentConverter[] Converters
        {
            get
            {
                if (converters is null)
                    FindConverters();
 
                return converters;
            }
        }
 
        public static bool CanConvert(string FromContentType, string ToContentType, out IContentConverter Converter)
        {
            lock (convertersByStep)
            {
                if (converters is null)
                    FindConverters();
 
                string PathKey = FromContentType + " -> " + ToContentType;
                if (convertersByStep.TryGetValue(PathKey, out Converter))
                    return !(Converter is null);
 
                if (!convertersByFrom.TryGetValue(FromContentType, out ChunkedList<IContentConverter> Converters))
                    return false;
 
                ChunkedList<ConversionStep> Queue = new ChunkedList<ConversionStep>();
                ConversionStep Step;
 
                foreach (IContentConverter C in Converters)
                {
                    Step = new ConversionStep()
                    {
                        From = FromContentType,
                        Converter = C,
                        TotalGrade = C.ConversionGrade,
                        Prev = null,
                        Distance = 1
                    };
 
                    Queue.Add(Step);
                }
 
                Dictionary<string, ConversionStep> Possibilities = new Dictionary<string, ConversionStep>();
                ConversionStep Best = null;
                Grade BestGrade = Grade.NotAtAll;
                int BestDistance = int.MaxValue;
                Grade StepGrade;
                int StepDistance;
                bool First;
 
                while (Queue.HasFirstItem)
                {
                    Step = Queue.RemoveFirst();
 
                    StepDistance = Step.Distance + 1;
                    StepGrade = Step.Converter.ConversionGrade;
                    if (Step.TotalGrade < StepGrade)
                        StepGrade = Step.TotalGrade;
 
                    foreach (string To in Step.Converter.ToContentTypes)
                    {
                        if (string.Compare(To, ToContentType, true) == 0 || To == "*")
                        {
                            if (StepGrade > BestGrade || StepGrade == BestGrade && StepDistance < BestDistance)
                            {
                                Best = Step;
                                BestGrade = StepGrade;
                                BestDistance = StepDistance;
                            }
                        }
                        else
                        {
                            if (Possibilities.TryGetValue(To, out ConversionStep NextStep) && NextStep.TotalGrade >= StepGrade && NextStep.Distance <= StepDistance)
                                continue;
 
                            if (!convertersByFrom.TryGetValue(To, out Converters))
                                continue;
 
                            First = true;
                            foreach (IContentConverter C in Converters)
                            {
                                NextStep = new ConversionStep()
                                {
                                    From = To,
                                    Converter = C,
                                    TotalGrade = StepGrade,
                                    Prev = Step,
                                    Distance = StepDistance
                                };
 
                                if (First)
                                {
                                    Possibilities[To] = NextStep;
                                    First = false;
                                }
 
                                Queue.Add(NextStep);
                            }
                        }
                    }
                }
 
                if (!(Best is null))
                {
                    ChunkedList<KeyValuePair<string, IContentConverter>> List = new ChunkedList<KeyValuePair<string, IContentConverter>>();
 
                    while (!(Best is null))
                    {
                        List.Insert(0, new KeyValuePair<string, IContentConverter>(Best.From, Best.Converter));
                        Best = Best.Prev;
                    }
 
                    Converter = new ConversionSequence(FromContentType, ToContentType, BestGrade, List.ToArray());
                    convertersByStep[PathKey] = Converter;
                    return true;
                }
                else
                {
                    convertersByStep[PathKey] = null;
                    Converter = null;
                    return false;
                }
            }
        }
 
        private class ConversionStep
        {
            public IContentConverter Converter;
            public Grade TotalGrade;
            public ConversionStep Prev;
            public string From;
            public int Distance;
        }
 
        private static void FindConverters()
        {
            ChunkedList<IContentConverter> Converters = new ChunkedList<IContentConverter>();
            IContentConverter Converter;
            Type[] ConverterTypes = Types.GetTypesImplementingInterface(typeof(IContentConverter));
 
            convertersByStep.Clear();
            convertersByFrom.Clear();
 
            lock (convertersByStep)
            {
                foreach (Type T in ConverterTypes)
                {
                    ConstructorInfo CI = Types.GetDefaultConstructor(T);
                    if (CI is null)
                        continue;
 
                    try
                    {
                        Converter = (IContentConverter)CI.Invoke(Types.NoParameters);
                    }
                    catch (Exception)
                    {
                        continue;
                    }
 
                    Converters.Add(Converter);
 
                    foreach (string From in Converter.FromContentTypes)
                    {
                        if (!convertersByFrom.TryGetValue(From, out ChunkedList<IContentConverter> List))
                        {
                            List = new ChunkedList<IContentConverter>();
                            convertersByFrom[From] = List;
                        }
 
                        List.Add(Converter);
 
                        foreach (string To in Converter.ToContentTypes)
                        {
                            if (To != "*")
                                convertersByStep[From + " -> " + To] = Converter;
                        }
                    }
                }
            }
 
            converters = Converters.ToArray();
        }
 
        public static IContentConverter[] GetConverters(string FromContentType)
        {
            lock (convertersByStep)
            {
                if (converters is null)
                    FindConverters();
 
                if (!convertersByFrom.TryGetValue(FromContentType, out ChunkedList<IContentConverter> Converters))
                    return null;
 
                return Converters.ToArray();
            }
        }
 
        #endregion
 
        #region Getting resources
 
        public static string[] CanGetUriSchemes
        {
            get
            {
                if (canGetUriSchemes is null)
                {
                    SortedDictionary<string, bool> UriSchemes = new SortedDictionary<string, bool>();
 
                    foreach (IContentGetter Getter in Getters)
                    {
                        foreach (string Scheme in Getter.UriSchemes)
                            UriSchemes[Scheme] = true;
                    }
 
                    string[] Schemes = new string[UriSchemes.Count];
                    UriSchemes.Keys.CopyTo(Schemes, 0);
 
                    canGetUriSchemes = Schemes;
                }
 
                return canGetUriSchemes;
            }
        }
 
        public static IContentGetter[] Getters
        {
            get
            {
                if (getters is null)
                    BuildGetters();
 
                return getters;
            }
        }
 
        private static void BuildGetters()
        {
            ChunkedList<IContentGetter> Getters = new ChunkedList<IContentGetter>();
            Type[] GetterTypes = Types.GetTypesImplementingInterface(typeof(IContentGetter));
            Dictionary<string, ChunkedList<IContentGetter>> ByScheme = new Dictionary<string, ChunkedList<IContentGetter>>();
            IContentGetter Getter;
 
            foreach (Type T in GetterTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                try
                {
                    Getter = (IContentGetter)CI.Invoke(Types.NoParameters);
                }
                catch (Exception)
                {
                    continue;
                }
 
                Getters.Add(Getter);
 
                foreach (string Schema in Getter.UriSchemes)
                {
                    if (!ByScheme.TryGetValue(Schema, out ChunkedList<IContentGetter> List))
                    {
                        List = new ChunkedList<IContentGetter>();
                        ByScheme[Schema] = List;
                    }
 
                    List.Add(Getter);
                }
            }
 
            lock (gettersByScheme)
            {
                foreach (KeyValuePair<string, ChunkedList<IContentGetter>> P in ByScheme)
                    gettersByScheme[P.Key] = P.Value.ToArray();
            }
 
            getters = Getters.ToArray();
        }
 
        public static bool CanGet(Uri Uri, out Grade Grade, out IContentGetter Getter)
        {
            if (Uri is null)
            {
                Grade = Grade.NotAtAll;
                Getter = null;
                return false;
            }
 
            if (getters is null)
                BuildGetters();
 
            IContentGetter[] Getters;
 
            lock (gettersByScheme)
            {
                if (Uri is null || !gettersByScheme.TryGetValue(Uri.Scheme, out Getters))
                {
                    Getter = null;
                    Grade = Grade.NotAtAll;
                    return false;
                }
            }
 
            Grade = Grade.NotAtAll;
            Getter = null;
 
            foreach (IContentGetter Getter2 in Getters)
            {
                if (Getter2.CanGet(Uri, out Grade Grade2) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Getter = Getter2;
                }
            }
 
            return !(Getter is null);
        }
 
        public static Task<ContentResponse> GetAsync(Uri Uri, params KeyValuePair<string, string>[] Headers)
        {
            return GetAsync(Uri, null, null, Headers);
        }
 
        public static Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return GetAsync(Uri, Certificate, null, Headers);
        }
 
        public static Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            params KeyValuePair<string, string>[] Headers)
        {
            if (!CanGet(Uri, out Grade _, out IContentGetter Getter))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (GET): " + Uri.Scheme, nameof(Uri))));
 
            return Getter.GetAsync(Uri, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentResponse> GetAsync(Uri Uri, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return GetAsync(Uri, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return GetAsync(Uri, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanGet(Uri, out Grade _, out IContentGetter Getter))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (GET): " + Uri.Scheme, nameof(Uri))));
 
            return Getter.GetAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, null, null, null, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, null, null, Destination, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, Certificate, null, null, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate, TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, Certificate, null, Destination, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanGet(Uri, out Grade _, out IContentGetter Getter))
                return Task.FromResult(new ContentStreamResponse(new ArgumentException("URI Scheme not recognized (GET): " + Uri.Scheme, nameof(Uri))));
 
            return Getter.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanGet(Uri, out Grade _, out IContentGetter Getter))
                return Task.FromResult(new ContentStreamResponse(new ArgumentException("URI Scheme not recognized (GET): " + Uri.Scheme, nameof(Uri))));
 
            return Getter.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, Destination, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, int TimeoutMs, TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, null, null, TimeoutMs, Destination, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate, int TimeoutMs,
            TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            return GetTempStreamAsync(Uri, Certificate, null, TimeoutMs, Destination, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanGet(Uri, out Grade _, out IContentGetter Getter))
                return Task.FromResult(new ContentStreamResponse(new ArgumentException("URI Scheme not recognized (GET): " + Uri.Scheme, nameof(Uri))));
 
            return Getter.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        public static Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, TemporaryStream Destination,
            params KeyValuePair<string, string>[] Headers)
        {
            if (!CanGet(Uri, out Grade _, out IContentGetter Getter))
                return Task.FromResult(new ContentStreamResponse(new ArgumentException("URI Scheme not recognized (GET): " + Uri.Scheme, nameof(Uri))));
 
            return Getter.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Destination, Headers);
        }
 
        #endregion
 
        #region Posting to resources
 
        public static string[] CanPostToUriSchemes
        {
            get
            {
                if (canPostToUriSchemes is null)
                {
                    SortedDictionary<string, bool> UriSchemes = new SortedDictionary<string, bool>();
 
                    foreach (IContentPoster Poster in Posters)
                    {
                        foreach (string Scheme in Poster.UriSchemes)
                            UriSchemes[Scheme] = true;
                    }
 
                    string[] Schemes = new string[UriSchemes.Count];
                    UriSchemes.Keys.CopyTo(Schemes, 0);
 
                    canPostToUriSchemes = Schemes;
                }
 
                return canPostToUriSchemes;
            }
        }
 
        public static IContentPoster[] Posters
        {
            get
            {
                if (posters is null)
                    BuildPosters();
 
                return posters;
            }
        }
 
        private static void BuildPosters()
        {
            ChunkedList<IContentPoster> Posters = new ChunkedList<IContentPoster>();
            Type[] PosterTypes = Types.GetTypesImplementingInterface(typeof(IContentPoster));
            Dictionary<string, ChunkedList<IContentPoster>> ByScheme = new Dictionary<string, ChunkedList<IContentPoster>>();
            IContentPoster Poster;
 
            foreach (Type T in PosterTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                try
                {
                    Poster = (IContentPoster)CI.Invoke(Types.NoParameters);
                }
                catch (Exception)
                {
                    continue;
                }
 
                Posters.Add(Poster);
 
                foreach (string Schema in Poster.UriSchemes)
                {
                    if (!ByScheme.TryGetValue(Schema, out ChunkedList<IContentPoster> List))
                    {
                        List = new ChunkedList<IContentPoster>();
                        ByScheme[Schema] = List;
                    }
 
                    List.Add(Poster);
                }
            }
 
            lock (postersByScheme)
            {
                foreach (KeyValuePair<string, ChunkedList<IContentPoster>> P in ByScheme)
                    postersByScheme[P.Key] = P.Value.ToArray();
            }
 
            posters = Posters.ToArray();
        }
 
        public static bool CanPost(Uri Uri, out Grade Grade, out IContentPoster Poster)
        {
            if (Uri is null)
            {
                Grade = Grade.NotAtAll;
                Poster = null;
                return false;
            }
 
            if (posters is null)
                BuildPosters();
 
            IContentPoster[] Posters;
 
            lock (postersByScheme)
            {
                if (Uri is null || !postersByScheme.TryGetValue(Uri.Scheme, out Posters))
                {
                    Poster = null;
                    Grade = Grade.NotAtAll;
                    return false;
                }
            }
 
            Grade = Grade.NotAtAll;
            Poster = null;
 
            foreach (IContentPoster Poster2 in Posters)
            {
                if (Poster2.CanPost(Uri, out Grade Grade2) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Poster = Poster2;
                }
            }
 
            return !(Poster is null);
        }
 
        public static Task<ContentResponse> PostAsync(Uri Uri, object Data, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, Data, null, null, Headers);
        }
 
        public static Task<ContentResponse> PostAsync(Uri Uri, object Data, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, Data, Certificate, null, Headers);
        }
 
        public static Task<ContentResponse> PostAsync(Uri Uri, object Data, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPost(Uri, out Grade _, out IContentPoster Poster))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (POST): " + Uri.Scheme, nameof(Uri))));
 
            return Poster.PostAsync(Uri, Data, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentResponse> PostAsync(Uri Uri, object Data, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, Data, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> PostAsync(Uri Uri, object Data, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, Data, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> PostAsync(Uri Uri, object Data, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPost(Uri, out Grade _, out IContentPoster Poster))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (POST): " + Uri.Scheme, nameof(Uri))));
 
            return Poster.PostAsync(Uri, Data, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> PostAsync(Uri Uri, byte[] EncodedData, string ContentType, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, EncodedData, ContentType, null, null, Headers);
        }
 
        public static Task<ContentBinaryResponse> PostAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, EncodedData, ContentType, Certificate, null, Headers);
        }
 
        public static Task<ContentBinaryResponse> PostAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPost(Uri, out Grade _, out IContentPoster Poster))
                return Task.FromResult(new ContentBinaryResponse(new ArgumentException("URI Scheme not recognized (POST): " + Uri.Scheme, nameof(Uri))));
 
            return Poster.PostAsync(Uri, EncodedData, ContentType, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentBinaryResponse> PostAsync(Uri Uri, byte[] EncodedData, string ContentType, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, EncodedData, ContentType, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> PostAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PostAsync(Uri, EncodedData, ContentType, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> PostAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs,
            params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPost(Uri, out Grade _, out IContentPoster Poster))
                return Task.FromResult(new ContentBinaryResponse(new ArgumentException("URI Scheme not recognized (POST): " + Uri.Scheme, nameof(Uri))));
 
            return Poster.PostAsync(Uri, EncodedData, ContentType, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        #endregion
 
        #region Putting to resources
 
        public static string[] CanPutToUriSchemes
        {
            get
            {
                if (canPutToUriSchemes is null)
                {
                    SortedDictionary<string, bool> UriSchemes = new SortedDictionary<string, bool>();
 
                    foreach (IContentPutter Putter in Putters)
                    {
                        foreach (string Scheme in Putter.UriSchemes)
                            UriSchemes[Scheme] = true;
                    }
 
                    string[] Schemes = new string[UriSchemes.Count];
                    UriSchemes.Keys.CopyTo(Schemes, 0);
 
                    canPutToUriSchemes = Schemes;
                }
 
                return canPutToUriSchemes;
            }
        }
 
        public static IContentPutter[] Putters
        {
            get
            {
                if (putters is null)
                    BuildPutters();
 
                return putters;
            }
        }
 
        private static void BuildPutters()
        {
            ChunkedList<IContentPutter> Putters = new ChunkedList<IContentPutter>();
            Type[] PutterTypes = Types.GetTypesImplementingInterface(typeof(IContentPutter));
            Dictionary<string, ChunkedList<IContentPutter>> ByScheme = new Dictionary<string, ChunkedList<IContentPutter>>();
            IContentPutter Putter;
 
            foreach (Type T in PutterTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                try
                {
                    Putter = (IContentPutter)CI.Invoke(Types.NoParameters);
                }
                catch (Exception)
                {
                    continue;
                }
 
                Putters.Add(Putter);
 
                foreach (string Schema in Putter.UriSchemes)
                {
                    if (!ByScheme.TryGetValue(Schema, out ChunkedList<IContentPutter> List))
                    {
                        List = new ChunkedList<IContentPutter>();
                        ByScheme[Schema] = List;
                    }
 
                    List.Add(Putter);
                }
            }
 
            lock (puttersByScheme)
            {
                foreach (KeyValuePair<string, ChunkedList<IContentPutter>> P in ByScheme)
                    puttersByScheme[P.Key] = P.Value.ToArray();
            }
 
            putters = Putters.ToArray();
        }
 
        public static bool CanPut(Uri Uri, out Grade Grade, out IContentPutter Putter)
        {
            if (Uri is null)
            {
                Grade = Grade.NotAtAll;
                Putter = null;
                return false;
            }
 
            if (putters is null)
                BuildPutters();
 
            IContentPutter[] Putters;
 
            lock (puttersByScheme)
            {
                if (Uri is null || !puttersByScheme.TryGetValue(Uri.Scheme, out Putters))
                {
                    Putter = null;
                    Grade = Grade.NotAtAll;
                    return false;
                }
            }
 
            Grade = Grade.NotAtAll;
            Putter = null;
 
            foreach (IContentPutter Putter2 in Putters)
            {
                if (Putter2.CanPut(Uri, out Grade Grade2) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Putter = Putter2;
                }
            }
 
            return !(Putter is null);
        }
 
        public static Task<ContentResponse> PutAsync(Uri Uri, object Data, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, Data, null, null, Headers);
        }
 
        public static Task<ContentResponse> PutAsync(Uri Uri, object Data, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, Data, Certificate, null, Headers);
        }
 
        public static Task<ContentResponse> PutAsync(Uri Uri, object Data, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPut(Uri, out Grade _, out IContentPutter Putter))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Putter.PutAsync(Uri, Data, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentResponse> PutAsync(Uri Uri, object Data, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, Data, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> PutAsync(Uri Uri, object Data, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, Data, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> PutAsync(Uri Uri, object Data, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPut(Uri, out Grade _, out IContentPutter Putter))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Putter.PutAsync(Uri, Data, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> PutAsync(Uri Uri, byte[] EncodedData, string ContentType, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, EncodedData, ContentType, null, null, Headers);
        }
 
        public static Task<ContentBinaryResponse> PutAsync(Uri Uri, byte[] EncodedData, string ContentType, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, EncodedData, ContentType, Certificate, null, Headers);
        }
 
        public static Task<ContentBinaryResponse> PutAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPut(Uri, out Grade _, out IContentPutter Putter))
                return Task.FromResult(new ContentBinaryResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Putter.PutAsync(Uri, EncodedData, ContentType, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentBinaryResponse> PutAsync(Uri Uri, byte[] EncodedData, string ContentType, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, EncodedData, ContentType, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> PutAsync(Uri Uri, byte[] EncodedData, string ContentType, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return PutAsync(Uri, EncodedData, ContentType, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> PutAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanPut(Uri, out Grade _, out IContentPutter Putter))
                return Task.FromResult(new ContentBinaryResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Putter.PutAsync(Uri, EncodedData, ContentType, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        #endregion
 
        #region Deleting to resources
 
        public static string[] CanDeleteToUriSchemes
        {
            get
            {
                if (canDeleteToUriSchemes is null)
                {
                    SortedDictionary<string, bool> UriSchemes = new SortedDictionary<string, bool>();
 
                    foreach (IContentDeleter Deleter in Deleters)
                    {
                        foreach (string Scheme in Deleter.UriSchemes)
                            UriSchemes[Scheme] = true;
                    }
 
                    string[] Schemes = new string[UriSchemes.Count];
                    UriSchemes.Keys.CopyTo(Schemes, 0);
 
                    canDeleteToUriSchemes = Schemes;
                }
 
                return canDeleteToUriSchemes;
            }
        }
 
        public static IContentDeleter[] Deleters
        {
            get
            {
                if (deleters is null)
                    BuildDeleters();
 
                return deleters;
            }
        }
 
        private static void BuildDeleters()
        {
            ChunkedList<IContentDeleter> Deleters = new ChunkedList<IContentDeleter>();
            Type[] DeleterTypes = Types.GetTypesImplementingInterface(typeof(IContentDeleter));
            Dictionary<string, ChunkedList<IContentDeleter>> ByScheme = new Dictionary<string, ChunkedList<IContentDeleter>>();
            IContentDeleter Deleter;
 
            foreach (Type T in DeleterTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                try
                {
                    Deleter = (IContentDeleter)CI.Invoke(Types.NoParameters);
                }
                catch (Exception)
                {
                    continue;
                }
 
                Deleters.Add(Deleter);
 
                foreach (string Schema in Deleter.UriSchemes)
                {
                    if (!ByScheme.TryGetValue(Schema, out ChunkedList<IContentDeleter> List))
                    {
                        List = new ChunkedList<IContentDeleter>();
                        ByScheme[Schema] = List;
                    }
 
                    List.Add(Deleter);
                }
            }
 
            lock (deletersByScheme)
            {
                foreach (KeyValuePair<string, ChunkedList<IContentDeleter>> P in ByScheme)
                    deletersByScheme[P.Key] = P.Value.ToArray();
            }
 
            deleters = Deleters.ToArray();
        }
 
        public static bool CanDelete(Uri Uri, out Grade Grade, out IContentDeleter Deleter)
        {
            if (Uri is null)
            {
                Grade = Grade.NotAtAll;
                Deleter = null;
                return false;
            }
 
            if (deleters is null)
                BuildDeleters();
 
            IContentDeleter[] Deleters;
 
            lock (deletersByScheme)
            {
                if (Uri is null || !deletersByScheme.TryGetValue(Uri.Scheme, out Deleters))
                {
                    Deleter = null;
                    Grade = Grade.NotAtAll;
                    return false;
                }
            }
 
            Grade = Grade.NotAtAll;
            Deleter = null;
 
            foreach (IContentDeleter Deleter2 in Deleters)
            {
                if (Deleter2.CanDelete(Uri, out Grade Grade2) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Deleter = Deleter2;
                }
            }
 
            return !(Deleter is null);
        }
 
        public static Task<ContentResponse> DeleteAsync(Uri Uri, params KeyValuePair<string, string>[] Headers)
        {
            return DeleteAsync(Uri, null, null, Headers);
        }
 
        public static Task<ContentResponse> DeleteAsync(Uri Uri, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return DeleteAsync(Uri, Certificate, null, Headers);
        }
 
        public static Task<ContentResponse> DeleteAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanDelete(Uri, out Grade _, out IContentDeleter Deleter))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (DELETE): " + Uri.Scheme, nameof(Uri))));
 
            return Deleter.DeleteAsync(Uri, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentResponse> DeleteAsync(Uri Uri, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return DeleteAsync(Uri, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> DeleteAsync(Uri Uri, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return DeleteAsync(Uri, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> DeleteAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs,
            params KeyValuePair<string, string>[] Headers)
        {
            if (!CanDelete(Uri, out Grade _, out IContentDeleter Deleter))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (DELETE): " + Uri.Scheme, nameof(Uri))));
 
            return Deleter.DeleteAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        #endregion
 
        #region Getting headers of resources
 
        public static string[] CanHeadUriSchemes
        {
            get
            {
                if (canHeadUriSchemes is null)
                {
                    SortedDictionary<string, bool> UriSchemes = new SortedDictionary<string, bool>();
 
                    foreach (IContentHeader Header in Headers)
                    {
                        foreach (string Scheme in Header.UriSchemes)
                            UriSchemes[Scheme] = true;
                    }
 
                    string[] Schemes = new string[UriSchemes.Count];
                    UriSchemes.Keys.CopyTo(Schemes, 0);
 
                    canHeadUriSchemes = Schemes;
                }
 
                return canHeadUriSchemes;
            }
        }
 
        public static IContentHeader[] Headers
        {
            get
            {
                if (headers is null)
                    BuildHeaders();
 
                return headers;
            }
        }
 
        private static void BuildHeaders()
        {
            ChunkedList<IContentHeader> Headers = new ChunkedList<IContentHeader>();
            Type[] HeaderTypes = Types.GetTypesImplementingInterface(typeof(IContentHeader));
            Dictionary<string, ChunkedList<IContentHeader>> ByScheme = new Dictionary<string, ChunkedList<IContentHeader>>();
            IContentHeader Header;
 
            foreach (Type T in HeaderTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                try
                {
                    Header = (IContentHeader)CI.Invoke(Types.NoParameters);
                }
                catch (Exception)
                {
                    continue;
                }
 
                Headers.Add(Header);
 
                foreach (string Schema in Header.UriSchemes)
                {
                    if (!ByScheme.TryGetValue(Schema, out ChunkedList<IContentHeader> List))
                    {
                        List = new ChunkedList<IContentHeader>();
                        ByScheme[Schema] = List;
                    }
 
                    List.Add(Header);
                }
            }
 
            lock (headersByScheme)
            {
                foreach (KeyValuePair<string, ChunkedList<IContentHeader>> P in ByScheme)
                    headersByScheme[P.Key] = P.Value.ToArray();
            }
 
            headers = Headers.ToArray();
        }
 
        public static bool CanHead(Uri Uri, out Grade Grade, out IContentHeader Header)
        {
            if (Uri is null)
            {
                Grade = Grade.NotAtAll;
                Header = null;
                return false;
            }
 
            if (headers is null)
                BuildHeaders();
 
            IContentHeader[] Headers;
 
            lock (headersByScheme)
            {
                if (Uri is null || !headersByScheme.TryGetValue(Uri.Scheme, out Headers))
                {
                    Header = null;
                    Grade = Grade.NotAtAll;
                    return false;
                }
            }
 
            Grade = Grade.NotAtAll;
            Header = null;
 
            foreach (IContentHeader Header2 in Headers)
            {
                if (Header2.CanHead(Uri, out Grade Grade2) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Header = Header2;
                }
            }
 
            return !(Header is null);
        }
 
        public static Task<ContentResponse> HeadAsync(Uri Uri, params KeyValuePair<string, string>[] Headers)
        {
            return HeadAsync(Uri, null, null, Headers);
        }
 
        public static Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return HeadAsync(Uri, Certificate, null, Headers);
        }
 
        public static Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            params KeyValuePair<string, string>[] Headers)
        {
            if (!CanHead(Uri, out Grade _, out IContentHeader Header))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (HEAD): " + Uri.Scheme, nameof(Uri))));
 
            return Header.HeadAsync(Uri, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentResponse> HeadAsync(Uri Uri, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return HeadAsync(Uri, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return HeadAsync(Uri, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanHead(Uri, out Grade _, out IContentHeader Header))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (HEAD): " + Uri.Scheme, nameof(Uri))));
 
            return Header.HeadAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        #endregion
 
        #region Querying resources
 
        public static string[] CanQueryToUriSchemes
        {
            get
            {
                if (canQueryUriSchemes is null)
                {
                    SortedDictionary<string, bool> UriSchemes = new SortedDictionary<string, bool>();
 
                    foreach (IContentQuery Query in Queries)
                    {
                        foreach (string Scheme in Query.UriSchemes)
                            UriSchemes[Scheme] = true;
                    }
 
                    string[] Schemes = new string[UriSchemes.Count];
                    UriSchemes.Keys.CopyTo(Schemes, 0);
 
                    canQueryUriSchemes = Schemes;
                }
 
                return canQueryUriSchemes;
            }
        }
 
        public static IContentQuery[] Queries
        {
            get
            {
                if (queries is null)
                    BuildQueries();
 
                return queries;
            }
        }
 
        private static void BuildQueries()
        {
            ChunkedList<IContentQuery> Queries = new ChunkedList<IContentQuery>();
            Type[] QueryTypes = Types.GetTypesImplementingInterface(typeof(IContentQuery));
            Dictionary<string, ChunkedList<IContentQuery>> ByScheme = new Dictionary<string, ChunkedList<IContentQuery>>();
            IContentQuery Query;
 
            foreach (Type T in QueryTypes)
            {
                ConstructorInfo CI = Types.GetDefaultConstructor(T);
                if (CI is null)
                    continue;
 
                try
                {
                    Query = (IContentQuery)CI.Invoke(Types.NoParameters);
                }
                catch (Exception)
                {
                    continue;
                }
 
                Queries.Add(Query);
 
                foreach (string Schema in Query.UriSchemes)
                {
                    if (!ByScheme.TryGetValue(Schema, out ChunkedList<IContentQuery> List))
                    {
                        List = new ChunkedList<IContentQuery>();
                        ByScheme[Schema] = List;
                    }
 
                    List.Add(Query);
                }
            }
 
            lock (queriesByScheme)
            {
                foreach (KeyValuePair<string, ChunkedList<IContentQuery>> P in ByScheme)
                    queriesByScheme[P.Key] = P.Value.ToArray();
            }
 
            queries = Queries.ToArray();
        }
 
        public static bool CanQuery(Uri Uri, out Grade Grade, out IContentQuery Query)
        {
            if (Uri is null)
            {
                Grade = Grade.NotAtAll;
                Query = null;
                return false;
            }
 
            if (queries is null)
                BuildQueries();
 
            IContentQuery[] Queries;
 
            lock (queriesByScheme)
            {
                if (Uri is null || !queriesByScheme.TryGetValue(Uri.Scheme, out Queries))
                {
                    Query = null;
                    Grade = Grade.NotAtAll;
                    return false;
                }
            }
 
            Grade = Grade.NotAtAll;
            Query = null;
 
            foreach (IContentQuery Query2 in Queries)
            {
                if (Query2.CanQuery(Uri, out Grade Grade2) && Grade2 > Grade)
                {
                    Grade = Grade2;
                    Query = Query2;
                }
            }
 
            return !(Query is null);
        }
 
        public static Task<ContentResponse> QueryAsync(Uri Uri, object Data, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, Data, null, null, Headers);
        }
 
        public static Task<ContentResponse> QueryAsync(Uri Uri, object Data, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, Data, Certificate, null, Headers);
        }
 
        public static Task<ContentResponse> QueryAsync(Uri Uri, object Data, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanQuery(Uri, out Grade _, out IContentQuery Query))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Query.QueryAsync(Uri, Data, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentResponse> QueryAsync(Uri Uri, object Data, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, Data, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> QueryAsync(Uri Uri, object Data, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, Data, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentResponse> QueryAsync(Uri Uri, object Data, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanQuery(Uri, out Grade _, out IContentQuery Query))
                return Task.FromResult(new ContentResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Query.QueryAsync(Uri, Data, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> QueryAsync(Uri Uri, byte[] EncodedData, string ContentType, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, EncodedData, ContentType, null, null, Headers);
        }
 
        public static Task<ContentBinaryResponse> QueryAsync(Uri Uri, byte[] EncodedData, string ContentType, X509Certificate Certificate, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, EncodedData, ContentType, Certificate, null, Headers);
        }
 
        public static Task<ContentBinaryResponse> QueryAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanQuery(Uri, out Grade _, out IContentQuery Query))
                return Task.FromResult(new ContentBinaryResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Query.QueryAsync(Uri, EncodedData, ContentType, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public static Task<ContentBinaryResponse> QueryAsync(Uri Uri, byte[] EncodedData, string ContentType, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, EncodedData, ContentType, null, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> QueryAsync(Uri Uri, byte[] EncodedData, string ContentType, X509Certificate Certificate, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return QueryAsync(Uri, EncodedData, ContentType, Certificate, null, TimeoutMs, Headers);
        }
 
        public static Task<ContentBinaryResponse> QueryAsync(Uri Uri, byte[] EncodedData, string ContentType,
            X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            if (!CanQuery(Uri, out Grade _, out IContentQuery Query))
                return Task.FromResult(new ContentBinaryResponse(new ArgumentException("URI Scheme not recognized (PUT): " + Uri.Scheme, nameof(Uri))));
 
            return Query.QueryAsync(Uri, EncodedData, ContentType, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
 
        #endregion
 
        #region Local domains
 
        public static bool IsLocalDomain(string DomainOrHost, bool IncludeAlternativeDomains)
        {
            if (DomainOrHost == "localhost")
                return true;
 
            LocalDomainEventArgs e = new LocalDomainEventArgs(DomainOrHost, IncludeAlternativeDomains);
            LocalDomainCheck.Raise(typeof(InternetContent), e);
 
            return e.IsLocal ?? false;
        }
 
        public static event EventHandler<LocalDomainEventArgs> LocalDomainCheck = null;
 
        #endregion
    }
}