ulvis.paste.net

Paste Search Dynamic
Recent pastes
KARTA 1
  1. using system;
  2. using system.Collections.Generic;
  3. using system.Linq;
  4. using system.Text;
  5. using system.Threading.Tasks;
  6. using system.IO;
  7.  
  8. namespace Worker
  9. {
  10.     enum Position { Junior = 1, Regular = 2, Senior = 3 };
  11.  
  12.     class Worker
  13.     {
  14.         public string Name;
  15.         public string Surname { get; set; }
  16.         public DateTime Date { get; set; }
  17.         private double toCover;
  18.         public double Salary
  19.         {
  20.             get
  21.             {
  22.                 return toCover;
  23.             }
  24.             set
  25.             {
  26.                 toCover = value;
  27.             }
  28.         }
  29.         public Position Position;
  30.         public Worker(string name, string surname, DateTime date, double salary, Position position)
  31.         {
  32.             Name = name;
  33.             Surname = surname;
  34.             Date = date;
  35.             Salary = salary;
  36.             Position = position;
  37.  
  38.         }
  39.  
  40.     }
  41.    class Program
  42.     {
  43.  
  44.         /// <summary>
  45.         /// This method take generic list of workers, write output to console and change name of position
  46.         ///  for user friendly language
  47.         /// </summary>
  48.         /// <param name="workers"></param>
  49.         ///
  50.         public static void WriteInfoAboutEmployees(List<Worker> workers)
  51.         {
  52.             workers.foreach(delegate(Worker ex)
  53.             {
  54.  
  55.                 Console.WriteLine("Imię: " + ex.Name);
  56.                 Console.WriteLine("Nazwisko: " + ex.Surname);
  57.                 Console.WriteLine("Data urodzenia: " + ex.Date);
  58.                 Console.WriteLine("Wynagrodzenie: " + ex.Salary);
  59.                 switch (ex.Position)
  60.                 {
  61.                     case Position.Junior:
  62.                         Console.WriteLine("Stanowisko: " + "Młodszy programista");
  63.                         break;
  64.                     case Position.Regular:
  65.                         Console.WriteLine("Stanowisko: " + "Programista");
  66.                         break;
  67.                     case Position.Senior:
  68.                         Console.WriteLine("Stanowisko: " + "Starszy programista");
  69.                         break;
  70.                 }
  71.             });
  72.         }
  73.  
  74.         public static void SaveWorkersToFile(List<Worker> workers)
  75.         {
  76.             File.WriteAllText(@"infoAboutWorkers.txt", string.Empty);
  77.             TextWriter info = new StreamWriter("infoAboutWorkers.txt");
  78.             workers.foreach(delegate(Worker ex)
  79.             {
  80.                 info.WriteLine("Imię: " + ex.Name);
  81.                 info.WriteLine("NazwiskoAs: " + ex.Surname);
  82.                 info.WriteLine("Data urodzenia: " + ex.Date);
  83.                 info.WriteLine("Wynagrodzenie: " + ex.Salary);
  84.                 info.WriteLine("Stanowisko: " + ex.Position);
  85.             });
  86.  
  87.             info.Close();
  88.         }
  89.        public static Worker SearchWorker(string FindItem,List<Worker> workers )
  90.        {
  91.  
  92.                 foreach (Worker worker in workers)
  93.             {
  94.  
  95.                if(worker.Name.Equals(FindItem))
  96.                    return worker;
  97.               }
  98.  
  99.             return null;
  100.        }
  101.         class MeanSalaryCalculator
  102.         {
  103.             public MeanSalaryCalculator()
  104.             {
  105.             }
  106.             public double CalculateForAgeRange(int up, int down,List<Worker> workers )
  107.             {
  108.                 double result = 0;
  109.                 DateTime oldest=new DateTime(up,01,01);
  110.                 DateTime youngest=new DateTime(down,01,01);
  111.                 List<double> salary=new List<double>();
  112.                 workers.foreach(delegate(Worker employeesWhichFitToRange)
  113.                  {
  114.                      if ((employeesWhichFitToRange.Date > oldest) && (employeesWhichFitToRange.Date < youngest))
  115.                      {
  116.                          salary.Add(employeesWhichFitToRange.Salary);
  117.                         result =+ salary.Average();
  118.  
  119.                      }
  120.                  });
  121.                 return result;
  122.             }
  123.         }
  124.         static void Main(string[] args)
  125.         {
  126.             List<Worker> workers = new List<Worker>();
  127.             Worker worker = new Worker("Anna", "Nowak", new DateTime(1980, 02, 10), 110230.02, Position.Senior);
  128.             Worker worker2 = new Worker("Aneta", "Kowalska", new DateTime(1973, 09, 02), 2340.02, Position.Junior);
  129.             Worker worker3 = new Worker("Jan", "Kowalski", new DateTime(1990, 03, 20), 5678.98, Position.Regular);
  130.  
  131.             workers.Add(worker);
  132.             workers.Add(worker2);
  133.             workers.Add(worker3);
  134.  
  135.             var ms = new MeanSalaryCalculator();
  136.             var guess = ms.CalculateForAgeRange(1969, 1991, workers);
  137.             Console.WriteLine("średnie wynagrodzenie: " + guess);
  138.  
  139.             if (SearchWorker("Jan", workers) != null)
  140.             {
  141.                 Console.WriteLine("Pensja tego pracownika: "+SearchWorker("Jan", workers).Salary);
  142.             }
  143.             else
  144.             {
  145.                 Console.WriteLine("Pensja tego pracownika: " + 0);
  146.             }
  147.  
  148.  
  149.  
  150.             #if (DEBUG)
  151.             WriteInfoAboutEmployees(workers);
  152.             #else
  153.             SaveWorkersToFile(workers);
  154.             #endif
  155.  
  156.  
  157.  
  158.         }
  159.  
  160.     }
  161. }
  162.  
  163.  
  164. KARTA 2
  165.  
  166.  
  167.  
  168.   using system;
  169. using system.Collections.Generic;
  170. using system.Linq;
  171. using system.Text;
  172. using system.Threading.Tasks;
  173.  
  174. namespace ConsoleApplication2
  175. {
  176.     struct Samochod1
  177.     {
  178.         public string Color;
  179.         public Samochod1(string co)
  180.         {
  181.             Color = co;
  182.         }
  183.     }
  184.     class Samochod2
  185.     {
  186.         public string Color;
  187.         public Samochod2(string s)
  188.         {
  189.             this.Color = s;
  190.         }
  191.     }
  192.     class Program
  193.     {
  194.         static public void PaintSamochod1(Samochod1 car)
  195.         {
  196.             car.Color = "czerwony";
  197.         }
  198.         static public void PaintSamochod2(Samochod2 car)
  199.         {
  200.             car.Color = "czerwony";
  201.         }
  202.         static void Main(string[] args)
  203.         {
  204.  
  205.             Samochod1 s1 = new Samochod1("niebieski");
  206.             Samochod2 s2 = new Samochod2("niebieski");
  207.  
  208.             Console.WriteLine(s1.Color);
  209.             Console.WriteLine(s2.Color);
  210.             PaintSamochod1(s1);
  211.             PaintSamochod2(s2);
  212.             Console.WriteLine(s1.Color);
  213.             Console.WriteLine(s2.Color);
  214.         }
  215.     }
  216. }
  217.  
  218.  
  219.  
  220. using system;
  221. using system.Collections.Generic;
  222. using system.Linq;
  223. using system.Text;
  224. using system.Threading.Tasks;
  225. using system.Diagnostics;
  226.  
  227. namespace Drugie
  228. {
  229.  
  230.  
  231.     class Program
  232.     {
  233.  
  234.         static void Main(string[] args)
  235.         {
  236.  
  237.             int[] table;
  238.             table = new int[100000000];
  239.             Random rnd = new Random();
  240.             Stopwatch stopWatch = new Stopwatch();
  241.             stopWatch.Start();
  242.             for (int i = 0; i < 100000000; i++ )
  243.             {
  244.                 table[i] = rnd.Next(0, 100000000);
  245.             }
  246.             stopWatch.Stop();
  247.             TimeSpan ts = stopWatch.Elapsed;
  248.             // Format and display the TimeSpan value.
  249.             string elapsedTime = string.Format("{0:00}:{1:00}:{2:00}.{3:00}",
  250.                 ts.Hours, ts.Minutes, ts.Seconds,
  251.                 ts.Milliseconds / 10);
  252.             Console.WriteLine("INICJALIZACJA" + elapsedTime);
  253.             int los=rnd.Next(0, 100000000-1);
  254.             int found;
  255.             Stopwatch stopWatch2 = new Stopwatch();
  256.             stopWatch2.Start();
  257.             found = Array.IndexOf(table, los);
  258.             stopWatch2.Stop();
  259.             TimeSpan ts2 = stopWatch2.Elapsed;
  260.             // Format and display the TimeSpan value.
  261.             string elapsedTime2 = string.Format("{0:00}:{1:00}:{2:00}.{3:00}",
  262.                 ts2.Hours, ts2.Minutes, ts2.Seconds,
  263.                 ts2.Milliseconds / 10);
  264.             Console.WriteLine("szukanie nieposort" + elapsedTime2);
  265.  
  266.             Stopwatch stopWatch3 = new Stopwatch();
  267.             stopWatch3.Start();
  268.             Array.Sort(table);
  269.             stopWatch3.Stop();
  270.             TimeSpan ts3 = stopWatch3.Elapsed;
  271.             // Format and display the TimeSpan value.
  272.             string elapsedTime3 = string.Format("{0:00}:{1:00}:{2:00}.{3:00}",
  273.                 ts3.Hours, ts3.Minutes, ts3.Seconds,
  274.                 ts3.Milliseconds / 10);
  275.             Console.WriteLine("szukanie sort" + elapsedTime3);
  276.  
  277.             Stopwatch stopWatch4 = new Stopwatch();
  278.             stopWatch4.Start();
  279.             int index1=Array.BinarySearch(table,12);
  280.             stopWatch4.Stop();
  281.             TimeSpan ts4 = stopWatch4.Elapsed;
  282.             // Format and display the TimeSpan value.
  283.             string elapsedTime4 = string.Format("{0:00}:{1:00}:{2:00}.{3:00}",
  284.                 ts4.Hours, ts3.Minutes, ts3.Seconds,
  285.                 ts4.Milliseconds / 10);
  286.  
  287.             Console.WriteLine("binary search" + elapsedTime4);
  288.  
  289.  
  290.  
  291.         }
  292.     }
  293. }
  294.  
  295.  
  296.  
  297.  
  298.  
  299.  
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315. using system;
  316. using system.Collections.Generic;
  317. using system.Linq;
  318. using system.Text;
  319. using system.Threading.Tasks;
  320. using system.Diagnostics;
  321.  
  322. namespace Drugie
  323. {
  324.  
  325.  
  326.     class Program
  327.     {
  328.         static int DoSomething(params int[] value)
  329.         {
  330.             return value.Length;
  331.         }
  332.  
  333.         static string[] SearchString(ref string[] tab)
  334.         {
  335.             string[] result = new string[5];
  336.             result = tab.FindAll();
  337.             Console.WriteLine(result);
  338.             return result;
  339.         }
  340.         static void Main(string[] args)
  341.         {
  342.             string[] tab;
  343.             tab = new string[5];
  344.             tab[0]="Nowa";
  345.             tab[1]=string.Empty;
  346.             tab[2]="stingowa";
  347.             tab[3]=string.Empty;
  348.             tab[3] = "tablica";
  349.            // SearchString(tab);
  350.            // string[] result = new string[5];
  351.            // result = SearchString(ref tab);
  352.             int res = 1;
  353.  
  354.             Console.WriteLine(DoSomething(1,2,3,4,4,4));
  355.  
  356.  
  357.         }
  358.     }
  359. }
  360.  
  361.  
  362.  
  363.   using system;
  364. using system.Collections.Generic;
  365. using system.Linq;
  366. using system.Text;
  367. using system.Threading.Tasks;
  368. using system.Diagnostics;
  369. using system.Collections;
  370. using Drugie;
  371.  
  372. namespace Drugie
  373. {
  374.     interface IComparer<Person>
  375.     {
  376.         void Sortuj();
  377.     }
  378.     class Person {
  379.         int Age;
  380.         private Dictionary<int, int> ascending;
  381.  
  382.         Person(Dictionary<int, int> dc)
  383.         {
  384.             dc = new Dictionary<int, int>();
  385.             dc.Add(2, 2);
  386.  
  387.         }
  388.     }
  389.     class PersonSorter
  390.     {
  391.         Person(Dictionary<int, int> dc)
  392.         {
  393.             dc = new Dictionary<int, int>();
  394.             dc.Add(1, 1);
  395.  
  396.         }
  397.         private Dictionary<int,int> ascending;
  398.         PersonSorter(Dictionary<int, int> dc)
  399.         {
  400.             dc = new Dictionary<int, int>();
  401.             dc.Add(2, 2);
  402.         }
  403.  
  404.         public PersonSorter()
  405.         {
  406.         }
  407.  
  408.         private class AgeCompare
  409.         {
  410.             private Array ps;
  411.  
  412.             void Sortuj()
  413.             {
  414.             //    Array.Sort(ps, delegate (Person x, Person y) {
  415.                     //return (x.Age.CompareTo(y.Age); });
  416.  
  417.               //  });
  418.                 Console.WriteLine("test");
  419.             }
  420.  
  421.             //
  422.  
  423.             }
  424.         }
  425.      }
  426.  
  427.  
  428.     class Program
  429.     {
  430.         static int DoSomething(params int[] value)
  431.         {
  432.             return value.Length;
  433.         }
  434.  
  435.         static string[] SearchString(ref string[] tab)
  436.         {
  437.             string[] result = new string[5];
  438.             string[] list= new string[5];
  439.            // var newList = list.FindAll(tab => tab !="");
  440.            // Console.WriteLine(newList);
  441.             return result;
  442.         }
  443.         static void Main(string[] args)
  444.         {
  445.  
  446.  
  447.         PersonSorter ps = new PersonSorter();
  448.  
  449.         }
  450.     }
  451.  
  452.  
  453.  
  454.  
  455. http://www.altcontroldelete.pl/artykuly/operacje-na-kolekcjach-w-c-/
  456. results = Books.FindAll(
  457.             delegate(Book bk)
  458.             {
  459.                 return bk.Price < 10.00;
  460.             }
  461.             );
  462.             if (results.Count != 0)
  463.             {
  464.                 DisplayResults(results, "Books under $10:");
  465.             }
  466.             else
  467.             {
  468.                 Console.WriteLine("\nNo books found.");
  469.             }
  470.  
  471.  
  472. var list = new List<string>();
  473. var newList = list.FindAll(s => s.Equals("match"));
  474.  
  475. zamiast
  476.  
  477. newList = list.FindAll(delegate(string s){return s == "match";});
  478.  
  479. delegate zastepuje (s=>s.Equals("match"));
  480.          string[] tab;
  481.             tab = new string[5];
  482.             tab[0] = "Nowa";
  483.             tab[1] = string.Empty;
  484.             tab[2] = "stingowa";
  485.             tab[3] = string.Empty;
  486.             tab[3] = "tablica";
  487.  
  488.             List<int> IntNumbers = new List<int>();
  489.             IntNumbers.Add(2);
  490.             IntNumbers.Add(3);
  491.             IntNumbers.Add(2);
  492.             IntNumbers.foreach(delegate (int ex)
  493.             {
  494.  
  495.                 Console.WriteLine("Lista " + ex);
  496.             });
  497.  
  498.             IntNumbers.Remove(2);
  499.             IntNumbers.Remove(2);
  500.             IntNumbers.foreach(delegate (int ex)
  501.             {
  502.  
  503.                 Console.WriteLine("Lista po skasowaniu " + ex);
  504.             });
  505.  
  506.             Dictionary<string, string> angPol = new Dictionary<string, string>();
  507.             angPol.Add("cat", "kot");
  508.             angPol.Add("dog", "pies");
  509.             angPol.Add("rabbit", "krolik");
  510.  
  511.             foreach (KeyValuePair<string,string> pair in angPol)
  512.             {
  513.                 string key = pair.Key;
  514.                 dynamic value = pair.Value;
  515.                 Console.WriteLine("Dictionary: "+ key+ " "+ value);
  516.             }
  517.             angPol.Remove("cat");
  518.  
  519.  
  520.             foreach (KeyValuePair<string, string> pair in angPol)
  521.             {
  522.                 string key = pair.Key;
  523.                 dynamic value = pair.Value;
  524.                 Console.WriteLine("Dictionary after delete: " + key + " " + value);
  525.             }
  526.             Queue testQueue = new Queue();
  527.             testQueue.Enqueue("Hello");
  528.             testQueue.Enqueue("World");
  529.             testQueue.Enqueue("!");
  530.  
  531.             foreach(var i in testQueue)
  532.             {
  533.                 Console.WriteLine("Kolejka przed" + i );
  534.             }
  535.             testQueue.Dequeue();
  536.             foreach (var i in testQueue)
  537.             {
  538.                 Console.WriteLine("Kolejka po" + i);
  539.             }
  540.  
  541.             Stack stackOverflow = new Stack();
  542.             stackOverflow.Push("Hello");
  543.             stackOverflow.Push("World");
  544.             stackOverflow.Push("!");
  545.             foreach (var i in stackOverflow)
  546.             {
  547.                 Console.WriteLine("Stos przed" + i);
  548.             }
  549.             stackOverflow.Pop();
  550.             foreach (var i in stackOverflow)
  551.             {
  552.                 Console.WriteLine("Stos po" + i);
  553.             }
  554.  
  555.  
  556. /////kolekcje    komentarz robie ///i enter przed metoda
  557.  
  558. using system;
  559. using system.Collections.Generic;
  560. using system.Linq;
  561. using system.Text;
  562. using system.Threading.Tasks;
  563.  
  564. namespace ConsoleApplication3
  565. {
  566.     class Program
  567.     {
  568.         public class ExtendedDictionary<T>
  569.         {
  570.             T key;
  571.             private Dictionary<T, string> items;
  572.             private int sum;
  573.             public int Sum
  574.             {
  575.              get
  576.             {
  577.                 return sum;
  578.             }
  579.  
  580.             }
  581.  
  582.             public void Insert(T k, string ob)
  583.             {
  584.  
  585.                 sum++;
  586.                 items.Add(k,ob);
  587.  
  588.             }
  589.  
  590.             public void Delete(T k)
  591.             {
  592.                 items.Remove(k);
  593.                 sum--;
  594.             }
  595.         }
  596.  
  597.         static void Main(string[] args)
  598.         {
  599.             ExtendedDictionary<int> ed = new ExtendedDictionary<int>();
  600.             ExtendedDictionary<string> ed2 = new ExtendedDictionary<string>();
  601.             ExtendedDictionary<float> ed3 = new ExtendedDictionary<float>();
  602.           //  Console.WriteLine(ed.Sum);
  603.             ed.Insert(2,"kot");
  604.  
  605.  
  606.  
  607.                 Console.WriteLine("Dictionary: " + ed);
  608.  
  609.         }
  610.     }
  611. }
  612.  
  613. //wlasne generyczne typu
  614.  
  615.  
  616. using system;
  617. using system.Collections.Generic;
  618. using system.Linq;
  619. using system.Text;
  620. using system.Threading.Tasks;
  621.  
  622. namespace ConsoleApplication3
  623. {
  624.     class Program
  625.     {
  626.         public class ExtendedDictionary<T>
  627.         {
  628.             T key;
  629.             private Dictionary<T, string> items=new Dictionary<T, string>();
  630.             private int sum;
  631.             public int Sum
  632.             {
  633.                 get
  634.                 {
  635.                     return sum;
  636.                 }
  637.  
  638.             }
  639.  
  640.             public void Insert(T k, string ob)
  641.             {
  642.                 sum++;
  643.                 items.Add(k, ob);
  644.             }
  645.  
  646.             public void Delete(T k)
  647.             {
  648.                 items.Remove(k);
  649.                 sum--;
  650.             }
  651.         }
  652.  
  653.         static void Main(string[] args)
  654.         {
  655.             ExtendedDictionary<int> ed = new ExtendedDictionary<int>();
  656.             ExtendedDictionary<string> ed2 = new ExtendedDictionary<string>();
  657.             ExtendedDictionary<float> ed3 = new ExtendedDictionary<float>();
  658.             //  Console.WriteLine(ed.Sum);
  659.  
  660.             ed.Insert(2, "kot");
  661.             ed.Insert(3, "pies");
  662.             ed.Insert(4, "krowa");
  663.  
  664.             ed2.Insert("cow","krowa");
  665.             ed2.Insert("dog","pies");
  666.  
  667.             ed3.Insert((float)2.222222 ,"kot");
  668.             ed3.Insert((float)4.444, "krowa");
  669.  
  670.             ed3.Delete((float)4.444);
  671.             ed2.Delete("cow");
  672.             ed.Delete(2);
  673.  
  674.         }
  675.     }
  676. }
  677.  
  678.  
  679.  
  680. zad 6 z 3
  681.  
  682.   using system;
  683. using system.Collections.Generic;
  684. using system.Linq;
  685. using system.Text;
  686. using system.Threading.Tasks;
  687.  
  688. namespace ConsoleApplication6
  689. {
  690.     class Program
  691.     {
  692.  
  693.         public static T GetMiddleElement<T>(T[] tab) where T : struct
  694.         {
  695.            T mid = tab[tab.Length / 2];
  696.  
  697.             return mid;
  698.         }
  699.         static void Main(string[] args)
  700.         {
  701.  
  702.             int[] tab = new int[6];
  703.             for (int i=0;i<6;i++)
  704.             {
  705.                 tab[i] = i;
  706.             }
  707.  
  708.             Console.WriteLine(GetMiddleElement(tab));
  709.  
  710.         }
  711.     }
  712. }
  713.  
  714.  
  715.  
  716.  
  717. cos o nadpisywaniu metod i linq
  718.  
  719.  
  720.   using system;
  721. using system.Collections.Generic;
  722. using system.Linq;
  723. using system.Text;
  724. using system.Threading.Tasks;
  725.  
  726.     //Extension methods must be defined in a static class
  727.  
  728.  
  729. namespace ConsoleApplication6
  730. {
  731.     using Rozszerz; // Używanie przestrzeni nazw, w której znajdują się nasze metody rozszerzające
  732.  
  733.     class Program
  734.     {
  735.  
  736.  
  737.         static void Main(string[] args)
  738.         {
  739.  
  740.  
  741.             string tekst = "abcdef";
  742.             string tekst2 = "ala";
  743.          //   Console.WriteLine(tekst.ToUpper());
  744.          //   tekst = tekst.Insert(4, " Boduch").ToUpper().Replace("CH", "SZEK");
  745. //Console.WriteLine(String.Compare(tekst,tekst2));
  746.          //   Console.WriteLine(tekst);
  747.  
  748.          //   Console.WriteLine(String.Concat(tekst, tekst2));
  749.          //   Console.WriteLine(tekst.Length);
  750.            // Console.WriteLine(tekst.Contains("A"));
  751.  
  752.  
  753.             Console.WriteLine(tekst2.GetCharacterAsciiCode(1));
  754.             Console.WriteLine(tekst2.GetFirstCharacterAsciiCode());
  755.  
  756.  
  757.         }
  758.  
  759.  
  760.     }
  761. }
  762. namespace Rozszerz
  763. {
  764.     public static class StringExtension
  765.     {
  766.         // This is the extension method.
  767.         // The first parameter takes the "this" modifier
  768.         // and specifies the type for which the method is defined.\
  769.  
  770.         public static int GetFirstCharacterAsciiCode(this string input)
  771.         {
  772.             // Create two different encodings.
  773.             Encoding ascii = Encoding.ASCII;
  774.             Encoding unicode = Encoding.Unicode;
  775.  
  776.             // Convert the string into a byte array.
  777.             byte[] unicodeBytes = unicode.GetBytes(input);
  778.  
  779.             // Perform the conversion from one encoding to the other.
  780.             byte[] asciiBytes = Encoding.Convert(unicode, ascii, unicodeBytes);
  781.  
  782.  
  783.             return asciiBytes[0];
  784.         }
  785.         public static int GetCharacterAsciiCode(this string input, int sign)
  786.         {
  787.             // Create two different encodings.
  788.             Encoding ascii = Encoding.ASCII;
  789.             Encoding unicode = Encoding.Unicode;
  790.  
  791.             // Convert the string into a byte array.
  792.             byte[] unicodeBytes = unicode.GetBytes(input);
  793.  
  794.             // Perform the conversion from one encoding to the other.
  795.             byte[] asciiBytes = Encoding.Convert(unicode, ascii, unicodeBytes);
  796.  
  797.  
  798.             return asciiBytes[sign];
  799.         }
  800.     }
  801. }
  802.  
  803.  
  804.  
  805. 4.10 i 4.11
  806.  
  807.  
  808.   using system;
  809. using system.Collections.Generic;
  810. using system.Linq;
  811. using system.Text;
  812. using system.Threading.Tasks;
  813.  
  814.     //Extension methods must be defined in a static class
  815.  
  816.  
  817. namespace ConsoleApplication6
  818. {
  819.     using Rozszerz; // Używanie przestrzeni nazw, w której znajdują się nasze metody rozszerzające
  820.     using ExtendList;
  821.     class Program
  822.     {
  823.  
  824.  
  825.         static void Main(string[] args)
  826.         {
  827.  
  828.  
  829.             string tekst = "abcdef";
  830.             string tekst2 = "ala";
  831.          //   Console.WriteLine(tekst.ToUpper());
  832.          //   tekst = tekst.Insert(4, " Boduch").ToUpper().Replace("CH", "SZEK");
  833. //Console.WriteLine(String.Compare(tekst,tekst2));
  834.          //   Console.WriteLine(tekst);
  835.  
  836.          //   Console.WriteLine(String.Concat(tekst, tekst2));
  837.          //   Console.WriteLine(tekst.Length);
  838.            // Console.WriteLine(tekst.Contains("A"));
  839.  
  840.  
  841.             Console.WriteLine(tekst2.GetCharacterAsciiCode(1));
  842.             Console.WriteLine(tekst2.GetFirstCharacterAsciiCode());
  843.             List<double> liczby = new List<double>();
  844.             liczby.Add(2.03);
  845.             liczby.Add(5.03);
  846.             liczby.Add(23.02);
  847.             Console.WriteLine(liczby.Median());
  848.             liczby.RemoveEverySecondElement();
  849.  
  850.             liczby.foreach(delegate (double ex)
  851.             {
  852.  
  853.                 Console.WriteLine("Lista " + ex);
  854.             });
  855.         }
  856.  
  857.  
  858.     }
  859. }
  860. namespace Rozszerz
  861. {
  862.     public static class StringExtension
  863.     {
  864.         // This is the extension method.
  865.         // The first parameter takes the "this" modifier
  866.         // and specifies the type for which the method is defined.\
  867.  
  868.         public static int GetFirstCharacterAsciiCode(this string input)
  869.         {
  870.             // Create two different encodings.
  871.             Encoding ascii = Encoding.ASCII;
  872.             Encoding unicode = Encoding.Unicode;
  873.  
  874.             // Convert the string into a byte array.
  875.             byte[] unicodeBytes = unicode.GetBytes(input);
  876.  
  877.             // Perform the conversion from one encoding to the other.
  878.             byte[] asciiBytes = Encoding.Convert(unicode, ascii, unicodeBytes);
  879.  
  880.  
  881.             return asciiBytes[0];
  882.         }
  883.         public static int GetCharacterAsciiCode(this string input, int sign)
  884.         {
  885.             // Create two different encodings.
  886.             Encoding ascii = Encoding.ASCII;
  887.             Encoding unicode = Encoding.Unicode;
  888.  
  889.             // Convert the string into a byte array.
  890.             byte[] unicodeBytes = unicode.GetBytes(input);
  891.  
  892.             // Perform the conversion from one encoding to the other.
  893.             byte[] asciiBytes = Encoding.Convert(unicode, ascii, unicodeBytes);
  894.  
  895.  
  896.             return asciiBytes[sign];
  897.         }
  898.     }
  899. }
  900. namespace ExtendList
  901. {
  902.     static class ListExtended
  903.     {
  904.         public static void RemoveEverySecondElement<T>(this List<T> list)
  905.         {
  906.  
  907.             list.RemoveAt(1);
  908.  
  909.         }
  910.         public static double Median(this List<double> list)
  911.         {
  912.             // Create a copy of the input, and sort the copy
  913.             double[] temp = list.ToArray();
  914.             Array.Sort(temp);
  915.  
  916.             int count = temp.Length;
  917.             if (count == 0)
  918.             {
  919.                 throw new InvalidOperationException("Empty collection");
  920.             }
  921.             else if (count % 2 == 0)
  922.             {
  923.                 // count is even, average two middle elements
  924.                 double a = temp[count / 2 - 1];
  925.                 double b = temp[count / 2];
  926.                 return (a + b) / 2;
  927.             }
  928.             else
  929.             {
  930.                 // count is odd, return the middle element
  931.                 return temp[count / 2];
  932.             }
  933.         }
  934.     }
  935. }
  936.  
  937.  
  938.  
  939.  
  940.  
  941.  
  942.  
  943.  
  944.  
  945.  
  946.  
  947.  
  948.  
  949.  
  950.  
  951.  
  952. using system;
  953. using system.Collections.Generic;
  954. using system.Linq;
  955. using system.Text;
  956. using system.Threading.Tasks;
  957.  
  958. namespace ConsoleApplication7
  959. {
  960.     public class Person
  961.     {
  962.         public string name;
  963.         public string surname;
  964.         public string data
  965.         {
  966.             set
  967.             {
  968.                 data = name + " " + surname;
  969.  
  970.             }
  971.         }
  972.          public Person(string n, string s)
  973.         {
  974.             n = this.name;
  975.             s = this.surname;
  976.  
  977.         }
  978.  
  979.         public Person()
  980.         {
  981.  
  982.             name = "Ania";
  983.             surname = "Kowalska";
  984.  
  985.         }
  986.  
  987.     }
  988.         class Program
  989.         {
  990.             static void Main(string[] args)
  991.             {
  992.            Person persona = new Person { name="Adam", surname="Krascko" };
  993.             Console.WriteLine(persona.name + " " + persona.surname);
  994.             Person p = new Person();
  995.                 Console.WriteLine(p.name+ " "+p.surname);
  996.                 Person p2 = new Person();
  997.               p2.name = "Nora";
  998.                 p2.surname = "Nowak";
  999.             Console.WriteLine(p2.name +" " + p2.surname);
  1000.             //inicjalizator kolekcji
  1001.             List<Person> people = new List<Person> { new Person("Ala", "Nowak"), new Person("Noe", "Kowalski"), new Person("Ada", "Bialoszewska") };
  1002.  
  1003.             //standardowa inicjalizacja
  1004.             List<Person> p1 = new List<Person>();
  1005.             p1.Add(new Person("Ala","Nowak"));
  1006.             p1.Add(new Person("Noe","Kowalski"));
  1007.             p1.Add(new Person("Ada","Bialoszewska"));
  1008.  
  1009.         }
  1010.         }
  1011.     }
  1012.  
  1013.  
  1014.  
  1015.  
  1016.  
  1017. using system;
  1018. using system.Collections.Generic;
  1019. using system.Linq;
  1020. using system.Text;
  1021. using system.Threading.Tasks;
  1022.  
  1023. namespace ConsoleApplication8
  1024. {
  1025.     public class StringDictionaryWithAlternative
  1026.     {
  1027.         private Dictionary<string,string> elements;
  1028.         public void Add(string key, string value)
  1029.         {
  1030.             elements.Add(key, value);
  1031.  
  1032.         }
  1033.         public string this[string key,string keyAlter]
  1034.         {
  1035.             get
  1036.             {
  1037.  
  1038.                 foreach (KeyValuePair<string, string> pair in elements)
  1039.                 {
  1040.                     string ne = pair.Key;
  1041.                     dynamic value = pair.Value;
  1042.                     return Console.WriteLine("Dictionary: " + ne + " " + value);
  1043.                     if( ne== pair.Key)
  1044.                     {
  1045.                         return ne;
  1046.                     }
  1047.                     else
  1048.                     {
  1049.  
  1050.                     }
  1051.                 }
  1052.  
  1053.  
  1054.  
  1055.  
  1056.  
  1057.                 }
  1058.             }
  1059.  
  1060.         }
  1061.     }
  1062.     class Program
  1063.     {
  1064.         static void Main(string[] args)
  1065.         {
  1066.  
  1067.  
  1068.             StringDictionaryWithAlternative sda = new StringDictionaryWithAlternative();
  1069.  
  1070.         }
  1071.     }
  1072.  
  1073.  
  1074. }
  1075.  
  1076.  
  1077.  
  1078.  
  1079. INDEKSERY - WAZNE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  1080.   using system;
  1081. using system.Collections.Generic;
  1082. using system.Linq;
  1083. using system.Text;
  1084. using system.Threading.Tasks;
  1085.  
  1086. namespace ConsoleApplication8
  1087. {
  1088.     public class Building
  1089.     {
  1090.         string color { get; set; }
  1091.         string type { get; set; }
  1092.         string year { get; set; }
  1093.     }
  1094.     public class StringDictionaryWithAlternative
  1095.     {
  1096.         private Dictionary<string,string> elements=new Dictionary<string, string>();
  1097.         public void Add(string key, string value)
  1098.         {
  1099.             elements.Add(key, value);
  1100.  
  1101.         }
  1102.         public string this[string key,string keyAlter]
  1103.         {
  1104.             get
  1105.             {
  1106.                 string Result="";
  1107.  
  1108.                 foreach (KeyValuePair<string, string> pair in elements)
  1109.                 {
  1110.                     string ne = pair.Key;
  1111.  
  1112.                     dynamic value = pair.Value;
  1113.  
  1114.                     if (key == ne)
  1115.                     {
  1116.                         Result = key;
  1117.                         Result = ne + " " + value;
  1118.  
  1119.                     }
  1120.                     else if (keyAlter == ne)
  1121.                     {
  1122.                         Result = keyAlter;
  1123.                         Result = ne + " " + value;
  1124.  
  1125.                     }
  1126.  
  1127.                 }
  1128.  
  1129.                 return Result;
  1130.  
  1131.                 }
  1132.             }
  1133.  
  1134.  
  1135.     }
  1136.     class Program
  1137.     {
  1138.         static void Main(string[] args)
  1139.         {
  1140.  
  1141.  
  1142.            StringDictionaryWithAlternative sda = new StringDictionaryWithAlternative();
  1143.             sda.Add("kot","bonifacy");
  1144.             sda.Add("alicja", "bachleda-curus");
  1145.             sda.Add("Adam", "Kowalski");
  1146.             string Result;
  1147.             Result=sda["Ada", "Adam"];
  1148.             Result = sda["kot", "Adeine"];
  1149.             Result = sda["nic", "niezajde"];
  1150.             Result = sda["kot", "Adam"];
  1151.             Result = sda["bonifacy", "Kowalski"];
  1152.  
  1153.  
  1154.             Console.WriteLine(Result);
  1155.         }
  1156.     }
  1157.  
  1158.  
  1159. }
  1160.  
  1161.  
  1162.  
  1163. using system;
  1164. using system.Collections.Generic;
  1165. using system.Linq;
  1166. using system.Text;
  1167. using system.Threading.Tasks;
  1168. using system.Text.RegularExpressions;
  1169.  
  1170.  
  1171. namespace ConsoleApplication8
  1172. {
  1173.     public class Building : IEquatable<Building>
  1174.     {
  1175.         public string Color { get; set; }
  1176.         public string Type { get; set; }
  1177.         public string Year { get; set; }
  1178.  
  1179.         public bool Equals(Building other)
  1180.         {
  1181.             if (other == null)
  1182.                 return false;
  1183.  
  1184.             if (this.Color == other.Color && this.Type==other.Type && this.Year==other.Year)
  1185.                 return true;
  1186.  
  1187.             else
  1188.                 return false;
  1189.         }
  1190.     }
  1191.     public class StringDictionaryWithAlternative
  1192.     {
  1193.         private Dictionary<string,string> elements=new Dictionary<string, string>();
  1194.         public void Add(string key, string value)
  1195.         {
  1196.             elements.Add(key, value);
  1197.  
  1198.         }
  1199.         public string this[string key,string keyAlter]
  1200.         {
  1201.             get
  1202.             {
  1203.                 string Result="";
  1204.  
  1205.                 foreach (KeyValuePair<string, string> pair in elements)
  1206.                 {
  1207.                     string ne = pair.Key;
  1208.  
  1209.                     dynamic value = pair.Value;
  1210.  
  1211.                     if (key == ne)
  1212.                     {
  1213.                         Result = key;
  1214.                         Result = ne + " " + value;
  1215.  
  1216.                     }
  1217.                     else if (keyAlter == ne)
  1218.                     {
  1219.                         Result = keyAlter;
  1220.                         Result = ne + " " + value;
  1221.  
  1222.                     }
  1223.  
  1224.                 }
  1225.  
  1226.                 return Result;
  1227.  
  1228.                 }
  1229.             }
  1230.  
  1231.  
  1232.     }
  1233.     class Program
  1234.     {
  1235.         static void Main(string[] args)
  1236.         {
  1237.  
  1238.             Building building1 = new Building()
  1239.             {
  1240.                 Color = "bialy",
  1241.                 Type = "kamienica",
  1242.                 Year = "1920"
  1243.         };
  1244.             Building building2 = new Building()
  1245.             {
  1246.                 Color = "bialy",
  1247.                 Type = "kamienica",
  1248.                 Year = "1920"
  1249.             };
  1250.  
  1251.             building2.Equals(building1);
  1252.             Console.WriteLine(building2.Equals(building1));
  1253.         }
  1254.     }
  1255.  
  1256.  
  1257. }
  1258. ///override equaltable itd
  1259.  
  1260.  
  1261.  
  1262. using system;
  1263. using system.Collections.Generic;
  1264. using system.Linq;
  1265. using system.Text;
  1266. using system.Threading.Tasks;
  1267. using system.Text.RegularExpressions;
  1268.  
  1269.  
  1270. namespace ConsoleApplication8
  1271. {
  1272.  interface IFlyingObject
  1273.     {
  1274.          void Fly();
  1275.     }
  1276.     class Duck : IFlyingObject
  1277.     {
  1278.        public void Fly()
  1279.         {
  1280.             Console.WriteLine("I am just duck. I am flying!");
  1281.         }
  1282.     }
  1283.     class Airplane : IFlyingObject
  1284.     {
  1285.         public void Fly()
  1286.         {
  1287.             Console.WriteLine("Captain Nelson . We are in the plane. We are  flying!");
  1288.  
  1289.         }
  1290.  
  1291.     }
  1292.     class Program
  1293.     {
  1294.         static void DoFly(IFlyingObject ob)
  1295.         {
  1296.             ob.Fly();
  1297.  
  1298.         }
  1299.         static void Main(string[] args)
  1300.         {
  1301.             Duck duck = new Duck();
  1302.             Airplane air = new Airplane();
  1303.             DoFly(duck);
  1304.             DoFly(duck);
  1305.             DoFly(air);
  1306.             DoFly(air);
  1307.  
  1308.             //      duck.Fly();
  1309.             //    air.Fly();
  1310.         }
  1311.     }
  1312.  
  1313.  
  1314. }
  1315.  
  1316. //interfejsy
  1317.  
  1318.  
  1319. using system;
  1320. using system.Collections.Generic;
  1321. using system.Linq;
  1322. using system.Text;
  1323. using system.Threading.Tasks;
  1324.  
  1325. namespace ConsoleApplication9
  1326. {
  1327.     partial class Bird
  1328.     {
  1329.       public string Name { get; set; }
  1330.         partial void Fly();
  1331.         public void DoFly()
  1332.         {
  1333.             Fly();
  1334.         }
  1335.  
  1336.     }
  1337.     partial class Bird
  1338.     {
  1339.         string Color;
  1340.         partial void Fly()
  1341.         {
  1342.             Console.WriteLine(" Fly()");
  1343.  
  1344.         }
  1345.     }
  1346.     class Program
  1347.     {
  1348.         static void Main(string[] args)
  1349.         {
  1350.  
  1351.             Bird b = new Bird();
  1352.             b.DoFly();
  1353.             Console.WriteLine( );
  1354.  
  1355.         }
  1356.     }
  1357. }
  1358. //metody czesciowe
  1359.  
  1360.  
  1361. PARAMETRY OPCJONALNE:
  1362.  
  1363.     class Program
  1364.     {
  1365.         static void ParamsOptional( int a, int b=1, int c=10)
  1366.         {
  1367.             Console.WriteLine(a+" "+b+" "+c+"\n");
  1368.         }
  1369.         static void Main(string[] args)
  1370.         {
  1371.             ParamsOptional(3);
  1372.             ParamsOptional(3,4,5);
  1373.             ParamsOptional(4,6);
  1374.             ParamsOptional(a:7, c:9);
  1375.             ParamsOptional(a: 4, c: 5, b: 6);
  1376.  
  1377.         }
  1378.      
  1379.      
  1380.      
  1381.      
  1382.       DELEGATY -0 wskazniki w c#
  1383.        
  1384.         using system;
  1385. using system.Collections.Generic;
  1386. using system.IO;
  1387. using system.Linq;
  1388. using system.Text;
  1389. using system.Threading.Tasks;
  1390.  
  1391. namespace ConsoleApplication1
  1392. {
  1393.     //tworzenie delegata
  1394.     public delegate void Test(string val);
  1395.  
  1396.     class Delegat
  1397.     {
  1398.         public void WriteToConsol(string tekst)
  1399.         {
  1400.             Console.WriteLine(tekst);
  1401.  
  1402.         }
  1403.         public async void WriteToFile(string tekst)
  1404.         {
  1405.             string mydocpath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
  1406.  
  1407.             using (StreamWriter outputFile = new StreamWriter(mydocpath + @"\WriteTextAsync.txt"))
  1408.             {
  1409.                 await outputFile.WriteAsync(tekst);
  1410.                 Console.WriteLine("zapis do pliku" + tekst);
  1411.                 outputFile.Close();
  1412.             }
  1413.         }
  1414.     }
  1415.     class Program
  1416.     {
  1417.  
  1418.         public static void Info(Test d)
  1419.         {
  1420.           //  d = new Test();
  1421.  
  1422.             d("Info about");
  1423.         }
  1424.  
  1425.         static void Main(string[] args)
  1426.         {
  1427.             object obiekt = 1;
  1428.             dynamic dyn = new { Name = "Dynamiczny", value=10 };
  1429.  
  1430.      //       Console.WriteLine(dyn.value);
  1431.        //     Console.WriteLine(dyn.Name);
  1432.             var obiekt_anonimowy = new { Name= "Anna", Age= 23 };
  1433.             Console.WriteLine(obiekt_anonimowy.Name);
  1434.             Console.WriteLine(obiekt_anonimowy.Age);
  1435.             Delegat p = new Delegat();
  1436.             Test t = new Test( p.WriteToFile );
  1437.             Test t2 = new Test(p.WriteToConsol);
  1438.             t2("Alicja");
  1439.             t("Kot");
  1440.  
  1441.             //Info(t2);
  1442.            // Info(delegate(string a) { Console.WriteLine("stl"); });
  1443.             Info(delegate(string a) {  a="stl"; });
  1444.             //Info(Test tr=new Test() );
  1445.             Test de2  = a => a="test";
  1446.             Info(de2);
  1447.        //     dyn.TreleMorele();
  1448.         }
  1449.     }
  1450. }
  1451.      
  1452.       6.32 i 6.4 refleksja
  1453.        
  1454.         using system;
  1455. using system.Collections.Generic;
  1456. using system.IO;
  1457. using system.Linq;
  1458. using system.Reflection;
  1459. using system.Text;
  1460. using system.Threading.Tasks;
  1461.  
  1462. namespace ConsoleApplication1
  1463. {
  1464.  
  1465.     public class ReflectionExample : Attribute
  1466.     {
  1467.         public int a { get; set; }
  1468.         protected string b { get; set; }
  1469.         private float c { get; set; }
  1470.         internal double d { get; set; }
  1471.         protected internal char e { get; set; }
  1472.         private int first;
  1473.         public string second;
  1474.         protected static float third;
  1475.         public static string MethodOne(string tmp)
  1476.         {
  1477.             return tmp + " sklejka ";
  1478.         }
  1479.         protected int MethodSecond(int a)
  1480.         {
  1481.             return a += 2;
  1482.         }
  1483.         private float MethodThird(float b)
  1484.         {
  1485.             return b += 3;
  1486.         }
  1487.         public ReflectionExample(int a, string b, float c, double d, char e)
  1488.         {
  1489.             this.a = a;
  1490.             this.b = b;
  1491.             this.c = c;
  1492.             this.d = d;
  1493.             this.e = e;
  1494.  
  1495.         }
  1496.     }
  1497.         [ReflectionExample(2, "costam", 2, 2.3, 'e')]
  1498.  
  1499.  
  1500.     class Program
  1501.     {
  1502.  
  1503.         public static void Info(delegat del)
  1504.         {
  1505.             del("Info about");
  1506.         }
  1507.  
  1508.         public delegate void delegat(string text);
  1509.  
  1510.         public void WriteToConsole(string text)
  1511.         {
  1512.             Console.WriteLine(text);
  1513.         }
  1514.  
  1515.         public void WriteToFile(string text)
  1516.         {
  1517.             Console.WriteLine("zapis do pliku: " + text);
  1518.         }
  1519.  
  1520.         static void Main(string[] args)
  1521.         {
  1522.             object obiekt = 1;
  1523.             dynamic dyn = new { Name = "Dynamiczny", value = 10 };
  1524.             Console.WriteLine(dyn.value);
  1525.             Console.WriteLine(dyn.Name);
  1526.  
  1527.             var obiekt_anonimowy = new { Name = "Anna", Age = 23 };
  1528.             Console.WriteLine(obiekt_anonimowy.Name);
  1529.             Console.WriteLine(obiekt_anonimowy.Age);
  1530.  
  1531.             Program obj = new Program();
  1532.  
  1533.             delegat d = obj.WriteToConsole;
  1534.             d += obj.WriteToFile;
  1535.  
  1536.             d("Jakis smieszny tekst");
  1537.  
  1538.             Info( new delegat(obj.WriteToConsole));
  1539.             Info(  (string txt) => obj.WriteToFile(txt));
  1540.  
  1541.          //   ReflectionExample tst = new ReflectionExample(2, "costam", 2, 2.3, 'e');
  1542.  
  1543.             FieldInfo[] fields = typeof(ReflectionExample).GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.static | BindingFlags.public);
  1544.             MethodInfo[] methods = typeof(ReflectionExample).GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.static | BindingFlags.public);
  1545.  
  1546.             foreach (FieldInfo field in fields)
  1547.             {
  1548.                 Console.WriteLine(field.Name);
  1549.                 Console.WriteLine(field.Attributes);
  1550.             }
  1551.  
  1552.             Console.WriteLine("---------------");
  1553.  
  1554.             foreach (MethodInfo method in methods)
  1555.             {
  1556.                 Console.WriteLine(method.Name);
  1557.             }
  1558.  
  1559.         }
  1560.     }
  1561. }
  1562.  
  1563.      
  1564.       developer attribute kartka 7 - zad1
  1565.        
  1566.        
  1567.         using system;
  1568. using system.Collections.Generic;
  1569. using system.Linq;
  1570. using system.Reflection;
  1571. using system.Text;
  1572. using system.Threading.Tasks;
  1573.  
  1574.  
  1575. [system.AttributeUsageAttribute(system.AttributeTargets.Method)]
  1576. class DeveloperAttribute : system.Attribute
  1577. {
  1578.     private string name;
  1579.     private bool reviewed;
  1580.  
  1581.     public DeveloperAttribute(string Name)
  1582.     {
  1583.         this.name = Name;
  1584.         this.reviewed = false;
  1585.     }
  1586.     public override string ToString()
  1587.     {
  1588.         return "Name: " + name + " reviewed: " + reviewed;
  1589.     }
  1590.  
  1591.     public string Name { get { return name; } }
  1592.     public bool Reviewed { get { return reviewed; } set { reviewed = value; } }
  1593. }
  1594.  
  1595. class Program
  1596. {
  1597.  
  1598.     [Developer("Jan Kowalski")]
  1599.     public void Method1()
  1600.     {
  1601.         Console.WriteLine("Metoda1");
  1602.     }
  1603.  
  1604.  
  1605.     [Developer("Jan Nowak", Reviewed = true)]
  1606.     public void Method2()
  1607.     {
  1608.         Console.WriteLine("Metoda2");
  1609.     }
  1610.  
  1611.  
  1612.     private static void PrintDevInfo(system.Type t, string method)
  1613.     {
  1614.         system.Attribute attr = system.Attribute.GetCustomAttribute(typeof(Program).GetMethod(method), typeof(DeveloperAttribute));
  1615.         system.Console.WriteLine(attr);
  1616.  
  1617.     }
  1618.  
  1619.  
  1620.     static void Main(string[] args)
  1621.     {
  1622.         Program p = new Program();
  1623.         PrintDevInfo(typeof(Program), "Method1");
  1624.         PrintDevInfo(typeof(Program), "Method2");
  1625.     }
  1626. }
  1627.      
  1628.      
  1629.      
  1630.      
  1631.  
  1632.  
  1633.  
  1634.  
  1635.  
Parsed in 0.364 seconds