JSON (JavaScript Object Notation) Utility Methods.

   
 
using System.Collections.Generic;
using System.Text;

namespace Facebook.Utility
{
    /// <summary>
    /// JSON (JavaScript Object Notation) Utility Methods.
    /// </summary>
    public static class JSONHelper
    {
        ///<summary>
        /// Converts a Dictionary to a JSON-formatted Associative Array.
        ///</summary>
        ///<param name="dict">Source Dictionary collection [string|string].</param>
        ///<returns>JSON Associative Array string.</returns>
        public static string ConvertToJSONAssociativeArray(Dictionary<string, string> dict)
        {
            var elements = new List<string>();

            foreach (var pair in dict)
            {
                if(!string.IsNullOrEmpty(pair.Value))
                {
                    elements.Add(string.Format(""{0}":{2}{1}{2}", EscapeJSONString(pair.Key), EscapeJSONString(pair.Value), IsJSONArray(pair.Value) || IsBoolean(pair.Value) ? string.Empty : """));
                }
            }
            return "{" + string.Join(",", elements.ToArray()) + "}";
        }

        /// <summary>
        /// Determines if input string is a formatted JSON Array.
        /// </summary>
        /// <param name="test">string</param>
        /// <returns>bool</returns>
        public static bool IsJSONArray(string test)
        {
            return test.StartsWith("{") &amp;&amp; !test.StartsWith("{*") || test.StartsWith("[");
        }

        /// <summary>
        /// Determines if input string is a boolean value.
        /// </summary>
        /// <param name="test">string</param>
        /// <returns>bool</returns>
        public static bool IsBoolean(string test)
        {
            return test.Equals("false") || test.Equals("true");
        }

        /// <summary>
        /// Converts a List collection of type string to a JSON Array.
        /// </summary>
        /// <param name="list">List of strings</param>
        /// <returns>string</returns>
        public static string ConvertToJSONArray(List<string> list)
        {
            if (list == null || list.Count == 0)
            {
                return "[]";
            }

            StringBuilder builder = new StringBuilder();
            builder.Append("[");
            foreach (var item in list)
            {
                builder.Append(string.Format("{0}{1}{0},", IsJSONArray(item) || IsBoolean(item) ? string.Empty : """, EscapeJSONString(item)));
            }
            builder.Replace(",", "]", builder.Length - 1, 1);
            return builder.ToString();
        }

        /// <summary>
        /// Converts a List collection of type long to a JSON Array.
        /// </summary>
        /// <param name="list">List of longs</param>
        /// <returns>string</returns>
        public static string ConvertToJSONArray(List<long> list)
        {
            if (list == null || list.Count == 0)
            {
                return "[]";
            }

            StringBuilder builder = new StringBuilder();
            builder.Append("[");
            foreach (var item in list)
            {
                builder.Append(string.Format("{0}{1}{0},", IsJSONArray(item.ToString()) || IsBoolean(item.ToString()) ? string.Empty : """, EscapeJSONString(item.ToString())));
            }
            builder.Replace(",", "]", builder.Length - 1, 1);
            return builder.ToString();
        }

        /// <summary>
        /// Converts a JSON Array string to a List collection of type string.
        /// </summary>
        /// <param name="array">JSON Array string</param>
        /// <returns>List of strings</returns>
        public static List<string> ConvertFromJSONArray(string array)
        {
            if (!string.IsNullOrEmpty(array))
            {
                array = array.Replace("[", "").Replace("]", "").Replace(""", "");
                return new List<string>(array.Split(&#039;,&#039;));
            }
           
            return new List<string>();
        }

        /// <summary>
        /// Converts a JSON Array string to a Dictionary collection of type string, string.
        /// </summary>
        /// <param name="array">JSON Array string</param>
        /// <returns>Dictionary of string, string</returns>
        public static Dictionary<string, string> ConvertFromJSONAssoicativeArray(string array)
        {
            var dict = new Dictionary<string, string>();
            if (!string.IsNullOrEmpty(array))
            {
                array = array.Replace("{", "").Replace("}", "").Replace("":", "|").Replace(""", "").Replace("/", "/");
                var pairs = new List<string>(array.Split(&#039;,&#039;));
                foreach (var pair in pairs)
                {
                    if (!string.IsNullOrEmpty(pair))
                    {
                        var pairArray = pair.Split(&#039;|&#039;);
                        dict.Add(pairArray[0], pairArray[1]);
                    }
                }
                return dict;
            }

            return new Dictionary<string, string>();
        }

        /// <summary>
        /// Escape backslashes and double quotes of valid JSON content string.
        /// </summary>
        /// <param name="originalString">string</param>
        /// <returns>string</returns>
        public static string EscapeJSONString(string originalString)
        {
            return IsJSONArray(originalString) ? originalString : originalString.Replace("/", "/").Replace("/", "/").Replace(""", """).Replace(""", """).Replace("
", "
").Replace("
", "
");
        }
    }
}

   
     


IPHostEntry.HostName

   
 

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

//DnsLookup

class Program {
    static void Main(string[] args) {
        IPHostEntry ipHostEntry = Dns.GetHostEntry("www.google.com");
        Console.WriteLine("Host: {0}", ipHostEntry.HostName);

        if (ipHostEntry.Aliases.Length > 0) {
            Console.WriteLine("
Aliases:");
            foreach (string alias in ipHostEntry.Aliases) {
                Console.WriteLine(alias);
            }
        }

        Console.WriteLine("
Address(es):");
        foreach (IPAddress address in ipHostEntry.AddressList) {
            Console.WriteLine("Address: {0}", address.ToString());
        }
    }
}

    


IPAddress: AddressFamily,MinPort,MaxPort,Serialize

   
 
using System;
using System.Net;
class IPEndPointSample {
    public static void Main() {
        IPAddress test1 = IPAddress.Parse("192.168.1.1");
        IPEndPoint ie = new IPEndPoint(test1, 8000);
        Console.WriteLine("The IPEndPoint is: {0}",ie.ToString());
        Console.WriteLine("The AddressFamily is: {0}",ie.AddressFamily);
        Console.WriteLine("The address is: {0}, and the port is: {1}
", ie.Address, ie.Port);
        Console.WriteLine("The min port number is: {0}",IPEndPoint.MinPort);
        Console.WriteLine("The max port number is: {0}
",IPEndPoint.MaxPort);
        ie.Port = 80;
        Console.WriteLine("The changed IPEndPoint value is: {0}", ie.ToString());
        SocketAddress sa = ie.Serialize();
        Console.WriteLine("The SocketAddress is: {0}",sa.ToString());
    }
}

    


new IPEndPoint(IPAddress.Parse(“127.0.0.1”), 8888)

   
 


using System;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

class MainClass {
    private static void Main() {
        IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);
        Thread receiveThread = new Thread(ReceiveData);
        receiveThread.IsBackground = true;
        receiveThread.Start();

        UdpClient client = new UdpClient();
        try {
            string text = "message";
            byte[] data = Encoding.UTF8.GetBytes(text);
            client.Send(data, data.Length, remoteEndPoint);
        } catch (Exception err) {
            Console.WriteLine(err.ToString());
        } finally {
            client.Close();
        }
    }

    private static void ReceiveData() {
        UdpClient client = new UdpClient(5555);
        while (true) {
            try {
                IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
                byte[] data = client.Receive(ref anyIP);
                string text = Encoding.UTF8.GetString(data);
                Console.WriteLine(">> " + text);
            } catch (Exception err) {
                Console.WriteLine(err.ToString());
            }
        }
    }
}

    


Get Host IP Address

   
 

///////////////////////////////////////////////////////////////////////////////////////////////
//
//    This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
//    Copyright (c) 2005-2008, Jim Heising
//    All rights reserved.
//
//    Redistribution and use in source and binary forms, with or without modification,
//    are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions and the following disclaimer in the documentation and/or
//      other materials provided with the distribution.
//
//    * Neither the name of Jim Heising nor the names of its contributors may be
//      used to endorse or promote products derived from this software without specific prior
//      written permission.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
//    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
//    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//    POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

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

namespace WOSI.Utilities
{
    public class NetworkUtils
    {


        public static IPAddress GetHostIPAddress(string hostName, System.Net.Sockets.AddressFamily addressFamily)
        {
            try
            {
                // If there&#039;s a port, remove it
                if (hostName.Contains(":"))
                    hostName = hostName.Split(&#039;:&#039;)[0];

                IPAddress parsedAddress;

                if (IPAddress.TryParse(hostName, out parsedAddress))
                    return parsedAddress;

                IPHostEntry ipEntry = Dns.GetHostEntry(hostName);

                if (ipEntry.AddressList.Length > 0)
                {
                    foreach (IPAddress address in ipEntry.AddressList)
                    {
                        if (address.AddressFamily == addressFamily &amp;&amp; address.GetAddressBytes()[0] > 0)
                            return address;
                    }
                }
            }
            catch
            {
            }

            return new IPAddress(0);
        }


    }
}

   
     


Get Current Ip Address

   
 
///////////////////////////////////////////////////////////////////////////////////////////////
//
//    This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
//    Copyright (c) 2005-2008, Jim Heising
//    All rights reserved.
//
//    Redistribution and use in source and binary forms, with or without modification,
//    are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions and the following disclaimer in the documentation and/or
//      other materials provided with the distribution.
//
//    * Neither the name of Jim Heising nor the names of its contributors may be
//      used to endorse or promote products derived from this software without specific prior
//      written permission.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
//    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
//    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//    POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

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

namespace WOSI.Utilities
{
    public class NetworkUtils
    {

        public static string GetCurrentIpAddress()
        {
            string hostname = Dns.GetHostName();

            IPAddress[] ips = Dns.GetHostAddresses(hostname);

            string ip = String.Empty;

            if (ips.Length > 0)
            {
                ip = ips[0].ToString();
            }

            return ip;
        }
    }
}

   
     


Parse Host String

   
 
///////////////////////////////////////////////////////////////////////////////////////////////
//
//    This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
//    Copyright (c) 2005-2008, Jim Heising
//    All rights reserved.
//
//    Redistribution and use in source and binary forms, with or without modification,
//    are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions and the following disclaimer in the documentation and/or
//      other materials provided with the distribution.
//
//    * Neither the name of Jim Heising nor the names of its contributors may be
//      used to endorse or promote products derived from this software without specific prior
//      written permission.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
//    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
//    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//    POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

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

namespace WOSI.Utilities
{
    public class NetworkUtils
    {

        public static void ParseHostString(string hostString, ref string hostName, ref int port)
        {
            hostName = hostString;

            if (hostString.Contains(":"))
            {
                string[] hostParts = hostString.Split(&#039;:&#039;);

                if (hostParts.Length == 2)
                {
                    hostName = hostParts[0];

                    int.TryParse(hostParts[1], out port);
                }
            }
        }
   }
}