public static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products PrintNamesOfTheFiveMostExpensiveProducts(allProducts); Console.WriteLine(new string('-', 10)); // Number of products in each category PrintNumberOfProductsInEachCategory(allProducts, allCategories); Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) PrintFiveTopProducts(allOrders, allProducts); Console.WriteLine(new string('-', 10)); // The most profitable category PrintMostProfitableCategory(allOrders, allProducts, allCategories); }
public static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products var mostExpensiveFiveProducts = allProducts .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, mostExpensiveFiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var productsInCategory = allProducts .GroupBy(p => p.CategoryId) .Select(group => new { Category = allCategories.First(c => c.Id == group.Key).Name, Count = group.Count() }) .ToList(); foreach (var item in productsInCategory) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var topFiveProducts = allOrders .GroupBy(o => o.ProductId) .Select(group => new { Product = allProducts.First(product => product.Id == group.Key).Name, Quantities = group.Sum(order => order.Quant) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in topFiveProducts) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var profitableCategory = allOrders .GroupBy(order => order.ProductId) .Select(group => new { categoryId = allProducts.First(p => p.Id == group.Key).CategoryId, price = allProducts.First(p => p.Id == group.Key).UnitPrice, quantity = group.Sum(p => p.Quant) }) .GroupBy(group => group.categoryId) .Select(group => new { name = allCategories.First(c => c.Id == group.Key).Name, totalQuantity = group.Sum(product => product.quantity * product.price) }) .OrderByDescending(group => group.totalQuantity) .First(); Console.WriteLine("{0}: {1}", profitableCategory.name, profitableCategory.totalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products var first = allProducts .OrderByDescending(product => product.UnitPrice) .Take(5) .Select(product => product.Name); Console.WriteLine(string.Join(Environment.NewLine, first)); Console.WriteLine(new string('-', NumberOfDashes)); // Number of products in each category var second = allProducts .GroupBy(product => product.CategoryId) .Select(products => new { Category = allCategories.First(category => category.Id == products.Key).Name , Count = products.Count() }) .ToList(); foreach (var item in second) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', NumberOfDashes)); // The 5 top products (by order quantity) var third = allOrders .GroupBy(order => order.ProductId) .Select(orders => new { Product = allProducts.First(product => product.Id == orders.Key).Name , Quantities = orders.Sum(order => order.Quant) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in third) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', NumberOfDashes)); // The most profitable category var mostProfitableCategory = allOrders .GroupBy(order => order.ProductId) .Select(grouping => new { catId = allProducts.First(product => product.Id == grouping.Key).CategoryId , price = allProducts.First(product => product.Id == grouping.Key).UnitPrice , quantity = grouping.Sum(order => order.Quant) }) .GroupBy(gg => gg.catId) .Select(group => new { CategoryName = allCategories.First(category => category.Id == group.Key).Name , TotalQuantity = group.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.CategoryName, mostProfitableCategory.TotalQuantity); }
private static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products IEnumerable<Product> products = allProducts as Product[] ?? allProducts.ToArray(); var top5MostExpensiveProducts = products .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, top5MostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each Category var NumsOfProducts = products .GroupBy(p => p.CategoryId) .Select(grp => new { Category = allCategories.First(category => category.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var item in NumsOfProducts) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by Order quantity) var orders = allOrders as Order[] ?? allOrders.ToArray(); var top5Products = orders .GroupBy(order => order.ProductId) .Select(grouping => new { Product = products.First(product => product.Id == grouping.Key).Name, Quantities = grouping.Sum(order => order.Quantity) }) .OrderByDescending(arg => arg.Quantities) .Take(5); foreach (var item in top5Products) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable Category var mostProfitableCategory = orders .GroupBy(order => order.ProductId) .Select(grouping => new {products.First(product => product.Id == grouping.Key).CategoryId, price = products.First(product => product.Id == grouping.Key).UnitPrice, quantity = grouping.Sum(order => order.Quantity) }) .GroupBy(group => group.CategoryId) .Select(grouping => new { category_name = allCategories.First(category => category.Id == grouping.Key).Name, total_quantity = grouping.Sum(arg => arg.quantity * arg.price) }) .OrderByDescending(arg => arg.total_quantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.category_name, mostProfitableCategory.total_quantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; DataMapper allData = new DataMapper(); var categories = allData.GetAllCategories(); var products = allData.GetAllProducts(); var orders = allData.GetAllOrders(); // Names of the 5 most expensive products IEnumerable<string> mostExpensiveProducts = products .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.ProductName); Console.WriteLine(string.Join(Environment.NewLine, mostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var productsByCategories = products .GroupBy(p => p.CategoryID) .Select(group => new { Category = categories.First(c => c.CategoryID == group.Key).CategoryName, Count = group.Count() }) .ToList(); foreach (var product in productsByCategories) { Console.WriteLine("{0}: {1}", product.Category, product.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var productsByQuantity = orders .GroupBy(order => order.ProductID) .Select(group => new { Product = products.First(p => p.ProductID == group.Key).ProductName, Quantities = group.Sum(order => order.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var product in productsByQuantity) { Console.WriteLine("{0}: {1}", product.Product, product.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var profitableCategory = orders .GroupBy(order => order.ProductID) .Select(group => new { CategoryID = products.First(p => p.ProductID == group.Key).CategoryID, price = products.First(p => p.ProductID == group.Key).UnitPrice, quantity = group.Sum(p => p.Quantity) }) .GroupBy(category => category.CategoryID) .Select(group => new { categoryName = categories.First(c => c.CategoryID == group.Key).CategoryName, totalQuantity = group.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.totalQuantity) .First(); Console.WriteLine("{0}: {1}", profitableCategory.categoryName, profitableCategory.totalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories() as Category[] ?? dataMapper.GetAllCategories().ToArray(); var allProducts = dataMapper.GetAllProducts() as Product[] ?? dataMapper.GetAllProducts().ToArray(); var allOrders = dataMapper.GetAllOrders() as Order[] ?? dataMapper.GetAllOrders().ToArray(); // Names of the 5 most expensive products var first = allProducts .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, first)); Console.WriteLine(new string('-', 10)); // Number of products in each Category var second = allProducts .GroupBy(p => p.CategoryId) .Select(grp => new { Category = allCategories.First(c => c.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var item in second) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by Order Quantity) var third = allOrders .GroupBy(group => group.ProductId) .Select(orders => new { Product = allProducts.First(p => p.Id == orders.Key).Name, Quantities = orders.Sum(s => s.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in third) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable Category var category = allOrders .GroupBy(groupId => groupId.ProductId) .Select(pId => new { allProducts.First(p => p.Id == pId.Key).CategoryId, Price = allProducts.First(p => p.Id == pId.Key).UnitPrice, Quantity = pId.Sum(q => q.Quantity) }) .GroupBy(groupCatId => groupCatId.CategoryId) .Select(catId => new { Category = allCategories.First(c => c.Id == catId.Key).Name, TotalQuantity = catId.Sum(g => g.Quantity * g.Price) }) .OrderByDescending(g => g.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", category.Category, category.TotalQuantity); }
public static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; DataMapper dataMapper = new DataMapper(); IEnumerable<Category> allCategories = dataMapper.GetAllCategories(); IEnumerable<Product> allProducts = dataMapper.GetAllProducts(); IEnumerable<Order> allOrders = dataMapper.GetAllOrders(); IEnumerable<string> FiveMostExpensiveProducts = NewMethod(allProducts); Console.WriteLine(string.Join(Environment.NewLine, FiveMostExpensiveProducts)); DrawSeparationLine(); var numberOfProductsByCategory = allProducts .GroupBy(p => p.CategoryId) .Select(grp => new { Category = allCategories.First(c => c.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var item in numberOfProductsByCategory) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } DrawSeparationLine(); var fiveTopProductsbyQuantity = allOrders .GroupBy(o => o.ProductId) .Select(grp => new { Product = allProducts.First(p => p.Id == grp.Key).Nome, Quantities = grp.Sum(grpgrp => grpgrp.Quant) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in fiveTopProductsbyQuantity) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } DrawSeparationLine(); // The most profitable category var category = allOrders .GroupBy(o => o.ProductId) .Select(g => new { catId = allProducts.First(p => p.Id == g.Key).CategoryId, price = allProducts.First(p => p.Id == g.Key).Price, quantity = g.Sum(p => p.Quant) }) .GroupBy(gg => gg.catId) .Select(grp => new { category_name = allCategories.First(c => c.Id == grp.Key).Name, total_quantity = grp.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.total_quantity) .First(); Console.WriteLine("{0}: {1}", category.category_name, category.total_quantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; DataMapper db = new DataMapper(); IEnumerable<Category> categories = db.GetCategories(); IEnumerable<Product> products = db.GetProducts(); IEnumerable<Order> orders = db.GetOrders(); // Names of the 5 most expensive products IEnumerable<string> mostExpensive = products .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.ProductName); Console.WriteLine(string.Join(Environment.NewLine, mostExpensive)); Console.WriteLine(new string('-', 10)); // Number of products in each category var second = products .GroupBy(p => p.ProductCategory) .Select(grp => new { Category = categories.First(c => c.CategoryID == grp.Key).CategoryName, Count = grp.Count() }) .ToList(); foreach (var item in second) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var third = orders .GroupBy(o => o.OrderProductID) .Select(grp => new { Product = products.First(p => p.ProductID == grp.Key).ProductName, Quantities = grp.Sum(grpgrp => grpgrp.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in third) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var category = orders .GroupBy(o => o.OrderProductID) .Select(g => new { catId = products.First(p => p.ProductID== g.Key).ProductCategory, price = products.First(p => p.ProductID == g.Key).UnitPrice, quantity = g.Sum(p => p.Quantity) }) .GroupBy(gg => gg.catId) .Select(grp => new { category_name = categories.First(c => c.CategoryID == grp.Key).CategoryName, total_quantity = grp.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.total_quantity) .First(); Console.WriteLine("{0}: {1}", category.category_name, category.total_quantity); }
public static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var filePaths = new DataMapper(); var allCategories = filePaths.GetAllCategories(); var allProducts = filePaths.GetAllProducts(); var allOrders = filePaths.GetAllOrders(); // Names of the 5 most expensive products var first = allProducts .OrderByDescending(product => product.UnitPrice) .Take(5) .Select(product => product.Name); Console.WriteLine(string.Join(Environment.NewLine, first)); Console.WriteLine(new string('-', 10)); // Number of products in each Category var second = allProducts .GroupBy(product => product.CatID) .Select(group => new { Category = allCategories.First(c => c.ID == group.Key).Name, Count = group.Count() }) .ToList(); foreach (var item in second) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by Order quantity) var third = allOrders .GroupBy(o => o.ProductID) .Select(group => new { Product = allProducts.First(p => p.ID == group.Key).Name, Quantities = group.Sum(grpgrp => grpgrp.Quant) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in third) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable Category var category = allOrders .GroupBy(order => order.ProductID) .Select(group => new { catId = allProducts.First(p => p.ID == group.Key).CatID, price = allProducts.First(p => p.ID == group.Key).UnitPrice, quantity = group.Sum(p => p.Quant) }) .GroupBy(categ => categ.catId) .Select(goup => new { category_name = allCategories.First(c => c.ID == goup.Key).Name, total_quantity = goup.Sum(g => g.quantity * g.price) }) .OrderByDescending(group => group.total_quantity) .First(); Console.WriteLine("{0}: {1}", category.category_name, category.total_quantity); }
internal static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products var mostExpensive5Products = dataMapper.Get5MostExpensiveProducts(); Console.WriteLine(string.Join(Environment.NewLine, mostExpensive5Products)); Console.WriteLine(new string('-', 10)); // Number of products in each Category var numberOfProductsForEachCategory = allProducts .GroupBy(p => p.CatalogueId) .Select(grp => new { Category = allCategories.First(c => c.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var item in numberOfProductsForEachCategory) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by Order quantity) var top5Products = allOrders .GroupBy(o => o.ProductId) .Select(grp => new { Product = allProducts.First(p => p.Id == grp.Key).Name, Quantities = grp.Sum(grpgrp => grpgrp.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in top5Products) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable Category var mostProfitableCategory = allOrders .GroupBy(o => o.ProductId) .Select(g => new { catId = allProducts.First(p => p.Id == g.Key).CatalogueId, price = allProducts.First(p => p.Id == g.Key).UnitPrice, quantity = g.Sum(p => p.Quantity) }) .GroupBy(gg => gg.catId) .Select(grp => new { categoryName = allCategories.First(c => c.Id == grp.Key).Name, totalQuantity = grp.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.totalQuantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.categoryName, mostProfitableCategory.totalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; IDataMapper dataMapper = new DataMapper(); IEnumerable<ICategory> categories = dataMapper.GetAllCategories(); IEnumerable<IProduct> products = dataMapper.GetAllProducts(); IEnumerable<IOrder> orders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products IEnumerable<string> fiveMostExpensiveProducts = GetNamesOfMostExpensiveProducts(products, 5); Console.WriteLine(string.Join(Environment.NewLine, fiveMostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var numberOfProductsInEachCategory = products .GroupBy(p => p.CategoryId) .Select(grp => new { Category = categories.First(c => c.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var item in numberOfProductsInEachCategory) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var fiveTopOrders = orders .GroupBy(o => o.ProductId) .Select(grp => new { Product = products.First(p => p.Id == grp.Key).Name, Quantities = grp.Sum(grpgrp => grpgrp.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in fiveTopOrders) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var mostProfitableCategory = orders .GroupBy(o => o.ProductId) .Select(g => new { catId = products.First(p => p.Id == g.Key).CategoryId, price = products.First(p => p.Id == g.Key).UnitPrice, quantity = g.Sum(p => p.Quantity) }) .GroupBy(gg => gg.catId) .Select(grp => new { category_name = categories.First(c => c.Id == grp.Key).Name, total_quantity = grp.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.total_quantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.category_name, mostProfitableCategory.total_quantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); var fiveMostExpensiveProducts = allProducts .OrderByDescending(product => product.UnitPrice) .Take(5) .Select(product => product.Name); Console.WriteLine(string.Join(Environment.NewLine, fiveMostExpensiveProducts)); Console.WriteLine(new string('-', 10)); var numberOfProductsInEachCategory = allProducts .GroupBy(product => product.CategoryID) .Select(properties => new { Category = allCategories.First(category => category.ID == properties.Key).Name, Count = properties.Count() }) .ToList(); foreach (var NumberOfProductsInCategory in numberOfProductsInEachCategory) { Console.WriteLine("{0}: {1}", NumberOfProductsInCategory.Category, NumberOfProductsInCategory.Count); } Console.WriteLine(new string('-', 10)); var fiveTopProductsByOrderQuantity = allOrders .GroupBy(order => order.ProductID) .Select(properties => new { Product = allProducts.First(product => product.ID == properties.Key).Name, Quantities = properties.Sum(order => order.Quantity) }) .OrderByDescending(products => products.Quantities) .Take(5); foreach (var item in fiveTopProductsByOrderQuantity) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); var mostProfitableCategory = allOrders .GroupBy(order => order.ProductID) .Select(grouping => new { CategoryId = allProducts.First(product => product.ID == grouping.Key).CategoryID, Price = allProducts.First(product => product.ID == grouping.Key).UnitPrice, Quantity = grouping.Sum(order => order.Quantity) }) .GroupBy(categories => categories.CategoryId) .Select(grouping => new { CategoryName = allCategories.First(category => category.ID == grouping.Key).Name, TotalQuantity = grouping.Sum(categories => categories.Quantity * categories.Price) }) .OrderByDescending(g => g.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.CategoryName, mostProfitableCategory.TotalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; DataMapper dataMapper = new DataMapper(); IEnumerable<Category> allCategories = dataMapper.GetAllCategories(); List<Category> allCategoriesList = allCategories.ToList(); IEnumerable<Product> allProducts = dataMapper.GetAllProducts(); List<Product> allProductsList = allProducts.ToList(); IEnumerable<Order> allOrders = dataMapper.GetAllOrders(); List<Order> allOrdersList = allOrders.ToList(); PrintMostExpensiveProducts(allProductsList); PrintNumberOfProductsInCategories(allProductsList, allCategoriesList); PrintTopProductsByOrderQuantity(allOrdersList, allProductsList); PrintMostProfitableCategory(allOrdersList, allProductsList, allCategoriesList); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var mapper = new DataMapper(); var categories = mapper.GetAllCategories(); var products = mapper.GetAllProducts(); var orders = mapper.GetAllOrders(); // Names of the 5 most expensive products GetTheMostExpensiveProducts(products, 5); // Number of products in each category PrintNumberOfProductsPerCategory(products, categories); // The 5 top products (by order quantity) PrintTheMostOrderedProducts(orders, products, 5); // The most profitable category PrintTheMostProfitableCategory(orders, products, categories); }
private static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var data = new DataMapper(); var allCategories = data.GetAllCategories(); var allProducts = data.GetAllProducts(); var allOrders = data.GetAllOrders(); PrintNamesOfTheFiveMostExpensiveProducts(allProducts); Console.WriteLine(new string('-', 10)); PrintNumberOfProductsInEachCategory(allProducts, allCategories); Console.WriteLine(new string('-', 10)); PrintFiveTopProducts(allOrders, allProducts); Console.WriteLine(new string('-', 10)); PrintMostProfitableCategory(allOrders, allProducts, allCategories); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; DataMapper dataMapper = new DataMapper(); IEnumerable <Category> categories = dataMapper.GetAllCategories(); IEnumerable <Product> products = dataMapper.GetAllProducts(); IEnumerable <Order> orders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products IEnumerable <string> expesiveProducts = products .OrderByDescending(product => product.UnitPrice) .Take(5) .Select(product => product.Name); Console.WriteLine(string.Join(Environment.NewLine, expesiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each Category var inEachCategory = products .GroupBy(product => product.CategoryId) .Select(grp => new { Category = categories.First(c => c.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var product in inEachCategory) { Console.WriteLine("{0}: {1}", product.Category, product.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by Order quantity) var topProducts = orders .GroupBy(order => order.ProductId) .Select(grp => new { Product = products.First(product => product.Id == grp.Key).Name, Quantities = grp.Sum(groupOrder => groupOrder.Quant) }) .OrderByDescending(quantity => quantity.Quantities) .Take(5); foreach (var product in topProducts) { Console.WriteLine("{0}: {1}", product.Product, product.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable Category var category = orders .GroupBy(order => order.ProductId) .Select(group => new { categoryId = products.First(product => product.Id == group.Key).CategoryId, price = products.First(product => product.Id == group.Key).UnitPrice, quantity = group.Sum(product => product.Quant) }) .GroupBy(categoryGroup => categoryGroup.categoryId) .Select(grp => new { categoryName = categories.First(cat => cat.Id == grp.Key).Name, totalQuantity = grp.Sum(group => group.quantity * group.price) }) .OrderByDescending(group => group.totalQuantity) .First(); Console.WriteLine("{0}: {1}", category.categoryName, category.totalQuantity); }
public static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategoriesInData = dataMapper.GetAllCategories(); var allProductsInData = dataMapper.GetAllProducts(); var allOrdersInData = dataMapper.GetAllOrders(); var fiveMostExpensiveProducts = allProductsInData .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, fiveMostExpensiveProducts)); PrintLine(); var numberOfProdcutsPerCategory = allProductsInData .GroupBy(p => p.CategoryId) .Select(group => new { Category = allCategoriesInData .First(c => c.Id == group.Key) .Name, Count = group.Count() }) .ToList(); foreach (var category in numberOfProdcutsPerCategory) { Console.WriteLine("{0}: {1}", category.Category, category.Count); } PrintLine(); var productsWithTheMostQuantity = allOrdersInData .GroupBy(order => order.ProductId) .Select(group => new { Product = allProductsInData .First(p => p.Id == group.Key) .Name, Quantities = group.Sum(grpgrp => grpgrp.Quantity) }) .OrderByDescending(products => products.Quantities) .Take(5); foreach (var product in productsWithTheMostQuantity) { Console.WriteLine("{0}: {1}", product.Product, product.Quantities); } PrintLine(); var mostProfitableCategory = allOrdersInData .GroupBy(o => o.ProductId) .Select(group => new { CatId = allProductsInData .First(product => product.Id == group.Key) .CategoryId, Price = allProductsInData .First(product => product.Id == group.Key) .UnitPrice, Quantity = group.Sum(order => order.Quantity) }) .GroupBy(group => group.CatId) .Select(group => new { CategoryName = allCategoriesInData .First(category => category.Id == group.Key) .Name, TotalQuantity = group.Sum(g => g.Quantity * g.Price) }) .OrderByDescending(group => group.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.CategoryName, mostProfitableCategory.TotalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var categories = dataMapper.getAllCategories(); var products = dataMapper.getAllProducts(); var orders = dataMapper.getAllOrders(); // Names of the 5 most expensive products var fiveMostExpensiveProducts = products .OrderByDescending(product => product.UnitPrice) .Take(5) .Select(product => product.Name); Console.WriteLine(string.Join(Environment.NewLine, fiveMostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var numberOfProductsInCategory = products .GroupBy(product => product.CategoryId) .Select(group => new { Category = categories.First(category => category.Id == group.Key).Name, Count = group.Count() }) .ToList(); foreach (var product in numberOfProductsInCategory) { Console.WriteLine("{0}: {1}", product.Category, product.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var fiveTopProductsByOrderQuantity = orders .GroupBy(order => order.ProductId) .Select(group => new { Product = products.First(product => product.Id == group.Key).Name, Quantity = group.Sum(item => item.Quantity) }) .OrderByDescending(group => group.Quantity) .Take(5); foreach (var product in fiveTopProductsByOrderQuantity) { Console.WriteLine("{0}: {1}", product.Product, product.Quantity); } Console.WriteLine(new string('-', 10)); // The most profitable category var mostProfitableCategory = orders .GroupBy(order => order.ProductId) .Select(group => new { categatyId = products.First(product => product.Id == group.Key).CategoryId, Price = products.First(product => product.Id == group.Key).UnitPrice, Quantity = group.Sum(product => product.Quantity) }) .GroupBy(order => order.categatyId) .Select(group => new { CategoryName = categories.First(category => category.Id == group.Key).Name, TotalQuantity = group.Sum(item => item.Quantity * item.Price) }) .OrderByDescending(group => group.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.CategoryName, mostProfitableCategory.TotalQuantity); }
private static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); var fiveMostExpensiveProductsNames = allProducts.OrderByDescending(p => p.UnitPrice).Take(5).Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, fiveMostExpensiveProductsNames)); Console.WriteLine(new string('-', 10)); var numberOfProductsInCategory = allProducts.GroupBy(p => p.CategoryId) .Select( group => new { Category = allCategories.First(c => c.Id == group.Key).Name, Count = group.Count() }) .ToList(); foreach (var item in numberOfProductsInCategory) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); var topFiveProductsOrderedByQuantity = allOrders.GroupBy(order => order.ProductId) .Select( group => new { Product = allProducts.FirstOrDefault(p => p.Id == group.Key).Name, Quantities = group.Sum(order => order.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in topFiveProductsOrderedByQuantity) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); var mostProfitableCategory = allOrders.GroupBy(o => o.ProductId) .Select( grouping => new { ProductCategoryId = allProducts.First(p => p.Id == grouping.Key).CategoryId, Price = allProducts.First(p => p.Id == grouping.Key).UnitPrice, Quantity = grouping.Sum(p => p.Quantity) }) .GroupBy(product => product.ProductCategoryId) .Select( productGroup => new { CategoryName = allCategories.First(c => c.Id == productGroup.Key).Name, TotalQuantity = productGroup.Sum(g => g.Quantity * g.Price) }) .OrderByDescending(productGroup => productGroup.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.CategoryName, mostProfitableCategory.TotalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var categories = dataMapper.GetAllCategories(); var products = dataMapper.GetAllProducts(); var orders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products var mostExpensiveProducts = products .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine("Most Expensive Products:"); Console.WriteLine(string.Join(Environment.NewLine, mostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var mostExpensiveByCategory = products .GroupBy(p => p.CategoryId) .Select ( grp => new { Category = categories.First(c => c.Id == grp.Key).Name, Count = grp.Count() } ) .ToList(); Console.WriteLine("Number of products in each category:"); foreach (var item in mostExpensiveByCategory) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var mostOrderedProducts = orders .GroupBy(o => o.ProductId) .Select ( grp => new { Product = products.First(p => p.Id == grp.Key).Name, Quantities = grp.Sum(x => x.Quantity) } ) .OrderByDescending(q => q.Quantities) .Take(5); Console.WriteLine("Top products by ordered quantity:"); foreach (var item in mostOrderedProducts) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var mostProfitableCategory = orders .GroupBy(o => o.ProductId) .Select ( g => new { catId = products.First(p => p.Id == g.Key).CategoryId, price = products.First(p => p.Id == g.Key).UnitPrice, quantity = g.Sum(p => p.Quantity) } ) .GroupBy(category => category.catId) .Select ( grp => new { categoryName = categories.First(c => c.Id == grp.Key).Name, totalQuantity = grp.Sum(g => g.quantity * g.price) } ) .OrderByDescending(g => g.totalQuantity) .First(); Console.WriteLine("Most profitable category:"); Console.WriteLine("{0}: {1}", mostProfitableCategory.categoryName, mostProfitableCategory.totalQuantity); }
public static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.GetAllCategories(); var allProducts = dataMapper.GetAllProducts(); var allOrders = dataMapper.GetAllOrders(); // Names of the 5 most expensive products var firstProduct = allProducts .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name) .ToList(); Console.WriteLine(string.Join(Environment.NewLine, firstProduct)); Console.WriteLine(new string('-', 10)); // Number of products in each category var secondProduct = allProducts .GroupBy(p => p.CatId) .Select(grp => new { Category = allCategories.First(c => c.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var item in secondProduct) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var thirdProduct = allOrders .GroupBy(id => id.ProductId) .Select(grp => new { Product = allProducts.First(p => p.Id == grp.Key).Name, Quantities = grp.Sum(grpgrp => grpgrp.Quant) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in thirdProduct) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var category = allOrders .GroupBy(id => id.ProductId) .Select(g => new { catId = allProducts.First(p => p.Id == g.Key).CatId, price = allProducts.First(p => p.Id == g.Key).UnitPrice, quantity = g.Sum(p => p.Quant) }) .GroupBy(gg => gg.catId) .Select(grp => new { category_name = allCategories.First(c => c.Id == grp.Key).Name, total_quantity = grp.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.total_quantity) .First(); Console.WriteLine("{0}: {1}", category.category_name, category.total_quantity); }
public static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var categories = dataMapper.GetCategories(); var products = dataMapper.GetProducts(); var orders = dataMapper.GetOrders(); // Print names of the 5 most expensive products var firstFiveMostExpensiveProducts = products .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Nome); Console.WriteLine(string.Join(Environment.NewLine, firstFiveMostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Print number of products in each category var productsInEachCategory = products .GroupBy(p => p.CategoryId) .Select(group => new { Category = categories.First(cat => cat.Id == group.Key).Name, Count = group.Count() }) .ToList(); foreach (var product in productsInEachCategory) { Console.WriteLine("{0}: {1}", product.Category, product.Count); } Console.WriteLine(new string('-', 10)); // Print the 5 top products (by Order quantity) var topFiveProductsByOrderQuantity = orders .GroupBy( order => order.ProductId) .Select(group => new { Product = products.First(p => p.Id == group.Key).Nome, Quantities = group.Sum(order => order.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in topFiveProductsByOrderQuantity) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // Print the most profitable category var category = orders .GroupBy(id => id.ProductId) .Select(group => new { catId = products.First(p => p.Id == group.Key).CategoryId, price = products.First(p => p.Id == group.Key).UnitPrice, quantity = group.Sum(p => p.Quantity) }) .GroupBy(group => group.catId) .Select(group => new { CategoryName = categories.First(c => c.Id == group.Key).Name, TotalQuantity = group.Sum(g => g.quantity * g.price) }) .OrderByDescending(g => g.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", category.CategoryName, category.TotalQuantity); }
private static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var categories = dataMapper.GetAllCategories().ToArray(); var products = dataMapper.GetAllProducts().ToArray(); var orders = dataMapper.GetAllOrders().ToArray(); // Names of the 5 most expensive products var top5MostExpensiveProducts = products .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, top5MostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var categoryProducts = products .GroupBy(p => p.CategoryId) .Select(group => new { Category = categories.First(c => c.Id == group.Key).Name, Count = group.Count() }) .ToList(); foreach (var item in categoryProducts) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var top5ProductsByOrderQuantity = orders .GroupBy(o => o.ProductId) .Select(group => new { Product = products.First(p => p.Id == group.Key).Name, Quantities = group.Sum(o => o.Quantity) }) .OrderByDescending(group => group.Quantities) .Take(5) .ToArray(); foreach (var item in top5ProductsByOrderQuantity) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var category = orders .GroupBy(o => o.ProductId) .Select(group => new { ProductCategoryId = products.First(p => p.Id == group.Key).CategoryId, Price = products.First(p => p.Id == group.Key).UnitPrice, Quantity = group.Sum(p => p.Quantity) }) .GroupBy(product => product.ProductCategoryId) .Select(productGroup => new { CategoryName = categories.First(c => c.Id == productGroup.Key).Name, TotalQuantity = productGroup.Sum(g => g.Quantity * g.Price) }) .OrderByDescending(productGroup => productGroup.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", category.CategoryName, category.TotalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var dataMapper = new DataMapper(); var allCategories = dataMapper.getAllCategories(); var allProducts = dataMapper.getAllProducts(); var allOrders = dataMapper.getAllOrders(); // Names of the 5 most expensive products var FiveMostExpensiveProducts = allProducts .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, FiveMostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var NumsOfProductsForEachCategory = allProducts .GroupBy(p => p.CategoryId) .Select(grp => new { Category = allCategories.First(c => c.Id == grp.Key).Name, Count = grp.Count() }).ToList(); foreach (var item in NumsOfProductsForEachCategory) { Console.WriteLine("{0}: {1}", item.Category, item.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order quantity) var FiveTopProductsOrderedByQuantity = allOrders .GroupBy(o => o.ProductId) .Select(grp => new { Product = allProducts.First(p => p.Id == grp.Key).Name, Quantities = grp.Sum(grpgrp => grpgrp.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var item in FiveTopProductsOrderedByQuantity) { Console.WriteLine("{0}: {1}", item.Product, item.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var category = allOrders .GroupBy(o => o.ProductId) .Select(g => new { CategoryId = allProducts.First(p => p.Id == g.Key).CategoryId, Price = allProducts.First(p => p.Id == g.Key).UnitPrice, Quantity = g.Sum(q => q.Quantity) }) .GroupBy(g => g.CategoryId) .Select(grp => new { CategoryName = allCategories.First(c => c.Id == grp.Key).Name, TotalQuantity = grp.Sum(g => g.Quantity * g.Price) }) .OrderByDescending(g => g.TotalQuantity) .First(); Console.WriteLine("{0}: {1}", category.CategoryName, category.TotalQuantity); }
static void Main() { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var mapper = new DataMapper(); var categories = mapper.GetAllCategories(); var products = mapper.GetAllProducts(); var orders = mapper.GetAllOrders(); // Names of the 5 most expensive products var mostExpensiveProducts = products .OrderByDescending(p => p.UnitPrice) .Take(5) .Select(p => p.Name); Console.WriteLine(string.Join(Environment.NewLine, mostExpensiveProducts)); Console.WriteLine(new string('-', 10)); // Number of products in each category var productsByCategories = products .GroupBy(p => p.CategoryId) .Select(grp => new { Category = categories .First(c => c.Id == grp.Key).Name, Count = grp.Count() }) .ToList(); foreach (var productsGroup in productsByCategories) { Console.WriteLine("{0}: {1}", productsGroup.Category, productsGroup.Count); } Console.WriteLine(new string('-', 10)); // The 5 top products (by order Quantity) var mostOrderedProducts = orders .GroupBy(o => o.ProductId) .Select(g => new { Product = products .First(p => p.Id == g.Key).Name, Quantities = g.Sum(o => o.Quantity) }) .OrderByDescending(q => q.Quantities) .Take(5); foreach (var order in mostOrderedProducts) { Console.WriteLine("{0}: {1}", order.Product, order.Quantities); } Console.WriteLine(new string('-', 10)); // The most profitable category var mostProfitableCategory = orders .GroupBy(o => o.ProductId) .Select(g => new { CategoryId = products .First(p => p.Id == g.Key).CategoryId, Price = products .First(p => p.Id == g.Key).UnitPrice, Quantity = g.Sum(p => p.Quantity) }) .GroupBy(g => g.CategoryId) .Select(g => new { CategoryName = categories .First(c => c.Id == g.Key).Name, TotalSum = g.Sum(o => o.Quantity * o.Price) }) .OrderByDescending(g => g.TotalSum) .First(); Console.WriteLine("{0}: {1}", mostProfitableCategory.CategoryName, mostProfitableCategory.TotalSum); }