ටීඑල්; ඩීආර්: කියවීමට කැමති නැද්ද? GitHub හි නියැදි ව්යාපෘති වෙත කෙලින්ම යන්න:
සංකල්පීය විස්තරය
ඔබ සංවර්ධනය කරන්නේ කුමන iOS අනුවාදයන් නොසලකා පහත පළමු පියවර 2 අදාළ වේ.
1. සීමාවන් සකසා එකතු කරන්න
ඔබේ UITableViewCellඋප පංතියේ, කොටුවේ අන්තර්ගතයන් දර්ශනයේ දාරවලට (වඩාත් වැදගත් ලෙස ඉහළ සහ පහළ දාරවලට ) සෛලවල උප දර්ශනවල දාර සවි කර ඇති පරිදි සීමාවන් එකතු කරන්න . සටහන: කොටුවටම උපසිරැසි නොතබන්න; සෛලයට පමණයි contentView! එක් එක් උපසිරැසි සඳහා සිරස් මානයන්හි අන්තර්ගත සම්පීඩන ප්‍රතිරෝධය සහ අන්තර්ගත වැළඳ ගැනීමේ බාධක ඔබ එකතු කළ ඉහළ ප්‍රමුඛතා බාධක මගින් අභිබවා නොයන බවට වග බලා ගැනීමෙන් මෙම උපසිරැසි වල සහජ අන්තර්ගත ප්‍රමාණය වගුවේ දර්ශන කොටුවේ අන්තර්ගත දර්ශනයේ උස වැඩි කිරීමට ඉඩ දෙන්න. ( හහ්? මෙහි ක්ලික් කරන්න. )
මතක තබා ගන්න, සෛලයේ උප දර්ශන සිරස් අතට සෛල අන්තර්ගතයට සම්බන්ධ කර ඇති අතර එමඟින් ඔවුන්ට “පීඩනය” යෙදිය හැකි අතර ඒවාට ගැලපෙන පරිදි අන්තර්ගත දර්ශනය පුළුල් කළ හැකිය. උපසිරැසි කිහිපයක් සහිත නිදර්ශන කොටුවක් භාවිතා කරමින් , ඔබේ අවහිරතා සමහරක් (සියල්ලම නොවේ!) මොන වගේ විය යුතුද යන්න පිළිබඳ දෘශ්‍ය නිදර්ශනයක් මෙන්න:
ඉහත උදාහරණ කොටුවේ බහු-රේඛා ශරීර ලේබලය වෙත වැඩි පෙළක් එක් කරන විට, පෙළට සරිලන සේ එය සිරස් අතට වැඩීමට අවශ්ය වනු ඇති අතර එමඟින් සෛලය උසින් වැඩීමට බල කරයි. (ඇත්ත වශයෙන්ම, මෙය නිවැරදිව වැඩ කිරීම සඳහා ඔබ අවහිරතා නිවැරදිව ලබා ගත යුතුය!)
ස්වයංක්‍රීය පිරිසැලසුම සමඟ වැඩ කරන ගතික සෛල උස ලබා ගැනීමේ දුෂ්කරම හා වැදගත්ම කොටස වන්නේ ඔබේ සීමාවන් නිවැරදිව ලබා ගැනීමයි. ඔබ මෙහි වැරැද්දක් කළහොත්, අනෙක් සියල්ල වැඩ කිරීමෙන් වළක්වා ගත හැකිය - එබැවින් ඔබේ කාලය ගන්න! කේතයේ ඔබේ සීමාවන් සැකසීමට මම නිර්දේශ කරමි, කොතැනට එකතු කරන්නේ කුමන බාධකදැයි ඔබ හරියටම දන්නා නිසා සහ දේවල් වැරදුණු විට නිදොස් කිරීම පහසුය. කේතයේ සීමාවන් එකතු කිරීම පිරිසැලසුම් නැංගුරම් භාවිතා කරමින් අතුරුමුහුණත් සාදන්නාට වඩා පහසු සහ සැලකිය යුතු තරම් බලවත් විය හැකිය, නැතහොත් GitHub හි ඇති අපූරු විවෘත කේත API වලින් එකකි.
- ඔබ කේතයේ සීමාවන් එකතු කරන්නේ නම්, ඔබ මෙය කළ යුත්තේ
updateConstraintsඔබේ UITableViewCell උප පංතියේ ක්‍රමයෙනි. updateConstraintsඑක් වරකට වඩා වැඩි වාර ගණනක් කැඳවිය හැකි බව සලකන්න , එම අවහිරතා එක් වරකට වඩා එක් කිරීමෙන් වළක්වා ගැනීම සඳහා, ඔබේ අවහිරතා එකතු කිරීමේ කේතය updateConstraintsබූලියන් දේපලක් සඳහා චෙක්පතක් තුළ එතීමට වග බලා ගන්න didSetupConstraints(ඔබ ඔබේ සීමාව ක්රියාත්මක කිරීමෙන් පසු ඔව් ලෙස සකසා ඇත කේතය එක් වරක් එකතු කිරීම). අනෙක් අතට, ඔබට පවතින සීමාවන් යාවත්කාලීන කරන කේතයක් තිබේ නම් ( constantදේපල යම් යම් සීමාවන් මත සකස් කිරීම වැනි ), මෙය updateConstraintsචෙක්පතෙහි පිටත නමුත් පිටත තබන්න didSetupConstraintsඑවිට ක්‍රමවේදය කැඳවන සෑම අවස්ථාවකම එය ක්රියාත්මක විය හැකිය.
2. අද්විතීය වගු දර්ශන සෛල නැවත භාවිතා කිරීමේ හඳුනාගැනීම් තීරණය කරන්න
සෛලයේ ඇති සෑම අද්විතීය අවහිරතා සමූහයක් සඳහාම, අද්විතීය සෛල නැවත භාවිතා කිරීමේ හඳුනාගැනීමක් භාවිතා කරන්න. වෙනත් වචන වලින් කිවහොත්, ඔබේ සෛල වලට අද්විතීය පිරිසැලසුමක් තිබේ නම්, සෑම අද්විතීය පිරිසැලසුමකටම නැවත භාවිතා කිරීමේ හඳුනාගැනීමක් ලැබිය යුතුය. (ඔබ නව නැවත භාවිතා කිරීමේ හඳුනාගැනීමක් භාවිතා කළ යුතු බවට හොඳ ඉඟියක් වන්නේ ඔබේ සෛල ප්‍රභේදයට වෙනස් උපසිරැසි සංඛ්‍යාවක් ඇති විට හෝ උප දර්ශන වෙනස් ආකාරයකින් සකසා ඇති විටය.)
උදාහරණයක් ලෙස, ඔබ එක් එක් කොටුව තුළ විද්‍යුත් තැපැල් පණිවිඩයක් ප්‍රදර්ශනය කරන්නේ නම්, ඔබට අද්විතීය පිරිසැලසුම් 4 ක් තිබිය හැකිය: විෂයයක් සහිත පණිවිඩ, විෂයයක් සහ ශරීරයක් සහිත පණිවිඩ, විෂයයක් සහ ඡායාරූප ඇමුණුමක් සහ විෂයයක් සහිත පණිවිඩ, ශරීරය සහ ඡායාරූප ඇමුණුම. සෑම පිරිසැලසුමකටම එය සාක්ෂාත් කර ගැනීම සඳහා සම්පූර්ණයෙන්ම වෙනස් අවහිරතා ඇත, එබැවින් සෛලය ආරම්භ කර මෙම සෛල වර්ග වලින් එකක් සඳහා සීමාවන් එකතු කළ පසු, සෛලයට එම සෛල වර්ගයට විශේෂිත වූ නැවත භාවිතා කිරීමේ හඳුනාගැනීමක් ලබා ගත යුතුය. මෙයින් අදහස් කරන්නේ ඔබ නැවත භාවිතා කිරීම සඳහා සෛලයක් ඉවත් කරන විට, අවහිරතා දැනටමත් එකතු කර ඇති අතර එම සෛල වර්ගයට යාමට සූදානම් බවයි.
සහජ අන්තර්ගත ප්‍රමාණයෙහි වෙනස්කම් හේතුවෙන් එකම අවහිරතා (වර්ගය) ඇති සෛලවලට තවමත් වෙනස් උස තිබිය හැකි බව සලකන්න! විවිධ ප්‍රමාණයේ අන්තර්ගතයන් හේතුවෙන් මූලික වශයෙන් වෙනස් පිරිසැලසුම් (විවිධ සීමාවන්) විවිධ ගණනය කළ දර්ශන රාමු සමඟ (සමාන සීමාවන්ගෙන් විසඳනු ලැබේ) පටලවා නොගන්න.
- එකම නැවත භාවිතා කරන සංචිතයට සම්පූර්ණයෙන්ම වෙනස් අවහිරතා සහිත සෛල එකතු නොකරන්න (එනම් එකම නැවත භාවිතා කිරීමේ හඳුනාගැනීමක් භාවිතා කරන්න) ඉන්පසු පැරණි අවහිරතා ඉවත් කර එක් එක් වර්‍ගයෙන් පසු මුල සිටම නව බාධක ඇති කිරීමට උත්සාහ කරන්න. අභ්‍යන්තර ස්වයංක්‍රීය පිරිසැලසුම් එන්ජිම සැලසුම් කර ඇත්තේ විශාල පරිමාණයේ වෙනස්කම් වලට මුහුණ දීම සඳහා නොවන අතර විශාල කාර්ය සාධන ගැටළු ඔබට පෙනෙනු ඇත.
IOS 8 සඳහා - ස්වයං ප්‍රමාණයේ සෛල
3. පේළි උස ඇස්තමේන්තු කිරීම සක්‍රීය කරන්න
ස්වයං-ප්‍රමාණ වගු දර්ශන සෛල සක්‍රීය කිරීම සඳහා, ඔබ මේස දර්ශනයේ පේළි උස දේපල UITableViewAutomaticDimension ලෙස සැකසිය යුතුය. ඇස්තමේන්තුගත රෝහයිට් දේපල සඳහා ඔබ වටිනාකමක් ලබා දිය යුතුය. මෙම ගුණාංග දෙකම සැකසූ විගස, පද්ධතිය ස්වයංක්‍රීය පිරිසැලසුම භාවිතා කර පේළියේ නියම උස ගණනය කරයි
ඇපල්: ස්වයං-ප්‍රමාණ වගු දර්ශන සෛල සමඟ වැඩ කිරීම
IOS 8 සමඟ, ඇපල් විසින් iOS 8 ට පෙර ඔබ විසින් ක්‍රියාවට නැංවිය යුතු බොහෝ කාර්යයන් අභ්‍යන්තරීකරණය කර ඇත. ස්වයං ප්‍රමාණයේ සෛල යාන්ත්‍රණය වැඩ කිරීමට ඉඩ දීම සඳහා, ඔබ පළමුව rowHeightමේස දර්ශනයේ ඇති දේපල නියතයට සැකසිය යුතුය. UITableViewAutomaticDimension. ඉන්පසුව, ඔබට වගු දර්ශනයේ estimatedRowHeightදේපල අස්ථිර අගයකට සැකසීම මඟින් පේළි උස තක්සේරු කිරීම සක්‍රීය කළ යුතුය, උදාහරණයක් ලෙස:
self.tableView.rowHeight = UITableViewAutomaticDimension;
self.tableView.estimatedRowHeight = 44.0; // set to whatever your "average" cell height is
මෙය කරන්නේ තිරයේ නොමැති සෛලවල පේළි උස සඳහා තාවකාලික ඇස්තමේන්තුවක් / ස්ථානගත කිරීමක් මේස දර්ශනයට ලබා දීමයි. එවිට, මෙම සෛල තිරය මත අනුචලනය වීමට ආසන්න වන විට, සත්‍ය පේළි උස ගණනය කෙරේ. එක් එක් පේළිය සඳහා සත්‍ය උස තීරණය කිරීම සඳහා, වගු දර්ශනය ස්වයංක්‍රීයව එක් එක් සෛලයට contentViewඅන්තර්ගතයේ දර්ශනයේ දන්නා ස්ථාවර පළල මත පදනම්ව එහි උස කොපමණ දැයි විමසයි (එය වගු දර්ශනයේ පළල මත පදනම් වේ, අංශ දර්ශකය වැනි අමතර දේවල් us ණ කරයි හෝ උපාංග දර්ශනය) සහ ඔබ කොටුවේ අන්තර්ගත දර්ශනයට සහ උප දර්ශන වලට එකතු කර ඇති ස්වයංක්‍රීය පිරිසැලසුම් බාධක. මෙම සත්‍ය සෛල උස තීරණය කළ පසු, පේළිය සඳහා පැරණි ඇස්තමේන්තුගත උස නව තථ්‍ය උස සමඟ යාවත්කාලීන වේ (සහ වගු දර්ශනයේ අන්තර්ගතයේ ඕනෑම වෙනස් කිරීමක් ඔබට අවශ්ය පරිදි සකසා ඇත).
පොදුවේ ගත් කල, ඔබ සපයන ඇස්තමේන්තුව ඉතා නිවැරදි විය යුතු නැත - එය භාවිතා කරනුයේ වගු දර්ශනයේ ඇති අනුචලන දර්ශකය නිවැරදිව ප්‍රමාණ කිරීම සඳහා පමණක් වන අතර වගු දර්ශනය ඔබ මෙන් වැරදි ඇස්තමේන්තු සඳහා අනුචලන දර්ශකය සකස් කිරීමේ හොඳ කාර්යයක් කරයි. තිරය මත සෛල අනුචලනය කරන්න. ඔබ estimatedRowHeightමේස දර්ශනයේ ඇති දේපල ( viewDidLoadසාමාන්‍ය හෝ පේළි උස) නියත අගයකට සැකසිය යුතුය . ඔබේ පේළි උසෙහි අතිශය විචල්‍යතාවයක් තිබේ නම් (උදා: විශාලත්වයේ අනුපිළිවෙලකින් වෙනස් වේ) සහ ඔබ අනුචලනය කරන විට අනුචලන දර්ශකය “පැනීම” ඔබ දුටුවහොත් tableView:estimatedHeightForRowAtIndexPath:පමණක් එක් එක් පේළිය සඳහා වඩාත් නිවැරදි ඇස්තමේන්තුවක් ලබා දීමට අවශ්ය අවම ගණනය කිරීම සිදු කිරීමට ඔබ කරදර විය යුතුය .
IOS 7 සහාය සඳහා (ස්වයංක්‍රීය සෛල ප්‍රමාණය ඔබම ක්රියාත්මක කිරීම)
3. පිරිසැලසුම් පාස් එකක් කර සෛල උස ලබා ගන්න
පළමුවෙන්ම, උස ගණනය කිරීම් සඳහා දැඩි ලෙස භාවිතා කරන එක් එක් නැවත භාවිතා කරන හඳුනාගැනීමේ එක් අවස්ථාවක් වන වගු දර්ශන කොටුවක ඕෆ්ස්ක්‍රීන් නිදසුනක් ක්ෂණිකව ස්ථාපනය කරන්න. (ඕෆ්ස්ක්‍රීන් යන්නෙන් අදහස් වන්නේ සෛල යොමුව දර්ශන පාලකයේ දේපල / අයිවරයක ගබඩා කර ඇති අතර එය tableView:cellForRowAtIndexPath:තිරය මත තිරය පෙන්වීම සඳහා කිසි විටෙකත් ආපසු නොඑනු ඇත .) ඊළඟට, කොටුව නිශ්චිත අන්තර්ගතයෙන් වින්‍යාසගත කළ යුතුය (උදා: පෙළ, රූප, ආදිය) එය වගු දර්ශනයේ පෙන්වන්නේ නම් එය රඳවා තබන බව.
එවිට, කිරීමට සෛල බල වහාම එහි subviews පිරිසැලසුම, පසුව භාවිතා systemLayoutSizeFittingSize:මත ක්රමය UITableViewCellගේ contentViewසෛලය අවශ්ය උස යනු කුමක්ද කියා සොයා බැලීමට. UILayoutFittingCompressedSizeසෛලයේ සියලුම අන්තර්ගතයන්ට සරිලන සේ අවශ්ය කුඩාම ප්‍රමාණය ලබා ගැනීමට භාවිතා කරන්න . උස පසුව tableView:heightForRowAtIndexPath:නියෝජිත ක්‍රමයෙන් ආපසු ලබා ගත හැකිය .
4. ඇස්තමේන්තුගත පේළි උස භාවිතා කරන්න
ඔබගේ වගු දර්ශනයේ පේළි දුසිමකට වඩා තිබේ නම්, ස්වයංක්‍රීය පිරිසැලසුම් අවහිරතා විසඳීම මඟින් වගු දර්ශනය ප්‍රථමයෙන් පැටවීමේදී ප්රධාන නූලට වේගයෙන් ඇද වැටිය හැකි බව ඔබට පෙනී tableView:heightForRowAtIndexPath:යනු ඇත. අනුචලන දර්ශකයේ ප්‍රමාණය ගණනය කිරීම සඳහා).
IOS 7 වන විට, ඔබට estimatedRowHeightමේස දර්ශනයේ ඇති දේපල භාවිතා කළ හැකිය (සහ අනිවාර්යයෙන්ම) . මෙය කරන්නේ තිරයේ නොමැති සෛලවල පේළි උස සඳහා තාවකාලික ඇස්තමේන්තුවක් / ස්ථානගත කිරීමක් මේස දර්ශනයට ලබා දීමයි. එවිට, මෙම සෛල තිරය මත අනුචලනය වීමට ආසන්න වන විට, සත්‍ය පේළි උස ගණනය කරනු ලැබේ (ඇමතීමෙන් tableView:heightForRowAtIndexPath:), සහ ඇස්තමේන්තුගත උස සත්‍යය සමඟ යාවත්කාලීන වේ.
පොදුවේ ගත් කල, ඔබ සපයන ඇස්තමේන්තුව ඉතා නිවැරදි විය යුතු නැත - එය භාවිතා කරනුයේ වගු දර්ශනයේ ඇති අනුචලන දර්ශකය නිවැරදිව ප්‍රමාණ කිරීම සඳහා පමණක් වන අතර වගු දර්ශනය ඔබ මෙන් වැරදි ඇස්තමේන්තු සඳහා අනුචලන දර්ශකය සකස් කිරීමේ හොඳ කාර්යයක් කරයි. තිරය මත සෛල අනුචලනය කරන්න. ඔබ estimatedRowHeightමේස දර්ශනයේ ඇති දේපල ( viewDidLoadසාමාන්‍ය හෝ පේළි උස) නියත අගයකට සැකසිය යුතුය . ඔබේ පේළි උසෙහි අතිශය විචල්‍යතාවයක් තිබේ නම් (උදා: විශාලත්වයේ අනුපිළිවෙලකින් වෙනස් වේ) සහ ඔබ අනුචලනය කරන විට අනුචලන දර්ශකය “පැනීම” ඔබ දුටුවහොත් tableView:estimatedHeightForRowAtIndexPath:පමණක් එක් එක් පේළිය සඳහා වඩාත් නිවැරදි ඇස්තමේන්තුවක් ලබා දීමට අවශ්ය අවම ගණනය කිරීම සිදු කිරීමට ඔබ කරදර විය යුතුය .
5. (අවශ්ය නම්) පේළි උස හැඹිලිය එක් කරන්න
ඔබ ඉහත සියල්ල කර ඇති අතර, බාධක විසඳීමේදී කාර්ය සාධනය පිළිගත නොහැකි ලෙස මන්දගාමී බව තවමත් සොයාගෙන තිබේ නම් tableView:heightForRowAtIndexPath:, අවාසනාවකට ඔබට සෛල උස සඳහා යම් හැඹිලියක් ක්රියාත්මක කිරීමට අවශ්ය වනු ඇත. (මෙය ඇපල් ඉංජිනේරුවන් විසින් යෝජනා කරන ලද ප්‍රවේශයයි.) සාමාන්‍ය අදහස නම් ස්වයංක්‍රීයව එන්ජිමට පළමු වරට බාධක විසඳීමට ඉඩ දීම, ඉන්පසු එම කොටුව සඳහා ගණනය කළ උස හැඹිලිගත කිරීම සහ එම සෛලයේ උස සඳහා අනාගත සියලු ඉල්ලීම් සඳහා හැඹිලි අගය භාවිතා කිරීමයි. ඇත්ත වශයෙන්ම උපක්‍රමය නම්, සෛලයක උස වෙනස් වීමට හේතු විය හැකි යමක් සිදු වූ විට ඔබ සෛලයක් සඳහා හැඹිලි උස ඉවත් කිරීමට වග බලා ගැනීමයි - මූලික වශයෙන්, මෙය සිදුවන්නේ එම සෛලයේ අන්තර්ගතය වෙනස් වන විට හෝ වෙනත් වැදගත් සිදුවීම් සිදු වූ විට (පරිශීලක සැකසීම වැනි) ගතික වර්ගයේ පෙළ ප්‍රමාණයේ ස්ලයිඩරය).
iOS 7 සාමාන්‍ය නියැදි කේතය (ඉස්ම සහිත අදහස් රාශියක් සමඟ)
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
// Determine which reuse identifier should be used for the cell at this
// index path, depending on the particular layout required (you may have
// just one, or may have many).
NSString *reuseIdentifier = ...;
// Dequeue a cell for the reuse identifier.
// Note that this method will init and return a new cell if there isn't
// one available in the reuse pool, so either way after this line of
// code you will have a cell with the correct constraints ready to go.
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:reuseIdentifier];
// Configure the cell with content for the given indexPath, for example:
// cell.textLabel.text = someTextForThisCell;
// ...
// Make sure the constraints have been set up for this cell, since it
// may have just been created from scratch. Use the following lines,
// assuming you are setting up constraints from within the cell's
// updateConstraints method:
[cell setNeedsUpdateConstraints];
[cell updateConstraintsIfNeeded];
// If you are using multi-line UILabels, don't forget that the
// preferredMaxLayoutWidth needs to be set correctly. Do it at this
// point if you are NOT doing it within the UITableViewCell subclass
// -[layoutSubviews] method. For example:
// cell.multiLineLabel.preferredMaxLayoutWidth = CGRectGetWidth(tableView.bounds);
return cell;
}
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
// Determine which reuse identifier should be used for the cell at this
// index path.
NSString *reuseIdentifier = ...;
// Use a dictionary of offscreen cells to get a cell for the reuse
// identifier, creating a cell and storing it in the dictionary if one
// hasn't already been added for the reuse identifier. WARNING: Don't
// call the table view's dequeueReusableCellWithIdentifier: method here
// because this will result in a memory leak as the cell is created but
// never returned from the tableView:cellForRowAtIndexPath: method!
UITableViewCell *cell = [self.offscreenCells objectForKey:reuseIdentifier];
if (!cell) {
cell = [[YourTableViewCellClass alloc] init];
[self.offscreenCells setObject:cell forKey:reuseIdentifier];
}
// Configure the cell with content for the given indexPath, for example:
// cell.textLabel.text = someTextForThisCell;
// ...
// Make sure the constraints have been set up for this cell, since it
// may have just been created from scratch. Use the following lines,
// assuming you are setting up constraints from within the cell's
// updateConstraints method:
[cell setNeedsUpdateConstraints];
[cell updateConstraintsIfNeeded];
// Set the width of the cell to match the width of the table view. This
// is important so that we'll get the correct cell height for different
// table view widths if the cell's height depends on its width (due to
// multi-line UILabels word wrapping, etc). We don't need to do this
// above in -[tableView:cellForRowAtIndexPath] because it happens
// automatically when the cell is used in the table view. Also note,
// the final width of the cell may not be the width of the table view in
// some cases, for example when a section index is displayed along
// the right side of the table view. You must account for the reduced
// cell width.
cell.bounds = CGRectMake(0.0, 0.0, CGRectGetWidth(tableView.bounds), CGRectGetHeight(cell.bounds));
// Do the layout pass on the cell, which will calculate the frames for
// all the views based on the constraints. (Note that you must set the
// preferredMaxLayoutWidth on multiline UILabels inside the
// -[layoutSubviews] method of the UITableViewCell subclass, or do it
// manually at this point before the below 2 lines!)
[cell setNeedsLayout];
[cell layoutIfNeeded];
// Get the actual height required for the cell's contentView
CGFloat height = [cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].height;
// Add an extra point to the height to account for the cell separator,
// which is added between the bottom of the cell's contentView and the
// bottom of the table view cell.
height += 1.0;
return height;
}
// NOTE: Set the table view's estimatedRowHeight property instead of
// implementing the below method, UNLESS you have extreme variability in
// your row heights and you notice the scroll indicator "jumping"
// as you scroll.
- (CGFloat)tableView:(UITableView *)tableView estimatedHeightForRowAtIndexPath:(NSIndexPath *)indexPath
{
// Do the minimal calculations required to be able to return an
// estimated row height that's within an order of magnitude of the
// actual height. For example:
if ([self isTallCellAtIndexPath:indexPath]) {
return 350.0;
} else {
return 40.0;
}
}
නියැදි ව්යාපෘති
මෙම ව්යාපෘති UILabels හි ගතික අන්තර්ගතයන් අඩංගු වගු දර්ශන සෛල නිසා විචල්ය පේළි උසකින් යුත් වගු දර්ශන සඳහා පූර්ණ ක්‍රියාකාරී උදාහරණ වේ.
Xamarin (C # /. NET)
ඔබ Xamarin භාවිතා කරන්නේ නම්, entKentBoogaart විසින් එකතු කරන ලද මෙම නියැදි ව්‍යාපෘතිය බලන්න .
