API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 20th, 2019
61
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 35.38 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5.  
  6. namespace csCourseWork
  7. {
  8. class Methods : Library
  9. {
  10. public static void Initialization()
  11. {
  12. try
  13. {
  14. int size;
  15. int i = 0;
  16. Console.WriteLine("How many objects will you use[max]?");//запрашиваем ввод максимального количества объектов, то есть пользователь не будет использовать большее количество объектов ни при каких условиях
  17. size = int.Parse(Console.ReadLine());//ввод количества объектов
  18. while (size <= 0)
  19. {
  20. Console.WriteLine("Inpur correct amount of objects[1-2^16]");
  21. size = int.Parse(Console.ReadLine());
  22. }
  23. Library[] objects = new Library[size];//инициализируем массив объектов
  24.  
  25. for (int j = 0; j < size; j++)//присваиваем каждому элементу массива объект типа Library
  26. objects[j] = new Library();
  27.  
  28. List<Library> libs = new List<Library> { };//создаем список, с которым будем работать в дальшейшем
  29. Menu(libs, objects, ref i);
  30. }
  31. catch (Exception e)
  32. {
  33. Console.WriteLine(e.Message);
  34. Initialization();
  35. }
  36. }
  37.  
  38. private static void Menu(List<Library> lib, Library[] objects, ref int i)
  39. {
  40. try
  41. {
  42. Console.WriteLine("Input:");
  43. Console.WriteLine("1-to add field");
  44. Console.WriteLine("2-to display field(s)");
  45. Console.WriteLine("3-to change field");
  46. Console.WriteLine("4-to delete field");
  47. Console.WriteLine("5-to write into the file");
  48. Console.WriteLine("6-to search using keyfield");
  49. Console.WriteLine("7-to sort objects using one field");
  50. Console.WriteLine("8-to read info from file");
  51. Console.WriteLine("9-to insert at chosen place");
  52. Console.WriteLine("10-to delete using conditional");
  53. Console.WriteLine("11-to find min and max in diapasone from selected");
  54. Console.WriteLine("12-to exit");
  55. int choice;
  56. choice = int.Parse(Console.ReadLine());
  57. while (choice > 13 || choice < 1)
  58. {
  59. Console.WriteLine("Wrong number! Use only [1-12]");
  60. choice = int.Parse(Console.ReadLine());
  61. }
  62. switch (choice)
  63. {
  64. case 1:
  65. Add(lib, objects, ref i);
  66. break;
  67. case 2:
  68. Display(lib, objects, ref i);
  69. break;
  70. case 3:
  71. Change(lib, objects, ref i);
  72. break;
  73. case 4:
  74. Delete(lib, objects, ref i);
  75. break;
  76. case 5:
  77. FDisplay(lib, objects, ref i);
  78. break;
  79. case 6:
  80. Search(lib, objects, ref i);
  81. break;
  82. case 7:
  83. Sort(lib, objects, ref i);
  84. break;
  85. case 8:
  86. Read(lib, objects, ref i);
  87. break;
  88. case 9:
  89. InsertAt(lib, objects, ref i);
  90. break;
  91. case 10:
  92. ConditionalDelete(lib, objects, ref i);
  93. break;
  94. case 11:
  95. MinMax(lib, objects, ref i);
  96. break;
  97. case 12:
  98. Environment.Exit(0);
  99. break;
  100. default:
  101. Console.WriteLine("You can only use [1,12] numbers");
  102. Menu(lib, objects, ref i);
  103. break;
  104. }
  105. }
  106. catch(Exception e)
  107. {
  108. Console.Clear();
  109. Console.WriteLine(e.Message);
  110. Menu(lib, objects, ref i);
  111. }
  112. }
  113.  
  114. private static void Add(List<Library> lib, Library[] objects, ref int i)
  115. {
  116. try
  117. {
  118. if (i < objects.Length)
  119. {
  120. Console.WriteLine("----------------------------");
  121. Console.WriteLine($"input {i + 1} field");
  122.  
  123. Console.WriteLine("Input inventory number");
  124. objects[i].Number = int.Parse(Console.ReadLine());
  125.  
  126. Console.WriteLine("Input author of book");
  127. objects[i].Author = Console.ReadLine();
  128.  
  129. Console.WriteLine("Input book name");
  130. objects[i].Book = Console.ReadLine();
  131.  
  132. Console.WriteLine("Input amount of copies");
  133. objects[i].Copies = int.Parse(Console.ReadLine());
  134.  
  135. Console.WriteLine("Input price of book");
  136. objects[i].Price = Double.Parse(Console.ReadLine());
  137.  
  138. Console.WriteLine("----------------------------");
  139. lib.Add(objects[i]);
  140. i++;
  141. }
  142. else
  143. Console.WriteLine("You cant add objects anymore");
  144. Menu(lib, objects, ref i);
  145. }
  146. catch(Exception e)
  147. {
  148. Console.Clear();
  149. Console.WriteLine(e.Message);
  150. Add(lib, objects, ref i);
  151. }
  152. }
  153.  
  154. private static void Display(List<Library> lib, Library[] objects, ref int i)
  155. {
  156. try
  157. {
  158. if (i == 0)
  159. {
  160. Console.WriteLine("No objects to display");
  161. }
  162. else
  163. {
  164. Console.WriteLine("1-Display chosen field | 2-Display all");
  165. int choice;
  166. int ind;
  167. choice = int.Parse(Console.ReadLine());
  168. switch (choice)
  169. {
  170. case 1:
  171. Console.Write($"Which element do you want to display?[1-{lib.Count}]:");
  172. ind = int.Parse(Console.ReadLine());
  173. Console.WriteLine(lib[ind - 1].ToString());
  174. break;
  175. case 2:
  176. for (int j = 0; j < lib.Count; j++)
  177. {
  178. Console.WriteLine("--------------------------");
  179. Console.WriteLine($"Field number:{j + 1}");
  180. Console.WriteLine(lib[j].ToString());
  181. }
  182. break;
  183. default:
  184. Console.WriteLine("You can only use those numbers here: [1,2]");
  185. Display(lib, objects, ref i);
  186. break;
  187. }
  188. }
  189. Menu(lib, objects, ref i);
  190. }
  191. catch(Exception e)
  192. {
  193. Console.WriteLine(e.Message);
  194. Display(lib, objects, ref i);
  195. }
  196.  
  197. }
  198.  
  199. private static void Change(List<Library> lib, Library[] objects, ref int i)
  200. {
  201. try
  202. {
  203. if(i==0)
  204. {
  205. Console.WriteLine("No objects to change");
  206. }
  207. else
  208. {
  209. Console.WriteLine($"Choose which field do you want to change [1-{lib.Count}]:");
  210. int choice = int.Parse(Console.ReadLine());
  211. if (choice > lib.Count && choice > 0)
  212. {
  213. Console.WriteLine($"Wrong number! Use only [1-{lib.Count}]");
  214. choice = int.Parse(Console.ReadLine());
  215. }
  216. Console.WriteLine("------------------------");
  217. Console.WriteLine("Input inventory number");
  218. lib[choice - 1].Number = int.Parse(Console.ReadLine());
  219.  
  220. Console.WriteLine("Input author of book");
  221. lib[choice - 1].Author = Console.ReadLine();
  222.  
  223. Console.WriteLine("Input book name");
  224. lib[choice = 1].Book = Console.ReadLine();
  225.  
  226. Console.WriteLine("Input amount of copies");
  227. lib[choice - 1].Copies = int.Parse(Console.ReadLine());
  228.  
  229. Console.WriteLine("Input price of book");
  230. lib[choice - 1].Price = Double.Parse(Console.ReadLine());
  231. }
  232. Menu(lib, objects, ref i);
  233. }
  234. catch(Exception e)
  235. {
  236. Console.WriteLine(e.Message);
  237. Change(lib, objects, ref i);
  238. }
  239. }
  240.  
  241. private static void Delete(List<Library> lib, Library[] objects, ref int i)
  242. {
  243. try
  244. {
  245. if (i == 0)
  246. {
  247. Console.WriteLine("No objects to delete");
  248. }
  249. else
  250. {
  251. Console.Write("1-Delete chosen field | 2-Delete all:");
  252. int choice;
  253. choice = int.Parse(Console.ReadLine());
  254. switch (choice)
  255. {
  256. case 1:
  257. int index;
  258. Console.Write($"Which field do you want to remove?[1-{lib.Count}]:");
  259. index = int.Parse(Console.ReadLine());
  260. if (index <= lib.Count && index >= 0)
  261. {
  262. lib.RemoveAt(index - 1);
  263. i--;
  264. }
  265. else
  266. {
  267. Console.WriteLine("You are out of list range, cannot delete field, which is not exist");
  268. Delete(lib, objects, ref i);
  269. }
  270. break;
  271.  
  272. case 2:
  273. lib.Clear();
  274. i = 0;
  275. break;
  276.  
  277. default:
  278. Console.WriteLine("You can only use those numbers here: [1,2]");
  279. Delete(lib, objects, ref i);
  280. break;
  281. }
  282. }
  283. Menu(lib, objects, ref i);
  284. }
  285. catch(Exception e)
  286. {
  287. Console.WriteLine(e.Message);
  288. Delete(lib, objects, ref i);
  289. }
  290. }
  291.  
  292. private static void FDisplay(List<Library> lib, Library[] objects, ref int i)
  293. {
  294. try
  295. {
  296. if (i == 0)
  297. {
  298. Console.WriteLine("No objects to write in file");
  299. Menu(lib, objects, ref i);
  300. }
  301. else
  302. {
  303. StreamWriter file = new StreamWriter("E:\\BrSTU\\CourseWork\\csCourseWork\\Display.txt");
  304. for (int j = 0; j < lib.Count; j++)
  305. {
  306. file.WriteLine($"-------------{j + 1}-------------");
  307. file.WriteLine(lib[j].ToString());
  308. }
  309. file.Close();
  310. }
  311. }
  312. catch(Exception e)
  313. {
  314. Console.WriteLine(e.Message);
  315. FDisplay(lib, objects, ref i);
  316. }
  317. finally
  318. {
  319. Console.WriteLine("Written succesfully!");
  320. Menu(lib, objects, ref i);
  321. }
  322. }
  323.  
  324. private static void Search(List<Library> lib, Library[] objects, ref int i)
  325. {
  326. try
  327. {
  328. if (i == 0)
  329. {
  330. Console.WriteLine("No objects to search");
  331. }
  332. else
  333. {
  334. Console.WriteLine("------------------------------");
  335. Console.Write("The keyfield is [inventory number]\nInput inventory number to find object:");
  336. int search;
  337. int size = 0;
  338. search = int.Parse(Console.ReadLine());
  339. for (int j = 0; j < lib.Count; j++)
  340. {
  341. if (search == lib[j].Number)
  342. {
  343. Console.WriteLine(lib[j].ToString());
  344. }
  345. else
  346. {
  347. size++;
  348. }
  349. }
  350. if (size == lib.Count)
  351. {
  352. Console.WriteLine("object with such inventory number not exist");
  353. }
  354. }
  355. Menu(lib, objects, ref i);
  356. }
  357. catch (Exception e)
  358. {
  359. Console.WriteLine(e.Message);
  360. Search(lib, objects, ref i);
  361. }
  362. }
  363.  
  364. public static void Sort(List<Library> lib, Library[] objects, ref int i)
  365. {
  366. try
  367. {
  368. if (lib.Count == 0)
  369. {
  370. Console.WriteLine("No objects to sort");
  371. Menu(lib, objects, ref i);
  372. }
  373. else
  374. {
  375. Console.WriteLine("----------------------------");
  376. Console.WriteLine("Using which field do you want to sort objects?");
  377. Console.WriteLine("1-Inventory number");
  378. Console.WriteLine("2-Author of book");
  379. Console.WriteLine("3-Book name");
  380. Console.WriteLine("4-Amount of copies");
  381. Console.WriteLine("5-Price of book");
  382. int choice;
  383. choice = int.Parse(Console.ReadLine());
  384. while (choice > 5 || choice < 1)
  385. {
  386. Console.WriteLine("Please use only given numbers[1-5]");
  387. choice = int.Parse(Console.ReadLine());
  388. }
  389. switch (choice)
  390. {
  391. case 1:
  392. var sorted = lib.OrderBy(x => x.Number).ToList();
  393. string path = @"E:\BrSTU\CourseWork\csCourseWork\sorted.dat";
  394. using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)))
  395. foreach (var x in sorted)
  396. {
  397. writer.Write("---------------------");
  398. writer.Write(x.BinaryToString());
  399. writer.Write("\r\n");
  400. }
  401. break;
  402. case 2:
  403. sorted = lib.OrderBy(x => x.Author).ToList();
  404. path = @"E:\BrSTU\CourseWork\csCourseWork\sorted.dat";
  405. using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)))
  406. foreach (var x in sorted)
  407. {
  408. writer.Write("---------------------");
  409. writer.Write(x.BinaryToString());
  410. writer.Write("\r\n");
  411. }
  412. break;
  413. case 3:
  414. sorted = lib.OrderBy(x => x.Book).ToList();
  415. path = @"E:\BrSTU\CourseWork\csCourseWork\sorted.dat";
  416. using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)))
  417. foreach (var x in sorted)
  418. {
  419. writer.Write("---------------------");
  420. writer.Write(x.BinaryToString());
  421. writer.Write("\r\n");
  422. }
  423. break;
  424. case 4:
  425. sorted = lib.OrderBy(x => x.Copies).ToList();
  426. path = @"E:\BrSTU\CourseWork\csCourseWork\sorted.dat";
  427. using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)))
  428. foreach (var x in sorted)
  429. {
  430. writer.Write("---------------------");
  431. writer.Write(x.BinaryToString());
  432. writer.Write("\r\n");
  433. }
  434. break;
  435. case 5:
  436. sorted = lib.OrderBy(x => x.Price).ToList();
  437. path = @"E:\BrSTU\CourseWork\csCourseWork\sorted.dat";
  438. using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)))
  439. foreach (var x in sorted)
  440. {
  441. writer.Write("---------------------");
  442. writer.Write(x.BinaryToString());
  443. writer.Write("\r\n");
  444. }
  445. break;
  446. default:
  447. Console.WriteLine("Wrong numbers inputed");
  448. Sort(lib, objects, ref i);
  449. break;
  450. }
  451. }
  452. }
  453.  
  454. catch(Exception e)
  455. {
  456. Console.WriteLine("Sort failed");
  457. Console.WriteLine(e.Message);
  458. Sort(lib, objects, ref i);
  459. }
  460. finally
  461. {
  462. Console.WriteLine("Sorted sucsessfully");
  463. Menu(lib, objects, ref i);
  464. }
  465. }
  466. private static void Read(List<Library> lib, Library[] objects, ref int i)
  467. {
  468. try
  469. {
  470. using (StreamReader reader = new StreamReader(@"E:\BrSTU\CourseWork\csCourseWork\display.txt", System.Text.Encoding.Default))
  471. {
  472. string line;
  473. int size=-1;
  474. int iterator=0;
  475. while ((line=reader.ReadLine())!= null)
  476. {
  477. if (size < objects.Length)
  478. {
  479. if (iterator == 0 || iterator % 6 == 0)
  480. {
  481. iterator = 0;
  482. iterator++;
  483. size++;
  484. i++;
  485. lib.Add(objects[size]);
  486. }
  487. else
  488. {
  489. line = line.Remove(0, line.LastIndexOf(":") + 2);
  490. switch(iterator)
  491. {
  492. case 1:
  493. objects[size].Number = int.Parse(line);
  494. break;
  495. case 2:
  496. objects[size].Author = line;
  497. break;
  498. case 3:
  499. objects[size].Book = line;
  500. break;
  501. case 4:
  502. objects[size].Copies = int.Parse(line);
  503. break;
  504. case 5:
  505. objects[size].Price = double.Parse(line);
  506. break;
  507. default:
  508. Console.WriteLine("Error");
  509. break;
  510. }
  511. iterator++;
  512. }
  513. }
  514. }
  515. }
  516. }
  517. catch(Exception e)
  518. {
  519. Console.WriteLine(e.Message);
  520. Read(lib, objects, ref i);
  521. }
  522. finally
  523. {
  524. Console.WriteLine("Readen from file succesfull!");
  525. Menu(lib, objects, ref i);
  526. }
  527. }
  528.  
  529. private static void InsertAt(List<Library> lib, Library[] objects, ref int i)
  530. {
  531. try
  532. {
  533. if(lib.Count<2)
  534. {
  535. Console.WriteLine("You need at least 2 objects");
  536. Add(lib, objects, ref i);
  537. }
  538. int index;
  539. Console.Write("Where do you want to insert objects?:");
  540. index = int.Parse(Console.ReadLine());
  541. if (index < lib.Count)
  542. {
  543. Console.WriteLine("----------------------------");
  544. Console.WriteLine($"input {index} field");
  545.  
  546. Console.WriteLine("Input inventory number");
  547. objects[i].Number = int.Parse(Console.ReadLine());
  548.  
  549. Console.WriteLine("Input author of book");
  550. objects[i].Author = Console.ReadLine();
  551.  
  552. Console.WriteLine("Input book name");
  553. objects[i].Book = Console.ReadLine();
  554.  
  555. Console.WriteLine("Input amount of copies");
  556. objects[i].Copies = int.Parse(Console.ReadLine());
  557.  
  558. Console.WriteLine("Input price of book");
  559. objects[i].Price = Double.Parse(Console.ReadLine());
  560.  
  561. Console.WriteLine("----------------------------");
  562. lib.Insert(index - 1, objects[i]);
  563. i++;
  564. }
  565. else
  566. Console.WriteLine($"You cant add objects anymore OR Wrong index[1-{lib.Count}]");
  567. Menu(lib, objects, ref i);
  568. }
  569. catch(Exception e)
  570. {
  571. Console.WriteLine(e.Message);
  572. InsertAt(lib, objects, ref i);
  573. }
  574. }
  575.  
  576. private static void ConditionalDelete(List<Library> lib, Library[] objects, ref int i)
  577. {
  578. try
  579. {
  580. if(lib.Count==0)
  581. {
  582. Console.WriteLine("No objects to delete");
  583. }
  584. else
  585. {
  586. int choice;
  587. Console.Write("Which conditional do you want to use?\n1-priсe\n2-copies amount\n3-inventory number:");
  588. choice = int.Parse(Console.ReadLine());
  589. switch (choice)
  590. {
  591. case 1:
  592. int flag;
  593. int number;
  594. Console.Write("which conditional do you want to use?\n0: < than number\n1 > than number\n?:");
  595. flag = int.Parse(Console.ReadLine());
  596. if (flag == 1)
  597. {
  598. Console.Write("input number:");
  599. number = int.Parse(Console.ReadLine());
  600. for (int j = 0; j < i; j++)
  601. {
  602. if (lib[j].Price > number)
  603. {
  604. lib.RemoveAt(j);
  605. i--;
  606. j--;
  607. }
  608. }
  609. }
  610. else if (flag == 0)
  611. {
  612. Console.Write("input number:");
  613. number = int.Parse(Console.ReadLine());
  614. for (int j = 0; j < i; j++)
  615. {
  616. if (lib[j].Price < number)
  617. {
  618. lib.RemoveAt(j);
  619. i--;
  620. j--;
  621. }
  622. }
  623. }
  624. else
  625. {
  626. Console.WriteLine("Wron flag[0-1] only");
  627. ConditionalDelete(lib, objects, ref i);
  628. }
  629. break;
  630. case 2:
  631. Console.Write("which conditional do you want to use?\n0: < than number\n1 > than number\n?:");
  632. flag = int.Parse(Console.ReadLine());
  633. if (flag == 1)
  634. {
  635. Console.Write("input number:");
  636. number = int.Parse(Console.ReadLine());
  637. for (int j = 0; j < i; j++)
  638. {
  639. if (lib[j].Copies > number)
  640. {
  641. lib.RemoveAt(j);
  642. i--;
  643. j--;
  644. }
  645. }
  646. }
  647. else if (flag == 0)
  648. {
  649. Console.Write("input number:");
  650. number = int.Parse(Console.ReadLine());
  651. for (int j = 0; j < i; j++)
  652. {
  653. if (lib[j].Copies < number)
  654. {
  655. lib.RemoveAt(j);
  656. i--;
  657. j--;
  658. }
  659. }
  660. }
  661. else
  662. {
  663. Console.WriteLine("Wron flag[0-1] only");
  664. ConditionalDelete(lib, objects, ref i);
  665. }
  666. break;
  667. case 3:
  668. Console.Write("which conditional do you want to use?\n0: < than number\n1 > than number\n?:");
  669. flag = int.Parse(Console.ReadLine());
  670. if (flag == 1)
  671. {
  672. Console.Write("input number:");
  673. number = int.Parse(Console.ReadLine());
  674. for (int j = 0; j < i; j++)
  675. {
  676. if (lib[j].Number > number)
  677. {
  678. lib.RemoveAt(j);
  679. i--;
  680. j--;
  681. }
  682. }
  683. }
  684. else if (flag == 0)
  685. {
  686. Console.Write("input number:");
  687. number = int.Parse(Console.ReadLine());
  688. for (int j = 0; j < i; j++)
  689. {
  690. if (lib[j].Number < number)
  691. {
  692. lib.RemoveAt(j);
  693. i--;
  694. j--;
  695. }
  696. }
  697. }
  698. else
  699. {
  700. Console.WriteLine("Wron flag[0-1] only");
  701. ConditionalDelete(lib, objects, ref i);
  702. }
  703. break;
  704. default:
  705. Console.WriteLine("Wrong number![1-3]only");
  706. ConditionalDelete(lib, objects, ref i);
  707. break;
  708. }
  709. }
  710. Menu(lib, objects, ref i);
  711. }
  712. catch(Exception e)
  713. {
  714. Console.WriteLine(e.Message);
  715. ConditionalDelete(lib, objects, ref i);
  716. }
  717. }
  718.  
  719. private static void MinMax(List<Library> lib, Library[] objects, ref int i)
  720. {
  721. try
  722. {
  723. if (lib.Count == 0)
  724. {
  725. Console.WriteLine("No objects to search");
  726. }
  727. else
  728. {
  729. int choice;
  730. int minDiap;
  731. int maxDiap;
  732. double max;
  733. double min;
  734. Console.Write("Which field do you want to use?\n1-priсe\n2-copies amount\n3-inventory number:");
  735. choice = int.Parse(Console.ReadLine());
  736. Console.Write("input minimal diapasone value:");
  737. minDiap = int.Parse(Console.ReadLine());
  738. Console.Write("input maximum diapasone value:");
  739. maxDiap = int.Parse(Console.ReadLine());
  740. switch (choice)
  741. {
  742. case 1:
  743. max = 0;
  744. min = Int32.MaxValue;
  745. for (int j = 0; j < i; j++)
  746. {
  747. if (lib[j].Price >= minDiap && lib[j].Price <= maxDiap)
  748. {
  749. if (max <= lib[j].Price)
  750. {
  751. max = lib[j].Price;
  752. }
  753. if (min >= lib[j].Price)
  754. {
  755. min = lib[j].Price;
  756. }
  757. }
  758. }
  759. if (max == 0 || min == Int32.MaxValue)
  760. {
  761. Console.WriteLine("No numbers found in given diapasone");
  762. }
  763. else
  764. {
  765. Console.WriteLine($"minimal price is:{min}");
  766. Console.WriteLine($"maximal price is:{max}");
  767. }
  768. break;
  769. case 2:
  770. max = 0;
  771. min = Int32.MaxValue;
  772. for (int j = 0; j < i; j++)
  773. {
  774. if (lib[j].Copies >= minDiap && lib[j].Copies <= maxDiap)
  775. {
  776. if (max <= lib[j].Copies)
  777. {
  778. max = lib[j].Copies;
  779. }
  780. if (min >= lib[j].Copies)
  781. {
  782. min = lib[j].Copies;
  783. }
  784. }
  785. }
  786. if (max == 0 || min == Int32.MaxValue)
  787. {
  788. Console.WriteLine("No numbers found in given diapasone");
  789. }
  790. else
  791. {
  792. Console.WriteLine($"minimal copies amount is:{min}");
  793. Console.WriteLine($"maximal copies amount is:{max}");
  794. }
  795. break;
  796. case 3:
  797. max = 0;
  798. min = Int32.MaxValue;
  799. for (int j = 0; j < i; j++)
  800. {
  801. if (lib[j].Number >= minDiap && lib[j].Number <= maxDiap)
  802. {
  803. if (max <= lib[j].Number)
  804. {
  805. max = lib[j].Number;
  806. }
  807. if (min >= lib[j].Number)
  808. {
  809. min = lib[j].Number;
  810. }
  811. }
  812. }
  813. if (max == 0 || min == Int32.MaxValue)
  814. {
  815. Console.WriteLine("No numbers found in given diapasone");
  816. }
  817. else
  818. {
  819. Console.WriteLine($"minimal inventory number is:{min}");
  820. Console.WriteLine($"maximal inventory number is:{max}");
  821. }
  822. break;
  823. default:
  824. Console.WriteLine("Wrong number![1-3]only");
  825. MinMax(lib, objects, ref i);
  826. break;
  827. }
  828. }
  829. Menu(lib, objects, ref i);
  830. }
  831. catch (Exception e)
  832. {
  833. Console.WriteLine(e.Message);
  834. MinMax(lib, objects, ref i);
  835. }
  836. }
  837. }
  838. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!