Upgrade to Pro — share decks privately, control downloads, hide ads and more …

C# 5.0までの自分なりのメモとか

C# 5.0までの自分なりのメモとか

かなり前に書いた自分用のC#メモ。

78eb99ff73e663e4e375e260a403bc5c?s=128

Es_Program

March 25, 2016
Tweet

Transcript

  1. C#௒ೖ໳ C#ͰϓϩάϥϜΛॻ͚ΔΑ͏ʹ(CLR)

  2. About Me &T w $ͰΞϓϦ࡞ͬͯ·͢ w 6OJUZͰήʔϜ࡞ͬͯ·͢ w άϥϑΟοΫε෼໺ʹڵຯ͕ ͋Γ·͢

  3. C#Λ͸͡ΊΔલʹ…

  4. C#ͱ͸ C#ͷίʔυ͸(.NET Framework ʹରԠͨ͢͠΂ͯͷݴޠ͸) IL (Intermediate Language)ʹίϯύΠϧ͞ΕΔ(ILίʔυ/ϝλσʔλ /CLRϔομ/PE32·ͨ͸PE32+ϔομΛؚΉ.exe) ੜ੒ͨ͠IL͸Windows ͷ

    CLR(Common Language Runtime)্Ͱ ࣮ߦ͞ΕΔ CLR͸CLI(Common Language Infrastructure)ͱ͍͏ILΛωΠςΟ ϒίʔυʹม׵͢ΔͨΊͷ࢓༷ͷ͜ͱɻCLIΛWindows༻ʹ࣮૷ ͨ͠ͷ͕CLR Linux ൛ͷ CLIΛ࣮૷ͨ͠΋ͷʹɺMonoͱ͍͏ͷ΋͋Δ
  5. ॏཁͳͷ͸ϝλσʔλ ϝλσʔλʹ͸੩తʹඞཁͳܕ৘ใ͕ ֨ೲ͞Ε͍ͯΔ ϝλσʔλ͔Βܕ৘ใΛಡΈࠐΜͩΓɺ ܕ৘ใ͔ΒϝϯόΛநग़ͨ͠Γग़དྷΔ ܕ৘ใ͕͋Ε͹৭ʑग़དྷΔ

  6. ILͱ͸ CLR͕࣮ߦ͢Δ໋ྩ܈ CLR͕ILΛ࣮ߦ͢Δࡍɺϓϥοτ ϑΥʔϜͷΪϟοϓΛٵऩͯ͘͠ΕΔ CLR༻ͷΞηϯϒϦݴޠΈ͍ͨͳײ ͡

  7. C#ͷԿ͕خ͍͠ʁ ։ൃָ͕ ϝϞϦͷ؅ཧ͸GCʹ೚ͤΔࣄ͕ग़དྷΔ ڧ͍੩తܕ෇͚ͳͷʹɺಈతย෇͚ʹ ͍ۙࣄ΋ग़དྷΔ(ݫີʹݴ͏ͱ͜Ε΋੩ త)

  8. ։ൃͰ͸ Ϣʔβʔͷϋʔυ΢ΣΞ؀ڥ΍ OS(Windows)ͷঢ়ଶΛ͋Δఔ౓ؾʹ͠ ͳͯ͘΋͍͍ ࣮ߦ࣌Τϥʔ(ྫ֎)͸ͳΔ΂͘๾໓(ั ଊ)͢Δ

  9. ೖҠຽ΁ͷ஫ҙ఺ σετϥΫλ͸΄΅࢖Θͳ͍(CGͰΦϒδΣΫτഁغ͕؅ ཧ͞Ε͍ͯΔͨΊ࢖͏ػձ͕΄ͱΜͲͳ্͍ݺͼग़͠λΠ ϛϯά͕GCґଘʹͳΔͨΊ͍ͭݺ͹ΕΔ͔Θ͔ͬͨ΋Μ ͡Όͳ͍) ੩తͳϩʔΧϧม਺(ϝιου಺੩తม਺)͸࢖͑ͳ͍(Φϒ δΣΫτࢦ޲ʹ͓͍ͯ͸ޡͬͨղऍͰ͋ΔͨΊ) unsafeͷࡍͷϙΠϯλม਺એݴ͸C΍C++ͱগ͠ҟͳΔ δΣωϦοΫʹvoidࢦఆ͸ग़དྷͳ͍ ͳͲͳͲ…

  10. ܕ

  11. ܕ͸େࣄ C#ϓϩάϥϛϯάͰ͸ܕΛҙࣝ͢Δ͜ͱ͕େ੾ ܕ৘ใ͸ϝλσʔλʹ֨ೲ͞ΕΔ Objectܕʹඪ४౥ࡌ͞Ε͍ͯΔඇԾ૝ϝιουGetType ͸ϝλσʔλ͔Βܕ৘ใΛऔಘ͢Δ(ϦϑϨΫγϣϯୈҰ า) ϓϦϛςΟϒܕΑΓFCLܕΛ࢖͏ͷਪ঑Β͍͠(ܕʹର͢ ΔޡղΛආ͚Δ/CLS(ڞ௨ݴޠ࢓༷)ͷܕΛҙࣝͯ͠ΈΔ)

  12. λΠϓηʔϑςΟ(ܕ҆શੑ) C#ͷ࣮ߦ࣌ܕ৘ใ͸શͯCLR͕؅ཧ͢Δɻ ܧঝؔ܎͕͋ΔܕͷΩϟετͷ৔߹͸CLR͕ ΩϟετΛڐՄ͢Δ͕ɺΞοϓΩϟετͷ৔߹ ͸ةݥͳ৔߹͕͋ΔͷͰ໌ࣔతͳΩϟετΛ ࢦఆ͢Δඞཁ͕͋Δ ௚઀ܧঝؔ܎͕ͳ͍Ωϟετͷ৔߹͸CLR͕ ةݥͱ൑அ͠ɺྫ֎Λ౤͛Δ

  13. ϓϦϛςΟϒܕͷΩϟετ Int32ͱInt64ʹ௚઀ܧঝؔ܎͸ͳ͍͕ɺ ҉໧తͳΩϟετΛར༻ग़དྷΔ C#ίϯύΠϥ͸ϓϦϛςΟϒܕΛख़஌ ͍ͯ͠ΔͨΊɺ͜ͷΑ͏ͳࣄ͕Մೳ ϓϦϛςΟϒܕʹ͍ͭͯ͸ܧঝؔ܎ͱ ͸ผͷΩϟετͷ֓೦͕ଘࡏ͢Δ

  14. isԋࢉࢠ ΦϒδΣΫτ͕ࢦఆ͞Εͨܕͱޓ׵ੑ͕͋Δ ͔ΛBooleanܕͰฦ͢(ྫ֎Λ཈੍ग़དྷΔ) ΦϒδΣΫτࢀর͕nullͷ৔߹͸ৗʹfalseΛฦ ͢ var  s  =  "͍͋͏͓͑";  

    if(s  is  String)        Console.WriteLine("stringܕ");   else        Console.WriteLine(“!stringܕ");   ݁Ռɿstringܕ string  s  =  null;   if(s  is  String)        Console.WriteLine("stringܕ");   else        Console.WriteLine(“!stringܕ");   ݁Ռɿ!stringܕ
  15. isԋࢉࢠ͸ύϑΥʔϚϯεࡴ͠ʁ CLR͸࣮͸̎ճܕΛݕ͍ࠪͯ͠Δ isԋࢉࢠͰ1ճ ΩϟετͰ1ճ class  A  {  public  void  Hello()

     {  Console.WriteLine("HelloA");  }  }   class  B  :  A  {  new  public  void  Hello()   {  Console.WriteLine("HelloB");  }  }   static  void  Main(string[]  args)   {          B  b  =  new  B();          b.Hello();          if(b  is  A)          {                  A  a  =  (A)b;                  a.Hello();          }   }
  16. asԋࢉࢠͰ1ճͷݕࠪ class  A  {  public  void  Hello()  {  Console.WriteLine("HelloA");  }

     }   class  B  :  A  {  new  public  void  Hello()  {  Console.WriteLine("HelloB");  }  }   static  void  Main(string[]  args)   {          B  b  =  new  B();          A  a  =  b  as  A;          if(a  !=  null)                  a.Hello();   } ݕࠪճ਺͸1ճʹͳ͍ͬͯΔͷͰ ύϑΥʔϚϯε͸ྑ͘ͳΔ
  17. asԋࢉࢠ ޓ׵ੑ͕͋Ε͹ɺͦͷܕʹΩϟετ͠ ͯฦ͢ ޓ׵ੑ͕ແ͚Ε͹nullΛฦ͢ ͳΔ΂͘isΑΓasΛ࢖͏

  18. isͱasͷ஫ҙ ͲͪΒ΋ΞοϓΩϟετํ޲ͷޓ׵ΛೝΊͳ͍ is/asͷޙΖʹ෇͚Δܕ͕ɺલͷΦϒδΣΫτͷ ਌ʹͳ͍ͬͯͳ͍ͱfalse/null [೿ੜΫϥεɹis/asɹجఈΫϥε]ͬͯܗͰॻ͘ is/asͰ͸Φʔόʔϩʔυͨ͠ΩϟετԋࢉࢠΛ ݺ͹ͳ͍

  19. ஋౉͠ͱࢀর౉͠

  20. جຊతʹϝιου͸஋౉͠ Կ΋ࢦఆ͠ͳ͚Ε͹஋౉͠ͱͳΔ ref΍outΛࢦఆ͢Δͱࢀর౉͠ͱͳΔ ࢀরܕΛ஋౉͢͠Δ৔߹ɺҾ਺ͱ͠ ͯ౉͞Εͨม਺ͷࢀরઌΛมߋ͢Δ ͜ͱ͸Ͱ͖ͳ͍ɻ

  21. ΦϒδΣΫτΞΫηεՄೳੑ

  22. C#ͷΩʔϫʔυ ܕ ϝιου/ϓϩύςΟ/Πϕϯτ ఆ਺/ϑΟʔϧυ abstract ͦͷܕͷΠϯελϯεΛ࡞੒ग़དྷͳ ͍ ೿ੜܕͷΠϯελϯεΛ࡞੒Մೳʹ ͢Δʹ͸ɺ೿ੜܕͰ͜ͷϝϯόΛΦ ʔόʔϥΠυ࣮ͯ͠૷͠ͳ͚Ε͹ͳ

    Βͳ͍ (࢖༻ग़དྷͳ͍) virtual (࢖༻ग़དྷͳ͍) ͜ͷϝϯόΛ೿ੜܕͰΦʔόʔϥΠ υग़དྷΔ͜ͱΛࣔ͢ (࢖༻ग़དྷͳ͍) override (࢖༻ग़དྷͳ͍) ೿ੜܕ͕جఈܕͷϝϯόΛΦʔόʔ ϥΠυग़དྷΔࣄΛࣔ͢ (࢖༻ग़དྷͳ͍) seald ͦͷܕΛجఈܕͱͯ͠࢖༻ग़དྷͳ͍ ࣄΛࣔ͢ ϝϯό͕೿ੜܕʹΑͬͯΦʔόʔϥ Πυग़དྷͳ͍ࣄΛࣔ͢ɻ͜ͷΩʔϫ ʔυ͸Ծ૝ϝιουΛΦʔόʔϥΠ υ͍ͯ͠ΔϝιουʹͷΈద༻Մೳ (࢖༻ग़དྷͳ͍) new ೖΕࢠʹ͞ΕͨܕɺϝιουɺϓϩύςΟɺΠϕϯτɺఆ਺ɺ·ͨ͸ϑΟʔϧυʹద༻͞ΕΔͱɺجఈΫϥεʹଘ ࡏ͢Δಉ͡छྨͷϝϯόͱແؔ܎Ͱ͋Δ͜ͱΛࣔ͢
  23. ੩తΫϥε

  24. staticͳΫϥεͱ͸ ΠϯελϯεԽ͠ͳ͍Ϋϥε(Πϯε λϯεԽͰ͖ͳ͍) ϝϯόͷάϧʔϓԽΛ໨తͱ͍ͯ͠Δ C#Ͱ͸Console/Math/Environment/ ThreadPoolͳͲ͸੩తΫϥε

  25. ແݶ੔਺ܕ

  26. BigInteger System.Numerics໊લۭؒͷ BigIntegerܕ͸ແݶ੔਺஋Λද͢ ੔਺ͳΒ͹ԿܻͰ΋֨ೲग़དྷΔ ಺෦తʹ͸UInt32Λ࢖͍ͬͯΔ BigInteger  bigint;   bigint  =

     BigInteger.Parse(Console.ReadLine());   Console.WriteLine(bigint  /  2);
  27. δΣωϦοΫ

  28. δΣωϦοΫͱ͸ ࢖༻࣌ʹࢦఆͨ͠ܕʹͳΔϚΫϩΈ͍ͨͳػೳͷ͜ͱ ఆٛ͢Δܕ໊ʹ”<>”Λ͚ͭɺδΣωϦοΫͳܕ໊Λ”,”۠੾ΓͰྻ ڍ͢Δ(class Test<T1, T2>{}) Ϋϥεʹ΋ϝιουʹ΋࢖͑Δ δΣωϦοΫʹvoid͸ࢦఆग़དྷͳ͍(Func<int,void>ͳͲ͸ग़དྷͳ ͍ɻAction<int>Λ࢖͏) δΣωϦοΫʹڞมੑɾ൓มੑΛ࣋ͨͤΔࣄͰδΣωϦοΫσϦ

    ήʔτͷܕʹ҉໧ͷม׵Λ࣮ݱग़དྷΔ(ͲͪΒ΋μ΢ϯΩϟετΛ ར༻)
  29. ؆୯ͳδΣωϦοΫྫ public  static  T  Max<T>(T  a,T  b)      

                       where  T  :  IComparable                  {                          return  a.CompareTo(b)  >  0  ?  a  :  b;                  } where۟Λ࢖͏ࣄͰɺܕʹ͍ͭ ੍ͯ໿ΛՃ͑Δࣄ΋ग़དྷΔ http://ufcpp.net/study/csharp/sp2_generics.html
  30. δΣωϦοΫΫϥεͷstaticϑΟʔϧυ͸ܧঝʹ Αͬͯڞ༗͞Εͳ͍     private  class  StaticClassBase<T>      

    {         private  static  bool  test;         public  static  bool  Test  {  get  {  return  test;  }  set  {  test  =  value;  }  }       }       private  class  StaticClass1  :  StaticClassBase<StaticClass1>       {       }       private  class  StaticClass2  :  StaticClassBase<StaticClass2>       {       }       private  void  Action()       {         //GenericΫϥεΛܧঝͨ͠৔߹ɺStaticม਺͸ڞ༗͞Εͯͳ͍ɻ         //ཧ༝ɿGenericΫϥε͸ɺςΩετੜ੒༻ͷϚΫϩػೳͷΑ͏ͳ΋ͷͰ͋ΔͨΊɻ         //ͭ·ΓɺίϯύΠϧ࣌ʹ         //ɹɾɹStaticClassBase<StaticClass1>         //ɹɾɹStaticClassBase<StaticClass2>         //ͱ͍͏2ͭͷܕ͕ͦΕͧΕ࡞ΒΕΔ͜ͱʹͳΔɻ         //ͳͷͰɺstaticͳtestϑΟʔϧυ͸ͦΕͧΕͷΫϥεͰ࡞ΒΕΔͨΊڞ༗͞Εͳ͍ɻ         StaticClass1.Test  =  true;         Console.WriteLine(StaticClass1.Test.ToString())//True;         Console.WriteLine(StaticClass2.Test.ToString())//False;       }
  31. มੑ

  32. ڞมੑͱ͸ جఈΫϥεΛ໭Γ஋ͱ͢ΔσϦήʔτʹର ͯ͠ɺ ೿ੜΫϥεΛ໭Γ஋ͱ͢Δϝιο υΛ୅ೖͰ͖Δ͜ͱΛڞมੑͱ͍͏ ೿ੜΫϥε͕ฦ͞ΕΔϝιου͕͋ͬͯ΋ɺ ͦͷϝιου͸جఈΫϥεʹμ΢ϯΩϟε τ͢Ε͹ಉ͡σϦήʔτʹ·ͱΊΒΕΔΑ Ͷ͓ͬͯ࿩(ͬͪ͜͸؆୯)

  33. ڞมੑͷྫ        class  Test        

     {                  static  void  Main(string[]  args)                  {                          //stringܕͷҾ਺Λobjectܕʹͯ͠ฦ͚ͩ͢ͷσϦήʔτ                          Func<string,  object>  ParseObj  =  x  =>  x;                  }          } ஫ҙ͢΂͖͸ɺσϦήʔτʹରͯ͠୅ೖग़དྷΔͷ͸ ೿ੜ ΫϥεΛ໭Γ஋ͱ͢ΔϝιουͰ͋Δͱ͍͏͜ͱɻ
  34. ൓มੑͱ͸ ೿ੜΫϥεΛҾ਺ͱ͢ΔσϦήʔτʹର͠ ͯɺ جఈΫϥεΛҾ਺ͱ͢ΔσϦήʔτΛ ୅ೖͰ͖Δ͜ͱΛ൓มੑͱ͍͏ ϝιουͷҾ਺ʹ೿ੜΫϥεΛ༩͑ͨ৔߹ Ͱ͋ͬͯ΋ɺجఈΫϥεΛҾ਺ͱ͢Δϝιο υ͸ͦͷΪϟοϓΛٵऩ͢Δࣄ͕ग़དྷΔͨ Ί͜ͷΑ͏ͳࣄ͕ՄೳʹͳΔ(ͪΐͬͱ೉ղ)

  35. ྫ͑͹ Action<string>͸Ҿ਺ʹstringܕΛࢦఆͯ͠ॲཧΛ͢Δ΋ͷͰ͋Δ͔ ΒɺҾ਺ʹ͸ʮ”จࣈ”ʯͷΑ͏ͳ΋ͷΛࢦఆग़དྷΔ Action<object>͸Ҿ਺ʹobjectܕΛࢦఆͯ͠ॲཧΛ͢Δ΋ͷͳͷ Ͱɺ[“จࣈ”]ͷΑ͏ͳ΋ͷΛࢦఆ͢Δࣄ΋ग़དྷΔ Action<object> objAction = x =>

    { Console.Write(x); }; Action<string> strAction = objAction; stringΛҾ਺ʹऔΔstrActionʹରͯ͠ɺobjActionΛ୅ೖ͢ Δࣄ͕ग़དྷΔཧ༝͸ɺobjActionͷҾ਺ʹstringܕΛࢦఆ͠ ͯ΋ྑ͍ͨΊ(μ΢ϯΩϟετͳͷͰ҆શ)
  36. ࢖͏৔߹Ͱߟ͑Δ strAction("str")ʹ஫໨͢ΔͱɺҾ਺͸stringܕͰ͋Δɻ strAction಺ͷobjActionͰ͸ɺ͜ͷ”str”Λ҉໧తʹμ΢ϯΩϟε τ͢Δ objActionͰ͸Ҿ਺͸౰વobjectͰ͋Δ͔ΒɺstringͷػೳΛ࢖͏ ͜ͱΛ໨తͱ͍ͯ͠ͳ͍ͨΊ҆શͰ͋Δ ΑͬͯɺҾ਺ͷܕ͕ಛԽͨ͠σϦήʔτʹҾ਺ͷܕ͕൚Խͨ͠ σϦήʔτΛ௥Ճ͢Δ͜ͱ͸҆શͰ͋Δ    

       class  Test          {                  static  void  Main(string[]  args)                  {                        Action<object>  objAction  =  x  =>  {  Console.Write(x);  };                        Action<string>  strAction  =  objAction;                        strAction("str");                  }          }  
  37. "൓"มੑ ී௨ʹμ΢ϯΩϟετʹΑͬͯ҉໧ͷܕม׵͕ߦΘΕΔ ৔߹ͷࣜ͸[൚༻ܕʹಛԽܕ]Ͱ͋Δ ൓มੑΛ΋ͭσϦήʔτͷ৔߹͸[ಛԽܕʹ൚༻ܕ]Ͱ͋Δ ͋Εɺ”൓”ରʹͳͬͯΔ…        class  Test

             {                  static  void  Main(string[]  args)                  {                          //ී௨ͷμ΢ϯΩϟετ                          int  n  =  10;                          object  obj  =  n;                          //൓มੑΛ΋ͭσϦήʔτͷμ΢ϯΩϟετ                          Action<object>  objAction  =  x  =>  {  Console.Write(x);  };                          Action<string>  strAction  =  objAction;                  }          }
  38. ൓มੑͷྫ        class  Test        

     {                  delegate  void  OneParam<T>(T  x);                  class  A  {  }                  class  B  :  A  {  }                  static  void  Main(string[]  args)                  {                          //൓มੑΛ࣋ͨͳ͍(Τϥʔ͕ग़Δ)                          OneParam<A>  oneA  =  _1  =>  Console.WriteLine(_1);                          OneParam<B>  oneB  =  oneA;//Τϥʔʂܕ͕҉໧తʹม׵Ͱ͖ͳ͍                          //൓มੑΛ࣋ͭ(σϦήʔτΛinʹΑͬͯम০ͨ͠৔߹)                          Action<A>  actA  =  _2  =>  Console.WriteLine(_2);                          Action<B>  actB  =  actA;                          actB(new  B());//actB಺ͷactAͰ͸ɺҾ਺BΫϥεΛAΫϥεʹμ΢ϯΩϟετ                  }          }
  39. ͪΐͬͱ੔ཧ͢Δͱ μ΢ϯΩϟετ͸҆શʹม׵ग़དྷΔ ڞมੑͱ൓มੑ͸δΣωϦοΫʹμ΢ϯΩϟετΛڐՄ͢Δͨ Ίͷ΋ͷ(҉໧తܕม׵ΛڐՄ͢Δ) ڞมੑ͸؆୯ʹཧղग़དྷΔ ൓มੑ͸ɺҰݟ͢ΔͱΞοϓΩϟετͬΆ͍Μ͚ͩͲɺ࢖͏ଆ Λߟ͑ͯΈΔͱͪΌΜͱμ΢ϯΩϟετʹͳͬͯΔ Ұݟ͢Δͱਅٯ͔ͩΒͦ͜ɺ"൓"มੑͬͯݴ͏ͷ͔΋Ͷ֮ͬͯ͑ ํ͢ΔͱҾ਺ʹ͸ಛԽΫϥεΛࢦఆग़དྷΔΑͳ͙ͬͯ͢Θ͔Δ

  40. ͭ·Γ μ΢ϯΩϟετ͸҆શੑ͕อূ͞Ε͍ͯΔ(҉໧ͷΩϟετ ͕Մೳ)ͷʹؔΘΒͣɺσϦήʔτʹ͸ࢦఆͨ͠ܕҎ֎ͷ໭ Γ஋ɾҾ਺Λࢦఆͨ͠ϝιουΛ࣋ͨͤΔࣄ͕ग़དྷͳ͍ (ͨͱ͑μ΢ϯΩϟετͰ͖Δ҆શͳؔ܎Ͱ͋ͬͯ΋) ΑͬͯɺҰൠతʹδΣωϦοΫͷ໭Γ஋ʹ͸ڞมੑΛɺҾ ਺ʹ͸൓มੑΛ࣋ͨͤΔ σϦήʔτʹ͓͍ͯɺҾ਺ͷܕ͕ಛԽͨ͠σϦήʔτʹҾ ਺ͷܕ͕൚Խͨ͠σϦήʔτΛ௥Ճ͢Δ͜ͱ͸҆શͰ͋Δ

  41. σϦήʔτ

  42. σϦήʔτͱ͸ ϝιουΛࢀর͢ΔͨΊͷܕ ୅ೖͰ͖Δͷ͸ಉ͡(·ͨ͸มੑʹैͬͨ)໭Γ ஋ɾҾ਺ܕΛ΋ͭϝιου΁ͷࢀর ࢖༻࣌͸ϝιουͱಉ͡Α͏ͳදه๏Ͱ࢖͑Δ ෳ਺ͷϝιουΛ֨ೲͯ͠ɺ̍௨Γͷύϥϝʔλ ʹରͯ͠ෳ਺ͷॲཧΛͤ͞Δࣄ͕ग़དྷΔ(Ϛϧν ΩϟετσϦήʔτ)

  43. ࣮ࡍʹ࢖ͬͯΈΔ        class  Test        

     {                  //intܕύϥϝʔλΛҾ਺ʹऔΔ໭Γ஋voidͷσϦήʔτ                  delegate  void  IntParam(int  x);                  static  void  Show(int  i)                  {                          Console.WriteLine(i);                  }                  static  void  Main(string[]  args)                  {                          IntParam  showIntParam1  =  new  IntParam(Show);//ݹ͍ॻ͖ํ                          IntParam  showIntParam2  =  Show;//৽͍͠ॻ͖ํɺ্ͱಉ͡ҙຯ                          showIntParam1  +=  Show;//ෳ਺ͷϝιουΛ֨ೲͰ͖Δ                          showIntParam1  +=  showIntParam2;//ܕ͕ಉ͡ͳͷͰ͜Ε΋Մೳ                          showIntParam1(999);//ෳ਺ͷϝιου΁ͷࢀরΛ΋ͭσϦήʔτΛ࢖ͬͯΈΔ                  }          } ϝιου໊͸ ϝιου΁ͷࢀর Λද͢ͱߟ͑Δ
  44. ൚༻σϦήʔτ δΣωϦοΫͳσϦήʔτ σϦήʔτΠϯελϯεੜ੒࣌ʹܕΛܾΊΔ ActionɾFunc౳͕༻ҙ͞Ε͍ͯΔ ActionɾFunc͸มੑΛ΋ͭ δΣωϦοΫʹvoidࢦఆ͸ग़དྷͳ͍

  45. ϥϜμࣜ

  46. ϥϜμࣜͷߏจ ࣜܗࣜͷϥϜμࣜ͸returnΛ෇͚ͳͯ͘΋ ࣗಈతʹਪ࿦͞ΕΔ(return͸লུͰ͖Δ) จܗࣜͷϥϜμࣜ͸஋Λฦ͢৔߹ɺ໌ࣔ తʹrerturnΛ෇͚ͳ͚Ε͹ͳΒͳ͍ ύϥϝʔλ => ࣜ; ύϥϝʔλ =>

    {จ;};
  47. ஗ԆධՁ

  48. Πϯελϯεͷ༧໿ ஗ԆධՁͷίϨΫγϣϯ͕࣮ࡍʹ࣮ ମԽ͞ΕΔͷ͸ɺಛఆͷϝιου΍ foreachʹΑΔΞΫηε͕͋Δͱ͖ ඞཁͳ࣌ʹΠϯελϯεԽ͞Εɺඞ ཁͳ͍৔߹ʹ͸ΠϯελϯεԽ͞Ε ͳ͍

  49. Πϝʔδͱͯ͠… ஗ԆධՁͷγʔέϯε͸ɺ͋Δཁૉͷ࣍ͷཁૉ͕ Ͳ͏ܾఆ͞ΕΔ͔Λ஌͍ͬͯΔ(LINQͷҰ෦ͷϝ ιου͸͜ͷΑ͏ͳΦϒδΣΫτΛฦ͢) ඞཁʹͳͬͨΒͦΕΒͷσʔλΛࢀߟʹɺඞཁͳ ෼͚ͩΛΠϯελϯεԽ͢Δ ΠϯελϯεԽͷඞཁ͕ͳ͍΋ͷΛखॱ͔Βল͘ ࣄͰɺϝϞϦ࢖༻཰ΛԼ͛ɺޮ཰΋ྑ͘ͳΔ܏޲

  50. class  MyValue   {          private  static

     Boolean  accessed;          private  Int32  sample;          public  Int32  Sample          {                  get                  {                          accessed  =  true;                          return  sample;                  }                  set                  {                          accessed  =  true;                          sample  =  value;                  }          }          public  MyValue(Int32  n)  {  sample  =  n;  }          public  static  void  Report()          {                  Console.WriteLine("ΞΫηε͞Ε"  +  (accessed  ?  "·ͨ͠"  :  "ͯ·ͤΜ"));          }   }   class  Test   {          static  void  Main(string[]  args)          {                  var  ar  =  new  MyValue[]                  {                          new  MyValue(1),                          new  MyValue(2),                          new  MyValue(3),                  };                  var  query  =  ar.Where(c  =>  c.Sample  !=  2);                  MyValue.Report();          }   } ΞΫηε͞ΕΔͱϑϥάཱ͕ͭ ͜͜Ͱɺ2Ҏ֎ͷ஋Λ࣋ͭΫΤϦ Λநग़͢ΔɻSampleΛ࢖͍ͬͯΔ ͷͰɺϑϥάཱ͕ͭ͸ͣ…?
  51. ࣮ߦ݁Ռ͸… ϑϥάཱ͕ͬͯͳ͍ʂ ʹ ΞΫηε͞Εͯͳ͍ ม਺queryΛ࣮ࡍʹ࢖͍ͬͯͳ͍ͨΊ

  52. ͭ·Γɾɾɾ Whereϝιου͔Β͸஗ԆධՁͷγʔέϯε͕ฦͬͯ͘Δ ஗Ԇ࣮ߦͳͷͰɺΠϯελϯεԽ͞ΕΔ·Ͱ͸ϝιου͸࣮ߦ ͞Εͣɺ଴ػ͍ͯ͠Δঢ়ଶʹͳΔ(࣮ࡍʹSample͕ࢀর͞Ε͍ͯ ͳ͍͜ͱ͔Β໌ന) ͜ΕʹΑΓɺϝϞϦޮ཰΍ύϑΥʔϚϯε͕Α͘ͳΔ ΠϯελϯεԽ͕ԿʹΑͬͯҾ͖ى͜͞ΕΔ͔஌ΔࣄͰΑΓৄ ࡉʹ஗Ԇ࣮ߦΛίϯτϩʔϧग़དྷΔ(CountϝιουͳͲ͸͢΂ ͯͷΦϒδΣΫτΛΠϯελϯεԽͯ͠਺্͑͛ΔͷͰϝϞϦ Λᷰ͏…౳)

  53. ࢼ͠ʹ MyValue.Report(); Console.WriteLine("σʔλ਺͸{0}Ͱ͢",  query.Count()); ͷ্ͷߦʹ Λ௥Ճͯ͠ΈΔͱ…

  54. ࣮ߦ݁Ռ͸… ϑϥάཱ͕͍ͬͯΔʂ ʹ ΞΫηε͞Εͨ

  55. ΠϯελϯεԽ CountϝιουʹΑͬͯɺγʔέϯε͸ΠϯελϯεԽ͞ ΕΔ(Countϝιουͷ৔߹͸શཁૉ͕ΠϯελϯεԽ) ΠϯελϯεԽ͞ΕΔ࣌͸ɺཷΊ͍ͯͨॲཧΛҰؾʹߦͬ ͯඞཁͳཁૉΛܭࢉ͠ɺඞཁͳ෼͚ͩΠϯελϯεԽ͢Δ ॲཧΛऴ͑ͨཁૉ͸͙͢ʹ࡟আ͞ΕΔ(࠶౓ܭࢉ͢Ε͹ಉ ͡஋ΛಘΔࣄ͕ग़དྷΔ)ͷͰɺϝϞϦతʹ༏͍͕͠ύ ϑΥʔϚϯεͰ͸೉͕͋ΔͷͰඞཁͰ͋Ε͹Ωϟογϡ͢ Δ

  56. ϝϞϦΛᷰΘͳ͍ IEnumerable͸ඞཁͳ΋ͷ͚ͩΛܭࢉ͠औΓ ग़͕͠ՄೳͳͷͰϝϞϦΛ΄ͱΜͲᷰΘͳ͍ CountͳͲɺ࣮ߦ࣌ʹ͕͔͔࣌ؒΔ΋ͷ΋͋ ΔͷͰ஫ҙ͢Δ ഑ྻ΍Ϧετʹม׵͢Δͱͦͷ෼ϝϞϦ͕ඞ ཁʹͳΔ

  57. ΠϯελϯεԽ·ͱΊ ΠϯελϯεԽ͸ɺͦͷཁૉͷΠϯελ ϯε͕ઈରʹඞཁʹͳͬͨ࣌ʹൃੜ͢Δ ΠϯελϯεԽ͕ෆཁͳ΋ͷ͸Πϯελ ϯεԽ͞Εͳ͍ ToArray/ToList/Count/foreachͳͲ͸Πϯ ελϯεԽ͕Ҿ͖ى͜͞ΕΔ୅දྫ

  58. IEnumerable͸খ͍͞ IEnumerable͸഑ྻͳͲͱൺ΂ͯͱͯͭ ΋ͳ͘খ͍͞༰ྔͰଟ͘ͷཁૉΛ࣮ݱ ग़དྷΔ(஗ԆධՁʹΑΔԸܙ) intܕཁૉ10000ݸͷ഑ྻͱ IEnumerable<int>ͷཁૉ10000ݸͰ͸ϝ ϞϦ࢖༻ྔ͕അࣛΈ͍ͨʹҧͬͯ͘Δ

  59. ଟ͘ͷཁૉΛ࣋ͭ৔߹ ͳΔ΂͘IEnumerableΛ࢖͏͜ͱ ཁૉ਺10000ݸͷ഑ྻͷLengthϓϩύςΟ͸ߴ ଎ʹ10000Λฦ͕͢ϝϞϦͷແବ ཁૉ਺10000ݸͷγʔέϯεͷCount͸௿଎Ͱ 10000Λฦ͕͢ϝϞϦΛؾʹ͠ͳͯ͘ྑ͘ɺ͞ Βʹཁૉ਺Λ૿΍ͦ͏͕ɺ্ݶ͸int͕දݱग़དྷ Δ஋·Ͱ֦ுग़དྷΔ

  60. ྻڍՄೳܕΛ؆୯ʹฦ͢

  61. ൓෮ࢠyield IEnumerable·ͨ͸IEnumratorΛฦ͢ϝιουʹ࢖ΘΕΔ yield return΍yield breakͱ͍͏ײ͡Ͱ࢖͏ yield returnΛ࢖͏ͱ஋Λฦ͠ɺϝιουͷॲཧҐஔ͕ه Ա͞Εɺ࣍ճϝιουΞΫηε࣌ʹ͔ͦ͜Β࠶։͞ΕΔ yield breakΛ࢖͏ͱɺ൓෮Λऴྃͯ͠ϝιουΛൈ͚Δ

    ͨΊɺ࣍ճϝιουݺͼग़࣌͠ʹ͸࠷ॳ͔Β࠶։͞ΕΔ
  62. ࣮ମԽͷࡍʹݺ͹ΕΔ ࣮ࡍɺ൓෮ࢠΛ༻͍ͨ(໭Γ஋͕ྻڍՄೳܕͳ)ϝ ιου͸ͦͷ৔Ͱ࣮ߦ͞Εͳ͍ ࣮ߦ͞ΕΔͷ͸ԿΒ͔ͷܗͰཁૉ͕ΠϯελϯεԽ ͞ΕΔඞཁ͕͋Δͱ͖ ྻڍՄೳܕͷม਺ʹ͸γʔέϯεΛੜ੒͢ΔͨΊͷ ϝιου΍σʔλΛσϦήʔτͷΑ͏ʹอ؅͠ɺ࣮ ମԽ͕ඞཁʹͳͬͨ࣌ʹͦΕΒΛ࣮ߦ͍ͯ͘͠Πϝʔ δ

  63. ڍಈΛ஌ΔͨΊʹ yield return΍yield breakΛ༻͍ͨγʔέϯεΛฦ͢ϝιο υΛ࣮ࡍʹ࢖͍ɺVSͰF11࿈ଧͯ͠ڍಈΛ͔֬ΊͯΈΔ ͜͏͢Δͱɺ࣮ࡍʹͲ͏΍ͬͯγʔέϯεΛධՁ͍ͯ͠ Δͷ͔͕ͳΜͱͳ͘Θ͔Δ ϝιουΛͦͷ৔Ͱ࣮ߦͤͣɺΠϯελϯεԽ͕ඞཁͳ ͱ͖ʹ࣮ߦ͍ͯ͠Δ͜ͱʹ΋ೲಘग़དྷΔ ҎԼʹڍ͛Δྫશ෦ɺVSͷσόοάػೳΛ༻͍࣮ͯߦ͠

    ͯΈΔͱ͍͍ײ͡
  64.        class  ൓෮ࢠ          {

                     static  void  Main(string[]  args)                  {                          var  n  =  YieldTest(4);                          foreach(var  a  in  n)                                  Console.WriteLine(a);                              }                  static  IEnumerable<string>  YieldTest(int  n)                  {                          int  i  =  1;                          while(true)                          {                                  yield  return  (i.ToString()  +  "จࣈ໨");                                  ++i;                                  if(i  >  n)                                          yield  break;                          }                          yield  return  (i.ToString()  +  "จࣈ໨");                  }          } yield࢖༻ྫ yield break͸breakͱҧ͍ɺ ϝιουΛऴྃ͢Δ ͦΕʹΑͬͯɺwhileͷ֎ͷ yield return͸࣮ߦ͞Εͳ͍ yield returnͰཁૉΛฦ͍ͯ͠ ͖ɺϝιουऴྃ࣌ʹγʔέ ϯεΛฦ͢ ൓෮ࢠΠϯλϑΣʔεܕҎ֎ ͷ஋͸ฦͤͳ͍(Ϧετ΍഑ ྻͳͲΛ໭Γ஋ʹ͢Δࣄ͸ग़ དྷͳ͍)
  65. ग़དྷΔࣄͱग़དྷͳ͍ࣄ ϝιου಺Ͱ͸ɺbreak Λ༻͍Δࣄ͕ग़དྷΔ ͦΕʹΑͬͯɺwhile֎ͷ yield return΋࣮ߦ͞ΕΔ breakͱyield break͸ҧ͏ return͸࢖͑ͳ͍ Αͬͯɺ୅ΘΓʹyield

    breakΛ࢖͏ class  ൓෮ࢠ          {                  static  void  Main(string[]  args)                  {                          var  n  =  YieldTest(4);                          foreach(var  a  in  n)                                  Console.WriteLine(a);                  }                  static  IEnumerable<string>  YieldTest(int  n)                  {                          int  i  =  1;                          while(true)                          {                                  yield  return  (i.ToString()  +  "จࣈ໨");                                  ++i;                                  if(i  >  n)                                          break;//break͸࢖͑Δ                                          /*yield  break;*/                          }                          /*return  (i.ToString()  +  "จࣈྻ");           —>>ɹreturn͸࢖͑ͳ͍    */                            yield  return  (i.ToString()  +  "จࣈ໨");                  }          }
  66. ແݶϧʔϓʁʁ private  static  IEnumerable<int>  Get123()   {      

       while(true)          {                  foreach(var  i  in  Enumerable.Range(1,  3))                          yield  return  i;          }   }   static  void  Main(string[]  args)   {          foreach(var  item  in  Get123())          {                  Console.Write(item);                  if(Console.KeyAvailable)                          return;          }   }
  67. ແݶϧʔϓʁʁ ྫͰ͸ɺGet123ϝιου಺Ͱແݶϧʔϓ͕ىͬͯ͜ ΔΑ͏ʹࡨ֮͠ɺදࣔ͸Ұ޲ʹ͞Εͳ͍ϓϩάϥϜ ͷΑ͏ʹࢥ͑Δ ͔ͦ͠͠Μͳ͜ͱ͸ͳ͍ɻ͔֬ʹແݶϧʔϓͰ͸͋ Δ͕ɺίϯιʔϧʹ͸123123…..ͱදࣔ͞Ε͍ͯ ͘ɻ VSͷσόοάػೳΛ༻͍࣮ͯߦ͢Ε͹ͦͷཧ༝Λཧ ղग़དྷΔ(yield return΍஗ԆධՁͷੑ࣭͕Θ͔Δ)

  68. foreach͕࢖͑Δέʔε IEnumerableΛ࣮૷͍ͯ͠Δඞཁ͕͋Δͱצҧ͍͞Ε͕ͪɻ࣮ ͸͜Ε͸ඞཁແ͍ɻ GetEnumeratorͱ͍͏໊લͷϝιου͕͋Ε͹͍͍(MoveNextͱ CurrentϝιουΛ࣮૷ͨ͠΋ͷΛฦ͢)ɻ ಉ༷ʹMoveNextͱCurrentͱ͍͏ϝιου͕͋Ε͹IEnumerator ѻ͍͞ΕΔ(ΠϯλϑΣʔεΛܧঝ͢Δඞཁͳ͠)ɻ ͭ·Γ্ه̏ͭͷϝιουΛ࣮૷͢Ε͹ΠϯλϑΣʔεෆཁɻ ࣮૷ํ๏͸ࣗ༝Ͱɺ(ͪΌΜͱҙਤͨ͠ಈ࡞͕ՄೳͳΒ)Կ΍ͬ ͯ΋͍͍ʂʂʂ

    http://neue.cc/2013/03/27_401.html
  69. ଐੑ

  70. ଐੑͱ͸ ओʹϦΫϨΫγϣϯΛ༻͍ͯϝϯό ΍ΫϥεࣗମʹԿ͔ಛผͳػೳΛ࣋ ͨͤΔ͜ͱ [ଐੑ໊(Ҿ਺)]Έ͍ͨͳܗͰॻ͍ͯ͘ ଐੑࣗମ΋Ϋϥε

  71. StructLayout ܕͷΠϯελϯε͕ϝϞϦ্ʹ֬อ͞ΕΔࡍͷϑΟʔϧυͷ ฒͼॱ(ϨΠΞ΢τ)Λࢦఆ͢Δ Ҿ਺͸LayoutKindྻڍମͷ͍ͣΕ͔ Auto͸CRLʹ೚ͤΔ Sequential͸ϑΟʔϧυͷϨΠΞ΢τΛ։ൃऀ͕ࢦఆͨ͠· ·ʹ͢Δ(એݴॱ) Explicit͸ΦϑηοτΛ࢖༻ͯ͠ϝϞϦ಺ͷϑΟʔϧυΛ໌ࣔ తʹ഑ஔ

  72. σϑΥϧτͰ͸ MicrosoftͷC#ίϯύΠϥͰ͸ࢀরܕ ͸AutoʹͳΔ ஋ܕ͸SequentialʹͳΔ

  73. using  System.Runtime.InteropServices;   [StructLayout(LayoutKind.Auto)]   internal  struct  SomeValue   {

           private  readonly  Byte  m_byte;        private  readonly  Int16  m_int;   }
  74. Explicit ΦϑηοτΛ࢖༻ͯ͠ϑΟʔϧυΛ໌ ࣔతͳॱ൪ʹ഑ஔ͢Δ ϑΟʔϧυʹ͸ɺΦϑηοτΛࣔ͢ FieldOffsetΛଐੑͱ͚ͯͭ͠Δ

  75. using  System.Runtime.InteropServices;   [StructLayout(LayoutKind.Explicit)]   internal  struct  SomeValue   {

           [FieldOffset(0)]        private  readonly  Byte  m_byte;        [FieldOffset(0)]        private  readonly  Int16  m_int;   }
  76. Φϑηοτ͕ॏͳΔ৔߹ [StructLayout(LayoutKind.Explicit)]          public  struct  SomeValue  

           {                  [FieldOffset(0)]                  public  Byte  m_byte;                  [FieldOffset(0)]                  public  Int16  m_int;          }          class  Test          {                  static  void  Main(string[]  args)                  {                          SomeValue  some  =  new  SomeValue();                          some.m_int  =  Int16.MaxValue;                          Console.WriteLine(some.m_byte);                  }          } Φϑηοτ͕ॏͳ͍ͬͯΔͷͰ m_byte͸ૢ࡞ͯ͠ͳ͍͕ ࣮ߦ݁Ռ͸255ʹͳΔ
  77. Dynamic

  78. Dynamic ࣮ࡍʹ͸Objectܕͱͯ͠ղऍ͞ΕΔ(੩త) ίϯύΠϥ͸dynamicࢦఆʹରͯ͠ద੾ͳ෦෼ʹ DynamicAttributeଐੑͷΠϯελϯεΛద༻͢Δ dynamic͔Βผͷܕ΁ͷม׵Ͱ͸ɺ໌ࣔతͳΩϟ ετΛলུग़དྷΔ ܕ͕ޓ׵ੑͷແ͍΋ͷʹΩϟετ͞ΕͨΒྫ֎

  79. ϦϑϨΫγϣϯͷίʔυ͕ //targetจࣈྻʹargจࣈྻؚ͕·ΕΔ͔Λ൑ఆ͢Δ   //ϦϑϨΫγϣϯΛ༻͍ͨϓϩάϥϜ   Object  target  =  "Target  string";

      Object  arg  =  "arg";   //ϝλσʔλͷܕ৘ใ͔ΒɺඞཁͳҾ਺ܕʹҰக͢Δϝιου৘ใΛநग़͢Δ   Type[]  argType  =  new  Type[]  {  arg.GetType()  };   _MethodInfo  method  =  target.GetType().GetMethod("Contains",  argType);   //ϝιου৘ใ͔ΒϝιουΛݺͼग़͢   Object[]  arguments  =  new  Object[]  {  arg  };   Boolean  result  =  Convert.ToBoolean(method.Invoke(target,  arguments));   Console.WriteLine(result);//݁Ռදࣔ
  80. ͜͜·Ͱ؆ܿʹͳΔ dynamic  target  =  "Target  string";   dynamic  arg  =

     "arg";   Boolean  result  =  target.Contains(arg);   Console.WriteLine(result); ϝλσʔλͷܕ৘ใͳͲΛಡΈࠐΉඞཁ͕͋Δ৔߹ dynamicΛ্ख͘࢖͏ࣄͰ͔ͳΓָʹϓϩάϥϜ͕ ॻ͚ΔΑ͏ʹͳΔʂʂ ಈతʹܕΛ൑ఆ͢Δͱ͍͏֓೦Λந৅ԽͰ͖Δ
  81. interface

  82. interfaceͱ͸ ػೳ(ϝιου)ͷΈΛ΋ͭந৅తͳܕ ͰɺΠϯελϯεԽͰ͖ͳ͍ ೚ҙͷΫϥεͰػೳͷڞ௨Խ͕ਤΕΔ ػೳΛڞ௨Խͨ͠೚ҙͷΫϥε͸ಉ͡ interfaceܕͷม਺ʹ֨ೲͰ͖ɺinterface Ͱఆٛͨ͠ػೳΛ࢖͏͜ͱ͕Ͱ͖Δ

  83. public abstract ϝιου͔͠ఆٛͰ͖ͳ͍ ͢΂ͯͷϝιου͸ΞΫηεम০ࢠΛ ࢦఆͰ͖ͳ͍(publicͱΈͳ͞ΕΔ) ͢΂ͯͷϝιου͸virtualͰ͋Δͱղ ऍ͞ΕΔ(೿ੜΫϥεͰoverride)

  84. interfaceͷҙٛ interfaceʹٻΊΒΕΔͷ͸ɺந৅తͰ͋Δ͜ͱ (࣮૷͸ҟͳͬͯ΋͍͍)ͱɺ೚ҙͷΫϥε͔Β ಉ͡Α͏ʹϝιουΛʮݺͼग़ͤΔʯ͜ͱ ந৅తͰ͋ΔͨΊɺϝιου͸abstractͱͯ͠ ղऍ͞ΕΔ ʮݺͼग़ͤΔඞཁ͕͋ΔʯͨΊɺϝιου͸ public

  85. ͭ·Γ interfaceͰ͸ɺ೚ҙͷΫϥεͰ࣮૷͕ ҟͳΔ͕ಉ໊͡લʹ͍ͨ͠ɺಉ͡ܕ ʹ֨ೲͯ۠͠ผͳ͘࢖͑ΔΑ͏ʹ͠ ͍ͨ৔߹ʹ༗༻ ػೳ͸ͳΔ΂͘interfaceʹநग़͠ɺͦ ΕΛ࣮૷͢ΔΑ͏ʹ͢Δ

  86. ྫ IComparebleΛ࣮૷͍ͯ͠ΔΫϥε͸஋ͷൺֱ ͕ՄೳͰ͋Δ ͜ΕΛจࣈͱ਺஋Ͱߟ͑ͯΈΔͱ࣮૷͸ҟͳ Δ͕ൺֱ(Compare)͍ͨ͠ͱ͍͏ҙຯͰ͸ಉ͡ ͜ͱ จࣈͩΖ͏͕਺஋ͩΖ͏͕IComparebleܕม਺ ʹͿͪࠐΊ͹ൺֱ͢Δػೳ͕࢖͑Δ

  87. abstract

  88. abstractͱ͸ ந৅Λҙຯ͢Δ Ϋϥεʹ࢖͏ͱந৅ΫϥεʹͳΔ ϝιουʹ࢖͏ͱந৅ϝιουʹͳΔ(ந৅Ϋϥε ಺ͰͷΈఆٛՄೳ) ந৅ϝιου͸҉໧తʹvirtual(೿ੜΫϥεͰ override) ந৅ϝιου͸࣮૷Λهड़͠ͳͯ͘Α͍

  89. interfaceͱͷҧ͍ ந৅ΫϥεͰ͸ϑΟʔϧυ͕΋ͯΔ ந৅ΫϥεͰ͸ϝιουΛ࣮૷ͯ͠΋Α͍ ந৅ϝιουʹ͢ΔϝιουʹͷΈ abstractΛ͚ͭΕ͹͍͍ ந৅౓͕ҧ͏(interfaceͷ΄͏͕ந৅త)

  90. interfaceͱͷ࢖͍෼͚ ಉ͡ίʔυΛ2౓ॻ͔ͳ͍ݪଇ͔ΒɺinterfaceͰ࣮૷Λผͷ΋ͷ ʹ͢Δඞཁͷͳ͍೚ҙͷΫϥε͸abstractʹ͢΂͖ ಺෦࣮૷(privateϝιου)Λ࣋ͭ͜ͱ͕Ͱ͖ΔͷͰɺinterfaceͰ ग़དྷͳ͍಺෦ॲཧͷڞ௨Խ΋Մೳ ϑΟʔϧυΛ࣋ͭ͜ͱ͕Ͱ͖ΔͷͰ೚ҙͷΫϥεͰಉ͡ϑΟʔ ϧυ͕ඞཁʹͳΔέʔε͕͋Δ৔߹ʹͪ͜ΒΛબͿ ͳΔ΂͘interfaceΛఆٛ͠ɺ͋Δఔ౓࣮૷ͷڞ௨ԽΛਤΔ৔߹ ͸abstractΛ࢖͏(interfaceΛܧঝ͢ΔabstractΫϥεΛఆٛ͢Δ ͷ͕ཧ૝)

  91. ந৅౓ͷҧ͍͔Βൺֱ ߦಈύλʔϯΛࣔ͢IActionPatternΠϯλϑΣʔε͕ ଘࡏ͢Δ IActionPatternΛܧঝ͢ΔPlayerActionPatternͱ EnemyActionPattern͕ଘࡏ͢Δͱ͢Δɻ͜ͷ྆ऀͰ ͸۩ମతͳߦಈύλʔϯͷ࣮૷΍ॴ࣋͢Δଐੑ͕ҟ ͳΔ ͲͪΒͷΦϒδΣΫτͰ͋Ζ͏ͱɺந৅౓ͷߴ͍ IActionPatternΠϯλϑΣʔε͔Βૢ࡞Մೳ

  92. ϚϧνίΞϓϩάϥϛϯά

  93. ϚϧνίΞͱ͸ ίΞ͸CPUͷத֩෦෼ ίΞ͕2ͭͷCPU͸2ίΞCPU 2ίΞCPU͸෺ཧίΞ਺2 1ίΞΛෳ਺ίΞ(࿦ཧίΞ਺ͰΧ΢ϯτ)ͷΑ͏ʹѻ͏ ϋΠύʔεϨοσΟϯά͕͋Δ ࿦ཧίΞ਺2ͷ෺ཧίΞΛ2ݸ౥ࡌͨ͠CPU͸࿦ཧίΞ ਺4

  94. ಉظ/ඇಉظͱ͸ ෳ਺ͷॲཧΛಉ࣌ʹ࣮ߦ͢Δ͜ͱ ಉظͷ৔߹ɺෳ਺ͷॲཧ͕ڞ௨ͷλ Πϛϯά৴߸ͳͲʹґଘ͢Δ ඇಉظͷ৔߹͸ڞ௨ͷλΠϛϯά৴ ߸౳ʹґଘ͠ͳ͍

  95. ϓϩηε ϓϩάϥϜΛ࣮ߦ͍ͯ͠Δঢ়ଶ ΞϓϦέʔγϣϯ1ݸىಈͯ͠Ε͹1ݸͷϓϩη ε͕ಈ͍ͯΔ ෳ਺ͷϓϩηεΛ࣮ߦ͍ͯ͠Δঢ়ଶ͕Ϛϧνϓ ϩηε ϚϧνϓϩηεͰͷ݁Ռͷ΍ΓऔΓ͸ग़དྷͳ͍ ͜ͱ͸ແ͍͕ҰൠతͰ͸ͳ͍

  96. εϨου ϓϩάϥϜΛ࣮ߦ͍ͯ͠Δͱ͖ͷ࠷খ࣮ߦ୯ Ґ 1ͭͷϓϩηε಺ʹ୯ମ·ͨ͸ෳ਺ଘࡏ͢Δ εϨου͕1ͭͳΒγϯάϧεϨου ෳ਺ͳΒϚϧνεϨου ϚϧνεϨουͳΒಉ࣌ʹॲཧΛ࣮ߦͰ͖Δ

  97. εϨουͷར఺ ىಈʹ͔͔ΔΦʔόʔϔου͕খ͍͞ εϨουؒͷ௨৴͕ϓϩηεؒ௨৴ʹൺ΂Ε͹ൺֱ త༰қʹߦ͑Δ OS͕؅ཧ͍ͯ͠Δ ࣮ߦ࣌ʹ͸ϥϯλΠϜ͕ෳ਺ͷεϨουΛੜ੒ͯ͠ ͍Δ εϨουϓʔϧͷར༻

  98. εϨουϓʔϧ Ұ౓ੜ੒ͨ͠εϨουΛཷΊ͓ͯ͘ͱ͜Ζ εϨου༻ͷΩϡʔʹॲཧΛ౤͛Δͱ͍͋ ͯΔεϨου্͕ख͍۩߹ʹॲཧΛ࣮ߦ͠ ͍ͯͬͯ͘ΕΔ εϨουΛ৽ͨʹੜ੒͠ͳ͍͍ͯͨ͘ΊΦʔ όʔϔου͕ແ͍

  99. εϨουͷ۠ผ جຊతʹεϨουʹछྨ͸ແ͍͕໨తʹ Α໊ͬͯલ͕͍͍ͭͯΔ ΞϓϦέʔγϣϯͰUIΛ੍ޚ͢ΔεϨο υΛUIεϨουͱ͍͏(UIͷมߋ͕Մೳ) UIεϨου͔Βىಈͨ͠εϨουΛϫʔ ΧʔεϨουͱ͍͏(UIͷมߋ͕ग़དྷͳ͍)

  100. ϑΥΞάϥ΢ϯυεϨου .NETͷϓϩάϥϜͰ௚઀ThreadΫϥεΛ ੜ੒͢ΔͱɺϑΥΞάϥ΢ϯυεϨου ͱͳΔ ෳ਺ͷϑΥΞάϥ΢ϯυεϨου͕͋ͬ ͨ৔߹ɺશͯͷϑΥΞάϥ΢ϯυεϨο υॲཧ͕׬ྃ͢Δ·ͰΞϓϦέʔγϣϯ ͸ऴྃ͠ͳ͍

  101. όοΫάϥ΢ϯυεϨου ThreadΫϥεΛੜ੒͠ɺIsBackgroundϓϩύςΟ Λftrueʹ͢Δ(͋Δ͍͸ผͷํ๏ͰεϨουΛੜ੒ ͢Δ)ͱόοΫάϥ΢ϯυεϨουͱͳΔ(نఆ஋͕ false) ϑΥΞάϥ΢ϯυεϨου͕શͯऴྃͨ࣌͠఺Ͱɺ όοΫάϥ΢ϯυεϨουͷॲཧ͕࢒͍ͬͯͯ΋ ΞϓϦέʔγϣϯ͸ڧ੍ऴྃ͢Δ εϨουϓʔϧ͸όοΫάϥ΢ϯυεϨου

  102. λεΫ εϨουʹ͔ΘΔ৽͍֓͠೦ ศརͰ൚༻ੑ͕ߴ͍ هड़͕؆ܿͰΘ͔Γ΍͍͢ ࢖͑ΔͳΒ͹ͳΔ΂͘λεΫΛ༻͍ Δ

  103. εϨουͷॲཧ׬ྃΛ஌Δʹ͸

  104. ϙʔϦϯά εϨουॲཧΛߦ͏ϝιουΛ࣋ͭ Ϋϥεʹɺॲཧ͕׬͍ྃͯ͠Δ͔Λ ද͢ϑϥάΛ࣋ͨͤɺ؅ཧ͓ͤͯ͞ ͘ ॲཧ͕׬͍ྃͯ͠Δ͔Ͳ͏͔͸ɺஞ ࣍ϑϥάΛ֬ೝ͢Ε͹Α͍

  105. Πϕϯτ௨஌ ओʹεϨουͰͷॲཧͷޙʹಛఆͷॲཧΛ࣮ ߦ͍ͨ࣌͠(tryʹର͢ΔfinallyͷΑ͏ͳ΋ͷ)ʹ ࢖͏ ॲཧ׬ྃޙʹΠϕϯτΛݺͼग़͢ߏ଄ʹͯ͠ ͓͘ ֎͔ΒΠϕϯτΛ௥Ճ͢Δ͜ͱͰॲཧ׬ྃ࣌ ʹࣗಈతʹͦͷΠϕϯτΛ࣮ߦͯ͘͠ΕΔ

  106. Wait ࣮ߦ͍ͯ͠Δॲཧ͕ऴͬͯ͘ΕΔ·Ͱɺ ϝΠϯͷεϨουͰ͸εϨουຖʹ ༻ҙ͞Ε͍ͯΔWaitΛ࣮ߦ͢Δ ͜͏͢Δ͜ͱͰɺWaitͰࢦఆͨ͠ε Ϩου͕ऴྃ͢Δ·Ͱ͸ॲཧΛࢭΊ ͓ͯ͘ࣄ͕ग़དྷΔ

  107. FCLͷ༷ʑͳεϨουॲཧ

  108. 1. ࢖͏ͷ͸UIεϨουʁϫʔΧʔεϨουʁ 2. εϨουͷ݁Ռ͸Ͳ͏΍ͬͯड͚औΔʁ 3. εϨουॲཧޙʹίʔϧόοΫϝιου (tryʹର͢ΔfinallyΈ͍ͨͳ΋ͷ)Λ࣮ߦͰ ͖Δʁ 4. ίʔϧόοΫϝιουͰεϨουॲཧޙ

    ͷ݁ՌΛड͚औΕΔʁ Question
  109. ThreadΫϥε ͜ͷํ๏͚͕ͩεϨουϓʔϧΛ࢖Θͳ͍ Thread t = new Thread(new ThreadStart(ॲཧ));ͱ͍͏ײ͡ͰεϨου Λ࡞Δ t.Start();ͰεϨου։࢝

    t.Join();ͰεϨουͷ׬ྃ·ͰݱࡏͷεϨουΛࢭΊΔ t.Abort();ͰॲཧΛଧͪ੾Δ(ThreadAbortExceptionΛൃੜͤ͞Δ) IsBackgroundͰϑΥΞ/όοΫάϥ΢ϯυΛมߋՄೳ IsBackgroundͷنఆ஋͸falseͰϑΥΞάϥ΢ϯυεϨου
  110. Answer -Thread- 1. UIεϨουͰ΋ϫʔΧʔεϨουͰ΋ࢦఆՄೳ 2. ड͚औΔखஈ͸ඪ४Ͱ༻ҙ͞Ε͍ͯͳ͍ɻThreadΛར༻͢ ΔΫϥεͷϑΟʔϧυͳͲΛར༻ͯ͠ڞ༗͢ΔͳͲ͔͠खஈ ͸ແ͍ 3. ඪ४Ͱ͸༻ҙ͞Ε͍ͯͳ͍ɻऴྃλΠϛϯάΛϙʔϦϯά/

    ΠϕϯτͳͲͰݕग़ͯࣗ͠෼ͰίʔϧόοΫϝιουΛݺͿ 4. ThreadͰ໭Γ஋Λαϙʔτ͍ͯ͠ͳ͍ͷͰແཧɻThreadΛ ར༻͢ΔΫϥεͷϑΟʔϧυͳͲΛར༻ͯ͠ڞ༗͢Δ
  111. ThreadPool bool result = ThreadPool.QueueUserWorkItem(new WaitCallback(ॲཧ),state);ͰΩϡʔʹॲཧΛૹΕΔ state͸ObjectܕͳͷͰɺ޷͖ͳҾ਺Λϥοϓͨ͠Ϋϥ εͳͲΛ౉ͯ͠ॲཧͰΩϟετ͠ɺ࢖ͬͨΓͰ͖Δ ໭Γ஋͸Ωϡʔʹ഑ஔͰ͖ͨΒtrue(͜ͷ໭Γ஋ʹҙຯ ͸͋·Γແ͍ͷͰࣺͯͯ΋OK)

    ॲཧ׬ྃΛ଴ͬͨΓڧ੍తʹதஅ͢Δ͜ͱ͸ग़དྷͳ͍
  112. Answer -ThreadPool- 1. ৗʹϫʔΧʔεϨου 2. Threadͱಉ༷ 3. Threadͱಉ༷ 4. Threadͱಉ༷

  113. Threadͱͷҧ͍ ৗʹϫʔΧʔεϨου ThreadͰ͸৽͍͠εϨουΛੜ੒͢Δ͕ɺ ThreadPoolͰ͸طʹଘࡏ͢ΔεϨουΛ্ख ͘ར༻ͯ͘͠ΕΔͷͰεϨουੜ੒ͷΦʔόʔ ϔου͕ແ͍ ϫʔΧʔεϨουͰ͍͍ͷͳΒͪ͜ΒΛੵۃ తʹར༻͢Δͱ͍͍

  114. delegate delegateܕ͸ίϯύΠϧ࣌ʹࣗಈͰBeginInvoke/EndInvoke͕࣮૷͞Ε Δ BeginInvokeΛ࣮ߦ͢ΔͱεϨουϓʔϧͷΩϡʔʹϝιουΛ౉ͤΔ Ҿ਺ʹ͸ॲཧ࣮ߦޙʹ࣮ߦͯ͠΄͍͠ॲཧ(ίʔϧόοΫϝιου)ͱͦ ͷॲཧʹඞཁͳҾ਺ ίʔϧόοΫϝιουͰॲཧ݁ՌΛར༻͍ͨ͠৔߹͸EndInvokeϝιο υΛ࢖͏(ίʔϧόοΫͰ݁ՌΛඞཁͱ͠ͳ͍ͷͳΒEndInvokeϝιο υ͸ෆཁͰ͋Δ) εϨουॲཧͷ׬ྃΛ଴ͭʹ͸໭Γ஋ͷIAsyncResultΛ࢖͑Δ

  115. Answer -delegate- 1. ৗʹϫʔΧʔεϨου(BeginInvoke͸εϨουϓʔϧʹ ॲཧΛ౤͛Δ) 2. BeginInvokeͷ݁ՌIAsyncResultΛ༻͍Δ 3. BeginInvokeͷୈೋୈࡾҾ਺͕ίʔϧόοΫϝιουؔ ܎

    4. BeginInvokeͷୈೋҾ਺ʹࢦఆͨ͠ϝιουͰEndInvoke Λ࣮ߦ͠ɺద੾ͳܕʹΩϟετ͢Δ͜ͱͰ݁ՌΛಘΒ ΕΔ
  116. BackgroundWorker ϑΥʔϜ༻ʹಋೖ͞Εͨ εϨουͰॲཧ͍ͤͨ͞ίʔυ͸DoWorkΠϕϯτϋϯ υϥʔʹ௥Ճ͢Δ RunWorkerAsyncͰεϨουΩϡʔʹॲཧΛૹΔ εϨουͷॲཧ͕׬ྃ͢ΔͱRunWorkerCompleteΠϕϯ τ͕ൃੜ͢Δ(͜ͷΠϕϯτ͸UIεϨουͰ࣮ߦ͞ΕΔ) CancelAsyncͰॲཧதஅΛཁٻͰ͖Δ

  117. Answer -BackgroundWorker- ϫʔΧʔεϨου ඪ४Ͱ͸උΘ͍ͬͯͳ͍ RunWorkerCompletedΠϕϯτʹొ࿥͢Ε ͹Α͍ ΠϕϯτϋϯυϥʔͷҾ਺Λ্ख͘࢖͑͹ ͍͚Δ

  118. EAPΛࣗ਎Ͱ࡞Δ System.ComponentModel໊લۭؒͷ ComponentΫϥεΛܧঝͯ͠ EAP(Event-based Asynchronous Pattern)ͷઃܭʹैͬͨಠࣗͷΫϥε Λ࡞ΕΔ ࠶ར༻ͯ͠΋Β͏෦඼ͳͲʹ࢖͏

  119. Task Task t = new Task(ॲཧ); t.Start();͜ΕͰॲཧΛελʔτग़དྷΔ Task t =

    Task.Run(ॲཧ);্2ߦΛ·ͱΊΒΕΔ Task t = new Task.Factory.StartNew(ॲཧ,Φϓγϣϯ);ͰΦϓγϣϯΛࢦఆ͠ ͯλεΫΛ࡞੒࣮͠ߦͰ͖Δ t.IsCompletedͰॲཧ͕׬͔ྃͨ͠Ͳ͏͔ௐ΂ΒΕΔ(ϙʔϦϯάͰ࢖͑Δ) t.Wait();ͰλεΫͷॲཧऴྃΛ଴ػͰ͖Δ Task.WaitAll(Մม௕ͰλεΫΛࢦఆ);੩తϝιουͰࢦఆͨ͠λεΫશͯͷ ऴྃΛ଴ػͰ͖Δ
  120. Answer -Task- 1. ϫʔΧʔεϨου 2. ໭Γ஋ͱͯ͠αϙʔτ͍ͯ͠Δ 3. ContinueWithϝιουΛνΣʔϯ͢ Δ͜ͱͰ؆୯ʹՄೳʹͳΔ 4.

    ؆୯ʹՄೳ
  121. εϨου͔Β໭Γ஋ΛಘΔ

  122. Thread/ThreadPool ໭Γ஋ͱͯ͠͸αϙʔτ͞Ε͍ͯͳ͍ ϑΟʔϧυͳͲΛڞ༗ͯ͠࢖͏ࣄͰ஋ ͷड͚౉͠Λ࣮ݱ͢Δ͔͠ͳ͍

  123. delegate BeginInvoke/EndInvokeϝιουΛ࢖༻͢Δ͜ͱͰ໭Γ஋Λऔ ಘͰ͖Δ ໭Γ஋IAsyncResultܕ͸AsyncResultʹΩϟετͰ͖Δ AsyncResult.AsyncDelegate͸εϨουϓʔϧʹ౤͛ͨ delegateʹΩϟετͰ͖Δ BeginInvokeϝιουͷ໭Γ஋͔Β͸࠷ऴతͳ݁ՌΛɺ EndInvokeϝιου͸ίʔϧόοΫϝιου಺Ͱ࢖༻͢Δ͜ ͱͰܧଓॲཧ͢ΔͨΊͷલͷॲཧͷ݁ՌΛಘΔ͜ͱ͕Ͱ͖Δ

  124. BackgroundWorker εϨουͰ࣮ߦ͞ΕΔϝιου͔Β௚઀஋͸ฦͤͳ ͍ DoWorkΠϕϯτϋϯυϥʔͷҾ਺DoWorkEventArgs ͷResultϓϩύςΟʹฦ͍ͨ͠஋ΛηοτͰ͖Δ RunWorkerCompletedΠϕϯτϋϯυϥʔͰ RunWorkerCompletedEventArgsͷResultϓϩύςΟ Λࢀর͢Δ͜ͱͰ஋ΛऔಘͰ͖Δ

  125. Task ໭Γ஋Λαϙʔτ͍ͯ͠Δ TaskΫϥεͷδΣωϦοΫ൛ʹฦ͍ͨ͠Ҿ਺Λࢦఆͯ͠ TaskΛ࡞੒͠࢖͏ Task<int> t = new Task<int>(ॲཧ); t.Start();

    int result = t.Result; ResultϓϩύςΟΛ࢖༻ͨ࣌͠఺Ͱɺݺͼग़͠ଆͷεϨο υ͸݁Ռ͕ฦͬͯ͘Δ·Ͱ଴ػ͢Δ
  126. εϨουͰॲཧ׬ྃޙʹ ଓ͚ͯผͷॲཧΛͤ͞Δ(ίʔϧόοΫ)

  127. Thread/ThreadPool ͜ΕΒͷΫϥεͰ͸εϨουॲཧ׬ ྃޙʹଓ͚ͯผͷॲཧΛ͢Δ࢓૊Έ ͸༻ҙ͞Ε͍ͯͳ͍ εϨουͷ׬ྃΛ଴ͬͯޙଓͷॲཧ Λ࣮ߦͤ͞Δඞཁ͕͋Δ

  128. delegate delegateͷBeginInvokeϝιουͷҾ਺ʹ͸ίʔϧόο Ϋϝιου͕౉ͤΔ εϨουͷॲཧ͕׬ྃ͢ΔͱίʔϧόοΫ͕ݺ͹ΕΔ ͜ͷίʔϧόοΫϝιου͸AsyncCallbackσϦήʔ τʹҰக͢ΔγάωνϟΛ࣋ͭඞཁ͕͋Δ ίʔϧόοΫϝιου͸ϫʔΧʔεϨουͰ࣮ߦ͞Ε ΔͷͰUIΛ௚઀ߋ৽Ͱ͖ͳ͍

  129. BackgroundWorker εϨουͰͷॲཧ͕׬ྃ͢ΔͱRunWorkerCompletedΠ ϕϯτ͕ݺ͹ΕΔ ͜ͷΠϕϯτϋϯυϥʹॲཧΛࢦఆ͓͚ͯ͠͹ܧଓ࣮ߦ ͞ΕΔ ͜ͷΠϕϯτϋϯυϥʔʹ౉͞ΕΔ RunWorkerCompletedEventArgsͷResultϓϩύςΟ͔Β લͷॲཧͷ݁ՌΛಘΔ͜ͱ͕Ͱ͖Δ UIεϨουͰ࣮ߦ͞ΕΔ

  130. EAP EAPͰ͸εϨουͷ׬ྃ࣌ʹ DoWorkCompletedΠϕϯτΛݺͼग़ ͢Α͏ʹ࡞Δ UIεϨουͰ࣮ߦ͞ΕΔ

  131. Task(ܧଓλεΫ) ContinueWithϝιουΛ࢖͏͜ͱͰॲཧΛܧଓ࣮ߦͤ͞Δ͜ͱ͕ Ͱ͖Δ ResultϓϩύςΟΛ࢖͏͜ͱͰ݁ՌΛಘΔ͜ͱ΋ग़དྷΔ ResultϓϩύςΟ࢖༻࣌ʹݺͼग़͠ଆͷεϨου͸ॲཧ׬ྃ·Ͱϒ ϩοΫ͞ΕΔ Task<string> t = Task.Run((

    ) => ॲཧ).ContinueWith<String>(_t => ॲཧ (_t.Result)); string result = t.Result;
  132. Thread

  133. using System;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Runtime.Remoting.Messaging;
 
 namespace

    ConsoleProject
 {
 class MainClass
 {
 public static void Main(string[] args)
 {
 Thread t = new Thread(new ThreadStart(Show));
 t.Start();
 Console.WriteLine("Main Method called.");
 t.Join();
 Console.WriteLine("exit...");
 }
 
 public static void Show()
 {
 Thread.Sleep(100);
 Console.WriteLine("Show Method called.");
 }
 }
 }

  134. using System;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Runtime.Remoting.Messaging;
 
 namespace

    ConsoleProject
 {
 class MainClass
 {
 static int x = 100;
 
 public static void Main(string[] args)
 {
 //2ͭͷεϨουͰڞ௨ͷϑΟʔϧυ(ࢿݯ)Λར༻͢Δ
 Thread t1 = new Thread(new ThreadStart(ShowAndIncrement));
 t1.Start();
 Thread t2 = new Thread(new ThreadStart(Show));
 t2.Start();
 
 //ऴྃ଴ͪ
 t1.Join();
 t2.Join();
 Console.WriteLine("exit...");
 }
 
 public static void ShowAndIncrement()
 {
 Thread.Sleep(100);
 Console.WriteLine("ShowAndIncrement Method called. ref value = { 0}", x++);
 }
 
 public static void Show()
 {
 Console.WriteLine("Show Method called. ref value = { 0}", x);
 }
 }
 } ShowAndIncrement͸͕࣌ؒ ͔͔ΔॲཧͳͷͰɺ͜ΕͰ͸ ࢥ͏Α͏ͳॱ൪Ͱ࣮ߦ͞Εͳ͍ Thread͸໭Γ஋Λαϙʔτ͍ͯ͠ͳ͍ͷͰ ϑΟʔϧυΛ࢖ͬͯڞ༗͢Δ(volatileम০͕٢ɻ ࠷దԽΛ๷͛Δ) ThreadStart͸Ҿ਺΋ αϙʔτ͞Εͯͳ͍
  135. using System;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Runtime.Remoting.Messaging;
 
 namespace

    ConsoleProject
 {
 class MainClass
 {
 static int x = 100;
 
 public static void Main(string[] args)
 {
 //2ͭͷεϨουͰڞ௨ͷϑΟʔϧυ(ࢿݯ)Λར༻͢Δ
 Thread t1 = new Thread(new ThreadStart(ShowAndIncrement));
 t1.Start();
 t1.Join();//ऴྃΛ଴ͭ
 Thread t2 = new Thread(new ThreadStart(Show));
 t2.Start();
 
 //ऴྃ଴ͪ
 t2.Join();
 Console.WriteLine("exit...");
 }
 
 public static void ShowAndIncrement()
 {
 Thread.Sleep(100);
 Console.WriteLine("ShowAndIncrement Method called. ref value = { 0}", x++);
 }
 
 public static void Show()
 {
 Console.WriteLine("Show Method called. ref value = { 0}", x);
 }
 }
 } ͜ΕͳΒ͏·͍͕͘͘ JoinͰॲཧΛ଴ͭ࣌ؒ ͕ඞཁʹͳΔ
  136. ThreadPool

  137. using System;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Runtime.Remoting.Messaging;
 
 namespace

    ConsoleProject
 {
 class MainClass
 {
 //ϙʔϦϯά͢ΔͨΊͷ࢓ֻ͚
 static bool endFunc = false;
 
 public static void Main(string[] args)
 {
 int x = 100;
 //Ωϡʔʹ഑ஔग़དྷͳ͔ͬͨ৔߹ʹfalse͕ฦͬͯ͘Δ͕΄΅ແҙຯͳͷͰී௨͸औಘ͠ͳͯ͘΋͍͍
 //ԿނͳΒɺ഑ஔग़དྷͳ͔ͬͨ৔߹͸ྫ֎͕ૹग़͞ΕΔ͔Β
 bool qurResult = ThreadPool.QueueUserWorkItem(new WaitCallback(Show), x);
 //εϨουϓʔϧͷॲཧ͕ऴ͔ྃͨ͠Λ൑ఆ͢Δ࢓ֻ͚͸ඪ४Ͱ͸༻ҙ͞Ε͍ͯͳ͍
 //ඞཁͳΒϙʔϦϯά͢Δ࢓ֻ͚Λࣗ෼Ͱ༻ҙ͢Δ
 while (!endFunc)
 {
 //ॲཧ͕ऴΔ·ͰϙʔϦϯά
 }
 Console.WriteLine("exit...");
 }
 
 public static void Show(object x)
 {
 Console.WriteLine(x);
 Thread.Sleep(2000);//2ඵ͔͔Δॲཧ
 endFunc = true;
 }
 }
 } ීஈ͸QueueUserWorkItem ͷ໭Γ஋͸ࣺͯͯΑ͍ ϙʔϦϯάͷखஈ͕༻ҙ ͞Ε͍ͯͳ͍ͨΊࣗ෼Ͱ ࣮૷͢Δඞཁ͕͋Δ WaitCallbackσϦήʔτͷ γάωνϟʹैͬͨϝιου
  138. delegate

  139. using System;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Runtime.Remoting.Messaging;
 
 namespace

    ConsoleProject
 {
 class MainClass
 {
 public static void Main(string[] args)
 {
 Action<int> act;
 act = n => Console.WriteLine(n);
 act.BeginInvoke(10, null, null);
 Console.ReadKey();
 }
 }
 }

  140. using System;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Runtime.Remoting.Messaging;
 
 namespace

    ConsoleProject
 {
 class TestDelegateAsync
 {
 
 class MainClass
 {
 public static void Main(string[] args)
 {
 TestDelegateAsync test = new TestDelegateAsync();
 TestDelegate d = test.DoWork;
 d.BeginInvoke(test.CallbackMethod, null);
 Console.ReadKey();
 }
 
 }
 
 public delegate int TestDelegate();
 
 //࣮ߦ͍ͨ͠ॲཧ
 public int DoWork()
 {
 Console.WriteLine("DoWork");
 return 100;
 }
 
 //AsyncCallbackͷγάωνϟʹैͬͨίʔϧόοΫϝιου
 public void CallbackMethod(IAsyncResult ar)
 {
 //BeginInvokeͷ݁ՌΛ࢖ͬͯɺͦͷεϨου͔Β݁ՌΛநग़ͯ͠දࣔ
 TestDelegate @delegate = (TestDelegate)((AsyncResult)ar).AsyncDelegate;
 int result = @delegate.EndInvoke(ar);
 Console.WriteLine(result);
 }
 }
 }
 ࣮ߦ͍ͨ͠ॲཧ͕ೖΔσϦήʔτΛ༻ҙͯ͠ ࣮ߦ͍ͨ͠ॲཧΛॻ͘ γάωνϟʹैͬͨίʔϧόοΫϝιου ͜ͷΑ͏ʹͯ݁͠ՌΛಘΒΕΔ
  141. Task

  142. namespace ConsoleProject
 {
 class MainClass
 {
 public static void Main(string[]

    args)
 {
 Console.WriteLine("Hello World!");
 var a = new TestAsync();
 //10͔Β1·Ͱදࣔ͢Δ͕
 //ঢ়گʹԠͯ͡දࣔॱ͕มΘΔ
 for (int i = 10; i > 0; --i)
 a.Func(i);
 Console.ReadKey();
 }
 }
 
 class TestAsync
 {
 public void Func(int x)
 {
 Task.Run(() =>
 {
 Thread.Sleep(100 * x);
 Console.WriteLine(x++);
 });
 }
 }
 }
 جຊతͳ࢖͍ํ Ҿ਺Λදࣔͯ͠Ճࢉ͢Δ ॏ͍ͨॲཧ
  143. ͔͠͠ɺ͜ͷํ๏ͩͱϓϩάϥϜ͕࣮ߦͯ͠ εϨουॲཧ͕ऴͬͯͳ͍ঢ়ଶͰ ΩʔΛೖྗͯ͠΋ ॲཧ్தͰڧ੍ऴྃ͞Εͯ͠·͏ ͜ΕΛղܾ͢ΔͨΊʹ ϝΠϯεϨουͰWait͢ΔͱҎԼͷΑ͏ʹͳΔ

  144. namespace ConsoleProject
 {
 class MainClass
 {
 public static void Main(string[]

    args)
 {
 Console.WriteLine("Hello World!");
 var a = new TestAsync();
 //10͔Β1·Ͱදࣔ͢Δ͕
 //ঢ়گʹԠͯ͡දࣔॱ͕มΘΔ
 Task[] tasks = new Task[10];
 for (int i = 10; i > 0; --i)
 tasks[i - 1] = a.Func(i);
 Task.WaitAll(tasks);
 Console.WriteLine("End All Tasks.");
 }
 }
 
 class TestAsync
 {
 public Task Func(int x)
 {
 return Task.Run(() =>
 {
 Thread.Sleep(100 * x);
 Console.WriteLine(x++);
 });
 }
 }
 } Runͷ໭Γ஋͸TaskܕͰ͋Δ (͖ͬ͞ͷϓϩάϥϜͰ͸ແࢹࣺͯͯͯͨ͠) શͯͷλεΫ(໭Γ஋Ͱಘͨ) ͕ऴྃ͢Δ·Ͱ଴ͭ
  145. namespace ConsoleProject
 {
 class MainClass
 {
 public static void Main(string[]

    args)
 {
 var a = new TestAsync();
 a.Func(100);
 }
 }
 
 class TestAsync
 {
 public void Func(int x)
 {
 var t = Task<int>.Run(() => x) .ContinueWith(a => Console.WriteLine(a.Result));
 t.Wait();
 }
 }
 } ໭Γ஋intͷॲཧΛͯ͠ɺͦͷ໭Γ஋Λ࢖༻ͨ͠ ίʔϧόοΫϝιουݺͼͩ͠ͷྫ ContinueWithϝιουͷҾ਺ʹೖ͖ͬͯͨ Runϝιουͷ໭Γ஋(Task<int>ܕ)ͷ ResultϓϩύςΟΛ࢖͑͹؆୯ʹ ίʔϧόοΫϝιουʹ஋ΛҾ͖౉ͤΔ
  146. async/await

  147. ໾ׂ TaskͷܧଓλεΫΛ؆қతʹߦ͏ͨΊͷߏจ ϝιου୯ҐͰܧଓεϨουΛ؆୯ʹهड़ग़དྷ ΔΑ͏ʹͳΔ ܧଓॲཧʹલͷॲཧ݁ՌΛ౉͢͜ͱ΋༰қ ܧଓॲཧ͚ͩͰͳ͘ɺผͷεϨουͰߦͬͯ΄ ͍͠ϝιουͷهड़ͷΑ͏ͳ࢖͍ํ΋ग़དྷΔ

  148. ໾ׂ(ଓ͖) ΞϓϦέʔγϣϯͷछྨ(WPF,Console,ASP౳)ʹԠ࣮ͨ͡ߦίϯςΩετΛ ղੳ͠ɺGUIεϨου΋͘͠͸ϫʔΧʔεϨουΛࣗಈͰ൑அ͢Δ(ͭ·Γ GUIΞϓϦέʔγϣϯͷ৔߹࣮ߦεϨου͸ࣗಈతʹGUIεϨουʹͳΔ) ࣮ߦίϯςΩετʹԠͯ͡GUIΞϓϦέʔγϣϯͷεϨου͕উखʹGUIε ϨουʹͳΔಈ࡞Λ཈੍͚ͨ͠Ε͹ɺTaskͷ੩తͳConfigureAwait(false)Λݺ ͼग़ͤ͹ྑ͍(trueΛ౉ͨ͠৔߹͸طఆͷಈ࡞ɻGUIΞϓϦέʔγϣϯͷ৔߹ ࣗಈతʹGUIεϨουʹͳΔ)ɻ ݫີʹݴ͏ͱɺܧଓλεΫͷ࣮ߦεϨου͕ࣗಈతʹGUIεϨουͰ࣮ߦ͞ ΕΔΑ͏ʹͳΔͨΊͷ৚݅͸ʮGUIΞϓϦέʔγϣϯ

    ͔ͭ ݺͼग़͠ݩε Ϩου͕GUIεϨουʯͰ͋Δ࣌ɻ
  149. async/awaitͷجຊ await͸म০ͨ͠Task<T>ܕΦϒδΣΫτͷඇಉظॲཧ͕׬ྃͨ͠ Βɺͦͷ݁ՌͷTܕม਺Λฦ͢ awaitͰम০ͨ͠จҎ߱ͷॲཧ͸ͦͷจ͕ऴྃͨ͠Β࣮ߦ͞ΕΔ awaitͰम০ͨ͠จͷ໭Γ஋Task<T>͸Tܕͷ݁Ռͱͯ͠ม׵͞ΕΔ async͸ϝιου಺ͰawaitΛ࢖͏͜ͱΛએݴ͢Δ async͸໭Γ஋ͱͯ͠return͞ΕͨTܕม਺ΛTask<T>ܕʹม׵͢Δ ϝιουͷ໭Γ஋͸void/Task(͜ͷ2ͭ͸ඇಉظॲཧͰͷ໭Γ஋ແ ͠)/Task<T>ܕͷ͍ͣΕ͔

  150. async/awaitΛ۩ମతʹ async͸C#ίϯύΠϥ͕ϝιουΛඇಉظεςʔτϚ γʔϯͱͯ͠ೝࣝ͢ΔͨΊʹඞཁɻͭ·Γawaitͱ͸ৗ ʹηοτͰ༻͍ΒΕΔ ඇಉظܧଓλεΫ͸͍ͭ݁Ռ͕ಘΒΕΔ͔͕ෆఆͰ͋ ΔɻͦͷͨΊɺ݁ՌΛTaskΦϒδΣΫτͰϥοϓ͠ɺ ݺͼग़͠ݩͰ׬͔ྃͨ͠Ͳ͏͔Λ֬ೝ͔ͯ͠Β݁ՌΛ औಘ͢Δඞཁ͕ΔɻͦͷͨΊɺasyncम০ࢠ͸ඇಉظ ܧଓλεΫͷ໭Γ஋ΛTaskͰϥοϓ͢Δ໾ׂ΋࣋ͭɻ

  151. async/awaitΛ۩ମతʹ(ଓ͖) await͸ޙଓͷTaskΦϒδΣΫτͷResultϓϩύςΟΛ໰ ͍߹Θͤɺॲཧ͕׬ྃͨ͠৔߹ʹޙଓͷॲཧΛݺͼग़͢ ͨΊͷػߏΛఏڙ͢Δɻ ࣮͸awaitͷޙଓͷΦϒδΣΫτ͸TaskͰͳ͘ͱ΋Α͘ɺ ࣮ࡍʹ͸GetAwaiter/IsCompletd/OnCompleted/GetResult ͕ͦΕͧΕ࣮૷͞Ε͍ͯΕ͹ɺͲΜͳܕͰ΋Α͍͜ͱʹ ͳ͍ͬͯΔɻ(ΠϯλϑΣʔε͢Βෆཁɻ༻ҙ͸͞Ε͍ͯ ΔͷͰɺग़དྷΔͳΒΠϯλϑΣʔεܧঝͨ͠΄͏͕਌੾) http://neue.cc/2013/03/27_401.html

  152. using System;
 using System.Threading.Tasks;
 using System.Threading;
 
 class async_await
 {


    static void Main(string[] args)
 {
 var test = new AsyncTest();
 test.Test1();
 Console.ReadKey();
 }
 }
 
 class AsyncTest
 {
 //͕͔͔࣌ؒΔͨΊɺผεϨουͰ࣮ߦͯ͠΄͍͠ॲཧ
 //(ผεϨουͰߦͬͯ΋ଞʹѱӨڹΛ༩͑ͳ͍લఏ)
 public async void Test1()
 {
 await Task.Run(() =>
 {
 Thread.Sleep(2000);
 Console.WriteLine("Test1ॲཧA");
 });
 }
 } ͜ͷ··ͩͱॲཧऴྃલʹ Կ͔ΩʔΛԡ͢ͱڧ੍ऴྃ
  153. using System;
 using System.Threading.Tasks;
 using System.Threading;
 
 class async_await
 {


    static void Main(string[] args)
 {
 var test = new AsyncTest();
 test.Test1();
 Console.ReadKey();
 }
 }
 
 class AsyncTest
 {
 //εϨουΛੜ੒͠ɺܧଓλεΫΛߦΘͤΔ
 //ॲཧB΋ॲཧAͱಉ͡εϨουͰߦΘΕ͍ͯΔ͜ͱʹ஫ҙ
 public async void Test1()
 {
 await Task.Run(() =>
 {
 //࣌ؒͷ͔͔ΔॲཧΛͯ͠΋awaitʹΑͬͯॲཧB͸࣮ߦ͞Εͳ͍
 Thread.Sleep(2000);
 Console.WriteLine("Test1ॲཧA");
 });
 Console.WriteLine("Test1ॲཧB");//ܧଓॲཧ
 }
 }
  154. using System;
 using System.Threading.Tasks;
 using System.Threading;
 
 
 class async_await


    {
 static void Main(string[] args)
 {
 var test = new AsyncTest();
 //√3Λදࣔ͢Δɻ
 //ResultϓϩύςΟʹΑΓॲཧऴྃ࣌·ͰϝΠϯεϨου΋ऴྃ͠ͳ͍
 Console.WriteLine(test.SumTwoAndSqrt(1.0, 2.0).Result);
 }
 }
 
 class AsyncTest
 {
 //2ͭͷҾ਺Λ଍ͯ͠ฏํࠜΛऔΔϝιουɻ
 //Sqrt͕return͢Δͷ͸doubleܕ͔ͩɺasyncम০ʹΑΓTask<double>ܕʹม׵͞ΕΔ
 public async Task<double> SumTwoAndSqrt(double num1, double num2)
 {
 //ຊདྷͳΒRun͸Task<double>Λฦ͕͢
 //awaitम০ʹΑΓ݁Ռͷdoubleܕม਺ͷΈ͕நग़͞Εͨ
 double result = await Task.Run(() => num1 + num2);
 return Math.Sqrt(result);//લͷॲཧ݁ՌresultΛ༰қʹ࢖͑Δ
 }
 }

  155. using  System;   using  System.Collections.Generic;   using  System.Linq;   using

     System.Text;   using  System.Threading;   using  System.Threading.Tasks;   internal  class  async_await   {      private  static  void  Main(string[]  args)      {          Task.Run(async  ()  =>          {              ////////////////////              //͜͜ʹԿΒ͔ͷॲཧ//              ////////////////////                await  Task.Run(()  =>  Thread.Sleep(1000));              Console.WriteLine("ඇಉظϥϜμࣜͷه๏");          });          Console.ReadKey();      }   }   ৽͍͠Task͔ΒܧଓλεΫΛݺͼग़͢ ͜ͱͰɺawait·ͰͷԿΒ͔ͷॲཧ͕ݺ ͼग़͠ݩͱಉ͡εϨου͔Βݺͼग़͞ ΕΔ͜ͱΛ๷͙͜ͱ͕Ͱ͖Δɻ ϥϜμࣜΛܧଓλεΫʹ͢Δ
  156. ܧଓλεΫͷར༻

  157. ڞ௨ͷࢿݯΛར༻͢Δ

  158. lockεςʔτϝϯτ MonitorΫϥεͷ؆қߏจ ϩοΫ͞ΕͨίʔυΛผͷεϨου͕࢖͓͏ͱ͢Δͱɺ ΦϒδΣΫτ͕ղ์͞ΕΔ·Ͱ଴ػ (ϒϩοΫ) ͢Δ lock͢Δ΂͖ΦϒδΣΫτΛlock͠ͳ͍Ͱ࢖༻͢Δϝιο υͳͲ͕ଘࡏͨ͠৔߹ɺlockΛ࢖͏ίʔυࣗ਎΋҆શͱ ݴ͑ͳ͘ͳΔ ڞ௨ʹѻ͏lock͕ඞཁͳ΋ͷΛࢀর͢Δ৔߹ɺࢀর͢Δ

    શͯͷՕॴͰlock͢΂͖Ͱ͋Δ
  159. using System;
 using System.Threading.Tasks;
 using System.Threading;
 
 
 class MainClass


    {
 public static void Main(string[] args)
 {
 var t1 = Task.Run(() =>
 {
 Console.WriteLine(ReadTargetLocked());
 });
 var t2 = Task.Run(() =>
 {
 IncrementLocked();
 });
 Task.WaitAll(t1, t2);
 }
 
 static int target = 1110;
 static object lockObj = new object();
 
 static int ReadTargetLocked()
 {
 lock (lockObj)
 {
 Thread.Sleep(1000);
 return target;
 }
 }
 
 static void IncrementLocked()
 {
 lock (lockObj)
 {
 ++target;
 }
 }
 } ΦϒδΣΫτ͕ϩοΫ͞Ε͍ͯΔͷͰ ଞͷεϨου͕ͦͷΦϒδΣΫτΛ ࢀর͠Α͏ͱ͢Δͱ ΦϒδΣΫτ͕ղ์͞ΕΔ·Ͱ଴ػ (ϒϩοΫ) ͞ΕΔ ௨ৗ͸lock༻ʹΦϒδΣΫτ Λ1ͭ༻ҙ͓ͯ͘͠ ڞ༗͍ͨ͠ΦϒδΣΫτࣗ਎Ͱ΋͍͍͕ ϩοΫม਺Λpublicͱͯ͠ѻ͍͍ͨ৔߹͸ σουϩοΫͷݪҼʹͳΓ͔Ͷͳ͍ ϩοΫ༻ม਺Λ༻ҙ͢Ε͹publicͰ΋ແ໰୊
  160. TPL

  161. TPLͷجຊ Task Parallel Library λεΫΛΑΓ؆୯ʹ࢖༻Ͱ͖Δ৔߹ ͕͋Δ

  162. using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;


    using System.Threading;
 
 class TPL
 {
 static void Main(string[] args)
 {
 var act = new Action[10];
 for (int i = 0; i < 10; ++i)
 act[i] = new Action(Show);
 //Invoke͸શͯ׬ྃ͢Δ·ͰϝΠϯεϨου͕ऴྃ͠ͳ͍ 
 Parallel.Invoke(act);
 Console.WriteLine("exit...");
 }
 
 static void Show()
 {
 Console.WriteLine("Hello.");
 }
 }
  163. using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;


    using System.Threading;
 
 class TPL
 {
 static void Main(string[] args)
 {
 //For͸શͯ׬ྃ͢Δ·ͰϝΠϯεϨου͕ऴྃ͠ͳ͍
 Parallel.For(0, 10, n =>
 {
 Thread.Sleep(100);
 Console.WriteLine(n);
 });
 
 Console.WriteLine("exit...");
 }
 }
  164. using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;


    using System.Threading;
 
 class TPL
 {
 static void Main(string[] args)
 {
 //ForAll͸શ࣮ͯߦ͞ΕΔ·ͰϝΠϯεϨου͕ऴྃ͠ͳ͍
 Enumerable.Range(0, 10).AsParallel().ForAll(n =>
 {
 Thread.Sleep(100);
 Console.WriteLine(n);
 });
 
 Console.WriteLine("exit...");
 }
 }
  165. ಉظίϯετϥΫτ

  166. ಉظίϯετϥΫτ εϨου(ϓϩηε)ؒʹ͓͚Δ஋ͷಉظ(ڞ༗)ΞʔΩςΫνϟ ϢʔβʔϞʔυͱΧʔωϧϞʔυ͕ଘࡏ͢Δ ϢʔβʔϞʔυͱΧʔωϧϞʔυͷػೳΛ࢖༻ͯ͠ػೳతʹ͍͍ ͱ͜औΓͷϋΠϒϦουίϯετϥΫτΛߏ੒Ͱ͖Δ Ͱ͖ΔݶΓϢʔβʔϞʔυΛ࢖༻͢Δ΂͖(ύϑΥʔϚϯεͷ໰୊) ΧʔωϧϞʔυͰ͸WindowsͷػೳΛར༻͢Δɻ௿଎͕ͩɺε Ϩου͕ผͷεϨουͷอ࣋͢ΔϦιʔεΛ࢖༻͠Α͏ͱ͢Δͱɺ Windows͕CPU࣌ؒΛແବʹ࢖༻͠ͳ͍Α͏ʹɺͦͷεϨουΛ ϒϩοΫ͢Δ͜ͱ͕Ͱ͖Δ

  167. ϢʔβʔϞʔυ volatileͱinterlocked͕ଘࡏ͢Δ volatile͸ίϯύΠϥʹΑΔ࠷దԽΛ཈ ੍ͯ͠͠·͏ͷͰଟ༻͢΂͖Ͱͳ͍ interlocked͸ൺֱతߴ଎Ͱ͋Γɺଟ༻ Ͱ͖Δ

  168. volatile ୯७ͳσʔλܕΛอ࣋͢Δม਺ʹର͢Δݪ࢝త ͳಡΈऔΓ·ͨ͸ॻ͖ࠐΈΛ࣮ߦ͢Δ volatileΩʔϫʔυΛ࢖༻ͨ͠ม਺͸ɺશͯ Volatile੩తΫϥεͷRead,WriteΛ༻͍ͯΞΫη ε͕ߦΘΕΔΑ͏ʹ͠ɺ͞ΒʹϑΟʔϧυΛϨ δελʹΩϟογϡͤͣɺશͯͷಡΈॻ͖͕࣮ ࡍʹϝϞϦͷ஋ͷಡΈॻ͖ʹͳΔΑ͏ʹ͢Δ

  169. interlocked ୯७ͳσʔλܕΛอ࣋͢Δม਺ʹର͢Δݪ࢝తͳಡΈऔΓ͓Αͼॻ ͖ࠐΈΛ࣮ߦ͢Δ InterlockedΫϥεͷ੩తͳϝιου (Increment,Decrement,Add,Exchange,CompareExchange)Λར༻͢Δ InterlockedΫϥεͷϝιουݺͼग़͠ΑΓ΋લͷ͋ΒΏΔม਺ͷॻ ͖ࠐΈ͸ϝιουݺͼग़͠ΑΓ΋લʹ࣮ߦ͞ΕΔ InterlockedΫϥεͷϝιουݺͼग़͠ΑΓ΋ޙͷ͋ΒΏΔม਺ͷಡ ΈࠐΈ͸ϝιουݺͼग़͠ΑΓ΋ޙʹ࣮ߦ͞ΕΔ ൺֱతߴ଎

  170. ΧʔωϧϞʔυ ΠϕϯτͱηϚϑΥ͕ଘࡏ͢Δ ΧʔωϧϞʔυ͸௿଎ ϛϡʔςοΫε͸Χ΢ϯτΛ1ʹͨ͠ ηϚϑΥ

  171. Πϕϯτ ΧʔωϧʹΑͬͯอ࣋͞ΕΔboolม਺ ʹΑͬͯɺεϨουͷ࣮ߦ΍ఀࢭΛ ੍ޚ͢Δ͜ͱ͕Ͱ͖Δ EventWaitHandleΛجఈΫϥεͱ͠ɺ AutoResetEvent,ManualResetEvent͕ ར༻ग़དྷΔ

  172. ηϚϑΥ ΧʔωϧʹΑͬͯอ࣋͞ΕΔInt32ܕͷม਺ ηϚϑΥΛ଴ػ͢ΔεϨου͸ɺηϚϑΥ͕0ͷͱ ͖͸ϒϩοΫ͞Εɺ0ΑΓେ͖͍৔߹ʹϒϩοΫ͕ ղআ͞ΕΔ ϒϩοΫ͕ղআ͞Εͨ࣌ɺΧʔωϧ͸ηϚϑΥͷ Χ΢ϯτΛ1ݮΒ͢ SemaphoreΫϥεʹΑΓػೳΛར༻ग़དྷΔ

  173. ϛϡʔςοΫε ૬ޓഉଞϩοΫΛදݱ͢Δ AutoResetEvent·ͨ͸Χ΢ϯτ͕1ͷ Semaphoreͱࣅͨಈ࡞Λ͢Δ ΑΓଟ͘ͷίετ͕͔͔ΔͨΊɺར ༻͸޷·Εͳ͍

  174. ϋΠϒϦου εϨουͷڝ߹͕ͳ͍৔߹ͷϢʔβʔϞʔυͷύ ϑΥʔϚϯεͷϝϦοτΛఏڙ͢Δ ෳ਺ͷεϨου͕ಉ࣌ʹಉظίϯετϥΫτʹର͠ ͯڝ߹ͨ͠৔߹ʹεϐϯॲཧ(CPU࣌ؒͷ࿘අ)Λ͠ ͳ͍ͱ͍͏ɺΧʔωϧϞʔυͷϝϦοτΛఏڙ͢Δ ͭ·ΓϢʔβʔϞʔυͱΧʔωϧϞʔυ(͜ͷ2ͭΛ ϓϦϛςΟϒίϯετϥΫτͱݴ͏)ͷϝϦοτͷΈ Λͱ͖ͬͯͯ࡞Γ্͛ͨػೳ

  175. FCLఏڙϋΠϒϦου ManualResetEventSlim SemaphoreSlim Monitor ReaderWriterLockSlim CountdownEvent Barrier