ARC සම්පාදකයා විසින් මට පහත අනතුරු ඇඟවීම ලැබෙමින් පවතී:

"performSelector may cause a leak because its selector is unknown".

මෙන්න මම කරන්නේ:

[_controller performSelector:NSSelectorFromString(@"someMethod")];

මට මෙම අනතුරු ඇඟවීම ලැබෙන්නේ ඇයි? තේරීම් කාරකය සිටීද නැද්ද යන්න සම්පාදකයාට පරීක්ෂා කළ නොහැකි බව මට වැටහී ඇත, නමුත් එය කාන්දු වීමට හේතුව කුමක්ද? මට තවදුරටත් මෙම අනතුරු ඇඟවීම නොලැබෙන පරිදි මගේ කේතය වෙනස් කරන්නේ කෙසේද?

විසඳුමක්

සම්පාදකයා මේ ගැන අනතුරු අඟවන්නේ හේතුවක් ඇතුවයි. මෙම අනතුරු ඇඟවීම නොසලකා හැරීම ඉතා කලාතුරකිනි, එය වටා වැඩ කිරීම පහසුය. මෙන්න කොහොමද:

if (!_controller) { return; }
SEL selector = NSSelectorFromString(@"someMethod");
IMP imp = [_controller methodForSelector:selector];
void (*func)(id, SEL) = (void *)imp;
func(_controller, selector);

හෝ වඩාත් දැඩි ලෙස (කියවීමට අපහසු සහ ආරක්ෂකයා නොමැතිව):

SEL selector = NSSelectorFromString(@"someMethod");
((void (*)(id, SEL))[_controller methodForSelector:selector])(_controller, selector);

පැහැදිලි කිරීම

මෙහි සිදුවන්නේ ඔබ පාලකයට අනුරූප වන ක්‍රමවේදය සඳහා සී ක්‍රියාකාරී දර්ශකය සඳහා පාලකගෙන් ඉල්ලා සිටීමයි. සියල්ලටම NSObjectප්‍රතිචාර දක්වයි methodForSelector:, නමුත් ඔබට class_getMethodImplementationපරමාර්ථ-සී ධාවන වේලාවේද භාවිතා කළ හැකිය (ඔබට ප්‍රයෝජනවත් වන්නේ ප්‍රොටොකෝල් යොමු කිරීමක් නම් පමණි id<SomeProto>). මෙම ශ්‍රිත දර්ශකයන් IMPs ලෙස හැඳින්වෙන අතර සරල typedefසංස්කරණ ශ්‍රිත දර්ශක ( id (*IMP)(id, SEL, ...)) ¹ වේ. මෙය ක්‍රමයේ සත්‍ය ක්‍රම අත්සනට ආසන්න විය හැකි නමුත් සෑම විටම හරියටම නොගැලපේ.

ඔබ සතුව ඇති පසු IMP, ඔබට එය ARC ට අවශ්‍ය සියලු තොරතුරු ඇතුළත් වන ක්‍රියාකාරී දර්ශකයකට දැමිය යුතුය (ව්‍යාජ සැඟවුණු තර්ක දෙක selfසහ _cmdසෑම අරමුණු-සී ක්‍රමවේදයම ඇතුළුව ). මෙය හසුරුවනු ලබන්නේ තුන්වන පේළියේ ය ( (void *)දකුණු පැත්තේ සරලවම ඔබ කරන්නේ කුමක්දැයි ඔබ දන්නා බවත්, දර්ශක වර්ග නොගැලපෙන බැවින් අනතුරු ඇඟවීමක් නොකළ යුතු බවත් සම්පාදකයාට කියයි).

අවසාන වශයෙන්, ඔබ ශ්‍රිත දර්ශකය ² අමතන්න .

සංකීර්ණ උදාහරණය

තේරීම්කරු තර්ක ගෙන හෝ වටිනාකමක් ලබා දුන් විට, ඔබට දේවල් ටිකක් වෙනස් කිරීමට සිදුවේ:

SEL selector = NSSelectorFromString(@"processRegion:ofView:");
IMP imp = [_controller methodForSelector:selector];
CGRect (*func)(id, SEL, CGRect, UIView *) = (void *)imp;
CGRect result = _controller ?
  func(_controller, selector, someRect, someView) : CGRectZero;

අවවාදය සඳහා තර්කනය

මෙම අනතුරු ඇඟවීමට හේතුව ARC සමඟ, ඔබ අමතන ක්‍රමයේ ප්‍රති result ලය සමඟ කුමක් කළ යුතු දැයි ධාවන කාලයට දැන ගැනීමට අවශ්‍ය වේ. ප්රතිඵලය කිසිම දෙයක් විය හැකි: void, int, char, NSString *, id, ආදිය ARC සාමාන්යයෙන් මෙම තොරතුරු ඔබ සමඟ වැඩ කරන්නේ වස්තුව වර්ගයේ ශීර්ෂ ලැබෙනවා. ³

ප්‍රතිලාභ අගය සඳහා ARC විසින් සලකා බැලිය යුතු කරුණු 4 ක් පමණි: ⁴

1. වස්තුව නොවන වර්ග (නොතකා void, int, ආදී)
2. වස්තු අගය රඳවා තබා, එය තවදුරටත් භාවිතා නොකරන විට මුදා හරින්න (සම්මත උපකල්පනය)
3. තවදුරටත් භාවිතා නොකරන විට නව වස්තු අගයන් මුදා හරින්න ( init/ copyපවුලේ ක්‍රම හෝ ආරෝපිත ns_returns_retained)
4. කිසිවක් නොකරන්න සහ ආපසු ලබා දුන් වස්තු වටිනාකම දේශීය විෂය පථයට වලංගු වේ යැයි උපකල්පනය කරන්න (අභ්‍යන්තරයේ බොහෝ මුදාහැරීමේ සංචිතය සිඳී යන තුරු, ආරෝපණය කර ඇත ns_returns_autoreleased)

methodForSelector:උපකල්පනය සඳහා වන ඇමතුම, එය කැඳවන ක්‍රමයේ ප්‍රතිලාභ අගය වස්තුවක් වන නමුත් එය රඳවා තබා ගැනීමට / මුදා හැරීමට නොහැකි වේ. එබැවින් ඉහත # 3 හි ඇති ආකාරයට ඔබේ වස්තුව මුදා හැරීමට අවශ්‍ය නම් ඔබට කාන්දුවක් නිර්මාණය විය හැකිය (එනම්, ඔබ අමතන ක්‍රමය නව වස්තුවක් ලබා දෙයි).

තේරීම්කරුවන් සඳහා ඔබ එම ආපසු voidහෝ වෙනත් වස්තු නොවන ඇමතුම් ලබා ගැනීමට උත්සාහ කරන්නේ නම් , ඔබට අනතුරු ඇඟවීම නොසලකා හැරීමට සම්පාදක විශේෂාංග සක්‍රීය කළ හැකි නමුත් එය භයානක විය හැකිය. ක්ලැන්ග් දේශීය විචල්‍යයන්ට පවරා නැති ප්‍රතිලාභ අගයන් හසුරුවන ආකාරය පිළිබඳ පුනරාවර්තන කිහිපයක් හරහා මම දැක ඇත්තෙමි. ARC සක්‍රීය කර ඇති විට ඔබට එය භාවිතා කිරීමට අවශ්‍ය නොවුවද ආපසු ලබා දුන් වස්තු අගය රඳවා තබා ගැනීමට සහ මුදා හැරීමට නොහැකි බවට කිසිදු හේතුවක් නැත methodForSelector:. සම්පාදකයාගේ දෘෂ්ටි කෝණයෙන් බලන කල, එය සියල්ලට පසු වස්තුවකි. එයින් අදහස් වන්නේ ඔබ අමතන ක්‍රමය, someMethodවස්තුවක් නොවන (ඇතුළුව void) ආපසු ලබා දෙන්නේ නම් , ඔබට කුණු කන්දක් අගයක් රඳවා තබා ගැනීම / මුදා හැරීම හා බිඳ වැටීම සමඟ අවසන් විය හැකි බවයි.

අතිරේක තර්ක

එක් සලකා බැලීමක් නම්, මෙය එකම අනතුරු ඇඟවීමක් වන අතර එම performSelector:withObject:ක්‍රමය පරාමිතීන් පරිභෝජනය කරන ආකාරය ප්‍රකාශ නොකිරීමත් සමඟ ඔබට සමාන ගැටළු වලට මුහුණ දිය හැකිය. පරිභෝජනය කරන ලද පරාමිතීන් ප්‍රකාශ කිරීමට ARC ඉඩ ලබා දෙන අතර, ක්‍රමය පරාමිතිය පරිභෝජනය කරන්නේ නම්, ඔබ අවසානයේදී පිල්ලියකට පණිවිඩයක් යවා බිඳ වැටෙනු ඇත. පාලම් වාත්තු කිරීම සමඟ මෙය වටා වැඩ කිරීමට ක්‍රම තිබේ, නමුත් ඇත්ත වශයෙන්ම IMPඉහත සහ ක්‍රියාකාරී දර්ශක ක්‍රමවේදය භාවිතා කිරීම වඩා හොඳය . පරිභෝජනය කරන ලද පරාමිතීන් කලාතුරකින් ගැටළුවක් වන බැවින්, මෙය මතු නොවනු ඇත.

ස්ථිතික තේරීම්

සිත්ගන්නා කරුණ නම්, සංඛ්‍යාත්මකව ප්‍රකාශයට පත් කරන ලද තේරීම් කාරක ගැන සම්පාදකයා පැමිණිලි නොකරනු ඇත:

[_controller performSelector:@selector(someMethod)];

එයට හේතුව සම්පාදකයාට තේරීම් කාරකය සහ වස්තුව පිළිබඳ සියලු තොරතුරු සම්පාදනය කිරීමේදී සැබවින්ම පටිගත කිරීමට හැකි වීමයි. එයට කිසිවක් ගැන උපකල්පන කිරීමට අවශ්‍ය නැත. (මම මීට වසරකට පෙර මූලාශ්‍රය බැලීමෙන් මෙය පරීක්ෂා කළෙමි, නමුත් දැන් යොමු කිරීමක් නොමැත.)

මර්දනය

මෙම අනතුරු ඇඟවීම යටපත් කිරීම අත්‍යවශ්‍ය සහ හොඳ කේත සැලසුමක් ගැන සිතීමට උත්සාහ කිරීමේදී, මම හිස්ව සිටිමි. මෙම අනතුරු ඇඟවීම නිශ්ශබ්ද කිරීම අවශ්‍ය වූ අත්දැකීමක් ඔවුන් සතුව තිබේ නම් කරුණාකර යමෙක් බෙදා ගන්න (සහ ඉහත කරුණු නිසි ලෙස හසුරුවන්නේ නැත).

තව

මෙය NSMethodInvocationහැසිරවීමට අවශ්‍යතාවයක් ගොඩනගා ගත හැකි නමුත් එසේ කිරීම සඳහා තවත් ටයිප් කිරීමක් අවශ්‍ය වන අතර එය මන්දගාමී වේ, එබැවින් එය කිරීමට සුළු හේතුවක් ඇත.

ඉතිහාසය

වූ විට performSelector:ක්රම පවුලේ පළමු අරමුණ සී එක් කරන ලදී, ARC පවතී නැත. ARC නිර්මාණය කරන අතරතුර, ඇපල් විසින් මෙම ක්‍රම සඳහා අනතුරු ඇඟවීමක් ජනනය කළ යුතු බව තීරණය කරන ලද්දේ නම් කරන ලද තේරීම් කාරකයක් හරහා අත්තනෝමතික පණිවිඩ යැවීමේදී මතකය හැසිරවිය යුතු ආකාරය පැහැදිලිව නිර්වචනය කිරීම සඳහා සංවර්ධකයින්ට වෙනත් ක්‍රම භාවිතා කිරීමට මඟ පෙන්වීම සඳහා ය. පරමාර්ථ-සී හි, අමු ශ්‍රිත දර්ශක මත සී ස්ටයිල් කැස්ට් භාවිතා කිරීමෙන් සංවර්ධකයින්ට මෙය කළ හැකිය.

ස්විෆ්ට් හදුන්වා දීමත් සමඟ Apple වාර්තා කර ඇත මෙම performSelector:"වලට අනාරක්ෂිත" ලෙස ක්රම පවුල සහ ඔවුන් ස්විෆ්ට් ලබා නැත.

කාලයත් සමඟ මෙම ප්‍රගතිය අපි දැක ඇත්තෙමු.

1. පරමාර්ථ-සී අවසරයේ මුල් සංස්කරණ performSelector:(අතින් මතක කළමනාකරණය)
2. ARC සමඟ පරමාර්ථ-සී භාවිතය සඳහා අනතුරු අඟවයි performSelector:
3. ස්විෆ්ට ප්‍රවේශයක් නොමැති performSelector:අතර මෙම ක්‍රම “සහජයෙන්ම අනාරක්ෂිත” යැයි ලේඛනගත කරයි

කෙසේ වෙතත් නම් කරන ලද තේරීම් කාරකයක් මත පදනම්ව පණිවිඩ යැවීමේ අදහස “සහජයෙන්ම අනාරක්ෂිත” අංගයක් නොවේ. මෙම අදහස දීර් Ob කාලයක් තිස්සේ Objective-C මෙන්ම වෙනත් බොහෝ ක්‍රමලේඛන භාෂාවල සාර්ථකව භාවිතා කර ඇත.

¹ සියලුම අරමුණ සී ක්රම සඟවා තර්ක දෙකක් තියෙනවා, selfහා _cmdඔබ ක්රමය කතා කළ බව නිසැකයෙන්ම එකතු වේ.

² වන ඇමතුම් NULLසී දී මෙම මුර අපි වස්තුවක් ඇති බව පාලක වගකීම ඉදිරියේ සඳහා පරීක්ෂා කිරීම සඳහා භාවිතා කාර්යය ආරක්ෂිත නෑ. මේ නිසා, අපි කරන්නම් කියලා IMPසිට methodForSelector:(එය විය හැකි වුවත් _objc_msgForward, එම පණිවිඩය යොමු පද්ධතියට පිවිසුම්). මූලික වශයෙන්, ආරක්ෂකයා සිටින විට, අපට ඇමතීමට ශ්‍රිතයක් ඇති බව අපි දනිමු.

³ ඇත්ත වශයෙන්ම, ඔබ වස්තූන් ලෙස ප්‍රකාශ කළහොත් idසහ ඔබ සියලු ශීර්ෂයන් ආනයනය නොකරන්නේ නම් එය වැරදි තොරතුරු ලබා ගත හැකිය . සම්පාදකයා හොඳයි කියා සිතන කේතයේ බිඳවැටීම් සමඟ ඔබට අවසන් විය හැකිය. මෙය ඉතා දුර්ලභ ය, නමුත් සිදුවිය හැකිය. සාමාන්‍යයෙන් ඔබට අනතුරු ඇඟවීමක් ලැබෙනුයේ කුමන ක්‍රම දෙකෙන් එකක් තෝරා ගත යුතු දැයි නොදන්නා බවය.

⁴ දින ARC යොමු බලන්න රඳවා ආපසු වටිනාකම් සහ unretained ආපසු වටිනාකම් වැඩි විස්තර සඳහා.

Xcode 4.2 හි LLVM 3.0 සම්පාදකයා තුළ ඔබට පහත පරිදි අනතුරු ඇඟවීම යටපත් කළ හැකිය:

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
    [self.ticketTarget performSelector: self.ticketAction withObject: self];
#pragma clang diagnostic pop

ඔබ ස්ථාන කිහිපයක දෝෂය ලබා ගන්නේ නම් සහ ප්‍රාග්මා සැඟවීමට සී මැක්‍රෝ පද්ධතිය භාවිතා කිරීමට අවශ්‍ය නම්, අනතුරු ඇඟවීම යටපත් කිරීම පහසු කිරීම සඳහා ඔබට සාර්ව අර්ථ දැක්විය හැකිය:

#define SuppressPerformSelectorLeakWarning(Stuff) \
    do { \
        _Pragma("clang diagnostic push") \
        _Pragma("clang diagnostic ignored \"-Warc-performSelector-leaks\"") \
        Stuff; \
        _Pragma("clang diagnostic pop") \
    } while (0)

ඔබට මේ ආකාරයට සාර්ව භාවිතා කළ හැකිය:

SuppressPerformSelectorLeakWarning(
    [_target performSelector:_action withObject:self]
);

සිදු කළ පණිවිඩයේ ප්‍රති result ලය ඔබට අවශ්‍ය නම්, ඔබට මෙය කළ හැකිය:

id result;
SuppressPerformSelectorLeakWarning(
    result = [_target performSelector:_action withObject:self]
);

මේ පිළිබඳ මගේ අනුමානය මෙයයි: තේරීම්කරු සම්පාදකයා නොදන්නා බැවින් ARC හට නිසි මතක කළමනාකරණය බලාත්මක කළ නොහැක.

ඇත්ත වශයෙන්ම, විශේෂිත සම්මුතියක් මගින් මතක කළමනාකරණය ක්‍රමයේ නමට බැඳී ඇති අවස්ථා තිබේ. විශේෂයෙන්, මම හිතනකොටත් පහසුව ඉදිකරන්නන් එදිරිව පසුබිම ක්රම; සම්මුතියෙන් කලින් ආපසු පැමිණීම ස්වයංක්‍රීයව මුදා හරින ලද වස්තුවකි; දෙවැන්න රඳවා ගත් වස්තුවකි. සම්මුතිය තේරීම්කරුගේ නම් මත පදනම් වේ, එබැවින් සම්පාදකයා තේරීම් කාරකය නොදන්නේ නම් එයට නිසි මතක කළමනාකරණ රීතිය ක්‍රියාත්මක කළ නොහැක.

මෙය නිවැරදි නම්, මතක කළමනාකරණය සම්බන්ධයෙන් සෑම දෙයක්ම හරි යැයි ඔබ සහතික කර ඇත්නම්, ඔබට ආරක්ෂිතව ඔබේ කේතය භාවිතා කළ හැකි යැයි මම සිතමි (උදා: ඔබේ ක්‍රම මඟින් ඔවුන් වෙන් කළ වස්තු ආපසු නොදෙනු ඇත).

ඔබගේ ව්‍යාපෘතියේ සැකසුම් ගොඩනඟන්න , වෙනත් අනතුරු ඇඟවීමේ කොඩි ( WARNING_CFLAGS) යටතේ, එකතු කරන්න
-Wno-arc-performSelector-leaks

දැන් ඔබ අමතන තේරීම් කාරකය ඔබේ වස්තුව රඳවා තබා ගැනීමට හෝ පිටපත් කිරීමට හේතු නොවන බවට වග බලා ගන්න.

සම්පාදකයා අනතුරු ඇඟවීම ඉක්මවා යාමට ඉඩ දෙන තෙක් ක්‍රියාමාර්ගයක් ලෙස, ඔබට ධාවන කාලය භාවිතා කළ හැකිය

objc_msgSend(_controller, NSSelectorFromString(@"someMethod"));

වෙනුවට

[_controller performSelector:NSSelectorFromString(@"someMethod")];

ඔයාට කරන්න වෙනවා

#import <objc/message.h>

කාර්ය සාධන තේරීම සමඟ ඇති ගොනුවේ පමණක් දෝෂය නොසලකා හැරීමට, පහත දැක්වෙන පරිදි # ප්‍රාග්මා එකක් එක් කරන්න:

#pragma clang diagnostic ignored "-Warc-performSelector-leaks"

මෙය මෙම රේඛාවේ අනතුරු ඇඟවීම නොසලකා හරිනු ඇත, නමුත් ඔබේ ව්‍යාපෘතියේ ඉතිරි කාලය පුරාම එයට ඉඩ දෙන්න.

අමුතු නමුත් සත්‍යය: පිළිගත හැකි නම් (එනම් ප්‍රති result ලය අවලංගු වන අතර ධාවන පථ චක්‍රයට එක් වරක් ඉඩ දීමට ඔබට අවශ්‍ය නැත), මෙය ශුන්‍ය වුවද ප්‍රමාදයක් එක් කරන්න:

[_controller performSelector:NSSelectorFromString(@"someMethod")
    withObject:nil
    afterDelay:0];

මෙය අනතුරු ඇඟවීම ඉවත් කරයි, අනුමාන වශයෙන් එය කිසිදු වස්තුවක් ආපසු ලබා දිය නොහැකි බවත් කෙසේ හෝ වැරදි ලෙස කළමනාකරණය කළ නොහැකි බවත් සම්පාදකයාට සහතික කරයි.

ඉහත දක්වා ඇති පිළිතුර මත පදනම්ව යාවත්කාලීන කළ සාර්වයක් මෙන්න. ආපසු ප්‍රකාශයක් සමඟ වුවද ඔබේ කේතය එතීමට මෙය ඔබට ඉඩ දිය යුතුය.

#define SUPPRESS_PERFORM_SELECTOR_LEAK_WARNING(code)                        \
    _Pragma("clang diagnostic push")                                        \
    _Pragma("clang diagnostic ignored \"-Warc-performSelector-leaks\"")     \
    code;                                                                   \
    _Pragma("clang diagnostic pop")                                         \


SUPPRESS_PERFORM_SELECTOR_LEAK_WARNING(
    return [_target performSelector:_action withObject:self]
);

මෙම කේතයට සම්පාදක ධජ හෝ සෘජු ධාවන කාල ඇමතුම් ඇතුළත් නොවේ:

SEL selector = @selector(zeroArgumentMethod);
NSMethodSignature *methodSig = [[self class] instanceMethodSignatureForSelector:selector];
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSig];
[invocation setSelector:selector];
[invocation setTarget:self];
[invocation invoke];

NSInvocationබහුවිධ තර්ක සැකසීමට ඉඩ දෙයි, එබැවින් performSelectorමෙය මෙන් නොව ඕනෑම ක්‍රමයක් මත ක්‍රියා කරයි.

හොඳයි, මෙහි පිළිතුරු ගොඩක් ඇත, නමුත් මෙය ටිකක් වෙනස් බැවින්, පිළිතුරු කිහිපයක් ඒකාබද්ධ කරමින් මම එය තැබිය යුතු යැයි සිතුවෙමි. මම එන්එස්ඕබෙක්ට් කාණ්ඩයක් භාවිතා කරමි, එය තේරීම්කරු අවලංගු වන බව තහවුරු කර ගැනීමටත්, සම්පාදකයා මර්දනය කිරීමටත් පරීක්ෂා කරයි. අනතුරු ඇඟවීම.

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "Debug.h" // not given; just an assert

@interface NSObject (Extras)

// Enforce the rule that the selector used must return void.
- (void) performVoidReturnSelector:(SEL)aSelector withObject:(id)object;
- (void) performVoidReturnSelector:(SEL)aSelector;

@end

@implementation NSObject (Extras)

// Apparently the reason the regular performSelect gives a compile time warning is that the system doesn't know the return type. I'm going to (a) make sure that the return type is void, and (b) disable this warning
// See http://stackoverflow.com/questions/7017281/performselector-may-cause-a-leak-because-its-selector-is-unknown

- (void) checkSelector:(SEL)aSelector {
    // See http://stackoverflow.com/questions/14602854/objective-c-is-there-a-way-to-check-a-selector-return-value
    Method m = class_getInstanceMethod([self class], aSelector);
    char type[128];
    method_getReturnType(m, type, sizeof(type));

    NSString *message = [[NSString alloc] initWithFormat:@"NSObject+Extras.performVoidReturnSelector: %@.%@ selector (type: %s)", [self class], NSStringFromSelector(aSelector), type];
    NSLog(@"%@", message);

    if (type[0] != 'v') {
        message = [[NSString alloc] initWithFormat:@"%@ was not void", message];
        [Debug assertTrue:FALSE withMessage:message];
    }
}

- (void) performVoidReturnSelector:(SEL)aSelector withObject:(id)object {
    [self checkSelector:aSelector];

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
    // Since the selector (aSelector) is returning void, it doesn't make sense to try to obtain the return result of performSelector. In fact, if we do, it crashes the app.
    [self performSelector: aSelector withObject: object];
#pragma clang diagnostic pop    
}

- (void) performVoidReturnSelector:(SEL)aSelector {
    [self checkSelector:aSelector];

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
    [self performSelector: aSelector];
#pragma clang diagnostic pop
}

@end

පසු පරම්පරාව වෙනුවෙන්, මම මගේ තොප්පිය වළල්ලට විසි කිරීමට තීරණය කළෙමි :)

මෑතකදී මම තව තවත් ඈත් කරන ප්රතිව්යුහගත දුටු හිටියේ target/ selectorසුසමාදර්ශය, එවැනි ආදිය ප්රොටෝකෝල, කුට්ටි, ලෙස දේවල් පක්ෂව කෙසේ වෙතත්, එහි එක් ඩ්රොප් සඳහා ආදේශ කිරීම පමණි performSelectorමම දැන් කිහිප වතාවක් භාවිතා කර ඇති බව:

[NSApp sendAction: NSSelectorFromString(@"someMethod") to: _controller from: nil];

මේවා පිරිසිදු, ARC- ආරක්ෂිත සහ බොහෝ දුරට සමාන performSelectorනොවී ප්‍රතිස්ථාපනය කිරීමක් ලෙස objc_msgSend()පෙනේ.

IOS හි ඇනලොග් තිබේදැයි මට අදහසක් නැත.

මෙම ත්‍රෙඩ් එකේ මැට් ගැලෝවේගේ පිළිතුර එයට හේතුව පැහැදිලි කරයි:

පහත සඳහන් කරුණු සලකා බලන්න:

id anotherObject1 = [someObject performSelector:@selector(copy)];
id anotherObject2 = [someObject performSelector:@selector(giveMeAnotherNonRetainedObject)];

දැන්, පළමුවැන්න රඳවා තබා ගැනීමේ ගණන් 1 ක් සහිත වස්තුවක් ආපසු ලබා දෙන බව ARC දැන ගන්නේ කෙසේද?

ඔබ ප්‍රතිලාභ අගය නොසලකා හරිනවා නම් අනතුරු ඇඟවීම යටපත් කිරීම සාමාන්‍යයෙන් ආරක්ෂිත බව පෙනේ. Performanceelector වෙතින් රඳවා ගත් වස්තුවක් ලබා ගැනීමට ඔබට අවශ්‍ය නම් හොඳම පුහුණුව කුමක්දැයි මට විශ්වාස නැත - "එසේ නොකරන්න" හැර.

@ c-road මෙහි ගැටළු විස්තරය සමඟ නිවැරදි සබැඳිය සපයයි . PerformSelector මතකය කාන්දු වන විට ඔබට මගේ උදාහරණය පහත දැක්වේ.

@interface Dummy : NSObject <NSCopying>
@end

@implementation Dummy

- (id)copyWithZone:(NSZone *)zone {
  return [[Dummy alloc] init];
}

- (id)clone {
  return [[Dummy alloc] init];
}

@end

void CopyDummy(Dummy *dummy) {
  __unused Dummy *dummyClone = [dummy copy];
}

void CloneDummy(Dummy *dummy) {
  __unused Dummy *dummyClone = [dummy clone];
}

void CopyDummyWithLeak(Dummy *dummy, SEL copySelector) {
  __unused Dummy *dummyClone = [dummy performSelector:copySelector];
}

void CloneDummyWithoutLeak(Dummy *dummy, SEL cloneSelector) {
  __unused Dummy *dummyClone = [dummy performSelector:cloneSelector];
}

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    Dummy *dummy = [[Dummy alloc] init];
    for (;;) { @autoreleasepool {
      //CopyDummy(dummy);
      //CloneDummy(dummy);
      //CloneDummyWithoutLeak(dummy, @selector(clone));
      CopyDummyWithLeak(dummy, @selector(copy));
      [NSThread sleepForTimeInterval:1];
    }} 
  }
  return 0;
}

මගේ උදාහරණයේ මතක කාන්දු වීමට හේතු වන එකම ක්‍රමය වන්නේ CopyDummyWithLeak ය. හේතුව, ARC නොදන්නා නිසා, පිටපත් සෙලෙක්ටර් විසින් රඳවා ගත් වස්තුව නැවත ලබා දෙයි.

ඔබ මතක කාන්දු කිරීමේ මෙවලම ක්‍රියාත්මක කරන්නේ නම් ඔබට පහත පින්තූරය දැකිය හැකිය: ... සහ වෙනත් කිසිදු අවස්ථාවක මතක කාන්දුවීම් නොමැත:

ස්කොට් තොම්සන්ගේ සාර්ව වඩාත් ජනක බවට පත් කිරීම සඳහා:

// String expander
#define MY_STRX(X) #X
#define MY_STR(X) MY_STRX(X)

#define MYSilenceWarning(FLAG, MACRO) \
_Pragma("clang diagnostic push") \
_Pragma(MY_STR(clang diagnostic ignored MY_STR(FLAG))) \
MACRO \
_Pragma("clang diagnostic pop")

ඉන්පසු එය මේ ආකාරයට භාවිතා කරන්න:

MYSilenceWarning(-Warc-performSelector-leaks,
[_target performSelector:_action withObject:self];
                )

අනතුරු ඇඟවීම් යටපත් නොකරන්න!

සම්පාදකයා සමඟ සම්බන්ධ වීම සඳහා විකල්ප විසඳුම් 12 කට නොඅඩු ගණනක් ඇත.
පළමු ක්‍රියාවට නැංවීමේදී ඔබ දක්ෂ ලෙස සිටියදී, පෘථිවියේ ඉංජිනේරුවන් කිහිප දෙනෙකුට ඔබේ අඩිපාරේ යා හැකි අතර මෙම කේතය අවසානයේදී බිඳී යනු ඇත.

ආරක්ෂිත මාර්ග:

මෙම සියලු විසඳුම් ඔබගේ මුල් අභිප්‍රායයෙන් යම් තරමක විචලනයකින් යුතුව ක්‍රියා කරනු ඇත. ඔබ කැමති නම් paramඑය nilඑසේ විය හැකි යැයි උපකල්පනය කරන්න :

ආරක්ෂිත මාර්ගය, එකම සංකල්පීය හැසිරීම:

// GREAT
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:YES];
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:YES modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:YES];
[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:YES modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

ආරක්ෂිත මාර්ගය, තරමක් වෙනස් හැසිරීම:

( මෙම ප්‍රතිචාරය බලන්න ) ඒ
වෙනුවට ඕනෑම නූල් භාවිතා කරන්න [NSThread mainThread].

// GOOD
[_controller performSelector:selector withObject:anArgument afterDelay:0];
[_controller performSelector:selector withObject:anArgument afterDelay:0 inModes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:NO];
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:NO];
[_controller performSelectorOnMainThread:selector withObject:anArgument waitUntilDone:NO modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

[_controller performSelectorInBackground:selector withObject:anArgument];

[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:NO];
[_controller performSelector:selector onThread:[NSThread mainThread] withObject:anArgument waitUntilDone:NO modes:@[(__bridge NSString *)kCFRunLoopDefaultMode]];

භයානක මාර්ග

බිඳ දැමීමට බැඳී ඇති යම් ආකාරයක සම්පාදක නිශ්ශබ්දතාවයක් අවශ්‍ය වේ. මේ කාලයේදී, එය බව කරුණාවෙන් කළ ඩව ස්විෆ්ට් .

// AT YOUR OWN RISK
[_controller performSelector:selector];
[_controller performSelector:selector withObject:anArgument];
[_controller performSelector:selector withObject:anArgument withObject:nil];

ඔබ ARC භාවිතා කරන නිසා ඔබ iOS 4.0 හෝ ඊට පසු භාවිතා කළ යුතුය. මෙයින් අදහස් කරන්නේ ඔබට කුට්ටි භාවිතා කළ හැකි බවයි. ඔබ ඉටු කිරීමට තේරීම් කාරකය මතක තබා ගැනීම වෙනුවට අවහිරයක් ගත්තේ නම්, ඇත්ත වශයෙන්ම සිදුවන්නේ කුමක්ද යන්න වඩා හොඳින් සොයා ගැනීමට ARC හට හැකි වනු ඇති අතර අහම්බෙන් මතක කාන්දුවක් හඳුන්වා දීමේ අවදානම ඔබ විසින් ක්‍රියාත්මක කළ යුතු නොවේ.

බ්ලොක් ප්රවේශය භාවිතා කරනවා වෙනුවට, මට ගැටළු කිහිපයක් ලබා දුන්නේය:

    IMP imp = [_controller methodForSelector:selector];
    void (*func)(id, SEL) = (void *)imp;

මම මේ ආකාරයට NSInvocation භාවිතා කරමි:

    -(void) sendSelectorToDelegate:(SEL) selector withSender:(UIButton *)button 

    if ([delegate respondsToSelector:selector])
    {
    NSMethodSignature * methodSignature = [[delegate class]
                                    instanceMethodSignatureForSelector:selector];
    NSInvocation * delegateInvocation = [NSInvocation
                                   invocationWithMethodSignature:methodSignature];


    [delegateInvocation setSelector:selector];
    [delegateInvocation setTarget:delegate];

    // remember the first two parameter are cmd and self
    [delegateInvocation setArgument:&button atIndex:2];
    [delegateInvocation invoke];
    }

ඔබට කිසිදු තර්කයක් ඉදිරිපත් කිරීමට අවශ්‍ය නැතිනම් භාවිතා කිරීම පහසු කාර්යයකි valueForKeyPath. මෙය Classවස්තුවක් මත පවා කළ හැකි ය .

NSString *colorName = @"brightPinkColor";
id uicolor = [UIColor class];
if ([uicolor respondsToSelector:NSSelectorFromString(colorName)]){
    UIColor *brightPink = [uicolor valueForKeyPath:colorName];
    ...
}

ඔබට මෙහි ප්‍රොටෝකෝලයක් ද භාවිතා කළ හැකිය. ඉතින්, ඒ වගේ ප්‍රොටෝකෝලයක් සාදන්න:

@protocol MyProtocol
-(void)doSomethingWithObject:(id)object;
@end

ඔබේ පන්තියේ ඔබේ තේරීම්කරු අමතන්න, එවිට ඔබට ropproperty එකක් ඇත.

@interface MyObject
    @property (strong) id<MyProtocol> source;
@end

ඔබට @selector(doSomethingWithObject:)MyObject හි උදාහරණයක් ඇමතීමට අවශ්‍ය වූ විට , මෙය කරන්න:

[self.source doSomethingWithObject:object];