$30 off During Our Annual Pro Sale. View Details »

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

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

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

Es_Program

March 25, 2016
Tweet

More Decks by Es_Program

Other Decks in Programming

Transcript

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

    View Slide

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

    View Slide

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

    View Slide

  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ͱ͍͏ͷ΋͋Δ

    View Slide

  5. ॏཁͳͷ͸ϝλσʔλ
    ϝλσʔλʹ͸੩తʹඞཁͳܕ৘ใ͕
    ֨ೲ͞Ε͍ͯΔ
    ϝλσʔλ͔Βܕ৘ใΛಡΈࠐΜͩΓɺ
    ܕ৘ใ͔ΒϝϯόΛநग़ͨ͠Γग़དྷΔ
    ܕ৘ใ͕͋Ε͹৭ʑग़དྷΔ

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  10. ܕ

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  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ܕ

    View Slide

  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();  
           }  
    }

    View Slide

  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ճʹͳ͍ͬͯΔͷͰ
    ύϑΥʔϚϯε͸ྑ͘ͳΔ

    View Slide

  17. asԋࢉࢠ
    ޓ׵ੑ͕͋Ε͹ɺͦͷܕʹΩϟετ͠
    ͯฦ͢
    ޓ׵ੑ͕ແ͚Ε͹nullΛฦ͢
    ͳΔ΂͘isΑΓasΛ࢖͏

    View Slide

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

    View Slide

  19. ஋౉͠ͱࢀর౉͠

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  23. ੩తΫϥε

    View Slide

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

    View Slide

  25. ແݶ੔਺ܕ

    View Slide

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

    View Slide

  27. δΣωϦοΫ

    View Slide

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

    View Slide

  29. ؆୯ͳδΣωϦοΫྫ
    public  static  T  Max(T  a,T  b)  
                           where  T  :  IComparable  
                   {  
                           return  a.CompareTo(b)  >  0  ?  a  :  b;  
                   }
    where۟Λ࢖͏ࣄͰɺܕʹ͍ͭ
    ੍ͯ໿ΛՃ͑Δࣄ΋ग़དྷΔ
    http://ufcpp.net/study/csharp/sp2_generics.html

    View Slide

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

    View Slide

  31. มੑ

    View Slide

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

    View Slide

  33. ڞมੑͷྫ
           class  Test  
           {  
                   static  void  Main(string[]  args)  
                   {  
                           //stringܕͷҾ਺Λobjectܕʹͯ͠ฦ͚ͩ͢ͷσϦήʔτ  
                           Func  ParseObj  =  x  =>  x;  
                   }  
           }
    ஫ҙ͢΂͖͸ɺσϦήʔτʹରͯ͠୅ೖग़དྷΔͷ͸ ೿ੜ
    ΫϥεΛ໭Γ஋ͱ͢ΔϝιουͰ͋Δͱ͍͏͜ͱɻ

    View Slide

  34. ൓มੑͱ͸
    ೿ੜΫϥεΛҾ਺ͱ͢ΔσϦήʔτʹର͠
    ͯɺ جఈΫϥεΛҾ਺ͱ͢ΔσϦήʔτΛ
    ୅ೖͰ͖Δ͜ͱΛ൓มੑͱ͍͏
    ϝιουͷҾ਺ʹ೿ੜΫϥεΛ༩͑ͨ৔߹
    Ͱ͋ͬͯ΋ɺجఈΫϥεΛҾ਺ͱ͢Δϝιο
    υ͸ͦͷΪϟοϓΛٵऩ͢Δࣄ͕ग़དྷΔͨ
    Ί͜ͷΑ͏ͳࣄ͕ՄೳʹͳΔ(ͪΐͬͱ೉ղ)

    View Slide

  35. ྫ͑͹
    Action͸Ҿ਺ʹstringܕΛࢦఆͯ͠ॲཧΛ͢Δ΋ͷͰ͋Δ͔
    ΒɺҾ਺ʹ͸ʮ”จࣈ”ʯͷΑ͏ͳ΋ͷΛࢦఆग़དྷΔ
    Action͸Ҿ਺ʹobjectܕΛࢦఆͯ͠ॲཧΛ͢Δ΋ͷͳͷ
    Ͱɺ[“จࣈ”]ͷΑ͏ͳ΋ͷΛࢦఆ͢Δࣄ΋ग़དྷΔ
    Action objAction = x => { Console.Write(x); };
    Action strAction = objAction;
    stringΛҾ਺ʹऔΔstrActionʹରͯ͠ɺobjActionΛ୅ೖ͢
    Δࣄ͕ग़དྷΔཧ༝͸ɺobjActionͷҾ਺ʹstringܕΛࢦఆ͠
    ͯ΋ྑ͍ͨΊ(μ΢ϯΩϟετͳͷͰ҆શ)

    View Slide

  36. ࢖͏৔߹Ͱߟ͑Δ
    strAction("str")ʹ஫໨͢ΔͱɺҾ਺͸stringܕͰ͋Δɻ
    strAction಺ͷobjActionͰ͸ɺ͜ͷ”str”Λ҉໧తʹμ΢ϯΩϟε
    τ͢Δ
    objActionͰ͸Ҿ਺͸౰વobjectͰ͋Δ͔ΒɺstringͷػೳΛ࢖͏
    ͜ͱΛ໨తͱ͍ͯ͠ͳ͍ͨΊ҆શͰ͋Δ
    ΑͬͯɺҾ਺ͷܕ͕ಛԽͨ͠σϦήʔτʹҾ਺ͷܕ͕൚Խͨ͠
    σϦήʔτΛ௥Ճ͢Δ͜ͱ͸҆શͰ͋Δ
           class  Test  
           {  
                   static  void  Main(string[]  args)  
                   {  
                         Action  objAction  =  x  =>  {  Console.Write(x);  };  
                         Action  strAction  =  objAction;  
                         strAction("str");  
                   }  
           }  

    View Slide

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

    View Slide

  38. ൓มੑͷྫ
           class  Test  
           {  
                   delegate  void  OneParam(T  x);  
                   class  A  {  }  
                   class  B  :  A  {  }  
                   static  void  Main(string[]  args)  
                   {  
                           //൓มੑΛ࣋ͨͳ͍(Τϥʔ͕ग़Δ)  
                           OneParam  oneA  =  _1  =>  Console.WriteLine(_1);  
                           OneParam  oneB  =  oneA;//Τϥʔʂܕ͕҉໧తʹม׵Ͱ͖ͳ͍  
                           //൓มੑΛ࣋ͭ(σϦήʔτΛinʹΑͬͯम০ͨ͠৔߹)  
                           Action  actA  =  _2  =>  Console.WriteLine(_2);  
                           Action  actB  =  actA;  
                           actB(new  B());//actB಺ͷactAͰ͸ɺҾ਺BΫϥεΛAΫϥεʹμ΢ϯΩϟετ  
                   }  
           }

    View Slide

  39. ͪΐͬͱ੔ཧ͢Δͱ
    μ΢ϯΩϟετ͸҆શʹม׵ग़དྷΔ
    ڞมੑͱ൓มੑ͸δΣωϦοΫʹμ΢ϯΩϟετΛڐՄ͢Δͨ
    Ίͷ΋ͷ(҉໧తܕม׵ΛڐՄ͢Δ)
    ڞมੑ͸؆୯ʹཧղग़དྷΔ
    ൓มੑ͸ɺҰݟ͢ΔͱΞοϓΩϟετͬΆ͍Μ͚ͩͲɺ࢖͏ଆ
    Λߟ͑ͯΈΔͱͪΌΜͱμ΢ϯΩϟετʹͳͬͯΔ
    Ұݟ͢Δͱਅٯ͔ͩΒͦ͜ɺ"൓"มੑͬͯݴ͏ͷ͔΋Ͷ֮ͬͯ͑
    ํ͢ΔͱҾ਺ʹ͸ಛԽΫϥεΛࢦఆग़དྷΔΑͳ͙ͬͯ͢Θ͔Δ

    View Slide

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

    View Slide

  41. σϦήʔτ

    View Slide

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

    View Slide

  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);//ෳ਺ͷϝιου΁ͷࢀরΛ΋ͭσϦήʔτΛ࢖ͬͯΈΔ  
                   }  
           }
    ϝιου໊͸
    ϝιου΁ͷࢀর
    Λද͢ͱߟ͑Δ

    View Slide

  44. ൚༻σϦήʔτ
    δΣωϦοΫͳσϦήʔτ
    σϦήʔτΠϯελϯεੜ੒࣌ʹܕΛܾΊΔ
    ActionɾFunc౳͕༻ҙ͞Ε͍ͯΔ
    ActionɾFunc͸มੑΛ΋ͭ
    δΣωϦοΫʹvoidࢦఆ͸ग़དྷͳ͍

    View Slide

  45. ϥϜμࣜ

    View Slide

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

    View Slide

  47. ஗ԆධՁ

    View Slide

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

    View Slide

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

    View Slide

  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Λ࢖͍ͬͯΔ
    ͷͰɺϑϥάཱ͕ͭ͸ͣ…?

    View Slide

  51. ࣮ߦ݁Ռ͸…
    ϑϥάཱ͕ͬͯͳ͍ʂ ʹ ΞΫηε͞Εͯͳ͍
    ม਺queryΛ࣮ࡍʹ࢖͍ͬͯͳ͍ͨΊ

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  64.        class  ൓෮ࢠ  
           {  
                   static  void  Main(string[]  args)  
                   {  
                           var  n  =  YieldTest(4);  
                           foreach(var  a  in  n)  
                                   Console.WriteLine(a);              
                   }  
                   static  IEnumerable  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ͰཁૉΛฦ͍ͯ͠
    ͖ɺϝιουऴྃ࣌ʹγʔέ
    ϯεΛฦ͢
    ൓෮ࢠΠϯλϑΣʔεܕҎ֎
    ͷ஋͸ฦͤͳ͍(Ϧετ΍഑
    ྻͳͲΛ໭Γ஋ʹ͢Δࣄ͸ग़
    དྷͳ͍)

    View Slide

  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  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()  +  "จࣈ໨");  
                   }  
           }

    View Slide

  66. ແݶϧʔϓʁʁ
    private  static  IEnumerable  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;  
           }  
    }

    View Slide

  67. ແݶϧʔϓʁʁ
    ྫͰ͸ɺGet123ϝιου಺Ͱແݶϧʔϓ͕ىͬͯ͜
    ΔΑ͏ʹࡨ֮͠ɺදࣔ͸Ұ޲ʹ͞Εͳ͍ϓϩάϥϜ
    ͷΑ͏ʹࢥ͑Δ
    ͔ͦ͠͠Μͳ͜ͱ͸ͳ͍ɻ͔֬ʹແݶϧʔϓͰ͸͋
    Δ͕ɺίϯιʔϧʹ͸123123…..ͱදࣔ͞Ε͍ͯ
    ͘ɻ
    VSͷσόοάػೳΛ༻͍࣮ͯߦ͢Ε͹ͦͷཧ༝Λཧ
    ղग़དྷΔ(yield return΍஗ԆධՁͷੑ࣭͕Θ͔Δ)

    View Slide

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

    View Slide

  69. ଐੑ

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  73. using  System.Runtime.InteropServices;  
    [StructLayout(LayoutKind.Auto)]  
    internal  struct  SomeValue  
    {  
         private  readonly  Byte  m_byte;  
         private  readonly  Int16  m_int;  
    }

    View Slide

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

    View Slide

  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;  
    }

    View Slide

  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ʹͳΔ

    View Slide

  77. Dynamic

    View Slide

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

    View Slide

  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);//݁Ռදࣔ

    View Slide

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

    View Slide

  81. interface

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide


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

    View Slide

  87. abstract

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  109. ThreadΫϥε
    ͜ͷํ๏͚͕ͩεϨουϓʔϧΛ࢖Θͳ͍
    Thread t = new Thread(new ThreadStart(ॲཧ));ͱ͍͏ײ͡ͰεϨου
    Λ࡞Δ
    t.Start();ͰεϨου։࢝
    t.Join();ͰεϨουͷ׬ྃ·ͰݱࡏͷεϨουΛࢭΊΔ
    t.Abort();ͰॲཧΛଧͪ੾Δ(ThreadAbortExceptionΛൃੜͤ͞Δ)
    IsBackgroundͰϑΥΞ/όοΫάϥ΢ϯυΛมߋՄೳ
    IsBackgroundͷنఆ஋͸falseͰϑΥΞάϥ΢ϯυεϨου

    View Slide

  110. Answer -Thread-
    1. UIεϨουͰ΋ϫʔΧʔεϨουͰ΋ࢦఆՄೳ
    2. ड͚औΔखஈ͸ඪ४Ͱ༻ҙ͞Ε͍ͯͳ͍ɻThreadΛར༻͢
    ΔΫϥεͷϑΟʔϧυͳͲΛར༻ͯ͠ڞ༗͢ΔͳͲ͔͠खஈ
    ͸ແ͍
    3. ඪ४Ͱ͸༻ҙ͞Ε͍ͯͳ͍ɻऴྃλΠϛϯάΛϙʔϦϯά/
    ΠϕϯτͳͲͰݕग़ͯࣗ͠෼ͰίʔϧόοΫϝιουΛݺͿ
    4. ThreadͰ໭Γ஋Λαϙʔτ͍ͯ͠ͳ͍ͷͰແཧɻThreadΛ
    ར༻͢ΔΫϥεͷϑΟʔϧυͳͲΛར༻ͯ͠ڞ༗͢Δ

    View Slide

  111. ThreadPool
    bool result = ThreadPool.QueueUserWorkItem(new
    WaitCallback(ॲཧ),state);ͰΩϡʔʹॲཧΛૹΕΔ
    state͸ObjectܕͳͷͰɺ޷͖ͳҾ਺Λϥοϓͨ͠Ϋϥ
    εͳͲΛ౉ͯ͠ॲཧͰΩϟετ͠ɺ࢖ͬͨΓͰ͖Δ
    ໭Γ஋͸Ωϡʔʹ഑ஔͰ͖ͨΒtrue(͜ͷ໭Γ஋ʹҙຯ
    ͸͋·Γແ͍ͷͰࣺͯͯ΋OK)
    ॲཧ׬ྃΛ଴ͬͨΓڧ੍తʹதஅ͢Δ͜ͱ͸ग़དྷͳ͍

    View Slide

  112. Answer -ThreadPool-
    1. ৗʹϫʔΧʔεϨου
    2. Threadͱಉ༷
    3. Threadͱಉ༷
    4. Threadͱಉ༷

    View Slide

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

    View Slide

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

    View Slide

  115. Answer -delegate-
    1. ৗʹϫʔΧʔεϨου(BeginInvoke͸εϨουϓʔϧʹ
    ॲཧΛ౤͛Δ)
    2. BeginInvokeͷ݁ՌIAsyncResultΛ༻͍Δ
    3. BeginInvokeͷୈೋୈࡾҾ਺͕ίʔϧόοΫϝιουؔ
    ܎
    4. BeginInvokeͷୈೋҾ਺ʹࢦఆͨ͠ϝιουͰEndInvoke
    Λ࣮ߦ͠ɺద੾ͳܕʹΩϟετ͢Δ͜ͱͰ݁ՌΛಘΒ
    ΕΔ

    View Slide

  116. BackgroundWorker
    ϑΥʔϜ༻ʹಋೖ͞Εͨ
    εϨουͰॲཧ͍ͤͨ͞ίʔυ͸DoWorkΠϕϯτϋϯ
    υϥʔʹ௥Ճ͢Δ
    RunWorkerAsyncͰεϨουΩϡʔʹॲཧΛૹΔ
    εϨουͷॲཧ͕׬ྃ͢ΔͱRunWorkerCompleteΠϕϯ
    τ͕ൃੜ͢Δ(͜ͷΠϕϯτ͸UIεϨουͰ࣮ߦ͞ΕΔ)
    CancelAsyncͰॲཧதஅΛཁٻͰ͖Δ

    View Slide

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

    View Slide

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

    View Slide

  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(Մม௕ͰλεΫΛࢦఆ);੩తϝιουͰࢦఆͨ͠λεΫશͯͷ
    ऴྃΛ଴ػͰ͖Δ

    View Slide

  120. Answer -Task-
    1. ϫʔΧʔεϨου
    2. ໭Γ஋ͱͯ͠αϙʔτ͍ͯ͠Δ
    3. ContinueWithϝιουΛνΣʔϯ͢
    Δ͜ͱͰ؆୯ʹՄೳʹͳΔ
    4. ؆୯ʹՄೳ

    View Slide

  121. εϨου͔Β໭Γ஋ΛಘΔ

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  125. Task
    ໭Γ஋Λαϙʔτ͍ͯ͠Δ
    TaskΫϥεͷδΣωϦοΫ൛ʹฦ͍ͨ͠Ҿ਺Λࢦఆͯ͠
    TaskΛ࡞੒͠࢖͏
    Task t = new Task(ॲཧ);
    t.Start();
    int result = t.Result;
    ResultϓϩύςΟΛ࢖༻ͨ࣌͠఺Ͱɺݺͼग़͠ଆͷεϨο
    υ͸݁Ռ͕ฦͬͯ͘Δ·Ͱ଴ػ͢Δ

    View Slide

  126. εϨουͰॲཧ׬ྃޙʹ
    ଓ͚ͯผͷॲཧΛͤ͞Δ(ίʔϧόοΫ)

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  132. Thread

    View Slide

  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.");

    }

    }

    }


    View Slide

  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͸Ҿ਺΋
    αϙʔτ͞Εͯͳ͍

    View Slide

  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ͰॲཧΛ଴ͭ࣌ؒ
    ͕ඞཁʹͳΔ

    View Slide

  136. ThreadPool

    View Slide

  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σϦήʔτͷ
    γάωνϟʹैͬͨϝιου

    View Slide

  138. delegate

    View Slide

  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 act;

    act = n => Console.WriteLine(n);

    act.BeginInvoke(10, null, null);

    Console.ReadKey();

    }

    }

    }


    View Slide

  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);

    }

    }

    }

    ࣮ߦ͍ͨ͠ॲཧ͕ೖΔσϦήʔτΛ༻ҙͯ͠
    ࣮ߦ͍ͨ͠ॲཧΛॻ͘
    γάωνϟʹैͬͨίʔϧόοΫϝιου
    ͜ͷΑ͏ʹͯ݁͠ՌΛಘΒΕΔ

    View Slide

  141. Task

    View Slide

  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++);

    });

    }

    }

    }

    جຊతͳ࢖͍ํ
    Ҿ਺Λදࣔͯ͠Ճࢉ͢Δ
    ॏ͍ͨॲཧ

    View Slide

  143. ͔͠͠ɺ͜ͷํ๏ͩͱϓϩάϥϜ͕࣮ߦͯ͠
    εϨουॲཧ͕ऴͬͯͳ͍ঢ়ଶͰ
    ΩʔΛೖྗͯ͠΋
    ॲཧ్தͰڧ੍ऴྃ͞Εͯ͠·͏
    ͜ΕΛղܾ͢ΔͨΊʹ
    ϝΠϯεϨουͰWait͢ΔͱҎԼͷΑ͏ʹͳΔ

    View Slide

  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ܕͰ͋Δ
    (͖ͬ͞ͷϓϩάϥϜͰ͸ແࢹࣺͯͯͯͨ͠)
    શͯͷλεΫ(໭Γ஋Ͱಘͨ)
    ͕ऴྃ͢Δ·Ͱ଴ͭ

    View Slide

  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.Run(() => x)
    .ContinueWith(a => Console.WriteLine(a.Result));

    t.Wait();

    }

    }

    }
    ໭Γ஋intͷॲཧΛͯ͠ɺͦͷ໭Γ஋Λ࢖༻ͨ͠
    ίʔϧόοΫϝιουݺͼͩ͠ͷྫ
    ContinueWithϝιουͷҾ਺ʹೖ͖ͬͯͨ
    Runϝιουͷ໭Γ஋(Taskܕ)ͷ
    ResultϓϩύςΟΛ࢖͑͹؆୯ʹ
    ίʔϧόοΫϝιουʹ஋ΛҾ͖౉ͤΔ

    View Slide

  146. async/await

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

  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");

    });

    }

    }
    ͜ͷ··ͩͱॲཧऴྃલʹ
    Կ͔ΩʔΛԡ͢ͱڧ੍ऴྃ

    View Slide

  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");//ܧଓॲཧ

    }

    }

    View Slide

  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ܕʹม׵͞ΕΔ

    public async Task SumTwoAndSqrt(double num1, double num2)

    {

    //ຊདྷͳΒRun͸TaskΛฦ͕͢

    //awaitम০ʹΑΓ݁Ռͷdoubleܕม਺ͷΈ͕நग़͞Εͨ

    double result = await Task.Run(() => num1 + num2);

    return Math.Sqrt(result);//લͷॲཧ݁ՌresultΛ༰қʹ࢖͑Δ

    }

    }


    View Slide

  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·ͰͷԿΒ͔ͷॲཧ͕ݺ
    ͼग़͠ݩͱಉ͡εϨου͔Βݺͼग़͞
    ΕΔ͜ͱΛ๷͙͜ͱ͕Ͱ͖Δɻ
    ϥϜμࣜΛܧଓλεΫʹ͢Δ

    View Slide

  156. ܧଓλεΫͷར༻

    View Slide

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

    View Slide

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

    View Slide

  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Ͱ΋ແ໰୊

    View Slide

  160. TPL

    View Slide

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

    View Slide

  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.");

    }

    }

    View Slide

  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...");

    }

    }

    View Slide

  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...");

    }

    }

    View Slide

  165. ಉظίϯετϥΫτ

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide