重构代码练习 - 如何解决这个问题 [英] Refactoring code exercise - how to approach this problem

问题描述

嗨有人可以建议我重构下面的代码，因为我正在寻找如何解决这个错误的代码作为练习。 
 
公共类OrderManager 
 {
 private readonly IOrderStore orderStore; 
 
 public OrderManager（IOrderStore orderStore）
 {
 this.orderStore = orderStore; 
} 
 
 public void WriteOutSmallOrders（）
 {
 var orders = orderStore.GetOrders（）; 
 SmallOrderFilter filter = new SmallOrderFilter（new OrderWriter（），orders）; 
 filter.WriteOutFiltrdAndPriceSortedOrders（new OrderWriter（））; 
} 
 
 public void WriteOutLargeOrders（）
 {
 var orders = orderStore.GetOrders（）; 
 LargeOrderFilter filter = new LargeOrderFilter（new OrderWriter（），orders）; 
 filter.WriteOutFiltrdAndPriceSortedOrders（new OrderWriter（））; 
} 
} 
 
 
公共类LargeOrderFilter 
 {
 private IOrderWriter orderWriter; 
 private List< Order>命令; 
 
 public LargeOrderFilter（IOrderWriter orderWriter，List< Order> order）
 {
 filterSize =100; 
 this.orderWriter = orderWriter; 
 this.orders = orders; 
} 
 
 protected string filterSize; 
 
 public void WriteOutFiltrdAndPriceSortedOrders（IOrderWriter writer）
 {
 List< Order> filteredOrders = this.FilterOrdersSmallerThan（orders，filterSize）; 
 Enumerable.OrderBy（filteredOrders，o => o.Price）; 
 
 ObservableCollection< Order> observableCollection = 
 new ObservableCollection< Order>（）; 
 
 foreach（filterOrders中的订单o）
 {
 observableCollection.Add（o）; 
} 
 
 writer.WriteOrders（observableCollection）; 
} 
 
 protected List< Order> FilterOrdersSmallerThan（List< Order> allOrders，string size）
 {
 List< Order> filtered = new List< Order>（）; 
 for（int i = 0; i< = allOrders.Count; i ++）
 {
 int number = orders [i] .toNumber（size）; 
 
 if（allOrders [i] .Size< = number）
 {
 continue; 
} 
其他
 {
 filtered.Add（orders [i]）; 
} 
} 
 
返回已过滤; 
} 
} 
 
公共类SmallOrderFilter：LargeOrderFilter 
 {
 public SmallOrderFilter（IOrderWriter orderWriter，List< Order> orders）
：base （orderWriter，orders）
 {
 filterSize =10; 
} 
} 
 
 
公共类订单
 {
公开双价格
 {
 get {return this .dPrice; } 
 set {this.dPrice = value; } 
} 
 
 public int大小
 {
 get {return this.iSize; } 
 set {this.iSize = value; } 
} 
 
公共字符串符号
 {
 get {return this.sSymbol; } 
 set {this.sSymbol = value; } 
} 
 
 private double dPrice; 
 private int iSize; 
 private string sSymbol; 
 
 public int toNumber（String Input）
 {
 bool canBeConverted = false; 
 int n = 0; 
尝试
 {
 n = Convert.ToInt32（输入）; 
 if（n！= 0）canBeConverted = true; 
} 
 catch（exception ex）
 {
} 
 
 if（canBeConverted == true）
 {
 return n ; 
} 
其他
 {
返回0; 
} 
} 
} 
 
 
 //这些是系统中已经存在的存根接口
 //它们不在代码审查范围
公共接口IOrderWriter 
 {
 void WriteOrders（IEnumerable< Order> orders）; 
} 
 
公共类OrderWriter：IOrderWriter 
 {
 public void WriteOrders（IEnumerable< Order> orders）
 {
} 
} 
 
公共接口IOrderStore 
 {
 List< Order> GetOrders（）; 
} 
 
 
公共类OrderStore：IOrderStore 
 {
 public List< Order> GetOrders（）
 {
返回新列表<订单> {新订单{
价格= 10，
尺寸= 1，
符号=TShirt
}，新订单{
价格= 15，
大小= 2，
符号=体育用品
}}; 
} 
} 

我的尝试：

 SmallOrderFilter filter = new SmallOrderFilter（new OrderWriter（），orders）; 

将以上内容移至一个构造函数并注入

删除重复的代码

创建一个抽象类

解决方案

我们不做你的为你做家庭作业或练习 - 练习将帮助 你 学习并将这些新知识融入 你的 大脑。



因此，如果我们只是给你所有的建议，那么我们会对你不喜欢。



您已经有一些建议尚未申请：

Quote：

将上述内容移至构造函数并注入

删除重复的代码

创建一个抽象类

@ Paulo-Zemek给了你一些其他的东西要看。



这里还有几行仔细看看......这些只是愚蠢的错误，看看你能解决原因：

  if （canBeConverted ==  true ）

  catch （例外情况）
 {
} 
 

Hi Can some one suggest me the Refactoring for the below code as I am looking for how to approach to fix this bad code as an exercise.  

public class OrderManager
    {
        private readonly IOrderStore orderStore;

        public OrderManager(IOrderStore orderStore)
        {
            this.orderStore = orderStore;
        }

        public void WriteOutSmallOrders()
        {
            var orders = orderStore.GetOrders();
            SmallOrderFilter filter = new SmallOrderFilter(new OrderWriter(), orders);
            filter.WriteOutFiltrdAndPriceSortedOrders(new OrderWriter());
        }

        public void WriteOutLargeOrders()
        {
            var orders = orderStore.GetOrders();
            LargeOrderFilter filter = new LargeOrderFilter(new OrderWriter(), orders);
            filter.WriteOutFiltrdAndPriceSortedOrders(new OrderWriter());
        }
    }


    public class LargeOrderFilter
    {
        private IOrderWriter orderWriter;
        private List<Order> orders;

        public LargeOrderFilter(IOrderWriter orderWriter, List<Order> orders)
        {
            filterSize = "100";
            this.orderWriter = orderWriter;
            this.orders = orders;
        }

        protected string filterSize;

        public void WriteOutFiltrdAndPriceSortedOrders(IOrderWriter writer)
        {
            List<Order> filteredOrders = this.FilterOrdersSmallerThan(orders, filterSize);
            Enumerable.OrderBy(filteredOrders, o => o.Price);

            ObservableCollection<Order> observableCollection =
                new ObservableCollection<Order>();

            foreach (Order o in filteredOrders)
            {
                observableCollection.Add(o);
            }

            writer.WriteOrders(observableCollection);
        }

        protected List<Order> FilterOrdersSmallerThan(List<Order> allOrders, string size)
        {
            List<Order> filtered = new List<Order>();
            for (int i = 0; i <= allOrders.Count; i++)
            {
                int number = orders[i].toNumber(size);

                if (allOrders[i].Size <= number)
                {
                    continue;
                }
                else
                {
                    filtered.Add(orders[i]);
                }
            }

            return filtered;
        }
    }

    public class SmallOrderFilter : LargeOrderFilter
    {
        public SmallOrderFilter(IOrderWriter orderWriter, List<Order> orders)
            : base(orderWriter, orders)
        {
            filterSize = "10";
        }
    }


    public class Order
    {
        public double Price
        {
            get { return this.dPrice; }
            set { this.dPrice = value; }
        }

        public int Size
        {
            get { return this.iSize; }
            set { this.iSize = value; }
        }

        public string Symbol
        {
            get { return this.sSymbol; }
            set { this.sSymbol = value; }
        }

        private double dPrice;
        private int iSize;
        private string sSymbol;

        public int toNumber(String Input)
        {
            bool canBeConverted = false;
            int n = 0;
            try
            {
                n = Convert.ToInt32(Input);
                if (n != 0) canBeConverted = true;
            }
            catch (Exception ex)
            {
            }

            if (canBeConverted == true)
            {
                return n;
            }
            else
            {
                return 0;
            }
        }
    }


    // These are stub interfaces that already exist in the system
    // They're out of scope of the code review
    public interface IOrderWriter
    {
        void WriteOrders(IEnumerable<Order> orders);
    }

    public class OrderWriter : IOrderWriter
    {
        public void WriteOrders(IEnumerable<Order> orders)
        {
        }
    }

    public interface IOrderStore
    {
        List<Order> GetOrders();
    }


    public class OrderStore : IOrderStore
    {
        public List<Order> GetOrders()
        {
            return new List<Order> { new Order {
                Price = 10,
                Size =1,
                Symbol = "TShirt"
            }, new Order {
                Price = 15,
                Size =2,
                Symbol = "Sport Goods"
            } };
        }
    }

What I have tried:

SmallOrderFilter filter = new SmallOrderFilter(new OrderWriter(), orders);

move the above to a constructor and inject
Remove repetitive code
create an abstract class

解决方案

We don't do your homework or exercises for you - exercises are set to help you learn and to cement that new knowledge into your brain.

So if we just gave you all the suggestions then we would be doing you a disfavour.

You already have some suggestions that you haven't applied yet:

Quote:

move the above to a constructor and inject
Remove repetitive code
create an abstract class

@Paulo-Zemek has given you some other things to look at.

Here are a couple of more lines to look at carefully ... these are just silly mistakes, see if you can work out why:

if (canBeConverted == true)

catch (Exception ex)
{
}

这篇关于重构代码练习 - 如何解决这个问题的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！