Esempio n. 1
0
        /* .NET automatically associates the IComparable type to all object.
         * Thus, all valueTypes and several .NET library classes inherit the IComparable interface.
         * Note: Mismatch types cannot be compared.
         * Note: In this example, different instance of the Order class can be compared with each other.
         * So a order1 can be compared to a order2 to determine its sort order (1: after, 0: same, -1: before).
         * Note: To compare a custom class created by you, you class must implement either or both of the generic/non-generic IComparable interface.
         * Note: Just note that the generic version of the IComparable interface offers better performance than the non-generic one which requires boxing and unboxing via casting.
         * */
        static private void AdvancedCompareExample()
        {
            #region OrderV1 - Using generic IComparable version
            OrderV1 obiOrder = new OrderV1
            {
                OrderId       = 1,
                OrderBy       = "Obi",
                OrderItemName = "PS4",
                OrderDate     = new DateTime(year: 2020, month: 07, day: 16, hour: 15, minute: 00, second: 00) //07/16/2020 @ 03:00 pm
            };
            OrderV1 kinisOrder = new OrderV1
            {
                OrderId       = 1,
                OrderBy       = "Kinis",
                OrderItemName = "Necklace",
                OrderDate     = new DateTime(year: 2020, month: 07, day: 16, hour: 20, minute: 30, second: 00)//07/16/2020 @ 08:30 pm
            };

            //An overload for CompareTo exist - one accepts Order, another accepts object. Because the Order class implemented both the generic and non-generic version of the IComparable interface.
            var compareResult = obiOrder.CompareTo(kinisOrder);
            switch (compareResult)
            {
            case 1: { Console.WriteLine("obiOrder was ordered after kinisOrder."); } break;

            case 0: { Console.WriteLine("obiOrder was ordered same time as kinisOrder."); } break;

            case -1: { Console.WriteLine("obiOrder was ordered before kinisOrder."); } break;
            }
            #endregion

            #region OrderV2 - Using non-generic IComparable version
            OrderV2 obiOrderV2 = new OrderV2
            {
                OrderId       = 1,
                OrderBy       = "Obi",
                OrderItemName = "PS4",
                OrderDate     = new DateTime(year: 2020, month: 07, day: 16, hour: 15, minute: 00, second: 00) //07/16/2020 @ 03:00 pm
            };
            OrderV2 kinisOrderV2 = new OrderV2
            {
                OrderId       = 1,
                OrderBy       = "Kinis",
                OrderItemName = "Necklace",
                OrderDate     = new DateTime(year: 2020, month: 07, day: 16, hour: 20, minute: 30, second: 00)//07/16/2020 @ 08:30 pm
            };

            //An overload for CompareTo exist - one accepts Order, another accepts object. Because the Order class implemented both the generic and non-generic version of the IComparable interface.
            var compareResultV2 = obiOrderV2.CompareTo(kinisOrderV2);
            switch (compareResultV2)
            {
            case 1: { Console.WriteLine("obiOrder was ordered after kinisOrder."); } break;

            case 0: { Console.WriteLine("obiOrder was ordered same time as kinisOrder."); } break;

            case -1: { Console.WriteLine("obiOrder was ordered before kinisOrder."); } break;
            }
            #endregion
        }
Esempio n. 2
0
        /*
         * This approach use the non-generic version of the IComparable interface. Consider using the non-generic version for better performance to avoid boxing and unboxing issues.
         * Good when you don't know exactly what the comparing Type will be.
         * Note: Do Not compare between the objects itself as this will force a recursive operation and a never ending execution. So avoid doing order1.CompareTo(order2)
         * Note: Compare with properties in both objects to determine how the sort against each other. So order1.OrderDate.CompareTo(order2.OrderDate)
         * */
        public int CompareTo(object obj)
        {
            OrderV2 order2 = obj as OrderV2;

            if (order2 is null) //if order to compare against is empty then return 1 to indicate order1 (Left hand) comes after or greater than the empty order2 (Right hand)
            {
                return(1);      //meaning order1 comes after order2 (even though there wasn't an actual order2)
            }

            switch (this.OrderDate.CompareTo(order2.OrderDate))
            {
            case 1: { return(1); }      //order1 comes after order2

            case 0: { return(0); }      //order1 is same position as order2

            case -1: { return(-1); }    //order1 comes before order2
            }

            throw new ArgumentException("Order cannot be sorted.");
        }