程式隨筆

public static class SystemTime
{
 //Internal For UnitTest
 internal static Func<DateTime> SetCurrentTime = () => DateTime.Now;

 public static DateTime Now
 {
  get
  {
   return SetCurrentTime();
  }
 }
}

void Main()
{
 if (SystemTime.Now == new DateTime(2016,10,17,12,0,0))
 {
  "時間到了".Dump();
 } 
 else
 {
  "時間不對".Dump();
 }
}

SystemTime.SetCurrentTime = () => new DateTime(2016,10,17,12,0,0);

public class TestSwaggerController : ApiController
    {
        /// <summary>
        /// 測試Swagger的API
        /// </summary>
        /// <param name="parameter">The parameter.</param>
        /// <returns></returns>
        [HttpGet]
        [Route("api/testSwagger")]
        public HttpResponseMessage Get([FromUri]testSwaggerGetParameter parameter)
        {

            //沒有帶Appkey在Header
            if (!Request.Headers.Contains("X-Key"))
            {
                return Request.CreateResponse(HttpStatusCode.NotAcceptable, "必須輸入AppKey");

            }

            var AppKey =  Request.Headers.GetValues("X-Key").FirstOrDefault();
            if (AppKey != "MyKey")
            {
                return Request.CreateResponse(HttpStatusCode.NotAcceptable, "AppKey不正確!!!");
            }

            if (parameter != null &&
                parameter.ID == "toyo" && 
                parameter.PassWord == "123456")
            {
                return Request.CreateResponse(HttpStatusCode.OK, "帳號密碼正確");
            }

            return Request.CreateResponse(HttpStatusCode.OK, "帳號密碼錯誤摟!!!!!");
        }
    }

void Main()
{
 var Parameter = new APIInputParameter 
 {
  ID = "123",
  Name = "Toyo"
 };

 Guid _ID;
 //驗證邏輯
 if (string.IsNullOrWhiteSpace(Parameter.ID) ||
           !Guid.TryParse(Parameter.ID,out _ID) ||
     string.IsNullOrWhiteSpace(Parameter.Name) )
 {
  "參數錯誤".Dump();
 }
 else
 {
  "參數正確".Dump();
 }

}

public class APIInputParameter 
{
 //此參數應該為Guid，但為了能Log下來所以接的時候要先接成String
 //否則輸入端不是傳入GUID就記錄不到了
 public string ID { get; set; }
 public string Name {get;set;}
}

/// <summary>
    /// Class ConvertHelper
    /// </summary>
    internal static class ConvertHelper
    {
        /// <summary>
        /// 轉型成 T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value">The value.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentException">Convert fail.;Convert</exception>
        public static T ToT<T>(string value, out bool result) where T : IComparable
        {
            result = false;

                try
            {
                switch (Type.GetTypeCode(typeof(T)))
                {
                    case TypeCode.Double:

                            double doubleValue;
                        if (double.TryParse(value, out doubleValue))
                        {
                            result = true;
                        }

                            return (T)(object)Convert.ToDouble(value);

                        case TypeCode.Int16:

                            Int16 int16Value;
                        if (Int16.TryParse(value, out int16Value))
                        {
                            result = true;
                        }

                            return (T)(object)Convert.ToInt16(value);

                        case TypeCode.Int32:

                            Int32 int32Value;
                        if (Int32.TryParse(value, out int32Value))
                        {
                            result = true;
                        }

                            return (T)(object)Convert.ToInt32(value);

                        case TypeCode.Int64:

                            Int64 int64Value;
                        if (Int64.TryParse(value, out int64Value))
                        {
                            result = true;
                        }

                            return (T)(object)Convert.ToInt64(value);

                        case TypeCode.Decimal:

                            decimal decimalValue;
                        if (decimal.TryParse(value, out decimalValue))
                        {
                            result = true;
                        }

                            return (T)(object)Convert.ToDecimal(value);

                        default:
                        return default(T);
                }
            }
            catch (Exception ex)
            {
                return default(T);
            }
        }
    }

/// <summary>
    /// Class QuadTreeNode.
    /// </summary>
    public class QuadTreeNode<T>
        where T : IQuadTreeNodeData
    {
        /// <summary>
        /// 西北象限.
        /// </summary>
        /// <value>
        /// The north west.
        /// </value>
        public QuadTreeNode<T> NorthWest { get; set; }
        /// <summary>
        /// 東北象限.
        /// </summary>
        /// <value>
        /// The north east.
        /// </value>
        public QuadTreeNode<T> NorthEast { get; set; }
        /// <summary>
        /// 西南象限.
        /// </summary>
        /// <value>
        /// The south west.
        /// </value>
        public QuadTreeNode<T> SouthWest { get; set; }
        /// <summary>
        /// 東南象限.
        /// </summary>
        /// <value>
        /// The south east.
        /// </value>
        public QuadTreeNode<T> SouthEast { get; set; }

        /// <summary>
        /// 邊界
        /// </summary>
        public BoundingBox BoundingBox { get; set; }

        /// <summary>
        /// 節點數量
        /// </summary>
        public int BucketCapacity { get; set; }

        /// <summary>
        /// 節點
        /// </summary>
        public List<T> Points { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="QuadTreeNode{T}"/> class.
        /// </summary>
        /// <param name="boundingBox">The bounding box.</param>
        /// <param name="capacity">The capacity.</param>
        public QuadTreeNode(BoundingBox boundingBox, int capacity)
        {
            BoundingBox = boundingBox;
            BucketCapacity = capacity;
            Points = new List<T>();
        }
    }

/// <summary>
    /// Interface IQuadTreeNodeData.
    /// </summary>
    public interface IQuadTreeNodeData
    {
        /// <summary>
        /// Gets or sets the position.
        /// </summary>
        /// <value>
        /// The position.
        /// </value>
        Coordinate Position { get; set; }
    }

/// <summary>
    /// Class BoundingBox.
    /// </summary>
    public class BoundingBox
    {
        /// <summary>
        /// 左上角節點
        /// </summary>
        public Coordinate LeftTop { get; set; }

        /// <summary>
        /// 右下角節點
        /// </summary>
        public Coordinate RightBottom { get; set; }
    }

/// <summary>
    /// Class Coordinate.
    /// </summary>
    public class Coordinate
    {
        /// <summary>
        /// 緯度
        /// </summary>
        public double Latitude { get; set; }
        /// <summary>
        /// 經度
        /// </summary>
        public double Longitude { get; set; }
    }

/// <summary>
    /// Class QuadTreeService.
    /// </summary>
    public static class QuadTreeService
    {
        /// <summary>
        /// Inserts the specified node.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        public static bool Insert<T>(QuadTreeNode<T> node, T data)
            where T : IQuadTreeNodeData
        {
            // Bail if our coordinate is not in the boundingBox
            if (!CheckBoundingBoxContainData(node.BoundingBox, data))
            {
                return false;
            }

            // Add the coordinate to the points array
            if ((node.Points.Count + 1) <= node.BucketCapacity)
            {
                node.Points.Add(data);
                return true;
            }

            // Check to see if the current node is a leaf, if it is, split
            if (node.NorthWest == null)
            {
                Subdivide(node);
            }

            // Traverse the tree
            if (Insert(node.NorthWest, data)) return true;
            if (Insert(node.NorthEast, data)) return true;
            if (Insert(node.SouthWest, data)) return true;
            if (Insert(node.SouthEast, data)) return true;

            return false;
        }

        /// <summary>
        /// 搜尋在範圍內的所有節點
        /// </summary>
        /// <param name="node">四元樹節點</param>
        /// <param name="range">範圍</param>
        /// <param name="datas"></param>
        public static void SearchDataInRange<T>(
            QuadTreeNode<T> node, 
            BoundingBox range, 
            ref List<T> datas)
            where T : IQuadTreeNodeData
        {
            //如果QuadTree完全在要搜尋的Range之內，
            //那包含在它底下的分裂節點都不用判斷,一定全部都在範圍內
            if (CheckBoundingBoxIncludeInRange(node.BoundingBox, range))
            {
                GetNodeAllPointData(node, ref datas);
                return;
            }

            // If range is not contained in the node's boundingBox then bail
            if (!CheckIntersectionBoundingBox(node.BoundingBox, range))
            {
                return;
            }

            foreach (var item in node.Points)
            {
                // Gather points contained in range
                if (CheckBoundingBoxContainData(range, item))
                {
                    datas.Add(item);
                }
            }

            // Bail if node is leaf
            if (node.NorthWest == null)
            {
                return;
            }

            // Otherwise traverse down the tree
            SearchDataInRange(node.NorthWest, range, ref datas);
            SearchDataInRange(node.NorthEast, range, ref datas);
            SearchDataInRange(node.SouthWest, range, ref datas);
            SearchDataInRange(node.SouthEast, range, ref datas);
        }

        /// <summary>
        /// 建立四元樹.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <param name="boundingBox">QuadTree Bounding</param>
        /// <returns></returns>
        public static QuadTreeNode<T> CreateQuadTree<T>(List<T> data, BoundingBox boundingBox)
            where T : IQuadTreeNodeData
        {
            var TreeNode = new QuadTreeNode<T>(
                boundingBox: boundingBox,
                capacity: 1);

            foreach (var d in data)
            {
                Insert(TreeNode, d);
            }

            return TreeNode;
        }

        /// <summary>
        /// 取得節點以及所有子節點的Point Data
        /// </summary>
        /// <param name="node">The node.</param>
        /// <param name="datas">The datas.</param>
        static void GetNodeAllPointData<T>(QuadTreeNode<T> node, ref List<T> datas)
            where T : IQuadTreeNodeData
        {
            datas.AddRange(node.Points);

            if (node.NorthWest == null)
            {
                return;
            }
            GetNodeAllPointData(node.NorthWest, ref datas);
            GetNodeAllPointData(node.NorthEast, ref datas);
            GetNodeAllPointData(node.SouthWest, ref datas);
            GetNodeAllPointData(node.SouthEast, ref datas);
        }

        /// <summary>
        /// 確認兩個區域是否有交集
        /// </summary>
        /// <param name="BoundingBox">The bounding box.</param>
        /// <param name="range">The range.</param>
        /// <returns></returns>
        static bool CheckIntersectionBoundingBox(BoundingBox BoundingBox, BoundingBox range)
        {

            if (BoundingBox.LeftTop.Latitude.ToString() == BoundingBox.RightBottom.Latitude.ToString() &&
                BoundingBox.LeftTop.Longitude.ToString() == BoundingBox.RightBottom.Longitude.ToString())
            {
                //Point
                var Lng =  range.LeftTop.Longitude <= BoundingBox.LeftTop.Longitude &&
                           BoundingBox.LeftTop.Longitude <= range.RightBottom.Longitude;

                var Lat =  range.RightBottom.Latitude <= BoundingBox.LeftTop.Latitude &&
                           BoundingBox.LeftTop.Latitude <= range.LeftTop.Latitude;
                return Lng && Lat;
            }
            else
            {
                var MinCx = Math.Max(range.LeftTop.Longitude, BoundingBox.LeftTop.Longitude);
                var MaxCy = Math.Min(range.LeftTop.Latitude, BoundingBox.LeftTop.Latitude);

                var MaxCx = Math.Min(range.RightBottom.Longitude, BoundingBox.RightBottom.Longitude);
                var MinCy = Math.Max(range.RightBottom.Latitude, BoundingBox.RightBottom.Latitude);

                return (MinCx < MaxCx) && (MinCy < MaxCy);
            }
        }

        /// <summary>
        /// 確認BoundingBox是否完全包含在要搜尋的區域範圍內(小於等於).
        /// </summary>
        /// <param name="BoundingBox">The bounding box.</param>
        /// <param name="range">The range.</param>
        /// <returns></returns>
        static bool CheckBoundingBoxIncludeInRange(BoundingBox BoundingBox, BoundingBox range)
        {
            var LTLng = (range.LeftTop.Longitude <= BoundingBox.LeftTop.Longitude &&
                        BoundingBox.LeftTop.Longitude <= range.RightBottom.Longitude);

            var LTLat = (range.RightBottom.Latitude <= BoundingBox.LeftTop.Latitude &&
                        BoundingBox.LeftTop.Latitude <= range.LeftTop.Latitude);

            var RBLng = (range.LeftTop.Longitude <= BoundingBox.RightBottom.Longitude &&
                        BoundingBox.RightBottom.Longitude <= range.RightBottom.Longitude);

            var RBLat = (range.RightBottom.Latitude <= BoundingBox.RightBottom.Latitude &&
                        BoundingBox.RightBottom.Latitude <= range.LeftTop.Latitude);

            return LTLng && LTLat && RBLng && RBLat;
        }

        static bool CheckBoundingBoxContainData(BoundingBox boundingBox, IQuadTreeNodeData data)
        {
            var CheckLng = (boundingBox.LeftTop.Longitude <= data.Position.Longitude &&
                            data.Position.Longitude <= boundingBox.RightBottom.Longitude);

            var CheckLat = (boundingBox.RightBottom.Latitude <= data.Position.Latitude &&
                            data.Position.Latitude <= boundingBox.LeftTop.Latitude);

            return CheckLng && CheckLat;
        }

        /// <summary>
        /// 四元樹分裂
        /// </summary>
        /// <param name="node">四元樹節點</param>
        static void Subdivide<T>(QuadTreeNode<T> node)
            where T:IQuadTreeNodeData
        {
            var box = node.BoundingBox;

            //中心點
            double LatMid = (box.LeftTop.Latitude + box.RightBottom.Latitude) / 2.0;
            double LngMid = (box.LeftTop.Longitude + box.RightBottom.Longitude) / 2.0;

            //左上
            var NorthWest = new BoundingBox
            {
                LeftTop = new Coordinate
                {
                    Latitude = box.LeftTop.Latitude,
                    Longitude = box.LeftTop.Longitude
                },
                RightBottom = new Coordinate
                {
                    Latitude = LatMid,
                    Longitude = LngMid
                }
            };
            node.NorthWest = new QuadTreeNode<T>(NorthWest, node.BucketCapacity);

            //右上
            var NorthEast = new BoundingBox
            {
                LeftTop = new Coordinate
                {
                    Latitude = box.LeftTop.Latitude,
                    Longitude = LngMid
                },
                RightBottom = new Coordinate
                {
                    Latitude = LatMid,
                    Longitude = box.RightBottom.Longitude
                }
            };
            node.NorthEast = new QuadTreeNode<T>(NorthEast, node.BucketCapacity);

            //左下
            var SouthWest = new BoundingBox
            {
                LeftTop = new Coordinate
                {
                    Latitude = LatMid,
                    Longitude = box.LeftTop.Longitude
                },
                RightBottom = new Coordinate
                {
                    Latitude = box.RightBottom.Latitude,
                    Longitude = LngMid
                }
            };
            node.SouthWest = new QuadTreeNode<T>(SouthWest, node.BucketCapacity);

            //右下
            var SouthEast = new BoundingBox
            {
                LeftTop = new Coordinate
                {
                    Latitude = LatMid,
                    Longitude = LngMid
                },
                RightBottom = new Coordinate
                {
                    Latitude = box.RightBottom.Latitude,
                    Longitude = box.RightBottom.Longitude
                }
            };
            node.SouthEast = new QuadTreeNode<T>(SouthEast, node.BucketCapacity);

        }
    }

void Main()
{
 Stopwatch timer = new Stopwatch();
 timer.Reset();
 timer.Start();
 var YouWantToSearchData = new List<UserQuery.YourCoordinateData>();
 for (int i = 0; i < 5000000; i++)
 {
  YouWantToSearchData.Add(
   new YourCoordinateData
   {
    Position = new Coordinate 
    {
      Latitude = GetRandomNumber(22,26),
      Longitude = GetRandomNumber(120,122)
    } 
   });
 } 
 var QuadTree = QuadTreeService.CreateQuadTree(YouWantToSearchData,GetBoundingBox()); //建立四元樹
 string.Format("建資料花了: {0} ticks ({1} msec)", timer.ElapsedTicks, timer.ElapsedMilliseconds).Dump();

 //要搜尋的範圍
 BoundingBox range = new BoundingBox
 {
  LeftTop = new Coordinate { Latitude = 24.997123, Longitude = 121.21940612793 },
  RightBottom = new Coordinate {Latitude =24.958553314209,Longitude = 121.485925}
 };

 //一般搜尋
 timer.Reset();
 timer.Start();
 var Result1 = Search(range,YouWantToSearchData);
 string.Format("搜尋資料花了: {0} ticks ({1} msec)", timer.ElapsedTicks, timer.ElapsedMilliseconds).Dump();

 //四元樹搜尋
 timer.Reset();
 timer.Start();
 var Result2 = new List<YourCoordinateData>();
 QuadTreeService.SearchDataInRange(QuadTree,range,ref Result2);
 string.Format("四元樹搜尋資料花了: {0} ticks ({1} msec)", timer.ElapsedTicks, timer.ElapsedMilliseconds).Dump();

 string.Format("一般搜尋資料筆數: {0}",Result1.Count()).Dump();
 string.Format("四元樹搜尋資料筆數: {0}",Result2.Count()).Dump();
}

public List<YourCoordinateData> Search(BoundingBox range,  List<YourCoordinateData> Datas) 
{
 return Datas.Where(x => range.RightBottom.Latitude  <= x.Position.Latitude  && x.Position.Latitude <= range.LeftTop.Latitude &&
                            range.LeftTop.Longitude  <= x.Position.Longitude  && x.Position.Longitude <= range.RightBottom.Longitude).ToList();
}

public class YourCoordinateData : IQuadTreeNodeData 
{
 public Coordinate Position{get;set;}
}

//台灣的範圍
public BoundingBox GetBoundingBox()
{
 return new BoundingBox
 {
  //台灣範圍
  LeftTop = new Coordinate
  {
   Latitude = 26,
   Longitude = 120
  },
  RightBottom = new Coordinate
  {
   Latitude = 22,
   Longitude = 122
  }
 };
}

//隨機取得經緯度亂數
static Random random = new Random();
public static double GetRandomNumber(double minimum, double maximum)
{
 return random.NextDouble() * (maximum - minimum) + minimum;
}

public class HomeController : Controller
    {
        IPOIService _POIService;
        public HomeController(IPOIService poiService)
        {
            //POIService改成依賴介面IPOIService
            //並且實體是由外部來決定，也就是所謂的依賴注入DI
            _POIService = poiService;
        }

        public ActionResult Index(string id)
        {
            //依賴外部注入的IPOIService介面
            var POIs = _POIService.Get(id);
            return Json(POIs,JsonRequestBehavior.AllowGet);
        }
    }

/// <summary>
    /// POI A供應商
    /// </summary>
    internal class ASupplierRepository : ISupplierRepository
    {
        public List<POI> Get()
        {
            Random rnd = new Random();

            //隨機建立十筆Supplier為A的資料回傳
            var fixture = new Fixture();
            var Result = fixture.Build<POI>()
                            .With(x => x.Name, string.Concat("捷運", rnd.Next(1, 100)))
                            .With(x => x.Supplier, SupplierEnum.A)
                            .CreateMany().ToList();

            return Result;
        }
    }

/// <summary>
    /// POI B供應商
    /// </summary>
    internal class BSupplierRepository : ISupplierRepository
    {
        public List<POI> Get()
        {
            Random rnd = new Random();

            //隨機建立十筆Supplier為B的資料回傳
            var fixture = new Fixture();
            var Result = fixture.Build<POI>()
                            .With(x => x.Name, string.Concat("捷運", rnd.Next(1, 100)))
                            .With(x => x.Supplier, SupplierEnum.B)
                            .CreateMany().ToList();

            return Result;
        }
    }

public class POIService :IPOIService
    {
        public List<POI> Get(string channelID)
        {
            var Result = new List<POI>();

            var channel = GetChannel(channelID);

            //逐一搜尋頻道底下的各類別
            foreach (var category in channel.Categorys)
            {
                //依據該類別所指定的供應商向Repository要資料
                category.Supplier.ForEach(x =>
                {
                    var Repository = SupplierFactory.Generate(x);
                    var POIs = Repository.Get();
                    Result.AddRange(POIs);
                });
            }

            //並接總合的結果回傳
            return Result;
        }

        /// <summary>
        /// 模擬頻道類別對應表
        /// </summary>
        /// <param name="channelID">The channel identifier.</param>
        /// <returns>Channel.</returns>
        Channel GetChannel(string channelID)
        {
            if (channelID == "1")
            {
                return new Channel
                {
                    ID = "1",
                    Categorys = new List<Channel.Category>
                    {
                        new Channel.Category
                        {
                            Name = "交通",
                            Supplier =new List<SupplierEnum> { SupplierEnum.A }
                        }
                    }
                };
            }

            return new Channel
            {
                ID = channelID,
                Categorys = new List<Channel.Category>
                {
                    new Channel.Category
                    {
                        Name = "交通",
                        Supplier = new List<SupplierEnum> { SupplierEnum.A , SupplierEnum.B }
                    }
                }
            };
        }
    }

public class ChannelService
    {
        /// <summary>
        /// 模擬頻道類別對應表
        /// </summary>
        /// <param name="channelID">The channel identifier.</param>
        /// <returns>Channel.</returns>
        public Channel Get(string channelID)
        {
            if (channelID == "1")
            {
                return new Channel
                {
                    ID = "1",
                    Categorys = new List<Channel.Category>
                    {
                        new Channel.Category
                        {
                            Name = "交通",
                            Supplier =new List<SupplierEnum> { SupplierEnum.A }
                        }
                    }
                };
            }

            return new Channel
            {
                ID = channelID,
                Categorys = new List<Channel.Category>
                {
                    new Channel.Category
                    {
                        Name = "交通",
                        Supplier = new List<SupplierEnum> { SupplierEnum.A , SupplierEnum.B }
                    }
                }
            };
        }
    }

public class POIService :IPOIService
    {
        public List<POI> Get(string channelID)
        {
            var Result = new List<POI>();

            //取得ChannelService實體，取得Channel對應供應商資料
            var channelService = new ChannelService();
            var channel = channelService.Get(channelID);

            //逐一搜尋頻道底下的各類別
            foreach (var category in channel.Categorys)
            {
                //依據該類別所指定的供應商向Repository要資料
                category.Supplier.ForEach(x =>
                {
                    var Repository = SupplierFactory.Generate(x);
                    var POIs = Repository.Get();
                    Result.AddRange(POIs);
                });
            }

            //並接總合的結果回傳
            return Result;
        }
    }

public interface IPOIService
    {
        /// <summary>
        /// 取得屬於頻道的POI資料
        /// </summary>
        /// <param name="channelID">The channel identifier.</param>
        /// <returns>List&lt;POI&gt;.</returns>
        List<POI> Get(string channelID);
    }

public class HomeController : Controller
    {
        IPOIService _POIService;
        public HomeController(IPOIService poiService)
        {
            //POIService改成依賴介面IPOIService
            //並且實體是由外部來決定，也就是所謂的依賴注入DI
            _POIService = poiService;
        }

        public ActionResult Index(string id)
        {
            //依賴外部注入的IPOIService介面
            var POIs = _POIService.Get(id);
            return Json(POIs,JsonRequestBehavior.AllowGet);
        }
    }