Saturday, November 11, 2017

UWP Equivalent for HttpUtility.ParseQueryString

Getting ready for my LUIS presentation at the Granite State Windows 10 Platform Devs Users Group (@WPDevNH), it made sense to demo LUIS using UWP rather than .NET classic.  (Join us, 11/16 at the Microsoft Store in Salem, NH...  https://www.meetup.com/Granite-State-NH-WPDev/events/243099117/ )

For a demo related to LUIS querying, I needed an alternative to System.Web.HttpUtility.ParseQueryString.  (based on this demo:  https://docs.microsoft.com/en-us/azure/cognitive-services/LUIS/luis-get-started-cs-get-intent )

I did a simple decorator of a Dictionary, adding a constructor to parse using WwwFormUrlDecoder, and overriding the ToString() to put it back together...

I whipped one up relatively quickly, but decided this would be a decent quick post.  Here's my alt code:

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Text;
using Windows.Foundation;

namespace LUIS_Examples
{
    public class ParseQueryString : IDictionary<string, string>
    {
        private IDictionary<string, string> _internalDictionary = new Dictionary<string, string>();
        public ParseQueryString(string queryString) :
            base()
        {
            var decoder = new WwwFormUrlDecoder(queryString);

            foreach (var item in decoder)
            {
                _internalDictionary.Add(item.Name, item.Value);
            }
        }

        public override string ToString()
        {
            var sb = new StringBuilder();
            foreach (var aPair in _internalDictionary)
            {
                sb.AppendFormat("{0}={1}", WebUtility.UrlEncode(aPair.Key), WebUtility.UrlEncode(aPair.Value));

            }
            return sb.ToString();
        }

        public string this[string key] { get => _internalDictionary[key]; set { _internalDictionary[key] = value; } }

        public ICollection<string> Keys => _internalDictionary.Keys;

        public ICollection<string> Values => _internalDictionary.Values;

        public int Count => _internalDictionary.Count;

        public bool IsReadOnly => _internalDictionary.IsReadOnly;

        public void Add(string key, string value)
        {
            _internalDictionary.Add(key, value);
        }

        public void Add(KeyValuePair<string, string> item)
        {
            _internalDictionary.Add(item);
        }

        public void Clear()
        {
            _internalDictionary.Clear();
        }

        public bool Contains(KeyValuePair<string, string> item)
        {
            return _internalDictionary.Contains(item);
        }

        public bool ContainsKey(string key)
        {
            return _internalDictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
        {
            _internalDictionary.CopyTo(array, arrayIndex);
        }

        public IEnumeratorstring, string>> GetEnumerator()
        {
            return _internalDictionary.GetEnumerator();
        }

        public bool Remove(string key)
        {
            return _internalDictionary.Remove(key);
        }

        public bool Remove(KeyValuePair<string, string> item)
        {
            return _internalDictionary.Remove(item);
        }

        public bool TryGetValue(string key, out string value)
        {
            return _internalDictionary.TryGetValue(key, out value);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_internalDictionary).GetEnumerator();
        }
    }
}


Post a Comment