XAML-ൽ ഡാറ്റ ബൈൻഡിംഗ്

ഒരു XAML ഫയലിൽ ഒബ്‌ജക്റ്റുകൾ പങ്കിടുന്നത് ഡാറ്റ ബൈൻഡിംഗിലൂടെയും ചെയ്യാം. സത്യത്തിൽ ഡാറ്റ ബൈൻഡിംഗ്വ്യത്യസ്ത വസ്തുക്കളുടെ രണ്ട് ഗുണങ്ങളെ ബന്ധിപ്പിക്കുന്നു. ഞങ്ങൾ പിന്നീട് കാണിക്കുന്നത് പോലെ, ഡാറ്റാ ഉറവിടങ്ങളുമായി പേജ് വിഷ്വലുകൾ ബന്ധപ്പെടുത്താൻ ഡാറ്റ ബൈൻഡിംഗുകൾ മിക്കപ്പോഴും ഉപയോഗിക്കുന്നു; കൂടാതെ, ജനപ്രിയമായത് നടപ്പിലാക്കുന്നതിൽ അവ ഒരു പ്രധാന ഘടകമാണ് വാസ്തുവിദ്യാ പാറ്റേൺ MVVM (മോഡൽ-വ്യൂ-വ്യൂ മോഡൽ). ബൈൻഡിംഗുകളും കളിക്കുന്നു പ്രധാന പങ്ക്ഡാറ്റാ ഒബ്ജക്റ്റുകൾ പ്രദർശിപ്പിക്കുന്നതിനുള്ള ടെംപ്ലേറ്റുകൾ നിർവചിക്കുമ്പോൾ.

രണ്ട് മൂലകങ്ങളുടെ ഗുണങ്ങളെ ബന്ധപ്പെടുത്താൻ ഡാറ്റ ബൈൻഡിംഗുകൾ ഉപയോഗിക്കാം. ബൈൻഡിംഗ് ഘടകം, StaticResource പോലെ, സാധാരണയായി ഒരു മാർക്ക്അപ്പ് വിപുലീകരണമായി പ്രകടിപ്പിക്കുന്നു, അതായത്, ചുരുണ്ട ബ്രേസുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു. എന്നിരുന്നാലും, ബൈൻഡിംഗ് എലമെന്റ് പ്രോപ്പർട്ടി എലമെന്റ് വാക്യഘടനയുടെ രൂപത്തിൽ ഒരു ബദൽ എക്സ്പ്രഷനും അനുവദിക്കുന്നു.

ഞങ്ങളുടെ ടെസ്റ്റ് പ്രോജക്റ്റിൽ ഇനിപ്പറയുന്ന ഉറവിട നിഘണ്ടു ഉപയോഗിക്കുക:

ബ്രഷ് ക്രമീകരണങ്ങൾ

അവ്യക്തമായ TextBlock ശൈലിയിൽ ഫോർഗ്രൗണ്ട് പ്രോപ്പർട്ടി അടങ്ങിയിട്ടില്ല. ഈ ബ്രഷ് ഉപയോഗിക്കുന്ന നാല് ടെക്സ്റ്റ്ബ്ലോക്ക് ഘടകങ്ങളിൽ ആദ്യത്തേതിന് ഒരു ലീനിയർഗ്രേഡിയന്റ് ബ്രഷ് നിർവചിച്ചിരിക്കുന്നു, കൂടാതെ തുടർന്നുള്ള ഘടകങ്ങൾ TextBlock ഒരു ബൈൻഡിംഗിലൂടെ ഒരേ ബ്രഷിനെ പരാമർശിക്കുന്നു:

ഡാറ്റ ബൈൻഡിംഗ് ഉണ്ട് ഉറവിടംഒപ്പം റിസീവർ (ലക്ഷ്യം). ലക്ഷ്യസ്ഥാനം എല്ലായ്പ്പോഴും ബൈൻഡിംഗ് സജ്ജീകരിക്കപ്പെടുന്ന വസ്തുവാണ്, ഉറവിടം അത് ബന്ധിപ്പിച്ചിരിക്കുന്ന സ്വത്താണ്. കാണിച്ചിരിക്കുന്ന ബൈൻഡിംഗുകളുടെ ഉറവിടം topTxb എന്ന് പേരുള്ള ഒരു TextBlock ഘടകമാണ്; ഫോർഗ്രൗണ്ട് പ്രോപ്പർട്ടി പങ്കിടുന്ന മൂന്ന് ടെക്സ്റ്റ്ബ്ലോക്ക് ഘടകങ്ങളാണ് റിസീവറുകൾ. രണ്ട് റിസീവറുകൾ കൂടുതൽ പ്രതിനിധീകരിക്കുന്നു സ്റ്റാൻഡേർഡ് വഴിഒബ്‌ജക്‌റ്റ് എക്‌സ്‌പ്രഷനുകളെ XAML മാർക്ക്അപ്പ് വിപുലീകരണങ്ങളായി ബന്ധിപ്പിക്കുന്നു:

(Binding ElementName=topTxb, Path=Forground)

XAML മാർക്ക്അപ്പ് വിപുലീകരണങ്ങൾ എല്ലായ്പ്പോഴും ചുരുണ്ട ബ്രേസുകളിൽ സ്ഥാപിച്ചിരിക്കുന്നു. ബൈൻഡിംഗിനായുള്ള ഒരു മാർക്ക്അപ്പ് എക്സ്റ്റൻഷനിൽ, നിങ്ങൾ സാധാരണയായി കോമകളാൽ വേർതിരിച്ച ഒരു ജോടി പ്രോപ്പർട്ടികൾ സജ്ജീകരിക്കേണ്ടതുണ്ട്. എലമെന്റ് നെയിം പ്രോപ്പർട്ടിആവശ്യമുള്ള പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിരിക്കുന്ന മൂലകത്തിന്റെ പേര് സൂചിപ്പിക്കുന്നു; പാത സ്വത്ത്വസ്തുവിന്റെ പേര് നൽകുന്നു.

ബൈൻഡിംഗ് മാർക്ക്അപ്പ് വിപുലീകരണങ്ങൾ ടൈപ്പുചെയ്യുമ്പോൾ, ഞാൻ എപ്പോഴും ഉദ്ധരണികളിൽ പ്രോപ്പർട്ടി മൂല്യങ്ങൾ ഉൾപ്പെടുത്താൻ ആഗ്രഹിക്കുന്നു, പക്ഷേ ഇത് തെറ്റാണ്. ബൈൻഡിംഗ് എക്സ്പ്രഷനുകളിൽ ഉദ്ധരണികൾ ആവശ്യമില്ല.

അവസാനത്തെ TextBlock ഘടകം ബൈൻഡിംഗ് എക്‌സ്‌പ്രഷൻ, സാധാരണമല്ലാത്ത പ്രോപ്പർട്ടി എലമെന്റ് സിന്റാക്സിൽ കാണിക്കുന്നു:

ഈ വാക്യഘടനയിൽ, പ്രോപ്പർട്ടി മൂല്യങ്ങളെ ചുറ്റിപ്പറ്റിയുള്ള ഉദ്ധരണികൾ ആവശ്യമാണ് കാരണം ഇവ സാധാരണമാണ് XML ആട്രിബ്യൂട്ടുകൾ. നിങ്ങൾക്ക് കോഡിൽ ഒരു ബൈൻഡിംഗ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കാനും രീതി ഉപയോഗിച്ച് സ്വീകരിക്കുന്ന പ്രോപ്പർട്ടിയിലേക്ക് അത് അസൈൻ ചെയ്യാനും കഴിയും സെറ്റ് ബൈൻഡിംഗ്()ഫ്രെയിംവർക്ക് എലമെന്റിൽ നിർവചിച്ചിരിക്കുന്നു. ബൈൻഡിംഗ് ഡെസ്റ്റിനേഷൻ എല്ലായ്പ്പോഴും ഒരു ഡിപൻഡൻസി പ്രോപ്പർട്ടി ആയിരിക്കണമെന്ന് ഇത് വെളിപ്പെടുത്തുന്നു.

ബൈൻഡിംഗ് ക്ലാസിന്റെ പാത്ത് പ്രോപ്പർട്ടിക്ക് അങ്ങനെ പേര് നൽകിയിരിക്കുന്നത് അതിൽ ഡോട്ടുകളാൽ വേർതിരിച്ച ഒന്നിലധികം പ്രോപ്പർട്ടി നാമങ്ങൾ അടങ്ങിയിരിക്കാം. ഉദാഹരണത്തിന്, ഒരെണ്ണം മാറ്റിസ്ഥാപിക്കാൻ ശ്രമിക്കുക ടെക്സ്റ്റ് മൂല്യങ്ങൾഇനിപ്പറയുന്ന മൂല്യമുള്ള പ്രോജക്റ്റിൽ:

Text="(Binding ElementName=topTxb, Path=FontFamily.Source)"

FontFamily പ്രോപ്പർട്ടിയിൽ നിന്നുള്ള ഡാറ്റ ഞങ്ങൾക്ക് ആവശ്യമാണെന്ന് പാതയുടെ ആദ്യ ഭാഗം സൂചിപ്പിക്കുന്നു. ഫോണ്ട് കുടുംബത്തിന്റെ പേര് സൂചിപ്പിക്കുന്ന ഉറവിടം എന്ന പേര് അടങ്ങിയ FontFamily എന്ന തരത്തിലുള്ള ഒബ്‌ജക്റ്റിലേക്ക് പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിരിക്കുന്നു. അതിനാൽ, TextBlock "Arial" എന്ന വാചകം പ്രദർശിപ്പിക്കും.

ഞങ്ങളുടെ പ്രോജക്റ്റിലെ ഏതെങ്കിലും TextBlock ഘടകത്തിലേക്ക് ഇനിപ്പറയുന്ന നിർമ്മാണം പ്രയോഗിക്കാൻ ശ്രമിക്കുക:

Text="(Binding RelativeSource=(RelativeSource Self), Path=FontSize)"

മാർക്ക്അപ്പ് വിപുലീകരണം ഇതാ ആപേക്ഷിക ഉറവിടംബൈൻഡിംഗ് മാർക്ക്അപ്പ് വിപുലീകരണത്തിനുള്ളിൽ കാണപ്പെടുന്നു, ബൈൻഡിംഗ് സജ്ജീകരിക്കുന്ന മൂലകത്തിന്റെ ഒരു പ്രോപ്പർട്ടി പരാമർശിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.

പ്രോഗ്രാമിംഗ്

വികസനത്തിന്റെ പ്രധാന പോയിന്റുകളിലൊന്ന് xaml-അധിഷ്ഠിത ആപ്ലിക്കേഷനുകൾ ബൈൻഡിംഗുകൾ ഉപയോഗിക്കുന്നതാണ് ( ബൈൻഡിംഗുകൾ). ബൈൻഡിംഗ്- ഈ മധ്യസ്ഥൻ(ഇടനിലക്കാരൻ), അതിന്റെ സഹായത്തോടെ പ്രോപ്പർട്ടി മൂല്യങ്ങൾ അനുബന്ധ വസ്തുക്കൾക്കിടയിൽ സമന്വയിപ്പിക്കുന്നു.

വ്യക്തമല്ലാത്തതും എന്നാൽ പ്രധാനപ്പെട്ടതുമായ ഒരു സൂക്ഷ്മത ശ്രദ്ധിക്കേണ്ടതാണ്: ബൈൻഡിംഗ് എങ്ങനെയെങ്കിലും സംവദിക്കുന്ന വസ്തുക്കളെ പരാമർശിക്കുന്നുവെങ്കിലും, അത് മാലിന്യങ്ങൾ ശേഖരിക്കപ്പെടുന്നതിൽ നിന്ന് അവയെ തടയുന്നില്ല!

ഒരു ക്ലാസിൽ നിന്നുള്ള അനന്തരാവകാശം ബൈൻഡിംഗ്അനുവദനീയമാണ്, എന്നാൽ കോഡ് സുരക്ഷാ കാരണങ്ങളാൽ രീതിയെ മറികടക്കുന്നു മൂല്യം നൽകുക, പ്രധാന പ്രവർത്തന യുക്തിയുമായി ബന്ധപ്പെട്ടത് അനുവദനീയമല്ല. ഇത് എങ്ങനെയെങ്കിലും പാറ്റേൺ ഉപയോഗിക്കാൻ ഡെവലപ്പർമാരെ പ്രേരിപ്പിക്കുന്നു കൺവെർട്ടർ, ബൈൻഡിംഗുകളുടെ പ്രമേയവുമായി അടുത്ത് ബന്ധപ്പെട്ടിരിക്കുന്നു.

ബൈൻഡിംഗുകൾ വളരെ ശക്തമായ ഒരു ഉപകരണമാണ്, എന്നാൽ ചില സന്ദർഭങ്ങളിൽ അവയുടെ പ്രഖ്യാപനം വാചാലവും അസൌകര്യവുമാകുമ്പോൾ പതിവ് ഉപയോഗം, ഉദാഹരണത്തിന്, പ്രാദേശികവൽക്കരണത്തിന്. ഈ ലേഖനത്തിൽ ഞങ്ങൾ കോഡ് കൂടുതൽ വൃത്തിയുള്ളതും മനോഹരവുമാക്കുന്ന ലളിതവും മനോഹരവുമായ ഒരു രീതി നോക്കും.

ബൈൻഡിംഗുകൾ പ്രഖ്യാപിക്കുക xamlരണ്ട് തരത്തിൽ അനുവദിച്ചിരിക്കുന്നു:

വ്യക്തമായും, ആദ്യ രീതി വളരെ സംക്ഷിപ്തമായി തോന്നുന്നില്ല, എന്നാൽ രണ്ടാമത്തേത്, ഉപയോഗത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് മാർക്ക്അപ്പ് വിപുലീകരണങ്ങൾ, മിക്കപ്പോഴും ഉപയോഗിക്കുന്നു. പ്ലാറ്റ്ഫോമിൽ WPFസൃഷ്ടിക്കാൻ അവസരമുണ്ട് ഇഷ്‌ടാനുസൃത മാർക്ക്അപ്പ് വിപുലീകരണങ്ങൾ. ഉദാഹരണത്തിന്, പ്രാദേശികവൽക്കരണത്തിനായി അവ ഉപയോഗിക്കാൻ സൗകര്യപ്രദമാണ്.

ഏറ്റവും ലളിതമായ സാഹചര്യത്തിൽ, നിങ്ങൾ ക്ലാസിൽ നിന്ന് അവകാശം നേടേണ്ടതുണ്ട് മാർക്ക്അപ്പ് എക്സ്റ്റൻഷൻരീതി നടപ്പിലാക്കുകയും ചെയ്യുക മൂല്യം നൽകുക, അതിൽ കീ ഉപയോഗിച്ച് ആവശ്യമുള്ള മൂല്യം ലഭിക്കും.

എന്നാൽ അത്തരമൊരു നടപ്പാക്കൽ പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് ഭാഷയുടെ ചൂടുള്ള മാറ്റത്തെ പിന്തുണയ്ക്കുന്നില്ല. ഈ മെച്ചപ്പെടുത്തൽ നടത്തുന്നതിന്, ഒന്നാമതായി, പ്രാദേശികവൽക്കരിച്ച ഇന്റർഫേസ് ഘടകത്തിലേക്കുള്ള ഒരു റഫറൻസ് സംഭരിക്കേണ്ടത് ആവശ്യമാണ്, രണ്ടാമതായി, വ്യക്തമല്ലാത്തത്, എങ്ങനെയെങ്കിലും ആപ്ലിക്കേഷനിൽ ക്ലാസ് ഉദാഹരണത്തിലേക്ക് തന്നെ ഒരു റഫറൻസ് ഉണ്ടായിരിക്കണം. പ്രാദേശികവൽക്കരിക്കുന്നു, മാലിന്യ ശേഖരണത്തിൽ നിന്ന് അതിനെ സംരക്ഷിക്കാൻ, മൂന്നാമതായി, ഭാഷാ മാറ്റ പരിപാടിയിൽ നിന്നുള്ള സബ്‌സ്‌ക്രിപ്‌ഷനും അൺസബ്‌സ്‌ക്രിപ്‌ഷനും ശരിയായി നടപ്പിലാക്കേണ്ടതുണ്ട്.

നിങ്ങൾ ഈ കാര്യങ്ങൾ തെറ്റായി ചെയ്യുകയാണെങ്കിൽ, ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുമ്പോൾ കാഴ്ചകൾ സൃഷ്ടിക്കുകയും ഡൈനാമിക് ആയി നശിപ്പിക്കപ്പെടുകയും ചെയ്താൽ മെമ്മറി ലീക്ക് ലഭിക്കുമെന്ന് നിങ്ങൾക്ക് ഉറപ്പുണ്ട്, ഇത് പല കേസുകളിലും സംഭവിക്കുന്നു. അതായത്, ഇത് ചേർക്കുന്നത് ഏറ്റവും മികച്ചതല്ലെന്ന് തോന്നുന്നു സങ്കീർണ്ണമായ പ്രവർത്തനം, നിസ്സാരമല്ലാത്ത വിഷയങ്ങൾ കൈകാര്യം ചെയ്യേണ്ടി വരും ദുർബലമായ ലിങ്കുകൾഒപ്പം ദുർബലമായ ഇവന്റ് സബ്‌സ്‌ക്രിപ്‌ഷനുകൾ. കൂടാതെ കോഡ് വളരെ ലളിതമായിരിക്കില്ല.

മാത്രമല്ല, ഓൺ xaml- പ്ലാറ്റ്ഫോമുകൾ വിൻഡോസ് ഫോൺ, വിൻഡോസ് സ്റ്റോർഒപ്പം Xamarin.Formsഇഷ്‌ടാനുസൃത മാർക്ക്അപ്പ് വിപുലീകരണങ്ങൾ സൃഷ്‌ടിക്കാൻ ഒരു മാർഗവുമില്ല, മാർക്ക്അപ്പ് എക്സ്റ്റൻഷനുകളായി ബൈൻഡിംഗുകൾ ഉപയോഗിക്കുന്നതിനുള്ള ആശയം കൊണ്ടുവരുന്നു …

നമുക്ക് കുറ്റിക്കാട്ടിൽ അടിക്കരുത്, നമുക്ക് വേണ്ടത് ഇതാ:

പൊതു അമൂർത്ത ക്ലാസ് ബൈൻഡിംഗ് എക്സ്റ്റൻഷൻ: ബൈൻഡിംഗ്, IValueConverter (സംരക്ഷിത ബൈൻഡിംഗ് എക്സ്റ്റൻഷൻ() (ഉറവിടം = കൺവെർട്ടർ = ഇത്; ) സംരക്ഷിത ബൈൻഡിംഗ് എക്സ്റ്റൻഷൻ(ഒബ്ജക്റ്റ് സോഴ്സ്) // ഡാറ്റാ കോൺടെക്സ്റ്റ് ഉപയോഗിക്കുന്നതിന് ഉറവിടം അസാധുവായി സജ്ജമാക്കുക (ഉറവിടം = ഉറവിടം; പരിവർത്തനം) ആപേക്ഷിക ഉറവിടം) (ആപേക്ഷിക ഉറവിടം = ആപേക്ഷിക ഉറവിടം; കൺവെർട്ടർ = ഇത്; ) പൊതു അമൂർത്തമായ ഒബ്‌ജക്റ്റ് പരിവർത്തനം (ഒബ്ജക്റ്റ് മൂല്യം, തരം ടാർഗെറ്റ് തരം, ഒബ്‌ജക്റ്റ് പാരാമീറ്റർ, കൾച്ചർ ഇൻഫോ കൾച്ചർ); പൊതു വെർച്വൽ ഒബ്‌ജക്റ്റ് പരിവർത്തനം (ഒബ്‌ജക്റ്റ് മൂല്യം, തരം ടാർഗെറ്റ് തരം, ഒബ്‌ജക്റ്റ് പാരാമീറ്റർ, കൾച്ചർ ഇൻഫോ കൾച്ചർ) (പുതിയ എറിയുക) നടപ്പാക്കാത്ത ഒഴിവാക്കൽ(); )
ബൈൻഡിംഗ് സ്വയം ഒരു കൺവെർട്ടറാണെന്നത് ശ്രദ്ധേയമാണ്. തൽഫലമായി, ഒരു ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന സ്വഭാവത്തിന് സമാനമായ പെരുമാറ്റം നമുക്ക് ലഭിക്കുന്നു മാർക്ക്അപ്പ് എക്സ്റ്റൻഷൻ, എന്നാൽ, കൂടാതെ, സാധാരണ മാലിന്യ ശേഖരണ നിയന്ത്രണ സംവിധാനങ്ങൾ ഉപയോഗിക്കുന്നത് സാധ്യമാണ്!

ഇപ്പോൾ ലോക്കലൈസേഷൻ ലുക്കിനുള്ള യുക്തി ലളിതമാകില്ല:

പൊതു ഭാഗിക ക്ലാസ് പ്രാദേശികവൽക്കരണം: Base.BindingExtension (പബ്ലിക് സ്റ്റാറ്റിക് റീഡൺലി മാനേജർ ActiveManager = new Manager(); public Localizing() (Source = ActiveManager; Path = new PropertyPath("Source"); ) public Localizing(string key) (Key = key) ; ഉറവിടം = ആക്റ്റീവ് മാനേജർ; പാത്ത് = പുതിയ പ്രോപ്പർട്ടിപാത്ത് ("ഉറവിടം"); ) പൊതു സ്ട്രിംഗ് കീ (ഗെറ്റ്; സെറ്റ്; ) പൊതു അസാധുവാക്കൽ ഒബ്ജക്റ്റ് പരിവർത്തനം (ഒബ്ജക്റ്റ് മൂല്യം, ടൈപ്പ് ടാർഗെറ്റ് ടൈപ്പ്, ഒബ്ജക്റ്റ് പാരാമീറ്റർ, കൾച്ചർഇൻഫോ കൾച്ചർ) (വാർ കീ = കീ; var റിസോഴ്സ് മാനേജർ = റിസോഴ്സ്മാനേജറായി മൂല്യം; var പ്രാദേശികവൽക്കരിക്കപ്പെട്ട മൂല്യം = റിസോഴ്സ്മാനേജർ == അസാധുവാണ് || string.IsNullOrEmpty(കീ) ? ":" + കീ + ":" : (resourceManager.GetString(കീ) ?? ":" + കീ + ":") പ്രാദേശികവൽക്കരിച്ച മൂല്യം തിരികെ നൽകുക;))
പൊതു ഭാഗിക ക്ലാസ് പ്രാദേശികവൽക്കരണം (പബ്ലിക് ക്ലാസ് മാനേജർ: INotifyPropertyChanged (സ്വകാര്യ റിസോഴ്‌സ് മാനേജർ _സോഴ്‌സ്; പബ്ലിക് റിസോഴ്‌സ് മാനേജർ ഉറവിടം (റിട്ടേൺ _സോഴ്‌സ്; ) സെറ്റ് (_source = മൂല്യം; പ്രോപ്പർട്ടിചേഞ്ച്ഡ് (ഇത്, പുതിയ പ്രോപ്പർട്ടിചേഞ്ച്ഡ് ഇവന്റ് ആർഗ്സ് ("സ്രോതസ്സ്)") string); സ്ട്രിംഗ് കീ, സ്ട്രിംഗ് സ്ട്രിംഗ് ഫോർമാറ്റ് = ശൂന്യം) ( (_source == null .NullOrEmpty(stringFormat) ? പ്രാദേശികവൽക്കരിച്ച മൂല്യം: string.Format(stringFormat, localizedValue); ) പൊതു ഇവന്റ് PropertyChangedEventHandler PropertyChanged = (അയക്കുന്നയാൾ, args) => ( ); ) )
അക്ഷരങ്ങളുടെ കേസ് മാറ്റാനുള്ള കഴിവ് ചേർക്കുന്നത് എളുപ്പമാണ്:

പൊതു ഭാഗിക ക്ലാസ് പ്രാദേശികവൽക്കരണം: Base.BindingExtension (പബ്ലിക് enum കേസുകൾ (Default, Lower, Upper ) പൊതു സ്റ്റാറ്റിക് റീഡൺലി മാനേജർ ActiveManager = പുതിയ മാനേജർ(); public Localizing() (Source = ActiveManager; Path = new PropertyPath ("Source"); ) പബ്ലിക് ലോക്കലൈസിംഗ് (സ്ട്രിംഗ് കീ) (കീ = കീ; ഉറവിടം = ആക്റ്റീവ് മാനേജർ; പാത = പുതിയ പ്രോപ്പർട്ടിപാത്ത് ("ഉറവിടം"); ) പൊതു സ്ട്രിംഗ് കീ (ഗെറ്റ്; സെറ്റ്; ) പൊതു കേസുകൾ കേസ് (ഗെറ്റ്; സെറ്റ്; ) പബ്ലിക് ഓവർറൈഡ് സ്ട്രിംഗ് ടോസ്ട്രിംഗ്() (ActiveManager.Source, null, Key, Thread.CurrentThread.CurrentCulture) സ്ട്രിംഗ് ആയി തിരികെ നൽകുക. var resourceManager = ResourceManager എന്ന നിലയിൽ മൂല്യം; var localizedValue = resourceManager == null || string.IsNullOrEmpty(key) ? ":" + key + ":" : (resourceManager.GetString(കീ) ?? ":" + key + ": "); സ്വിച്ച് (കേസ്) (കേസ് കേസുകൾ. ലോവർ: റിട്ടേൺ ലോക്കലൈസ്ഡ് വാല്യൂ.ടൊലോവർ(); കേസ് കേസുകൾ.അപ്പർ സ്ഥിരസ്ഥിതി: പ്രാദേശികവൽക്കരിച്ച മൂല്യം തിരികെ നൽകുക; )))
IN xamlറെക്കോർഡിംഗ് സൗകര്യപ്രദവും മനോഹരവുമാണെന്ന് തോന്നുന്നു, എന്നാൽ വിവിധ പ്ലാറ്റ്ഫോമുകളിൽ മാർക്ക്അപ്പ് പാഴ്സറുകൾക്ക് ചില പരിമിതികളുണ്ട്:

ഒഴിവാക്കാൻ WPFആവശ്യമായ പ്രിഫിക്സിൽ നിന്ന് മീറ്റർ:നിങ്ങൾ മാർക്ക്അപ്പ് വിപുലീകരണം ഒരു പ്രത്യേക അസംബ്ലിയിലും അകത്തും സ്ഥാപിക്കേണ്ടതുണ്ട് പ്രോപ്പർട്ടികൾ/AssemblyInfo.csഇനിപ്പറയുന്ന നിർദ്ദേശങ്ങൾ വ്യക്തമാക്കുക:

എന്ന പ്രിഫിക്‌സിന്റെ പേര് ക്രമീകരിക്കാൻ വിൻഡോസ് ഫോൺഅഥവാ സ്റ്റോർ:

ബൈൻഡിംഗ് എക്സ്റ്റൻഷനുകൾ ഉപയോഗിക്കുന്നു ( ബൈൻഡിംഗ് എക്സ്റ്റൻഷനുകൾ) ഓൺ WPFസാധാരണ മാർക്ക്അപ്പ് വിപുലീകരണങ്ങൾ ഒഴിവാക്കില്ല, എന്നാൽ ചില സന്ദർഭങ്ങളിൽ ഇതിലും സുരക്ഷിതമാണ് ലളിതമായ ഓപ്ഷൻ. കൂടാതെ, ഇതെല്ലാം പ്രാദേശികവൽക്കരണത്തിൽ മാത്രം ഒതുങ്ങുന്നില്ല, മറ്റ് പല ആവശ്യങ്ങൾക്കും അനുയോജ്യമാണ് ...

പ്രദർശിപ്പിച്ച സമീപനം ലൈബ്രറിയിൽ വ്യാപകമായി ഉപയോഗിക്കുന്നു

ഇപ്പോൾ നിങ്ങൾ നിങ്ങളുടെ ആപ്ലിക്കേഷനായി പൂർണ്ണമായ പേജുകൾ സൃഷ്ടിച്ചു. ഇപ്പോൾ നിങ്ങൾ അവ വിവിധ ഡാറ്റ ഉപയോഗിച്ച് പൂരിപ്പിക്കാൻ ആഗ്രഹിച്ചേക്കാം.

ഈ ഭാഗത്ത് നിങ്ങൾ പഠിക്കും:

• ഉപയോക്തൃ ഇന്റർഫേസിലേക്ക് ഡാറ്റ എങ്ങനെ ബന്ധിപ്പിക്കാം.
• ഡാറ്റ ബൈൻഡിംഗുകൾ സൃഷ്ടിക്കാൻ വിഷ്വൽ സ്റ്റുഡിയോ നിങ്ങളെ എങ്ങനെ സഹായിക്കും.
• ഒരു പട്ടികയിൽ ഡാറ്റ എങ്ങനെ പ്രദർശിപ്പിക്കാം.
• കൂടുതൽ സങ്കീർണ്ണമായ ബൈൻഡിംഗ് സാഹചര്യങ്ങളെ എങ്ങനെ കൈകാര്യം ചെയ്യാം.

ഉപയോക്തൃ ഇന്റർഫേസിലേക്ക് ഡാറ്റ ബന്ധിപ്പിക്കുന്നു

ഫ്യൂവൽ ട്രാക്കർ ആപ്പിന് മൂന്ന് ഡാറ്റ പേജുകളുണ്ട്. പ്രധാനമായും മൂന്ന് ക്ലാസുകളിലായാണ് ഡാറ്റ സംഭരിക്കുന്നത്. ഇനിപ്പറയുന്ന ചിത്രം പേജുകളും അവയുമായി ബന്ധപ്പെട്ട ക്ലാസുകളും കാണിക്കുന്നു.

ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിന് സാധാരണയായി ഡാറ്റ ബൈൻഡിംഗ് ഉപയോഗിക്കുന്നു. ഡാറ്റ ബൈൻഡിംഗ് ഒരു ഉപയോക്തൃ ഇന്റർഫേസ് ഒരു ഡാറ്റ ഉറവിടത്തിലേക്ക് ബന്ധിപ്പിക്കുന്നതിനുള്ള കഴിവ് നൽകുന്നു. ബൈൻഡിംഗുകൾ സൃഷ്ടിക്കപ്പെടുകയും ഡാറ്റ ഉറവിടം മാറുകയും ചെയ്യുമ്പോൾ, ഡാറ്റ ഉറവിടവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന UI ഘടകങ്ങൾ സ്വയമേവ മാറ്റങ്ങളെ പ്രതിഫലിപ്പിക്കുന്നു. അതുപോലെ, ഒരു യുഐ ഘടകത്തിലേക്ക് ഉപയോക്താവ് വരുത്തിയ മാറ്റങ്ങൾ ഡാറ്റ ഉറവിടത്തിൽ പ്രതിഫലിക്കുന്നു. ഉദാഹരണത്തിന്, ഉപയോക്താവ് ഒരു ടെക്സ്റ്റ് ബോക്സിൽ ഒരു മൂല്യം മാറ്റുകയാണെങ്കിൽ, ആ മാറ്റങ്ങൾ പ്രതിഫലിപ്പിക്കുന്നതിന് അനുബന്ധ ഡാറ്റ ഉറവിടം യാന്ത്രികമായി അപ്ഡേറ്റ് ചെയ്യും.

ഇനിപ്പറയുന്ന XAML കോഡ് സ്‌നിപ്പറ്റ് ബൈൻഡിംഗിനായി ഉപയോഗിക്കുന്ന വാക്യഘടനയെ ചിത്രീകരിക്കുന്നു ടെക്സ്റ്റ് പ്രോപ്പർട്ടികൾസോഴ്സ് ഒബ്ജക്റ്റിന്റെ നെയിം പ്രോപ്പർട്ടിയിലേക്കുള്ള ടെക്സ്റ്റ്ബോക്സ് നിയന്ത്രണം.

1. < TextBox x:Name ="NameTextBox" Text ="(ബൈൻഡിംഗ് നെയിം, മോഡ്=ടുവേ)" />

ഇനിപ്പറയുന്ന ചിത്രം അത്തരമൊരു ബൈൻഡിംഗിന്റെ ഒരു ഉദാഹരണം കാണിക്കുന്നു.

ഓരോ ബൈൻഡിംഗിനും ഒരു മോഡ് പ്രോപ്പർട്ടി ഉണ്ട്, അത് ഡാറ്റ എങ്ങനെ, എപ്പോൾ അപ്ഡേറ്റ് ചെയ്യണമെന്ന് നിർണ്ണയിക്കുന്നു. OneWay ബൈൻഡിംഗ് എന്നാൽ ഉറവിടം മാറുകയാണെങ്കിൽ ടാർഗെറ്റ് UI ഘടകം അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നു എന്നാണ്. ടുവേ ബൈൻഡിംഗ് എന്നാൽ ലക്ഷ്യവും ഉറവിടവും അവയിലേതെങ്കിലും മാറുകയാണെങ്കിൽ അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നു എന്നാണ്. നിങ്ങൾ OneWay അല്ലെങ്കിൽ TwoWay ബൈൻഡിംഗുകളാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, ഉറവിട ഒബ്‌ജക്‌റ്റിലെ മാറ്റങ്ങളെക്കുറിച്ച് ബൈൻഡിംഗിനെ അറിയിക്കുന്നതിന്, നിങ്ങൾ INotifyPropertyChanged ഇന്റർഫേസ് നടപ്പിലാക്കണം. ഈ ഇന്റർഫേസ് അടുത്ത ഭാഗമായ "ഡാറ്റ ക്ലാസുകൾ സൃഷ്ടിക്കുന്നു" എന്നതിൽ കൂടുതൽ വിശദമായി ചർച്ച ചെയ്യും.

DataContext പ്രോപ്പർട്ടി സജ്ജീകരിച്ചുകൊണ്ട് നിങ്ങൾ ഒരു സോഴ്സ് ഒബ്ജക്റ്റ് വ്യക്തമാക്കുന്നു. നിങ്ങൾ ഒരു ListBox നിയന്ത്രണമാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, ItemsSource പ്രോപ്പർട്ടി സജ്ജീകരിച്ചുകൊണ്ട് നിങ്ങൾ ഉറവിട ഒബ്‌ജക്റ്റ് വ്യക്തമാക്കണം. ഒരു സ്റ്റാറ്റിക് പ്രോപ്പർട്ടിയിൽ നിന്ന് വീണ്ടെടുത്ത ഒരു സോഴ്സ് ഒബ്‌ജക്റ്റിലേക്ക് ഒരു CarHeader പാനലിന്റെ DataContext പ്രോപ്പർട്ടി എങ്ങനെ സജ്ജീകരിക്കാമെന്ന് ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു.

1. CarHeader.DataContext = CarDataStore.Car;

* ഈ സോഴ്സ് കോഡ് സോഴ്സ് കോഡ് ഹൈലൈറ്റർ ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്തു.

DataContext പ്രോപ്പർട്ടി, അതിന്റെ എല്ലാ ചൈൽഡ് ഘടകങ്ങളും ഉൾപ്പെടെ, ഒരു മുഴുവൻ UI ഘടകത്തിനും ഒരു സ്റ്റാൻഡേർഡ് ബൈൻഡിംഗ് സജ്ജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ചില സന്ദർഭങ്ങളിൽ, മുഴുവൻ പേജിനും DataContext പ്രോപ്പർട്ടി സജ്ജീകരിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമാണെന്ന് നിങ്ങൾ കണ്ടെത്തും, മറ്റുള്ളവയിൽ, പേജിലെ ഓരോ ഘടകത്തിനും വ്യക്തിഗതമായി ഇത് സജ്ജീകരിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമാണെന്ന് നിങ്ങൾ കണ്ടെത്തും. ഓരോ XAML ലെവലിലും DataContext സജ്ജീകരിക്കുന്നത് ഉയർന്ന തലത്തിലുള്ള ഏത് ക്രമീകരണങ്ങളെയും അസാധുവാക്കുന്നു. കൂടാതെ, വ്യക്തിഗത ബൈൻഡിംഗുകൾക്കായി അവയുടെ ഉറവിട പ്രോപ്പർട്ടി സജ്ജീകരിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് ഏത് ഡാറ്റാ കോൺടെക്‌സ് ക്രമീകരണവും അസാധുവാക്കാനാകും.

ഉദാഹരണത്തിന്, Fuel Tracker ആപ്ലിക്കേഷനിൽ, ഓരോ പേജും DataContext നെ വ്യത്യസ്ത മൂല്യത്തിലേക്ക് സജ്ജമാക്കുന്നു. എന്നിരുന്നാലും, പേജിൽ ഫില്ലപ്പ് പേജ്കാറിന്റെ പേരും ഫോട്ടോയും പ്രദർശിപ്പിക്കുന്ന പാനലിനായി പേജ് ലെവൽ DataContext അസാധുവാക്കിയിരിക്കുന്നു. ഇനിപ്പറയുന്ന ചിത്രം ഫ്യൂവൽ ട്രാക്കർ ആപ്ലിക്കേഷന്റെ ഡാറ്റാ സന്ദർഭ ക്രമീകരണങ്ങൾ കാണിക്കുന്നു.

ഡാറ്റ ബൈൻഡിംഗ് ബിൽഡർ ഉപയോഗിക്കുന്നു

XAML-ൽ ഡാറ്റ ബൈൻഡിംഗുകൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ സഹായിക്കുന്നതിന് വിഷ്വൽ സ്റ്റുഡിയോയിൽ ഒരു ഡാറ്റ ബൈൻഡിംഗ് ബിൽഡർ ഉൾപ്പെടുന്നു. ഡാറ്റ ബൈൻഡിംഗ് ബിൽഡറിന് പ്രകടന മെച്ചപ്പെടുത്തലുകൾ നൽകാൻ കഴിയുമെങ്കിലും, സാധ്യമായ എല്ലാ സാഹചര്യങ്ങളെയും ഇത് പിന്തുണയ്ക്കുന്നില്ല. ഉദാഹരണത്തിന്, ഇൻഡെക്‌സ് ചെയ്‌ത ഘടകങ്ങളുമായി ബന്ധിപ്പിക്കുന്നതിനെ ഇത് പിന്തുണയ്‌ക്കുന്നില്ല, കൂടാതെ കോഡിൽ സൃഷ്‌ടിച്ച ബൈൻഡിംഗുകൾ ഇത് തിരിച്ചറിയുന്നില്ല. അതിനാൽ, ചില സാഹചര്യങ്ങളിൽ നിങ്ങൾ ഡാറ്റ ബൈൻഡിംഗുകൾ സ്വമേധയാ വ്യക്തമാക്കേണ്ടതുണ്ട്.

ഒരു പട്ടികയിൽ ഡാറ്റ പ്രദർശിപ്പിക്കുന്നു

ഒരു ലിസ്റ്റിലെ ഇനങ്ങളുടെ ഒരു ശേഖരം പ്രദർശിപ്പിക്കുന്നത് നിങ്ങളുടെ ഫോണിലെ പ്രധാന ജോലികളിലൊന്നാണ്. ഡാറ്റ ബൈൻഡിംഗ് ഉപയോഗിച്ച് ഒരു ലിസ്റ്റിലെ ഇനങ്ങളുടെ ഒരു ശേഖരം പ്രദർശിപ്പിക്കുന്നതിന് നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യേണ്ടതുണ്ട്:

1. നിങ്ങളുടെ ആപ്ലിക്കേഷനിലേക്ക് ListBox ചേർക്കുക.
2. ശേഖരം ItemsSource പ്രോപ്പർട്ടിയുമായി ബന്ധിപ്പിച്ചുകൊണ്ട് ListBox-നുള്ള ഡാറ്റ ഉറവിടം വ്യക്തമാക്കുക.
3. സജ്ജീകരിക്കാൻ രൂപം ListBox-ലെ ഓരോ ഇനവും, ListBox-നായി ഒരു ഡാറ്റ ടെംപ്ലേറ്റ് ചേർക്കുക.
4. ഡാറ്റ ടെംപ്ലേറ്റിൽ, ListBox ഇനങ്ങളെ ഇനം ശേഖരണ സവിശേഷതകളിലേക്ക് ബന്ധിപ്പിക്കുക.

ഫ്യൂവൽ ട്രാക്കർ ആപ്പ് സംഗ്രഹ പേജിലെ ലിസ്റ്റ്ബോക്സിനുള്ള ബൈൻഡിംഗുകൾ ഇനിപ്പറയുന്ന ചിത്രം കാണിക്കുന്നു.

ListBox-നുള്ള ബൈൻഡിംഗുകൾ എങ്ങനെയാണ് വ്യക്തമാക്കിയതെന്ന് ഇനിപ്പറയുന്ന XAML കാണിക്കുന്നു.

1. < ListBox ItemContainerStyle = "(സ്റ്റാറ്റിക് റിസോഴ്സ് ലിസ്റ്റ്ബോക്സ് സ്റ്റൈൽ)"
2. ItemsSource="(Binding FillupHistory)"
3. ഉയരം = "380" തിരശ്ചീന അലൈൻമെന്റ് = "ഇടത്" മാർജിൻ = "5.25,0.0"
4. വെർട്ടിക്കൽ അലൈൻമെന്റ് = "ടോപ്പ്" വിഡ്ത്ത് = "444" >
5. < ListBox.ItemTemplate >
6. < DataTemplate >
7. < StackPanel Orientation ="Horizontal" >
8. < TextBlock Style
9. വാചകം ="(ബൈൻഡിംഗ് തീയതി, കൺവെർട്ടർ=(സ്റ്റാറ്റിക് റിസോഴ്സ് StringFormatter), ConverterParameter=\(0:d\) )"
10. വീതി="105" ടെക്സ്റ്റ് വ്രാപ്പിംഗ് = "റാപ്പ്" />
11. < TextBlock Style = "(സ്റ്റാറ്റിക് റിസോഴ്സ് സംഗ്രഹ ശൈലി)"
12. വാചകം = "(ബൈൻഡിംഗ് ഫ്യുവൽ ക്വാണ്ടിറ്റി)" ടെക്സ്റ്റ് റാപ്പിംഗ് = "റാപ്പ്" />
13. < TextBlock Style = "(സ്റ്റാറ്റിക് റിസോഴ്സ് സംഗ്രഹ ശൈലി)"
14. ടെക്സ്റ്റ് ="(ബൈൻഡിംഗ് ഡിസ്റ്റൻസ്ഡ്രൈവൻ)" ടെക്സ്റ്റ് റാപ്പിംഗ് = "റാപ്പ്" />
15. < TextBlock Style = "(സ്റ്റാറ്റിക് റിസോഴ്സ് സംഗ്രഹ ശൈലി)"
16. വാചകം ="(Binding PricePerFuelUnit, Converter=(StaticResource StringFormatter), ConverterParameter=\(0:c\), ConverterCulture=en-US)" />
17. < TextBlock Style = "(സ്റ്റാറ്റിക് റിസോഴ്സ് സംഗ്രഹ ശൈലി)"
18. ടെക്‌സ്‌റ്റ് ="(ബൈൻഡിംഗ് ഫ്യൂവൽ എഫിഷ്യൻസി, കൺവെർട്ടർ=(സ്റ്റാറ്റിക് റിസോഴ്‌സ് സ്ട്രിംഗ് ഫോർമാറ്റർ), കൺവെർട്ടർ പാരാമീറ്റർ=\(0: എഫ്\))" ടെക്‌സ്‌റ്റ് റാപ്പിംഗ് = "റാപ്പ്" />

* ഈ സോഴ്സ് കോഡ് സോഴ്സ് കോഡ് ഹൈലൈറ്റർ ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്തു.

മുമ്പത്തെ XAML-ൽ, ListBox.ItemsSource പ്രോപ്പർട്ടി ഇനിപ്പറയുന്നതിലേക്ക് ബന്ധിപ്പിച്ചിരിക്കുന്നു കാർ.ഫില്ലപ്പ് ഹിസ്റ്ററിഅങ്ങനെ ഓരോ വസ്തുവും പൂരിപ്പിക്കൽചരിത്ര ശേഖരത്തിൽ ലിസ്റ്റ്ബോക്സിൽ ഒരു പ്രത്യേക ഇനമായി ദൃശ്യമാകും. DataTemplate ഘടകം ഓരോ ഇനത്തിന്റെയും രൂപഭാവം നിർവചിക്കുകയും നിരവധി ടെക്സ്റ്റ്ബ്ലോക്ക് ഘടകങ്ങൾ ഉൾക്കൊള്ളുകയും ചെയ്യുന്നു, അവയിൽ ഓരോന്നും ഒരു ക്ലാസ് പ്രോപ്പർട്ടിയുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. പൂരിപ്പിക്കൽ.

ഈ XAML ഒബ്ജക്റ്റ് ആയിരിക്കുമ്പോൾ മാത്രമേ പ്രവർത്തിക്കൂ കാർ SummaryPage.xaml.cs-ൽ നിന്നുള്ള ഇനിപ്പറയുന്ന കോഡിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, ആദ്യം പേജുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.

1. ഈ .DataContext = CarDataStore.Car;

* ഈ സോഴ്സ് കോഡ് സോഴ്സ് കോഡ് ഹൈലൈറ്റർ ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്തു.

പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനുള്ള നുറുങ്ങ്:
നിങ്ങളുടെ ListBox-ൽ സ്ക്രോൾ ചെയ്യുന്നത് സുഗമവും പ്രതികരണശേഷിയുമുള്ളതായി തോന്നുന്നില്ലെങ്കിൽ, ഈ നുറുങ്ങുകൾ പരീക്ഷിക്കുക:

• ലിസ്റ്റ്ബോക്സിലെ ഇനങ്ങൾ ലളിതമാക്കുക.
• പശ്ചാത്തലത്തിൽ ചിത്രങ്ങൾ ലോഡ് ചെയ്യുക.
• ഡാറ്റ വെർച്വലൈസേഷൻ ഉപയോഗിക്കുക.
• DeferredLoadListBox അല്ലെങ്കിൽ LazyListBox ഉപയോഗിക്കുന്നത് ശ്രദ്ധിക്കുക.
• നെസ്റ്റഡ് ലിസ്റ്റുകൾ ഉപയോഗിക്കരുത്.

സങ്കീർണ്ണമായ ബൈൻഡിംഗ് പാതകൾ

DataContext പ്രോപ്പർട്ടി ഏത് തലത്തിലും സജ്ജീകരിക്കുന്നതിനുള്ള ഫ്ലെക്സിബിലിറ്റിക്ക് പുറമേ (ഉയർന്ന തലത്തിൽ ക്രമീകരണങ്ങൾ അസാധുവാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു), റഫറൻസ് പ്രോപ്പർട്ടികളിലേക്ക് തുളച്ചുകയറുന്നതിനുള്ള സങ്കീർണ്ണമായ ബൈൻഡിംഗ് പാതകളും നിങ്ങൾക്ക് വ്യക്തമാക്കാം. കാർ.ഫില്ലപ്പ് ഹിസ്റ്ററി. ഉദാഹരണത്തിന്, SummaryPage.xaml-ൽ നിന്നുള്ള ഇനിപ്പറയുന്ന XAML പ്രോപ്പർട്ടി ബൈൻഡിംഗ് കാണിക്കുന്നു Fillup.FuelEfficiencyഗ്യാസ് സ്റ്റേഷൻ ചരിത്രത്തിന്റെ ശേഖരത്തിലെ ആദ്യ ഇനം.

1. < TextBlock Text ="(ബൈൻഡിംഗ് ഫില്ലപ്പ് ഹിസ്റ്ററി. ഫ്യൂവൽ എഫിഷ്യൻസി, Converter=(StaticResource StringFormatter), ConverterParameter=\(0:F\))" />

* ഈ സോഴ്സ് കോഡ് സോഴ്സ് കോഡ് ഹൈലൈറ്റർ ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്തു.

ഇനിപ്പറയുന്ന ചിത്രം SummaryPage.xaml-ലെ ബൈൻഡിംഗുകൾ കാണിക്കുന്നു, കൂടാതെ സങ്കീർണ്ണമായ ബൈൻഡിംഗുകളും ഡാറ്റ ടെംപ്ലേറ്റുകളും വ്യത്യസ്ത പ്രോപ്പർട്ടികളിലേക്ക് നിയന്ത്രണങ്ങൾ ബന്ധിപ്പിക്കാൻ നിങ്ങളെ എങ്ങനെ അനുവദിക്കുന്നുവെന്ന് കാണിക്കുന്നു വിവിധ വസ്തുക്കൾ, അവയെല്ലാം ഒരേ DataContext-ൽ പെട്ടതാണെങ്കിലും.

ഇടത് പിവറ്റ് സ്ക്രീനിലെ പച്ച ദീർഘചതുരങ്ങൾ സങ്കീർണ്ണമായ പാതകൾ ഉപയോഗിച്ച് സ്നാപ്പ് ചെയ്ത നിയന്ത്രണങ്ങൾ കാണിക്കുന്നു. ഈ പാതകൾ ശേഖരത്തിലെ ആദ്യ ഘടകത്തിൽ (സൂചിക 0) ആരംഭിക്കുന്നു കാർ.ഫില്ലപ്പ് ഹിസ്റ്ററിവിവിധ ക്ലാസ് പ്രോപ്പർട്ടികൾ ഉപയോഗിച്ച് അവസാനിക്കുന്നു പൂരിപ്പിക്കൽ. ഉദാഹരണത്തിന്, നിലവിലെ MPG ഫീൽഡ് ബൈൻഡിംഗ് പാത്ത് ഉപയോഗിക്കുന്നു FillupHistory.FuelEfficiency. ഈ പാതയിൽ നിങ്ങൾ പേജിന്റെ DataContext ക്രമീകരണം ഉൾപ്പെടുത്തിയാൽ, മുഴുവൻ ബൈൻഡിംഗ് പാതയും ഇതുപോലെ കാണപ്പെടും: CarDataStore.Car.FillupHistory.FuelEfficiency.

ടാഗുകൾ:

• വിൻഡോസ് ഫോൺ 7
• ഒരു ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുന്നു
• തുടക്കം മുതൽ അവസാനം വരെ

ടാഗ് ചേർക്കുക

വിൻഡോസ് പ്രസന്റേഷൻ ഫൗണ്ടേഷൻ (WPF) ആദ്യമായി .NET റഡാറിലേക്ക് വന്നപ്പോൾ, മിക്ക ലേഖനങ്ങളും ഡെമോകളും അതിന്റെ മുൻനിര റെൻഡറിംഗ് എഞ്ചിനും റെൻഡറിംഗ് കഴിവുകളും പറഞ്ഞു. 3D ഗ്രാഫിക്സ്. അവ വായിക്കാനും കളിക്കാനും രസകരമാണെങ്കിലും, അത്തരം ഉദാഹരണങ്ങൾ വിശാലതയെ പ്രതിഫലിപ്പിക്കുന്നില്ല യഥാർത്ഥ സാധ്യതകൾ WPF. ക്ലിക്ക് ചെയ്യുമ്പോൾ പടക്കമായി പൊട്ടിത്തെറിക്കുന്ന സ്പിന്നിംഗ് വീഡിയോ ക്യൂബുകൾ ഉപയോഗിച്ച് ആപ്പുകൾ സൃഷ്ടിക്കേണ്ട ആവശ്യമില്ല. സങ്കീർണ്ണമായ ശാസ്ത്രീയ അല്ലെങ്കിൽ ബിസിനസ്സ് ഡാറ്റയുടെ വലിയ അളവുകൾ പ്രദർശിപ്പിക്കുന്നതിനും എഡിറ്റുചെയ്യുന്നതിനുമായി ഞങ്ങളിൽ മിക്കവരും ഞങ്ങളുടെ ലിവിംഗ് റൈറ്റിംഗ് സോഫ്‌റ്റ്‌വെയർ നിർമ്മിക്കുന്നു.

സങ്കീർണ്ണമായ ഡാറ്റയുടെ പ്രദർശനവും എഡിറ്റിംഗും നിയന്ത്രിക്കുന്നതിന് WPF മികച്ച പിന്തുണ വാഗ്ദാനം ചെയ്യുന്നു എന്നതാണ് നല്ല വാർത്ത. MSDN® മാസികയുടെ ഡിസംബർ 2007 ലക്കത്തിൽ, WPF-ലെ ഡാറ്റ ബൈൻഡിംഗിന്റെ പ്രധാന ആശയങ്ങൾ വിശദീകരിക്കുന്നതിൽ ജോൺ പാപ്പ ഒരു ലേഖനം എഴുതി, "ഡാറ്റ ബൈൻഡിംഗ് ഇൻ WPF" (msdn.microsoft.com/magazine/cc163299). മുകളിൽ സൂചിപ്പിച്ച ഡാറ്റാ പോയിന്റ് ശ്രേണിയിൽ ജോൺ അവതരിപ്പിച്ചതിനെ അടിസ്ഥാനമാക്കിയുള്ള കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റ ബൈൻഡിംഗ് കേസുകൾ ഞാൻ ഇവിടെ നോക്കും. വായിച്ചതിനുശേഷം, മിക്ക ബിസിനസ്സ് ആപ്ലിക്കേഷനുകളിലും കാണുന്ന പൊതുവായ ഡാറ്റ ബൈൻഡിംഗ് ആവശ്യകതകൾ നടപ്പിലാക്കുന്നതിനുള്ള വിവിധ മാർഗങ്ങളെക്കുറിച്ച് വായനക്കാർക്ക് ബോധമുണ്ടാകും.

കോഡിൽ ബൈൻഡിംഗ്

ഡെസ്‌ക്‌ടോപ്പ് ആപ്ലിക്കേഷൻ ഡെവലപ്പർമാർക്ക് WPF അവതരിപ്പിക്കുന്ന ഏറ്റവും വലിയ മാറ്റങ്ങളിലൊന്ന് ഡിക്ലറേറ്റീവ് പ്രോഗ്രാമിംഗിന്റെ വ്യാപകമായ ഉപയോഗവും പിന്തുണയുമാണ്. എക്സ്റ്റൻസിബിൾ ആപ്ലിക്കേഷൻ മാർക്ക്അപ്പ് ലാംഗ്വേജ് (XAML) ഉപയോഗിച്ച് WPF ഉപയോക്തൃ ഇന്റർഫേസുകളും ഉറവിടങ്ങളും പ്രഖ്യാപിക്കാനാകും. സാധാരണ ഭാഷ XML അടിസ്ഥാനമാക്കിയുള്ള മാർക്ക്അപ്പ്. WPF ഡാറ്റ ബൈൻഡിംഗിന്റെ മിക്ക വിശദീകരണങ്ങളും XAML-ലെ ബൈൻഡിംഗുകൾ ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് കാണിക്കുന്നു. XAML-ൽ ചെയ്യാൻ കഴിയുന്നതെല്ലാം കോഡിലും നേടാനാകുമെന്നതിനാൽ, പ്രൊഫഷണൽ WPF ഡവലപ്പർമാർ ഡാറ്റ ബൈൻഡിംഗുമായി എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് ഡിക്ലറേറ്റീവ് ആയി മാത്രമല്ല, പ്രോഗ്രാമാറ്റിക്കും അറിയേണ്ടത് പ്രധാനമാണ്.

മിക്ക കേസുകളിലും, XAML-ൽ ബൈൻഡിംഗുകൾ പ്രഖ്യാപിക്കുന്നത് എളുപ്പവും സൗകര്യപ്രദവുമാണ്. സിസ്റ്റങ്ങൾ കൂടുതൽ സങ്കീർണ്ണവും ചലനാത്മകവുമാകുമ്പോൾ, കോഡിലെ ബൈൻഡിംഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നത് ചിലപ്പോൾ അർത്ഥമാക്കുന്നു. കൂടുതൽ മുന്നോട്ട് പോകുന്നതിന് മുമ്പ്, പ്രോഗ്രാമാറ്റിക് ഡാറ്റ ബൈൻഡിംഗിൽ ഉൾപ്പെട്ടിരിക്കുന്ന ചില പൊതുവായ ക്ലാസുകളും രീതികളും ആദ്യം നോക്കാം.

WPF ഘടകങ്ങൾ FrameworkElement അല്ലെങ്കിൽ FrameworkContentElement എന്നിവയിൽ നിന്ന് SetBinding, GetBindingExpression രീതികൾ അവകാശമാക്കുന്നു. ബൈൻഡിംഗ് ഓപ്പറേഷൻസ് യൂട്ടിലിറ്റി ക്ലാസിലെ അതേ പേരുകളുള്ള രീതികളെ വിളിക്കുന്ന സൗകര്യപ്രദമായ രീതികളാണ് ഇവ. ഒരു ടെക്‌സ്റ്റ് ബോക്‌സിന്റെ ടെക്‌സ്‌റ്റ് പ്രോപ്പർട്ടി മറ്റൊരു ഒബ്‌ജക്റ്റിലെ പ്രോപ്പർട്ടിയുമായി ബന്ധിപ്പിക്കുന്നതിന് ബൈൻഡിംഗ് ഓപ്പറേഷൻസ് ക്ലാസ് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഇനിപ്പറയുന്ന കോഡ് കാണിക്കുന്നു:

സ്റ്റാറ്റിക് അസാധുവായ BindText(ടെക്സ്റ്റ്ബോക്സ് ടെക്സ്റ്റ്ബോക്സ്, സ്ട്രിംഗ് പ്രോപ്പർട്ടി)
{
എങ്കിൽ (!BindingOperations.IsDataBound(textBox, textProp))
{
ബൈൻഡിംഗ് ബി = പുതിയ ബൈൻഡിംഗ്(സ്വത്ത്);
BindingOperations.SetBinding(ടെക്സ്റ്റ്ബോക്സ്, ടെക്സ്റ്റ്പ്രോപ്പ്, ബി);
}
}

ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിച്ച് ഒരു പ്രോപ്പർട്ടി അൺബൈൻഡ് ചെയ്യുന്നത് എളുപ്പമാണ്:

സ്റ്റാറ്റിക് ശൂന്യമായ അൺബൈൻഡ് ടെക്സ്റ്റ്(ടെക്സ്റ്റ്ബോക്സ് ടെക്സ്റ്റ്ബോക്സ്)
{
DependencyProperty textProp = TextBox.TextProperty;
എങ്കിൽ (BindingOperations.IsDataBound(textBox, textProp))
{
BindingOperations.ClearBinding(textBox, textProp);
}
}

ഒരു ബൈൻഡിംഗ് ക്ലിയർ ചെയ്യുമ്പോൾ, ടാർഗെറ്റ് പ്രോപ്പർട്ടിയിൽ നിന്ന് ബൗണ്ട് മൂല്യവും നീക്കം ചെയ്യപ്പെടും.

XAML-ൽ ഡാറ്റ ബൈൻഡിംഗ് പ്രഖ്യാപിക്കുന്നത് അടിസ്ഥാനപരമായ ചില വിശദാംശങ്ങൾ മറയ്ക്കുന്നു. നിങ്ങൾ കോഡിലെ ബൈൻഡിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ തുടങ്ങുമ്പോൾ, ഈ വിശദാംശങ്ങൾ പ്രത്യക്ഷപ്പെടാൻ തുടങ്ങും. ഒന്ന്, ഒരു ബൈൻഡിംഗിന്റെ ഉറവിടവും അതിന്റെ ലക്ഷ്യവും തമ്മിലുള്ള ബന്ധം യഥാർത്ഥത്തിൽ ബൈൻഡിംഗ് ക്ലാസിനേക്കാൾ, ബൈൻഡിംഗ് എക്‌സ്‌പ്രഷൻ ക്ലാസിന്റെ ഒരു ഉദാഹരണത്തിലൂടെയാണ് നിലനിർത്തുന്നത്. ഒന്നിലധികം ബൈൻഡിംഗ് എക്‌സ്‌പ്രഷൻ ക്ലാസുകൾക്ക് പങ്കിടാൻ കഴിയുന്ന ഉയർന്ന തലത്തിലുള്ള വിവരങ്ങൾ ബൈൻഡിംഗ് ക്ലാസിൽ അടങ്ങിയിരിക്കുന്നു, എന്നാൽ അടിസ്ഥാനപരമായ പദപ്രയോഗം രണ്ട് ബൗണ്ട് പ്രോപ്പർട്ടികൾ തമ്മിലുള്ള ബന്ധം നൽകുന്നു. ഒരു ടെക്‌സ്‌റ്റ് ബോക്‌സിന്റെ ടെക്‌സ്‌റ്റ് പ്രോപ്പർട്ടി പരിശോധിച്ചിട്ടുണ്ടെന്ന് പ്രോഗ്രമാറ്റിക്കായി ഉറപ്പാക്കാൻ ഒരു ബൈൻഡിംഗ് എക്‌സ്‌പ്രഷൻ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഇനിപ്പറയുന്ന കോഡ് കാണിക്കുന്നു:

സ്റ്റാറ്റിക് ബൂൾ ഐസ്‌ടെക്‌സ്‌റ്റ് വാലിഡേറ്റഡ് (ടെക്‌സ്‌റ്റ് ബോക്‌സ് ടെക്‌സ്‌റ്റ്‌ബോക്‌സ്)
{
DependencyProperty textProp = TextBox.TextProperty;

var expr = textBox.GetBindingExpression(textProp);
എങ്കിൽ (expr == null)
തെറ്റായി മടങ്ങുക;

ബൈൻഡിംഗ് b = expr.ParentBinding;
തിരികെ b.ValidationRules.Any();
}

ബൈൻഡിംഗ് എക്‌സ്‌പ്രഷൻ ക്ലാസിന് അത് സാധൂകരിക്കപ്പെടുന്നുണ്ടെന്ന് അറിയാത്തതിനാൽ, അതിന്റെ പാരന്റ് ബൈൻഡിംഗിനെക്കുറിച്ച് ചോദ്യം ചോദിക്കേണ്ടതുണ്ട്. വിവിധ സാങ്കേതിക വിദ്യകൾഞാൻ ഇൻപുട്ട് ചെക്കുകൾ താഴെ കൊടുക്കും.

ടെംപ്ലേറ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

ഫലപ്രദമായ ഒരു ഉപയോക്തൃ ഇന്റർഫേസ്, അതിൽ നിന്ന് അർത്ഥവത്തായ വിവരങ്ങൾ അവബോധപൂർവ്വം വേർതിരിച്ചെടുക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുന്ന തരത്തിൽ റോ ഡാറ്റ അവതരിപ്പിക്കുന്നു. ഇതാണ് ഡാറ്റ വിഷ്വലൈസേഷന്റെ സാരാംശം. ഡാറ്റാ വിഷ്വലൈസേഷൻ പസിലിന്റെ ഒരു ഭാഗം മാത്രമാണ് ഡാറ്റ ബൈൻഡിംഗ്. ഏറ്റവും നിസ്സാരമായ WPF പ്രോഗ്രാമുകൾ ഒഴികെ മറ്റെല്ലാത്തിനും കൂടുതൽ ഡാറ്റയെ പ്രതിനിധീകരിക്കാൻ ഒരു മാർഗം ആവശ്യമാണ് വിശാലമായ സാധ്യതകൾഡാറ്റാ ഒബ്‌ജക്‌റ്റിലെ ഒരു പ്രോപ്പർട്ടിയുമായി നിയന്ത്രണത്തിലുള്ള ഒരു പ്രോപ്പർട്ടി ബന്ധിപ്പിക്കുന്നതിനേക്കാൾ. യഥാർത്ഥ ഡാറ്റാ ഒബ്‌ജക്‌റ്റുകൾക്ക് അവയുമായി ബന്ധപ്പെട്ട നിരവധി ഗുണങ്ങളുണ്ട്, കൂടാതെ ഈ വ്യത്യസ്‌ത ഗുണവിശേഷതകൾ യോജിച്ച വിഷ്വൽ പ്രാതിനിധ്യമായി മാറണം. WPF-ന് ഡാറ്റ ടെംപ്ലേറ്റുകൾ ഉള്ളതിന്റെ കാരണം ഇതാണ്.

System.Windows.DataTemplate ക്ലാസ് WPF-ലെ ടെംപ്ലേറ്റിന്റെ ഒരു രൂപം മാത്രമാണ്. അടിസ്ഥാനപരമായി, സ്വന്തം വിഷ്വൽ പ്രാതിനിധ്യം ഇല്ലാത്ത ഒബ്‌ജക്‌റ്റുകൾ റെൻഡർ ചെയ്യാൻ സഹായിക്കുന്ന വിഷ്വൽ ഘടകങ്ങൾ സൃഷ്‌ടിക്കാൻ WPF ഫ്രെയിംവർക്ക് ഉപയോഗിക്കുന്ന ഒരു കുക്കി കട്ടറാണ് ടെംപ്ലേറ്റ്. അത്തരം ഒരു പ്രാതിനിധ്യം ഇല്ലാത്ത ഒരു ഒബ്‌ജക്‌റ്റ് റെൻഡർ ചെയ്യാൻ ഒരു ഘടകം ശ്രമിക്കുമ്പോൾ, നിലവാരമില്ലാത്ത ഒരു ബിസിനസ്സ് ഒബ്‌ജക്റ്റ് പറയുക, ഒരു ഡാറ്റ ടെംപ്ലേറ്റ് നൽകി ഒബ്‌ജക്റ്റ് എങ്ങനെ റെൻഡർ ചെയ്യാമെന്ന് നിങ്ങൾക്ക് എലമെന്റിനോട് പറയാൻ കഴിയും.
ഒരു ഡാറ്റാ ഒബ്‌ജക്‌റ്റ് പ്രദർശിപ്പിക്കുന്നതിന് ആവശ്യമായത്ര വിഷ്വലുകൾ സൃഷ്‌ടിക്കാൻ ഒരു ഡാറ്റ ടെംപ്ലേറ്റിന് കഴിയും. ഒരു ഡാറ്റാ ഒബ്‌ജക്റ്റിന്റെ ഗുണങ്ങളുടെ മൂല്യം പ്രദർശിപ്പിക്കുന്നതിന് ഈ ഘടകങ്ങൾ ഡാറ്റ ബൈൻഡിംഗുകൾ ഉപയോഗിക്കുന്നു. ഒരു ഘടകത്തിന് അത് റെൻഡർ ചെയ്യാൻ പറഞ്ഞ ഒബ്‌ജക്റ്റ് എങ്ങനെ റെൻഡർ ചെയ്യണമെന്ന് അറിയില്ലെങ്കിൽ, അത് അതിലെ ToString രീതിയിലേക്ക് വിളിക്കുകയും ഫലങ്ങൾ ഒരു TextBlock-ൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു.

ഒരു വ്യക്തിയുടെ പേര് സംഭരിക്കുന്ന ഫുൾ നെയിം എന്ന ലളിതമായ ക്ലാസ് ഞങ്ങൾക്കുണ്ടെന്ന് പറയാം. ഓരോ വ്യക്തിയുടെയും അവസാന നാമം മറ്റുള്ളവരിൽ നിന്ന് വേറിട്ടുനിൽക്കുന്ന പേരുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് ഫുൾനെയിം ഒബ്ജക്റ്റ് എങ്ങനെ റെൻഡർ ചെയ്യാം എന്ന് വിവരിക്കുന്ന ഒരു ഡാറ്റ ടെംപ്ലേറ്റ് സൃഷ്ടിക്കാൻ കഴിയും. ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്ന കോഡ്. 1, പേരുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്ന ഒരു വിൻഡോയുടെ ഫുൾനെയിം ക്ലാസും പശ്ചാത്തല കോഡും പ്രദർശിപ്പിക്കുന്നു.

അരി. 1. DataTemplate ഉപയോഗിച്ച് ഫുൾ നെയിം ഒബ്ജക്റ്റുകൾ പ്രദർശിപ്പിക്കുന്നു

പൊതു ക്ലാസ് മുഴുവൻ പേര്
{
പബ്ലിക് സ്ട്രിംഗ് ഫസ്റ്റ് നെയിം ( നേടുക; സജ്ജമാക്കുക; )
പബ്ലിക് ചാർ മിഡിൽഇനിഷ്യൽ (നേടുക; സജ്ജമാക്കുക;)
പൊതു സ്ട്രിംഗ് ലാസ്റ്റ് നെയിം ( നേടുക; സജ്ജമാക്കുക; )
}

പൊതു ഭാഗിക ക്ലാസ് വർക്കിംഗ് വിത്ത് ടെംപ്ലേറ്റുകൾ: വിൻഡോ
{
// ഇതാണ് വിൻഡോയുടെ കൺസ്ട്രക്റ്റർ.
പൊതു വർക്കിംഗ് വിത്ത് ടെംപ്ലേറ്റുകൾ()
{
InitializeComponent();

base.DataContext = പുതിയ മുഴുവൻ പേര്
{
പുതിയ പൂർണ്ണനാമം
{
ആദ്യനാമം = "ജൊഹാൻ",
മിഡിൽഇനിഷ്യൽ = "എസ്",
അവസാന നാമം = "ബാച്ച്"
},
പുതിയ പൂർണ്ണനാമം
{
ആദ്യനാമം = "ഗുസ്താവ്",
മിഡിൽഇനിഷ്യൽ = "",
അവസാന നാമം = "മാഹ്ലർ"
},
പുതിയ പൂർണ്ണനാമം
{
ആദ്യനാമം = "ആൽഫ്രഡ്",
മിഡിൽഇനിഷ്യൽ = "ജി",
അവസാന നാമം = "ഷ്നിറ്റ്കെ"
}
};
}
}

ചിത്രത്തിൽ കാണുന്നത് പോലെ. 2, വിൻഡോ XAML ഫയലിൽ ഒരു ItemsControl കൺട്രോൾ ഉണ്ട്. ഉപയോക്താവിന് തിരഞ്ഞെടുക്കാനോ ഇല്ലാതാക്കാനോ കഴിയാത്ത ഇനങ്ങളുടെ ഒരു ലളിതമായ ലിസ്റ്റ് ഇത് സൃഷ്ടിക്കുന്നു. ItemsControl-ന് അതിന്റെ ItemTemplate പ്രോപ്പർട്ടിയിലേക്ക് ഒരു DataTemplate അസൈൻ ചെയ്‌തിരിക്കുന്നു, അത് ജാലകത്തിന്റെ കൺസ്‌ട്രക്‌ടറിൽ സൃഷ്‌ടിച്ച ഓരോ ഫുൾനെയിം ഇൻസ്‌റ്റൻസും റെൻഡർ ചെയ്യുന്നു. DataTemplate-ലെ മിക്ക TextBlock ഘടകങ്ങളും അവ പ്രതിനിധീകരിക്കുന്ന FullName ഒബ്‌ജക്റ്റിന്റെ പ്രോപ്പർട്ടികളുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന ടെക്‌സ്‌റ്റ് പ്രോപ്പർട്ടി ഉണ്ടെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും.

അരി. 2. DataTemplate ഉപയോഗിച്ച് ഫുൾ നെയിം ഒബ്ജക്റ്റുകൾ പ്രദർശിപ്പിക്കുന്നു

നിങ്ങൾ ഈ ഡെമോ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ചിത്രം പോലെ കാണപ്പെടുന്നു. 3. ഒരു പേര് റെൻഡർ ചെയ്യാൻ ഒരു DataTemplate ഉപയോഗിക്കുന്നത് ഓരോ വ്യക്തിയുടെയും അവസാന നാമം ഹൈലൈറ്റ് ചെയ്യുന്നത് എളുപ്പമാക്കുന്നു, കാരണം അനുബന്ധ TextBlock-ന്റെ FontWeight ക്രമീകരണം ബോൾഡ് ആണ്. ഈ ലളിതമായ ഉദാഹരണം WPF ഡാറ്റ ബൈൻഡിംഗും ടെംപ്ലേറ്റുകളും തമ്മിലുള്ള ബന്ധം തെളിയിക്കുന്നു. ഞാൻ വിഷയം കൂടുതൽ ആഴത്തിൽ പരിശോധിക്കുമ്പോൾ, ദൃശ്യവൽക്കരിക്കാനുള്ള വഴികൾ സൃഷ്ടിക്കാൻ ഞാൻ ഈ ഫംഗ്ഷനുകൾ സംയോജിപ്പിക്കും സങ്കീർണ്ണമായ വസ്തുക്കൾഎക്കാലത്തെയും വലിയ സാധ്യതകളോടെ.

അരി. 3. DataTemplate റെൻഡർ ചെയ്‌ത പൂർണ്ണനാമം ഒബ്‌ജക്‌റ്റുകൾ

പാരമ്പര്യ ഡാറ്റാ സന്ദർഭത്തിൽ പ്രവർത്തിക്കുന്നു

മറ്റുവിധത്തിൽ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, എല്ലാ ബൈൻഡിംഗുകളും മൂലകത്തിന്റെ ഡാറ്റാ കോൺടെക്‌സ് പ്രോപ്പർട്ടിയുമായി പരോക്ഷമായി ബന്ധിപ്പിക്കുന്നു. ഒരു മൂലകത്തിന്റെ ഡാറ്റാ കോൺടെക്‌സ് അതിന്റെ ഡാറ്റ ഉറവിടത്തെ സൂചിപ്പിക്കുന്നു. DataContext എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട ചില പ്രത്യേക കാര്യങ്ങളുണ്ട്. ഡാറ്റാ കോൺടെക്‌സ്‌റ്റിന്റെ ഈ അവ്യക്തമായ വശം മനസ്സിലാക്കുന്നത് സങ്കീർണ്ണമായ ഡാറ്റ-ബൗണ്ട് യൂസർ ഇന്റർഫേസുകൾ രൂപകൽപ്പന ചെയ്യുന്നത് വളരെ എളുപ്പമാക്കുന്നു.

ഒരു ഡാറ്റ ഉറവിട ഒബ്‌ജക്‌റ്റ് റഫർ ചെയ്യുന്നതിന്, DataContext പ്രോപ്പർട്ടി സജ്ജീകരിക്കേണ്ട ആവശ്യമില്ല. ഒരു മൂലക ട്രീയിലെ (സാങ്കേതികമായി പറഞ്ഞാൽ, ലോജിക്കൽ ട്രീ) ഒരു പൂർവ്വിക മൂലകത്തിന്റെ ഡാറ്റാ കോൺടെക്‌സ് പ്രോപ്പർട്ടിക്ക് അതിന്റെ ഡാറ്റാ കോൺടെക്‌സ്റ്റിന് ഒരു മൂല്യം നൽകിയാൽ, ഉപയോക്തൃ ഇന്റർഫേസിലെ എല്ലാ ഡിറൈവ്ഡ് എലമെന്റിനും മൂല്യം സ്വയമേവ അവകാശപ്പെടും. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, DataContext എന്നത് ഒരു Foo ഒബ്‌ജക്‌റ്റിനെ പരാമർശിക്കാൻ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, സ്ഥിരസ്ഥിതിയായി, വിൻഡോയിലെ എല്ലാ ഘടകങ്ങളുടെയും DataContext ഒരേ ഫൂ ഒബ്‌ജക്റ്റിനെ സൂചിപ്പിക്കും. ഒരു വിൻഡോയിലെ ഏത് ഘടകത്തിനും അതിന്റേതായ ഡാറ്റാ കോൺടെക്‌സ് മൂല്യം എളുപ്പത്തിൽ നൽകാനാകും, അത് ആ ഘടകത്തിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ എല്ലാ ഘടകങ്ങളും പുതിയ ഡാറ്റാ കോൺടെക്‌സ് മൂല്യം അവകാശമാക്കും. ഇത് വിൻഡോസ് ഫോമുകളിലെ ഒരു ബാഹ്യ പ്രോപ്പർട്ടിക്ക് സമാനമാണ്.

മുമ്പത്തെ വിഭാഗത്തിൽ, ഡാറ്റാ ഒബ്‌ജക്‌റ്റുകളുടെ ദൃശ്യവൽക്കരണങ്ങൾ സൃഷ്‌ടിക്കാൻ ഞാൻ DataTemplates ഉപയോഗിക്കുന്നത് നോക്കി. ചിത്രത്തിലെ ടെംപ്ലേറ്റ് സൃഷ്ടിച്ച മൂലകങ്ങളുടെ ഗുണവിശേഷതകൾ. 2 ഫുൾ നെയിം ഒബ്ജക്റ്റിന്റെ ഗുണങ്ങളുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. ഈ ഘടകങ്ങൾ അവയുടെ DataContext പ്രോപ്പർട്ടിയുമായി പരോക്ഷമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. DataTemplate ടെംപ്ലേറ്റ് സൃഷ്ടിച്ച മൂലകങ്ങളുടെ DataContext പ്രോപ്പർട്ടി, ഫുൾനെയിം ഒബ്‌ജക്റ്റ് പോലെയുള്ള ടെംപ്ലേറ്റ് ഉപയോഗിക്കുന്ന ഡാറ്റാ ഒബ്‌ജക്റ്റിനെ സൂചിപ്പിക്കുന്നു.

ഡാറ്റാ കോൺടെക്‌സ് പ്രോപ്പർട്ടിയുടെ മൂല്യം അവകാശമാക്കുന്നതിൽ മാന്ത്രികതയില്ല. ഇത് പാരമ്പര്യമായി ലഭിച്ച ഡിപൻഡൻസി പ്രോപ്പർട്ടികൾക്കായി WPF-ന്റെ ബിൽറ്റ്-ഇൻ പിന്തുണ ഉപയോഗിക്കുന്നു. WPF ഡിപൻഡൻസി പ്രോപ്പർട്ടി സിസ്റ്റത്തിൽ ആ പ്രോപ്പർട്ടി രജിസ്റ്റർ ചെയ്യുമ്പോൾ നൽകിയിട്ടുള്ള മെറ്റാഡാറ്റയിൽ ഒരു ഫ്ലാഗ് നൽകിയാൽ, ഏതൊരു ആശ്രിത പ്രോപ്പർട്ടിയും ഒരു പാരമ്പര്യ സ്വത്തായിരിക്കും.

എല്ലാ ഘടകങ്ങളും ഉള്ള ഫോണ്ട്-സൈസ് പ്രോപ്പർട്ടി ആണ് പാരമ്പര്യമായി ലഭിച്ച ഡിപൻഡൻസി പ്രോപ്പർട്ടിയുടെ മറ്റൊരു ഉദാഹരണം. നിങ്ങൾ ഒരു വിൻഡോയിൽ FontSize ഡിപൻഡൻസി പ്രോപ്പർട്ടി സജ്ജമാക്കുകയാണെങ്കിൽ, സ്ഥിരസ്ഥിതിയായി ഈ വിൻഡോയിലെ എല്ലാ ഘടകങ്ങളും അത് വ്യക്തമാക്കിയ ഫോണ്ട് വലുപ്പത്തിൽ വാചകമായി പ്രദർശിപ്പിക്കും. എലമെന്റ് ട്രീയിൽ FontSize മൂല്യം പ്രചരിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന ഇൻഫ്രാസ്ട്രക്ചറും DataContext പ്രചരിപ്പിക്കുന്നു.

ഇവിടെ "പൈതൃകം" എന്ന പദം അതിന്റെ ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് അർത്ഥത്തിൽ നിന്ന് വ്യത്യസ്തമായ അർത്ഥത്തിലാണ് ഉപയോഗിക്കുന്നത്, അവിടെ ഒരു ഉപവിഭാഗം പാരന്റ് ക്ലാസ്സിലെ അംഗങ്ങളെ അവകാശമാക്കുന്നു. പ്രോപ്പർട്ടി മൂല്യങ്ങളുടെ അനന്തരാവകാശം റൺ ടൈമിൽ മൂലക മരത്തിന് താഴെയുള്ള മൂല്യങ്ങളുടെ പ്രചരണത്തെ മാത്രമാണ് സൂചിപ്പിക്കുന്നത്. സ്വാഭാവികമായും, ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് അർത്ഥത്തിൽ മൂല്യ പൈതൃകത്തെ പിന്തുണയ്ക്കുന്നതിന് ഒരു വിഭാഗത്തിന് ഒരു ആശ്രിത സ്വത്ത് അവകാശമാക്കാൻ കഴിയും.

ശേഖരണ കാഴ്‌ചകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

WPF നിയന്ത്രണങ്ങൾ ഒരു ഡാറ്റാ ശേഖരണവുമായി ബന്ധിപ്പിക്കുമ്പോൾ, അവ നേരിട്ട് ശേഖരണവുമായി ബന്ധിപ്പിക്കുന്നില്ല. പകരം, അവർ ഒരു കാഴ്ചയുമായി പരോക്ഷമായി ബന്ധിപ്പിക്കുന്നു, അത് യാന്ത്രികമായി ആ ശേഖരത്തിന്റെ പൊതിയായി മാറുന്നു. കാഴ്ച IcollectionViews ഇന്റർഫേസ് നടപ്പിലാക്കുന്നു, കൂടാതെ ListCollectionView പോലെയുള്ള നിരവധി നിർണ്ണായക നിർവ്വഹണങ്ങളിൽ ഒന്നാകാം.

ഒരു ശേഖരം അവതരിപ്പിക്കുന്നതിന് നിരവധി ജോലികളുണ്ട്. ഇത് ശേഖരത്തിലെ നിലവിലെ ഇനത്തിന്റെ ട്രാക്ക് സൂക്ഷിക്കുന്നു, ഇത് സാധാരണയായി ഒരു ലിസ്റ്റ് ബോക്സ് നിയന്ത്രണത്തിൽ തിരഞ്ഞെടുത്ത/സജീവമായ ഇനമാണ്. ഒരു ലിസ്റ്റിലെ ഇനങ്ങൾ ഓർഡർ ചെയ്യാനും ഫിൽട്ടർ ചെയ്യാനും ഗ്രൂപ്പുചെയ്യാനുമുള്ള പൊതുവായ വഴികളും ശേഖര കാഴ്‌ചകൾ വാഗ്ദാനം ചെയ്യുന്നു. ഒന്നിലധികം നിയന്ത്രണങ്ങൾക്ക് ഒരു ശേഖരത്തിന് ചുറ്റുമുള്ള ഒരേ കാഴ്ചയുമായി ബന്ധിപ്പിക്കാൻ കഴിയും, പരസ്പരം അവയുടെ ഏകോപനം ഉറപ്പാക്കുന്നു. ചുവടെയുള്ള കോഡ് IcollectionView-ന്റെ ചില കഴിവുകൾ കാണിക്കുന്നു:

// ഉപഭോക്താക്കളുടെ പട്ടികയിൽ പൊതിഞ്ഞ് സ്ഥിരസ്ഥിതി കാഴ്ച നേടുക.
IcollectionView കാഴ്ച = CollectionViewSource.GetDefaultView(allCustomers);

// യുഐയിൽ തിരഞ്ഞെടുത്ത ഉപഭോക്താവിനെ നേടുക.
ഉപഭോക്താവ് തിരഞ്ഞെടുത്ത ഉപഭോക്താവ് = കാണുക. നിലവിലെ ഇനം ഉപഭോക്താവായി;

// തിരഞ്ഞെടുത്ത ഉപഭോക്താവിനെ യുഐയിൽ സജ്ജമാക്കുക.
view.MoveCurrentTo(മറ്റൊരു ഉപഭോക്താവ്);

ലിസ്റ്റ് ബോക്‌സുകൾ, കോംബോ ബോക്‌സുകൾ, ലിസ്റ്റ് കാഴ്‌ചകൾ എന്നിവയുൾപ്പെടെ എല്ലാ ലിസ്റ്റ് തരം നിയന്ത്രണങ്ങൾക്കും CurrentItem എന്ന കളക്ഷൻ വ്യൂ പ്രോപ്പർട്ടിയുമായി സമന്വയിപ്പിച്ച് തുടരുന്നതിന് IsSynchronizedWithCurrentItem പ്രോപ്പർട്ടി ശരി എന്ന് സജ്ജീകരിച്ചിരിക്കണം. ഈ പ്രോപ്പർട്ടി അമൂർത്ത ക്ലാസ് സെലക്ടറെ നിർവചിക്കുന്നു. ഇത് true ആയി സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, ലിസ്റ്റ് ബോക്‌സ് നിയന്ത്രണത്തിൽ ഒരു ഇനം തിരഞ്ഞെടുക്കുന്നത് ശേഖരണ കാഴ്‌ചയുടെ CurrentItem അപ്‌ഡേറ്റ് ചെയ്യില്ല, കൂടാതെ CurrentItem ഒരു പുതിയ മൂല്യത്തിലേക്ക് സജ്ജീകരിക്കുന്നത് ലിസ്റ്റ് ബോക്‌സ് നിയന്ത്രണത്തിൽ പ്രതിഫലിക്കില്ല.

ഹൈറാർക്കിക്കൽ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നു

യഥാർത്ഥ ലോകം ശ്രേണിപരമായ ഡാറ്റകളാൽ നിറഞ്ഞതാണ്. ഒരു ഉപഭോക്താവ് നിരവധി ഓർഡറുകൾ നൽകുന്നു, ഒരു തന്മാത്രയിൽ നിരവധി ആറ്റങ്ങൾ അടങ്ങിയിരിക്കുന്നു, ഒരു ഡിപ്പാർട്ട്‌മെന്റ് നിരവധി ജീവനക്കാരെ ഉൾക്കൊള്ളുന്നു, സൗരയൂഥത്തിൽ ഒരു കൂട്ടം ആകാശഗോളങ്ങൾ അടങ്ങിയിരിക്കുന്നു. വായനക്കാർക്ക് ഈ മാസ്റ്റർ/ഡീറ്റെയിൽ സ്കീം പരിചിതമാണ്.
WPF നൽകുന്നു വിവിധ വഴികൾശ്രേണിപരമായ ഡാറ്റ ഘടനകളുമായി പ്രവർത്തിക്കുന്നു, അവ ഓരോന്നും അതിന്റേതായ സാഹചര്യങ്ങൾക്ക് അനുയോജ്യമാണ്. അടിസ്ഥാനപരമായി, ഒന്നുകിൽ ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിന് ഒന്നിലധികം നിയന്ത്രണങ്ങൾ ഉപയോഗിക്കുക അല്ലെങ്കിൽ ഒരൊറ്റ നിയന്ത്രണത്തിൽ ഒന്നിലധികം ഡാറ്റാ ശ്രേണി പ്രദർശിപ്പിക്കുക എന്നതാണ് ഇതര മാർഗം. ഈ രണ്ട് സമീപനങ്ങളും ഞാൻ ഇവിടെ വിശകലനം ചെയ്യും.

XML ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിന് ഒന്നിലധികം നിയന്ത്രണങ്ങൾ ഉപയോഗിക്കുന്നു

ശ്രേണിയുടെ ഓരോ തലവും ഒരു പ്രത്യേക നിയന്ത്രണമായി പ്രദർശിപ്പിക്കുക എന്നതാണ് ഹൈറാർക്കിക്കൽ ഡാറ്റയുമായി പ്രവർത്തിക്കാനുള്ള വളരെ സാധാരണമായ മാർഗ്ഗം. ഒരു ഉദാഹരണമായി, ഉപഭോക്താക്കൾ, ഓർഡറുകൾ, ഓർഡർ വിശദാംശങ്ങൾ എന്നിവയെ പ്രതിനിധീകരിക്കുന്ന ഒരു സിസ്റ്റം ഞങ്ങളുടെ പക്കലുണ്ടെന്ന് പറയാം. അത്തരമൊരു സാഹചര്യത്തിൽ, ഉപഭോക്താക്കളെ പ്രദർശിപ്പിക്കുന്നതിന് ഒരു കോംബോ ബോക്സും തിരഞ്ഞെടുത്ത ഉപഭോക്താക്കളുടെ എല്ലാ ഓർഡറുകളും പ്രദർശിപ്പിക്കുന്നതിന് ഒരു ലിസ്റ്റ് ബോക്സും ഒടുവിൽ തിരഞ്ഞെടുത്ത ഓർഡറിന്റെ വിശദാംശങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന് ഒരു ItemsControl ഉം ഉപയോഗിക്കാം. ശ്രേണിപരമായ ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിനുള്ള മികച്ച മാർഗമാണിത്, WPF-ൽ നടപ്പിലാക്കാൻ വളരെ എളുപ്പമാണ്.

ചിത്രത്തിൽ. മുകളിൽ വിവരിച്ച സാഹചര്യത്തെ അടിസ്ഥാനമാക്കിയുള്ള ചിത്രം 4, WPF XmlDataProvider ഘടകത്തിൽ പൊതിഞ്ഞ് ഒരു ആപ്ലിക്കേഷനുമായി പ്രവർത്തിക്കാൻ കഴിയുന്ന ഡാറ്റയുടെ ലളിതമായ ഉദാഹരണം കാണിക്കുന്നു. ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നതിന് സമാനമായ ഒരു ഉപയോക്തൃ ഇന്റർഫേസിൽ ഈ ഡാറ്റ പ്രദർശിപ്പിക്കാൻ കഴിയും. 5. ഉപഭോക്താക്കളെയും ഓർഡറുകളും തിരഞ്ഞെടുക്കാനാകുമെന്ന കാര്യം ശ്രദ്ധിക്കുക, എന്നാൽ ഓർഡർ വിശദാംശങ്ങൾ വായന-മാത്രം ലിസ്റ്റ് ഫോമിൽ നിലവിലുണ്ട്. ഇതിന് ഒരു കാരണമുണ്ട് - ഒരു വിഷ്വൽ ഒബ്‌ജക്റ്റ് തിരഞ്ഞെടുക്കാനുള്ള കഴിവ് അത് ആപ്ലിക്കേഷൻ നിലയെ ബാധിക്കുമ്പോഴോ അല്ലെങ്കിൽ മ്യൂട്ടബിൾ ആകുമ്പോഴോ മാത്രമേ നൽകാവൂ.

അരി. 4. XML ഫോർമാറ്റിലുള്ള ഉപഭോക്തൃ ഓർഡറുകളുടെയും ഓർഡർ വിവരങ്ങളുടെയും ശ്രേണി

അരി. 5 XML ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഒരു വഴി

ചിത്രത്തിലെ XAML കോഡിൽ. ഇവ എങ്ങനെ ഉപയോഗിക്കണമെന്ന് 6 വിവരിക്കുന്നു വിവിധ ഘടകങ്ങൾഇപ്പോൾ കാണിച്ചിരിക്കുന്ന ശ്രേണിപരമായ ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിനുള്ള നിയന്ത്രണങ്ങൾ. ഈ വിൻഡോയ്ക്ക് കോഡ് ആവശ്യമില്ല; ഇത് പൂർണ്ണമായും XAML കോഡിൽ നിലവിലുണ്ട്.

അരി. 6. ഹൈറാർക്കിക്കൽ XML ഡാറ്റ ഉപയോക്തൃ ഇന്റർഫേസിലേക്ക് ബന്ധിപ്പിക്കുന്നതിനുള്ള XAML കോഡ്

"(ബൈൻഡിംഗ് സോഴ്സ്=(സ്റ്റാറ്റിക് റിസോഴ്സ് xmlData),
XPath=ഉപഭോക്താക്കൾ/ഉപഭോക്താക്കൾ)"
മാർജിൻ="4"
>

ItemsSource="(ബൈൻഡിംഗ്)"
>

x:Name="orderSelector"
DataContext="(ബൈൻഡിംഗ് പാത്ത്=നിലവിലെ ഇനം)"
IsSynchronizedWithCurrentItem="True"
ItemsSource="(ബൈൻഡിംഗ് XPath=ഓർഡർ)"
>

ടെക്സ്റ്റ്="ഓർഡർ വിശദാംശങ്ങൾ" />
ഡാറ്റാ സന്ദർഭം=
"(Binding ElementName=orderSelector, Path=Selected Item)"
ItemsSource="(Binding XPath=orderDetail)">



ഉൽപ്പന്നം:

(

)

വ്യാപകമായ ഉപയോഗം ശ്രദ്ധിക്കുക ചെറിയ ചോദ്യങ്ങൾനിങ്ങൾക്ക് ബൗണ്ട് മൂല്യങ്ങൾ ലഭിക്കാൻ ആഗ്രഹിക്കുന്ന സ്ഥലത്തേക്ക് WPF ഫ്രെയിംവർക്ക് പോയിന്റ് ചെയ്യുന്നതിനുള്ള ഒരു XPath. XmlNode.SelectNodes രീതി പിന്തുണയ്ക്കുന്ന ഏത് XPath അന്വേഷണത്തിനും അസൈൻ ചെയ്യാവുന്ന ഒരു XPath പ്രോപ്പർട്ടി ബൈൻഡിംഗ് ക്ലാസ് നൽകുന്നു. XPath അന്വേഷണങ്ങൾ നടപ്പിലാക്കാൻ WPF ഇന്റേണലുകൾ ഈ രീതി ഉപയോഗിക്കുന്നു. നിർഭാഗ്യവശാൽ, XmlNode.SelectNodes നിലവിൽ XPath ഫംഗ്‌ഷനുകളുടെ ഉപയോഗത്തെ പിന്തുണയ്‌ക്കാത്തതിനാൽ, WPF ഡാറ്റ ബൈൻഡിംഗ് അവയെ പിന്തുണയ്‌ക്കുന്നില്ല എന്നാണ് ഇതിനർത്ഥം.

ഉപഭോക്തൃ ലിസ്റ്റ് ബോക്സും ഓർഡർ ലിസ്റ്റും റൂട്ട് ഗ്രിഡ് എലമെന്റിന്റെ DataContext ക്വറി നടപ്പിലാക്കിയ XPath ക്വറി നോഡുകളുടെ ഫലമായ സെറ്റുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. പട്ടികയുടെ ഡാറ്റാ കോൺടെക്‌സ്‌റ്റിനായി സൃഷ്‌ടിച്ച XmlNodes ശേഖരണത്തിനുള്ള റാപ്പറായ, ശേഖര കാഴ്‌ചയുടെ നിലവിലെ ഇനം സ്വയമേവ തിരികെ നൽകും. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ലിസ്റ്റിന്റെ ഡാറ്റാ സന്ദർഭം നിലവിൽ തിരഞ്ഞെടുത്ത ക്ലയന്റാണ്. ലിസ്‌റ്റിന്റെ ItemsSource അതിന്റെ സ്വന്തം DataContext-മായി ബന്ധപ്പെട്ടിരിക്കുന്നതിനാൽ (മറ്റൊരു ഉറവിടവും വ്യക്തമാക്കിയിട്ടില്ലാത്തതിനാൽ) അതിന്റെ ItemsSource ബൈൻഡിംഗ് ഇനങ്ങൾ വീണ്ടെടുക്കുന്നതിന് ഒരു XPath അന്വേഷണം നടത്തുന്നു. DataContext-ൽ നിന്ന്, ItemsSource യഥാർത്ഥത്തിൽ തിരഞ്ഞെടുത്ത ഉപഭോക്താവിന്റെ ഓർഡറുകളുടെ പട്ടികയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.

XML ഡാറ്റയിലേക്ക് ബൈൻഡുചെയ്യുമ്പോൾ, യഥാർത്ഥ ബൈൻഡിംഗ് XmlNode.SelectNodes-ലേക്കുള്ള കോൾ സൃഷ്ടിച്ച ഒബ്‌ജക്റ്റുകളിലേക്കാണെന്ന് ഓർമ്മിക്കുക. നിങ്ങൾ ശ്രദ്ധാലുക്കളല്ലെങ്കിൽ, ലോജിക്കലി തുല്യമായതും എന്നാൽ ശാരീരികമായി വ്യത്യസ്തവുമായ XmlNodes സെറ്റുകളുമായി ബന്ധിപ്പിക്കുന്ന ഒന്നിലധികം നിയന്ത്രണങ്ങൾ നിങ്ങൾക്ക് ലഭിക്കും. കാരണം, XmlNode-ലേക്കുള്ള ഓരോ കോളും.SelectNodes ഒരു പുതിയ XmlNodes സൃഷ്ടിക്കുന്നു, നിങ്ങൾ ഓരോ തവണയും ഒരേ XMLNode-ലേക്ക് ഒരേ XPath അന്വേഷണം നൽകിയാലും. ഈ പ്രത്യേക പ്രശ്നം XML ഡാറ്റയുമായി ബന്ധിപ്പിക്കുന്നു, അതിനാൽ ബിസിനസ്സ് ഒബ്ജക്റ്റുകളുമായി ബന്ധിപ്പിക്കുമ്പോൾ നിങ്ങൾക്ക് അത് സുരക്ഷിതമായി അവഗണിക്കാം.

ബിസിനസ്സ് ഒബ്ജക്റ്റുകൾ പ്രദർശിപ്പിക്കുന്നതിന് ഒന്നിലധികം നിയന്ത്രണങ്ങൾ ഉപയോഗിക്കുന്നു

മുമ്പത്തെ ഉദാഹരണത്തിൽ നിന്നുള്ള ഡാറ്റയുമായി ബന്ധിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് ഇപ്പോൾ പറയാം, എന്നാൽ ഡാറ്റ XML കോഡിനേക്കാൾ ബിസിനസ്സ് ഒബ്ജക്റ്റുകളായി നിലവിലുണ്ട്. ഡാറ്റാ ശ്രേണിയുടെ വിവിധ തലങ്ങളിലേക്ക് നാം ബന്ധിപ്പിക്കുന്ന രീതിയെ ഇത് എങ്ങനെ മാറ്റും? സ്വീകരണം എത്രത്തോളം സമാനമോ വ്യത്യസ്തമോ ആയിരിക്കും?

ചിത്രത്തിലെ കോഡിൽ. 7 കാണിച്ചിരിക്കുന്നു ലളിതമായ ക്ലാസുകൾ, ബൈൻഡിംഗ് സംഭവിക്കുന്ന ഡാറ്റ സംഭരിക്കുന്ന ബിസിനസ്സ് വസ്തുക്കൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു. മുമ്പത്തെ വിഭാഗത്തിൽ ഉപയോഗിച്ച XML ഡാറ്റയുടെ അതേ ലോജിക്കൽ സ്കീമയാണ് ഈ ക്ലാസുകൾ ഉണ്ടാക്കുന്നത്.

അരി. 7. ബിസിനസ് ഒബ്ജക്റ്റുകളുടെ ഒരു ശ്രേണി സൃഷ്ടിക്കുന്നതിനുള്ള ക്ലാസുകൾ

പൊതു ക്ലാസ് ഉപഭോക്താവ്
{
പൊതു സ്ട്രിംഗ് പേര് (നേടുക; സജ്ജമാക്കുക;)
പൊതു പട്ടിക ഓർഡറുകൾ (നേടുക; സജ്ജമാക്കുക;)

{
ഇത് തിരികെ നൽകുക. പേര്;
}
}

പൊതു ക്ലാസ് ഓർഡർ
{
പൊതു സ്ട്രിംഗ് ഡെസ്ക് (നേടുക; സജ്ജമാക്കുക;)
പൊതു പട്ടിക ഓർഡർ വിശദാംശങ്ങൾ (നേടുക; സജ്ജമാക്കുക;)

പൊതു അസാധുവാക്കൽ സ്ട്രിംഗ് ToString()
{
ഇത് തിരികെ നൽകുക.
}
}

പൊതു ക്ലാസ് ഓർഡർ വിശദാംശങ്ങൾ
{
പൊതു സ്ട്രിംഗ് ഉൽപ്പന്നം (നേടുക; സജ്ജമാക്കുക;)
പബ്ലിക് ഇൻറ്റ് അളവ് (നേടുക; സജ്ജമാക്കുക;)
}

ഈ ഒബ്‌ജക്‌റ്റുകൾ പ്രദർശിപ്പിക്കുന്ന വിൻഡോയുടെ XAML കോഡ് ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നു. 8. ഇത് ചിത്രത്തിലെ XAML കോഡുമായി വളരെ സാമ്യമുള്ളതാണ്. 6, എന്നാൽ അതിനിടയിൽ ഉണ്ട് പ്രധാനപ്പെട്ട വ്യത്യാസങ്ങൾ, അത് ശ്രദ്ധിക്കേണ്ടതാണ്. XAML കോഡ് കാണാത്തത്, XAML കോഡ് ഒരു റിസോഴ്‌സായി ഒരു റഫറൻസ് സജ്ജീകരിക്കുന്നതിനുപകരം, ഡാറ്റാ ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കുകയും DataContext സജ്ജമാക്കുകയും ചെയ്യുന്ന ഒരു വിൻഡോ കൺസ്‌ട്രക്‌ടറാണ്. നിയന്ത്രണങ്ങൾക്കൊന്നും DataContext പ്രോപ്പർട്ടി നേരിട്ട് സജ്ജീകരിച്ചിട്ടില്ലെന്നത് ശ്രദ്ധിക്കുക. അവയ്‌ക്കെല്ലാം ഒരേ DataContext പ്രോപ്പർട്ടി അവകാശമായി ലഭിക്കുന്നു, അത് ഒരു ലിസ്റ്റ് ഉദാഹരണമാണ് .

അരി. 8. ഹൈറാർക്കിക്കൽ ബിസിനസ്സ് ഒബ്ജക്റ്റുകൾ ഉപയോക്തൃ ഇന്റർഫേസുമായി ബന്ധിപ്പിക്കുന്നതിനുള്ള XAML കോഡ്

/>
IsSynchronizedWithCurrentItem="True"
ItemsSource="(ബൈൻഡിംഗ് പാത്ത്=.)"
/>

IsSynchronizedWithCurrentItem="True"
ItemsSource="(ബൈൻഡിംഗ് പാത്ത്=CurrentItem.Orders)"
/>

ടെക്സ്റ്റ്="ഓർഡർ വിശദാംശങ്ങൾ" />
ItemsSource="(Binding Path=CurrentItem.Orders.CurrentItem.
ഓർഡർ വിശദാംശങ്ങൾ)"
>



ഉൽപ്പന്നം:

(

)

XML-ന് പകരം ബിസിനസ്സ് ഒബ്ജക്റ്റുകളിലേക്ക് ബൈൻഡുചെയ്യുമ്പോൾ മറ്റൊരു പ്രധാന വ്യത്യാസം, ഓർഡർ വിവരങ്ങൾ സൂക്ഷിക്കുന്ന ItemsControl, ഓർഡർ ലിസ്റ്റിലെ തിരഞ്ഞെടുത്ത ഇനവുമായി ബന്ധിപ്പിക്കേണ്ടതില്ല എന്നതാണ്. അഭാവം മൂലം XML ബൈൻഡിംഗിന്റെ കാര്യത്തിൽ ഈ സമീപനം ആവശ്യമായിരുന്നു സാർവത്രിക രീതിപ്രാദേശിക XPath അന്വേഷണത്തിൽ നിന്ന് വരുന്ന ഘടകങ്ങൾ നിലവിലുള്ള ലിസ്റ്റ് ഘടകത്തിലേക്ക് റഫർ ചെയ്യുക.

XML-ന് പകരം ബിസിനസ്സ് ഒബ്‌ജക്‌റ്റുകളിലേക്ക് ബൈൻഡുചെയ്യുമ്പോൾ, തിരഞ്ഞെടുത്ത ഘടകങ്ങളുടെ നെസ്റ്റഡ് ലെവലുകളിലേക്ക് ബൈൻഡുചെയ്യുന്നു നിസ്സാരമായ ദൗത്യം. ItemsControl-ന്റെ ItemsSource ബൈൻഡിംഗ് ബൈൻഡിംഗ് പാതയിൽ CurrentItem രണ്ടുതവണ വ്യക്തമാക്കുന്നതിലൂടെ ഈ സൗകര്യം പ്രയോജനപ്പെടുത്തുന്നു: തിരഞ്ഞെടുത്ത ഉപഭോക്താവിന് ഒരിക്കൽ, തിരഞ്ഞെടുത്ത ഓർഡറിന് ഒരിക്കൽ. CurrentItem പ്രോപ്പർട്ടി, മുകളിൽ ചർച്ച ചെയ്‌തതുപോലെ, ഡാറ്റാ ഉറവിടത്തെ പൊതിഞ്ഞിരിക്കുന്ന IcollectionView-ലെ അംഗമാണ്.

സമീപനങ്ങളിലെ വ്യത്യാസവുമായി ബന്ധപ്പെട്ട മറ്റൊരു രസകരമായ പോയിന്റുണ്ട് XML വർക്ക്ബിസിനസ്സ് വസ്തുവും. എന്തുകൊണ്ടെന്നാല് XML ഉദാഹരണം XmlElements-ലേക്ക് ബന്ധിപ്പിക്കുന്നു, ഉപഭോക്താക്കളെയും ഓർഡറുകളും എങ്ങനെ ദൃശ്യവൽക്കരിക്കാം എന്ന് വിശദീകരിക്കാൻ നിങ്ങൾ ഡാറ്റ ടെംപ്ലേറ്റുകൾ നൽകേണ്ടതുണ്ട്. ഇഷ്‌ടാനുസൃത ബിസിനസ്സ് ഒബ്‌ജക്‌റ്റുകളുമായി ബന്ധിപ്പിക്കുമ്പോൾ, ഉപഭോക്തൃ, ഓർഡർ ക്ലാസുകളുടെ ടോസ്‌ട്രിംഗ് രീതി അസാധുവാക്കുകയും ആ ഒബ്‌ജക്റ്റുകൾക്കായി ആ രീതിയുടെ ഔട്ട്‌പുട്ട് പ്രദർശിപ്പിക്കാൻ WPF-നെ അനുവദിക്കുകയും ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് ഈ അധിക ജോലി ഒഴിവാക്കാനാകും. ലളിതമായ ടെക്‌സ്‌റ്റ് പ്രാതിനിധ്യമുള്ള ഒബ്‌ജക്‌റ്റുകൾക്ക് മാത്രം ഈ ട്രിക്ക് മതിയാകും. കൂടെ ജോലി ചെയ്യുമ്പോൾ സങ്കീർണ്ണമായ വസ്തുക്കൾഡാറ്റ, ഈ സൗകര്യപ്രദമായ സാങ്കേതികത ഉപയോഗിക്കുന്നത് അർത്ഥമാക്കുന്നില്ല.

മുഴുവൻ ശ്രേണിയും പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഒരു നിയന്ത്രണം

ഈ ഘട്ടം വരെ, ശ്രേണിയുടെ ഓരോ ലെവലും പ്രത്യേക നിയന്ത്രണങ്ങളിൽ പ്രദർശിപ്പിച്ചുകൊണ്ട് ഹൈറാർക്കിക്കൽ ഡാറ്റ പ്രദർശിപ്പിക്കാനുള്ള വഴികൾ മാത്രമേ ഞങ്ങൾ കാണിച്ചിട്ടുള്ളൂ. ഒരു ശ്രേണിപരമായ ഡാറ്റാ ഘടനയുടെ എല്ലാ തലങ്ങളും ഒരൊറ്റ നിയന്ത്രണത്തിൽ പ്രദർശിപ്പിക്കുന്നത് പലപ്പോഴും ഉപയോഗപ്രദവും ആവശ്യവുമാണ്. ഈ സമീപനത്തിന്റെ കാനോനിക്കൽ ഉദാഹരണം TreeView കൺട്രോളാണ്, ഇത് നെസ്റ്റഡ് ഡാറ്റയുടെ അനിയന്ത്രിതമായ എണ്ണം ലെവലിലൂടെ പ്രദർശിപ്പിക്കുന്നതും ആവർത്തിക്കുന്നതും പിന്തുണയ്ക്കുന്നു.

നിങ്ങൾക്ക് WPF-ൽ രണ്ട് വഴികളിൽ ഒന്നിൽ ഘടകങ്ങൾ ഉപയോഗിച്ച് TreeView പോപ്പുലേറ്റ് ചെയ്യാം. കോഡിലോ XAML-ലോ ഘടകങ്ങൾ സ്വമേധയാ ചേർക്കുന്നതാണ് ആദ്യ മാർഗം, രണ്ടാമത്തേത് ഡാറ്റ ബൈൻഡിംഗിലൂടെ അവ സൃഷ്ടിക്കുക എന്നതാണ്.

XAML-ലെ ഒരു TreeView-ലേക്ക് TreeViewItems എങ്ങനെ ചേർക്കാമെന്ന് ഇനിപ്പറയുന്ന XAML കാണിക്കുന്നു:

ഒരു ട്രീവ്യൂവിൽ ഘടകങ്ങൾ സ്വമേധയാ സൃഷ്ടിക്കുന്നതിനുള്ള സാങ്കേതികത, നിയന്ത്രണം എല്ലായ്പ്പോഴും ചെറുതും സ്ഥിരവുമായ ഘടകങ്ങളുടെ ഒരു കൂട്ടം പ്രദർശിപ്പിക്കുന്ന സാഹചര്യങ്ങളിൽ അർത്ഥവത്താണ്. കാലക്രമേണ മാറിയേക്കാവുന്ന വലിയ അളവിലുള്ള ഡാറ്റ പ്രദർശിപ്പിക്കേണ്ട ആവശ്യമുണ്ടെങ്കിൽ, കൂടുതൽ ചലനാത്മകമായ സമീപനം ആവശ്യമാണ്. ഈ ഘട്ടത്തിൽ രണ്ട് ഓപ്ഷനുകൾ ഉണ്ട്. നിങ്ങൾക്ക് ഡാറ്റാ ഘടനയിലൂടെ കടന്നുപോകുന്ന കോഡ് എഴുതാനും അത് കണ്ടെത്തുന്ന ഡാറ്റാ ഒബ്‌ജക്റ്റുകളെ അടിസ്ഥാനമാക്കി TreeViewItems സൃഷ്‌ടിക്കാനും TreeView-ലേക്ക് ആ ഇനങ്ങൾ ചേർക്കാനും കഴിയും. ഹൈറാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുകയും എല്ലാ ജോലികളും WPF-ന് വിടുകയും ചെയ്യുക എന്നതാണ് ഒരു ബദൽ.

ഹൈറാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നു

ഹൈരാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റുകളിലൂടെ WPF എങ്ങനെയാണ് ഹൈറാർക്കിക്കൽ ഡാറ്റ ദൃശ്യവൽക്കരിക്കേണ്ടത് എന്ന് പ്രഖ്യാപനപരമായി പ്രകടിപ്പിക്കാം. ഹൈരാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റ് ക്ലാസ് തമ്മിലുള്ള ഒരു പാലമാണ് സങ്കീർണ്ണമായ ഘടനഈ ഡാറ്റയുടെ ഡാറ്റയും വിഷ്വൽ പ്രാതിനിധ്യവും. ഇത് ഒരു സാധാരണ ഡാറ്റ ടെംപ്ലേറ്റുമായി വളരെ സാമ്യമുള്ളതാണ്, മാത്രമല്ല ഡാറ്റാ ഒബ്‌ജക്റ്റിന്റെ കുട്ടികൾ എവിടെ നിന്നാണ് വരുന്നതെന്ന് വ്യക്തമാക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു. ഇവ റെൻഡർ ചെയ്യുന്നതിനായി നിങ്ങൾക്ക് ഒരു ടെംപ്ലേറ്റിനൊപ്പം ഹൈറാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റ് ക്ലാസും നൽകാം കുട്ടികളുടെ ഘടകങ്ങൾ.

ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്ന ഡാറ്റ ഇപ്പോൾ പ്രദർശിപ്പിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് കരുതുക. ഒരു TreeView നിയന്ത്രണത്തിനുള്ളിൽ 7. തത്ഫലമായുണ്ടാകുന്ന TreeView ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നത് പോലെയായിരിക്കാം. 9. ഇത് നടപ്പിലാക്കുന്നതിൽ രണ്ട് ഹൈറാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റുകളും ഒരു ഡാറ്റ ടെംപ്ലേറ്റും ഉൾപ്പെടുന്നു.

അരി. 9. ഒരു ട്രീവ്യൂവിൽ ഒരു മുഴുവൻ ഡാറ്റാ ശ്രേണിയും പ്രദർശിപ്പിക്കുന്നു

രണ്ട് ശ്രേണിപരമായ ടെംപ്ലേറ്റുകൾ ഉപഭോക്തൃ, ഓർഡർ ഒബ്ജക്റ്റുകൾ പ്രദർശിപ്പിക്കുന്നു. OrderDetail ഒബ്‌ജക്‌റ്റുകൾക്ക് കുട്ടികളില്ലാത്തതിനാൽ, അവ ഒരു നോൺ-ഹൈരാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് റെൻഡർ ചെയ്യാൻ കഴിയും. TreeView-ന്റെ ഇനം ടെംപ്ലേറ്റ് പ്രോപ്പർട്ടി ഉപഭോക്തൃ ഒബ്‌ജക്‌റ്റുകൾക്കായി ഒരു ടെംപ്ലേറ്റ് ഉപയോഗിക്കുന്നു, കാരണം ഉപഭോക്തൃ ഒബ്‌ജക്റ്റുകളും ഡാറ്റാ ഒബ്‌ജക്റ്റുകളും TreeView-ന്റെ റൂട്ട് ലെവലിൽ അടങ്ങിയിരിക്കുന്നു. ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്ന XAML കോഡിൽ. ഈ പസിലിന്റെ എല്ലാ ഭാഗങ്ങളും എങ്ങനെ ഒത്തുചേരുന്നുവെന്ന് ചിത്രം 10 കാണിക്കുന്നു.

അരി. 10. ട്രീവ്യൂവിന് പിന്നിൽ XAML

xmlns:local="clr-namespace:VariousBindingExamples"
ഒബ്ജക്റ്റ് ടൈപ്പ്="(x:ടൈപ്പ് ലോക്കൽ:കസ്റ്റമർ)"
രീതിയുടെ പേര്="ഉപഭോക്താക്കളെ സൃഷ്ടിക്കുക"
/>

ഉൽപ്പന്നം:

(

)

x:കീ="ഓർഡർ ടെംപ്ലേറ്റ്"
ItemsSource="(ബൈൻഡിംഗ് പാത്ത്=ഓർഡർ വിശദാംശങ്ങൾ)"
ItemTemplate="(StaticResource OrderDetailTemplate)"
>

x:കീ="കസ്റ്റമർ ടെംപ്ലേറ്റ്"
ItemsSource="(ബൈൻഡിംഗ് പാത്ത്=ഓർഡറുകൾ)"
ഇനം ടെംപ്ലേറ്റ്="(സ്റ്റാറ്റിക് റിസോഴ്സ് ഓർഡർ ടെംപ്ലേറ്റ്)"
>

ItemsSource="(ബൈൻഡിംഗ് പാത്ത്=.)"
ഇനം ടെംപ്ലേറ്റ്="(സ്റ്റാറ്റിക് റിസോഴ്‌സ് കസ്റ്റമർ ടെംപ്ലേറ്റ്)"
/>

TreeView അടങ്ങിയിരിക്കുന്ന ഒരു പട്ടികയുടെ (ഗ്രിഡ്) ഡാറ്റാ കോൺടെക്‌സിലേക്ക് ഞാൻ ഉപഭോക്തൃ ഒബ്‌ജക്റ്റുകളുടെ ഒരു ശേഖരം അനുവദിക്കുന്നു. XAML-ൽ, ObjectDataProvider ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും, ഇത് XAML-ൽ നിന്ന് ഒരു രീതിയെ വിളിക്കാനുള്ള സൗകര്യപ്രദമായ മാർഗമാണ്. മൂലക ട്രീയിൽ നിന്ന് ഡാറ്റാ കോൺടെക്‌സ് പാരമ്പര്യമായി ലഭിച്ചതിനാൽ, ഈ ഉപഭോക്തൃ ഒബ്‌ജക്‌റ്റുകൾക്ക് ട്രീവ്യൂവിന്റെ ഡാറ്റാ കോൺടെക്‌സ് ഒരു റഫറൻസ് നൽകുന്നു. ഇക്കാരണത്താൽ നമുക്ക് അതിന്റെ ItemsSource പ്രോപ്പർട്ടിക്ക് "(Binding Path=.)" എന്നതിന്റെ ഒരു ബൈൻഡിംഗ് നൽകാം, ഇത് ItemsSource പ്രോപ്പർട്ടി TreeView-യുടെ DataContext-ലേക്ക് ബന്ധിപ്പിച്ചിരിക്കുന്നു എന്ന് സൂചിപ്പിക്കാനുള്ള ഒരു മാർഗമാണ്.

TreeView-ന്റെ ItemTemplate പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, TreeView ഉയർന്ന തലത്തിലുള്ള ഉപഭോക്തൃ ഒബ്‌ജക്‌റ്റുകൾ മാത്രം പ്രദർശിപ്പിക്കും. ഒരു ഉപഭോക്താവിനെ എങ്ങനെ റെൻഡർ ചെയ്യണമെന്ന് WPF-ന് അറിയാത്തതിനാൽ, അത് ഓരോ ഉപഭോക്താവിനെയും ToString എന്ന് വിളിക്കുകയും ഓരോ ഘടകത്തിനും ആ വാചകം പ്രദർശിപ്പിക്കുകയും ചെയ്യും. ഓരോ ഉപഭോക്താവിനും അതുമായി ബന്ധപ്പെട്ട ഓർഡർ ഒബ്‌ജക്റ്റുകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടെന്നും ഓരോ ഓർഡർ ഒബ്‌ജക്റ്റിന്റെ ഒരു ലിസ്റ്റ് OrderDetail ഒബ്‌ജക്റ്റുകളും ഉണ്ടെന്നും ഇതിന് ഒരു വഴിയുമില്ല. WPF-ന് നിലവിലുള്ള ഒരു ഡാറ്റാ സ്കീമയെ മാന്ത്രികമായി മനസ്സിലാക്കാൻ കഴിയാത്തതിനാൽ, WPF-ന് സ്കീമ വിശദീകരിക്കേണ്ടത് ആവശ്യമാണ്, അതുവഴി ഡാറ്റാ ഘടന ശരിയായി ദൃശ്യവൽക്കരിക്കാൻ കഴിയും.

WPF-ന് ഡാറ്റയുടെ ഘടനയും രൂപവും വിശദീകരിക്കേണ്ടിവരുമ്പോൾ ഹൈറാർക്കിക്കൽ ഡാറ്റ ടെംപ്ലേറ്റുകൾ പ്രവർത്തിക്കുന്നു. ഈ ഡെമോയിൽ ഉപയോഗിച്ചിരിക്കുന്ന ടെംപ്ലേറ്റുകളിൽ വളരെ ലളിതമായ വിഷ്വൽ ട്രീകൾ അടങ്ങിയിരിക്കുന്നു, അടിസ്ഥാനപരമായി ചെറിയ അളവിലുള്ള ടെക്‌സ്‌റ്റ് ഉള്ള ടെക്‌സ്റ്റ്ബ്ലോക്ക് ഫീൽഡുകൾ മാത്രം. കൂടുതൽ സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകളിൽ, ടെംപ്ലേറ്റുകൾക്ക് ഇന്ററാക്ടീവ് റൊട്ടേറ്റിംഗ് ഉണ്ടായിരിക്കാം 3D മോഡലുകൾ, ചിത്രങ്ങൾ, ഡ്രോയിംഗുകൾ വെക്റ്റർ ഗ്രാഫിക്സ്, സങ്കീർണ്ണ ഘടകങ്ങൾ UserControl അല്ലെങ്കിൽ അടിസ്ഥാന ഡാറ്റാ ഒബ്‌ജക്‌റ്റ് റെൻഡർ ചെയ്യാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന മറ്റേതെങ്കിലും WPF ഉള്ളടക്കം.

ഫലകങ്ങൾ പ്രഖ്യാപിക്കുന്ന ക്രമത്തിൽ ശ്രദ്ധിക്കേണ്ടത് പ്രധാനമാണ്. ഒരു സ്റ്റാറ്റിക് റിസോഴ്‌സ് എക്‌സ്‌പ്രഷനിലൂടെ റഫറൻസ് ചെയ്യുന്നതിന് മുമ്പ് ഒരു ടെംപ്ലേറ്റ് പ്രഖ്യാപിക്കണം. ഇത് XAML റീഡർ ചുമത്തിയ ഒരു ആവശ്യകതയാണ് കൂടാതെ ടെംപ്ലേറ്റുകൾക്ക് മാത്രമല്ല, എല്ലാ ഉറവിടങ്ങൾക്കും ഇത് ബാധകമാണ്.

പകരം, ഒരു ഡൈനാമിക് റിസോഴ്സ് എക്സ്പ്രഷൻ ഉപയോഗിച്ച് ടെംപ്ലേറ്റുകൾ പരാമർശിക്കാം; ഈ സാഹചര്യത്തിൽ, ടെംപ്ലേറ്റ് പ്രഖ്യാപനങ്ങളുടെ ലെക്സിക്കൽ ക്രമം പ്രധാനമല്ല. എന്നിരുന്നാലും, സ്റ്റാറ്റിക് റിസോഴ്‌സ് ലിങ്കുകൾക്ക് വിരുദ്ധമായി ഡൈനാമിക് റിസോഴ്‌സ് ലിങ്കുകൾ ഉപയോഗിക്കുന്നത് ചില എക്‌സിക്യൂഷൻ ഓവർഹെഡുമായി വരുന്നു, കാരണം അവ റിസോഴ്‌സ് സിസ്റ്റത്തിലെ മാറ്റങ്ങൾ ട്രാക്കുചെയ്യുന്നു. റൺടൈമിൽ ഞങ്ങൾ ടെംപ്ലേറ്റുകൾ മാറ്റിസ്ഥാപിക്കാത്തതിനാൽ, ഈ ഓവർഹെഡ് അനാവശ്യമാണ്, അതിനാൽ സ്റ്റാറ്റിക് റിസോഴ്സ് റഫറൻസുകൾ ഉപയോഗിക്കുകയും ടെംപ്ലേറ്റ് പ്രഖ്യാപനങ്ങൾ ശരിയായ ക്രമത്തിൽ സ്ഥാപിക്കുകയും ചെയ്യുന്നതാണ് നല്ലത്.

ഉപയോക്തൃ ഇൻപുട്ടിനൊപ്പം പ്രവർത്തിക്കുന്നു

മിക്ക പ്രോഗ്രാമുകൾക്കും, ഡാറ്റ പ്രദർശിപ്പിക്കുന്നത് യുദ്ധത്തിന്റെ പകുതി മാത്രമാണ്. ഉപയോക്തൃ ഇൻപുട്ട് പാഴ്‌സിംഗ്, സ്വീകരിക്കൽ, നിരസിക്കുക എന്നിവയാണ് മറ്റൊരു പ്രധാന വെല്ലുവിളി. IN അനുയോജ്യമായ ലോകം, എല്ലാ ഉപയോക്താക്കളും എല്ലായ്പ്പോഴും ലോജിക്കലും കൃത്യവുമായ ഡാറ്റ നൽകുമ്പോൾ, ഇത് ഒരു ലളിതമായ ജോലിയായിരിക്കും. എന്നാൽ യഥാർത്ഥ ലോകത്ത് ഇത് അങ്ങനെയല്ല. യഥാർത്ഥ ഉപയോക്താക്കൾഅക്ഷരത്തെറ്റുകൾ ഉണ്ടാക്കുക, ആവശ്യമായ മൂല്യങ്ങൾ നൽകാൻ മറക്കുക, തെറ്റായ സ്ഥലങ്ങളിൽ മൂല്യങ്ങൾ നൽകുക, മായ്ക്കാൻ പാടില്ലാത്ത എൻട്രികൾ മായ്‌ക്കുക, ചേർക്കാൻ പാടില്ലാത്ത എൻട്രികൾ ചേർക്കുക, സാധ്യമാകുന്നിടത്തെല്ലാം മർഫിയുടെ നിയമങ്ങൾ പിന്തുടരുക.

ഡെവലപ്പർമാരും ആർക്കിടെക്‌റ്റുകളും എന്ന നിലയിലുള്ള ഞങ്ങളുടെ ജോലി, അബദ്ധത്തിൽ അല്ലെങ്കിൽ ദുരുദ്ദേശ്യത്തോടെ ഉപയോക്താക്കൾ അനിവാര്യമായും പ്രവേശിക്കുന്നതിനെ ചെറുക്കുക എന്നതാണ്. WPF ബൈൻഡിംഗ് ഫ്രെയിംവർക്ക് ഇൻപുട്ട് മൂല്യനിർണ്ണയത്തെ പിന്തുണയ്ക്കുന്നു. ഈ ലേഖനത്തിന്റെ അടുത്ത കുറച്ച് വിഭാഗങ്ങളിൽ, WPF-ന്റെ മൂല്യനിർണ്ണയ പിന്തുണ എങ്ങനെ ഉപയോഗിക്കാമെന്നും മൂല്യനിർണ്ണയ പിശകുകൾ കണ്ടെത്തുമ്പോൾ ഉപയോക്താവിന് പിശക് സന്ദേശങ്ങൾ എങ്ങനെ പ്രദർശിപ്പിക്കാമെന്നും ഞാൻ വിശദീകരിക്കും.

ValidationRules വഴി ഇൻപുട്ടിന്റെ മൂല്യനിർണ്ണയം

Microsoft® ന്റെ ഭാഗമായ WPF പ്ലാറ്റ്‌ഫോമിന്റെ ആദ്യ പതിപ്പിൽ. നെറ്റ് ഫ്രെയിംവർക്ക് 3.0, ഇൻപുട്ട് മൂല്യനിർണ്ണയത്തിന് പരിമിതമായ പിന്തുണ മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ. ബൈൻഡിംഗ് ക്ലാസിന് വാലിഡേഷൻ റൂൾസ് പ്രോപ്പർട്ടി ഉണ്ടായിരുന്നു, അത് എത്ര വേണമെങ്കിലും വാലിഡേഷൻ റൂൾ ഡിറൈവ്ഡ് ക്ലാസുകൾ സംഭരിക്കാൻ കഴിയും. ഈ നിയമങ്ങളിൽ ഓരോന്നിലും ബൗണ്ട് മൂല്യം സാധുതയുള്ളതാണോ എന്ന് പരിശോധിക്കുന്ന ചില യുക്തികൾ അടങ്ങിയിരിക്കാം.

അക്കാലത്ത്, ഡബ്ല്യുപിഎഫിന് എക്സപ്ഷൻ വാലിഡേഷൻ റൂൾ എന്ന ഒരു വാലിഡേഷൻ റൂൾ സബ്ക്ലാസ് മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ. ഡെവലപ്പർമാർക്ക് ഈ നിയമം ഒരു ബൈൻഡിംഗിന്റെ ValidationRules പ്രോപ്പർട്ടിയിലേക്ക് ചേർക്കാൻ കഴിയും, അത് ഡാറ്റ ഉറവിടത്തിലേക്കുള്ള അപ്‌ഡേറ്റ് സമയത്ത് ഒഴിവാക്കപ്പെടുന്ന ഒഴിവാക്കലുകൾ പിടിക്കും, ഇത് ഒരു അപവാദ പിശക് സന്ദേശം പ്രദർശിപ്പിക്കാൻ ഉപയോക്തൃ ഇന്റർഫേസിനെ അനുവദിക്കുന്നു. ഇൻപുട്ട് മൂല്യനിർണ്ണയത്തിനുള്ള ഈ സമീപനത്തിന്റെ പ്രയോജനം ചർച്ചാവിഷയമാണ്, ഒരു നല്ല ഉപയോക്തൃ അനുഭവത്തിന്റെ അടിസ്ഥാനം അനാവശ്യ സാങ്കേതിക വിശദാംശങ്ങളിലേക്ക് അവരെ തുറന്നുകാട്ടുന്നത് ഒഴിവാക്കുക എന്നതാണ്. ഡാറ്റ വിശകലന ഒഴിവാക്കലുകളിലെ പിശക് സന്ദേശങ്ങൾ സാധാരണയായി മിക്ക ഉപയോക്താക്കൾക്കും അത്തരം വിശദാംശങ്ങളാണ്, പക്ഷേ ഞങ്ങളുടെ വിഷയത്തിലേക്ക് മടങ്ങുക.

ഇവിടെ കാണിച്ചിരിക്കുന്ന ലളിതമായ എറ ക്ലാസ് പോലെയുള്ള ഒരു കാലഘട്ടത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു ക്ലാസ് ഞങ്ങളുടെ പക്കലുണ്ടെന്ന് പറയാം:

പൊതു ക്ലാസ് യുഗം
{

}

ഒരു യുഗത്തിന്റെ ആരംഭ തീയതിയും കാലാവധിയും മാറ്റാൻ ഉപയോക്താവിനെ അനുവദിക്കണമെങ്കിൽ, നിങ്ങൾക്ക് രണ്ട് ടെക്സ്റ്റ് ബോക്‌സ് നിയന്ത്രണങ്ങൾ ഉപയോഗിക്കാനും അവരുടെ ടെക്‌സ്‌റ്റ് പ്രോപ്പർട്ടികൾ എറ ഇൻസ്‌റ്റൻസിന്റെ പ്രോപ്പർട്ടികളുമായി ബന്ധിപ്പിക്കാനും കഴിയും. ഉപയോക്താവിന് അവർ ആഗ്രഹിക്കുന്നതെന്തും ഒരു ടെക്‌സ്‌റ്റ് ഫീൽഡിലേക്ക് നൽകാനാകുന്നതിനാൽ, അവർ നൽകുന്ന ടെക്‌സ്‌റ്റ് ഒരു ഡേറ്റ്‌ടൈം അല്ലെങ്കിൽ ടൈംസ്‌പാൻ ഇൻസ്‌റ്റൻസിലേക്ക് പരിവർത്തനം ചെയ്യുമെന്ന് ഉറപ്പാക്കാൻ ഒരു മാർഗവുമില്ല. IN ഈ സാഹചര്യത്തിൽഡാറ്റാ പരിവർത്തനത്തിലെ പിശകുകൾ റിപ്പോർട്ടുചെയ്യുന്നതിന് നിങ്ങൾക്ക് ExceptionValidationRule ഉപയോഗിക്കാം, തുടർന്ന് ആ പിശകുകൾ ഉപയോക്തൃ ഇന്റർഫേസിൽ പ്രദർശിപ്പിക്കും. ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്ന XAML കോഡിൽ. ഈ ടാസ്ക് എങ്ങനെ നിർവഹിക്കാമെന്ന് ചിത്രം 11 കാണിക്കുന്നു.

അരി. 11. ഒരു കാലഘട്ടത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു ലളിതമായ ക്ലാസ്

ആരംഭിക്കുന്ന തീയതി:

കാലാവധി:
ഗ്രിഡ്.റോ="3"
വാചകം="(ബൈൻഡിംഗ്
പാത = ദൈർഘ്യം

/>

XAML-ലെ ഒരു ബൈൻഡിംഗിന്റെ ValidationRules പ്രോപ്പർട്ടിയിലേക്ക് ഒരു ExceptionValidationRule ചേർക്കാനാകുന്ന രണ്ട് വഴികൾ ഈ രണ്ട് ടെക്സ്റ്റ് ഫീൽഡുകളും കാണിക്കുന്നു. ആരംഭ തീയതി ടെക്‌സ്‌റ്റ് ബോക്‌സ് ഒരു റൂൾ നേരിട്ട് ചേർക്കുന്നതിന് വിപുലീകരിച്ച പ്രോപ്പർട്ടി എലമെന്റ് സിന്റാക്‌സ് ഉപയോഗിക്കുന്നു. ValidatesOnExceptions ബൈൻഡിംഗ് പ്രോപ്പർട്ടി true ആയി സജ്ജീകരിക്കുന്ന ഒരു ഷോർട്ട്‌ഹാൻഡ് വാക്യഘടനയാണ് Duration text box ഉപയോഗിക്കുന്നത്. രണ്ട് ബൈൻഡിംഗുകൾക്കും അവയുടെ UpdateSourceTrigger പ്രോപ്പർട്ടി PropertyChanged ആയി സജ്ജീകരിച്ചിരിക്കുന്നു, അങ്ങനെ ഓരോ തവണയും ടെക്സ്റ്റ് ഫീൽഡിന്റെ ടെക്സ്റ്റ് പ്രോപ്പർട്ടിക്ക് പുതിയ മൂല്യം നൽകുമ്പോൾ ഇൻപുട്ട് പരിശോധിക്കപ്പെടും, നിയന്ത്രണം ഫോക്കസ് നഷ്‌ടപ്പെടുന്നതുവരെ കാത്തിരിക്കുന്നതിന് പകരം. പ്രോഗ്രാമിന്റെ ഒരു സ്ക്രീൻഷോട്ട് ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നു. 12.

അരി. 12. ExceptionValidationRule മൂല്യനിർണ്ണയ പിശകുകൾ പ്രദർശിപ്പിക്കുന്നു

മൂല്യനിർണ്ണയ പിശകുകൾ പ്രദർശിപ്പിക്കുന്നു

ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ. 13, കാലാവധി ടെക്സ്റ്റ് ബോക്സിൽ തെറ്റായ മൂല്യം അടങ്ങിയിരിക്കുന്നു. അതിൽ അടങ്ങിയിരിക്കുന്ന സ്‌ട്രിംഗ് ഒരു ടൈംസ്‌പാൻ ഉദാഹരണത്തിലേക്ക് പരിവർത്തനം ചെയ്യാനാവില്ല. ടെക്സ്റ്റ് ബോക്‌സിന്റെ ടോസ്റ്റ് സന്ദേശം ഒരു പിശക് സന്ദേശം പ്രദർശിപ്പിക്കുന്നു, നിയന്ത്രണത്തിന്റെ വലതുവശത്ത് ഒരു ചെറിയ ചുവന്ന പിശക് ഐക്കൺ ദൃശ്യമാകുന്നു. ഈ സ്വഭാവം സ്വയമേവയുള്ളതല്ല, എന്നാൽ ഒരു നിർദ്ദിഷ്ട കേസിൽ നടപ്പിലാക്കാനും പൊരുത്തപ്പെടുത്താനും എളുപ്പമാണ്.

അരി. 13. ഉപയോക്താവിനുള്ള ഇൻപുട്ട് പരിശോധനയ്ക്കിടെ കണ്ടെത്തിയ പിശകുകളുടെ ദൃശ്യവൽക്കരണം

DockPanel.Dock="വലത്"
മാർജിൻ="2.0"
ToolTip="അസാധുവായ ഡാറ്റ അടങ്ങിയിരിക്കുന്നു"
വീതി="10" ഉയരം="10"
>

സ്റ്റാറ്റിക് മൂല്യനിർണ്ണയ ക്ലാസ്, അറ്റാച്ച് ചെയ്ത പ്രോപ്പർട്ടികളുടെയും സ്റ്റാറ്റിക് രീതികളുടെയും ഉപയോഗത്തിലൂടെ നിയന്ത്രണവും അതിൽ അടങ്ങിയിരിക്കുന്ന ഏതെങ്കിലും മൂല്യനിർണ്ണയ പിശകുകളും തമ്മിലുള്ള ബന്ധം രൂപപ്പെടുത്തുന്നു. ഉപയോക്താവിന് ഇൻപുട്ട് മൂല്യനിർണ്ണയ സമയത്ത് നേരിടേണ്ടിവരുന്ന പിശകുകൾ ഉപയോക്തൃ ഇന്റർഫേസ് എങ്ങനെ അവതരിപ്പിക്കണം എന്നതിന്റെ സിംഗിൾ-മാർക്ക്അപ്പ് വിവരണങ്ങൾ സൃഷ്ടിക്കുന്നതിന് ഈ അറ്റാച്ച് ചെയ്ത പ്രോപ്പർട്ടികൾ XAML-ൽ പരാമർശിക്കാവുന്നതാണ്. ചിത്രത്തിൽ XAML കോഡ്. മുമ്പത്തെ ഉദാഹരണത്തിൽ നിന്ന് രണ്ട് ടെക്സ്റ്റ് ബോക്സ് നിയന്ത്രണങ്ങൾക്കായി ഇൻപുട്ട് പിശക് സന്ദേശങ്ങൾ എങ്ങനെ റെൻഡർ ചെയ്യാമെന്ന് വിശദീകരിക്കുന്നതിന് 13 ഉത്തരവാദിയാണ്.

ചിത്രത്തിൽ സ്റ്റൈൽ ("സ്റ്റൈൽ"). 13 ഉപയോക്തൃ ഇന്റർഫേസിലെ ഒരു ടെക്സ്റ്റ് ഫീൽഡിന്റെ എല്ലാ സന്ദർഭങ്ങളെയും ടാർഗെറ്റുചെയ്യുന്നു. ഇത് ടെക്സ്റ്റ് ഫീൽഡിൽ മൂന്ന് പാരാമീറ്ററുകൾ പ്രയോഗിക്കുന്നു. ആദ്യത്തേത്, സെറ്റർ, ടെക്സ്റ്റ് ഫീൽഡിന്റെ മാർജിൻ പ്രോപ്പർട്ടിയെ ബാധിക്കുന്നു. വലതുവശത്ത് പിശക് ഐക്കൺ പ്രദർശിപ്പിക്കുന്നതിന് മതിയായ ഇടം നൽകുന്ന ഒരു മൂല്യത്തിലേക്ക് മാർജിൻ പ്രോപ്പർട്ടി സജ്ജീകരിച്ചിരിക്കുന്നു.

അസാധുവായ ഡാറ്റ അടങ്ങിയിരിക്കുമ്പോൾ ടെക്സ്റ്റ് ഫീൽഡ് റെൻഡർ ചെയ്യാൻ ഉപയോഗിക്കുന്ന കൺട്രോൾ ടെംപ്ലേറ്റ് സ്റ്റൈലിലെ ഇനിപ്പറയുന്ന സെറ്റർ പ്രോപ്പർട്ടി അസൈൻ ചെയ്യുന്നു. ഇത് Style-ന് മുകളിൽ പ്രഖ്യാപിച്ചിരിക്കുന്ന ControlTemplate-ലേക്ക് Validation.ErrorTemplate അറ്റാച്ച് ചെയ്ത പ്രോപ്പർട്ടി സജ്ജമാക്കുന്നു. ഒരു ടെക്സ്റ്റ് ഫീൽഡിൽ മൂല്യനിർണ്ണയം ഒന്നോ അതിലധികമോ പിശകുകൾ തിരിച്ചറിഞ്ഞതായി മൂല്യനിർണ്ണയ ക്ലാസ് റിപ്പോർട്ട് ചെയ്യുമ്പോൾ, ടെക്സ്റ്റ് ഫീൽഡ് ഈ ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് സന്ദേശം റെൻഡർ ചെയ്യുന്നു. ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്ന ചുവന്ന പിശക് ഐക്കൺ സൃഷ്ടിക്കുന്നത് ഇതാണ്. 12.

ടെക്‌സ്‌റ്റ് ഫീൽഡിൽ ഘടിപ്പിച്ചിരിക്കുന്ന മൂല്യനിർണ്ണയം.HasError പ്രോപ്പർട്ടി നിരീക്ഷിക്കുന്ന ഒരു ട്രിഗറും ശൈലിയിൽ അടങ്ങിയിരിക്കുന്നു. മൂല്യനിർണ്ണയ ക്ലാസ് ഒരു പ്രത്യേക ടെക്‌സ്‌റ്റ് ഫീൽഡിനായി അറ്റാച്ച് ചെയ്‌തിരിക്കുന്ന HasError പ്രോപ്പർട്ടി ശരിയാക്കുമ്പോൾ, സ്‌റ്റൈലിലെ ട്രിഗർ ഫയർ ചെയ്യുകയും ടെക്‌സ്‌റ്റ് ഫീൽഡിലേക്ക് ഒരു ടോസ്റ്റ് സന്ദേശം നൽകുകയും ചെയ്യുന്നു. ഒരു ടെക്‌സ്‌റ്റ് ബോക്‌സിൽ നിന്ന് ഡാറ്റ സോഴ്‌സ് പ്രോപ്പർട്ടിയുടെ ഡാറ്റാ തരത്തിന്റെ ഉദാഹരണത്തിലേക്ക് ടെക്‌സ്‌റ്റ് പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ എറിഞ്ഞ ഒഴിവാക്കലിന്റെ പിശക് സന്ദേശവുമായി ടോസ്റ്റ് സന്ദേശത്തിന്റെ ഉള്ളടക്കം ബന്ധപ്പെട്ടിരിക്കുന്നു.

IDataErrorInfo വഴി ഇൻപുട്ട് മൂല്യനിർണ്ണയം

Microsoft .NET Framework 3.5 പുറത്തിറങ്ങിയതോടെ, WPF-ൽ ഇൻപുട്ട് മൂല്യനിർണ്ണയത്തിനുള്ള പിന്തുണ നാടകീയമായി മെച്ചപ്പെട്ടു. ലളിതമായ ആപ്ലിക്കേഷനുകൾക്ക് ValidationRule സമീപനം ഉപയോഗപ്രദമാണ്, എന്നാൽ യഥാർത്ഥ-ലോക ആപ്ലിക്കേഷനുകൾ യഥാർത്ഥ-ലോക ഡാറ്റയുടെയും ബിസിനസ്സ് നിയമങ്ങളുടെയും സങ്കീർണ്ണത കൈകാര്യം ചെയ്യുന്നു. വാലിഡേഷൻ റൂൾ ഒബ്‌ജക്‌റ്റുകളിലേക്ക് ബിസിനസ്സ് നിയമങ്ങൾ കോഡുചെയ്യുന്നത് ആ കോഡിനെ WPF ചട്ടക്കൂടുമായി ബന്ധിപ്പിക്കുക മാത്രമല്ല, ബിസിനസ്സ് ലോജിക് അത് ഉൾപ്പെടുന്നിടത്ത് നിന്ന് തടയുകയും ചെയ്യുന്നു: ബിസിനസ്സ് ഒബ്‌ജക്റ്റുകളിൽ!

പല ആപ്ലിക്കേഷനുകൾക്കും ഒരു ബിസിനസ്സ് ലെയർ ഉണ്ട്, അവിടെ ബിസിനസ്സ് നിയമങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിന്റെ എല്ലാ സങ്കീർണ്ണതയും ഒരു കൂട്ടം ബിസിനസ് ഒബ്ജക്റ്റുകളിൽ അടങ്ങിയിരിക്കുന്നു. Microsoft .NET Framework 3.5-ലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് IDataErrorInfo ഇന്റർഫേസ് ഉപയോഗിച്ച് ബിസിനസ്സ് വസ്‌തുക്കൾ സാധുവായ അവസ്ഥയിലാണോ അല്ലയോ എന്ന് അന്വേഷിക്കാൻ WPF-നെ നിർബന്ധിതമാക്കാൻ കഴിയും. ബിസിനസ്സ് ലെയറിൽ നിന്ന് വേറിട്ട് ഒബ്‌ജക്റ്റുകളിൽ ബിസിനസ്സ് ലോജിക് സ്ഥാപിക്കേണ്ടതിന്റെ ആവശ്യകത ഇത് ഒഴിവാക്കുകയും ഉപയോക്തൃ ഇന്റർഫേസ് പ്ലാറ്റ്‌ഫോമിൽ നിന്ന് സ്വതന്ത്രമായ ബിസിനസ്സ് ഒബ്‌ജക്റ്റുകൾ സൃഷ്‌ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു. IDataErrorInfo ഇന്റർഫേസ് നിരവധി വർഷങ്ങളായി ഉപയോഗിക്കുന്നതിനാൽ, പഴയ വിൻഡോസ് ഫോമുകളിൽ നിന്നോ ASP.NET ആപ്ലിക്കേഷനുകളിൽ നിന്നോ ബിസിനസ്സ് ഒബ്‌ജക്റ്റുകൾ വീണ്ടും ഉപയോഗിക്കുന്നതും ഇത് എളുപ്പമാക്കുന്നു.

ഉപയോക്താവ് നൽകുന്ന ടെക്‌സ്‌റ്റ് ഒരു ഡാറ്റ സോഴ്‌സ് പ്രോപ്പർട്ടിയുടെ ഡാറ്റാ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാവുന്നതാണെന്ന് ഉറപ്പാക്കുന്നതിന് അപ്പുറം പോകുന്ന ഒരു യുഗത്തിന് മൂല്യനിർണ്ണയം നൽകാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് കരുതുക. ഭാവിയിൽ ഒരു യുഗത്തിന്റെ ആരംഭ തീയതി സ്ഥാപിക്കാതിരിക്കുന്നതിൽ അർത്ഥമുണ്ട്, കാരണം ഇനിയും വരാനിരിക്കുന്ന യുഗങ്ങളെക്കുറിച്ച് ഞങ്ങൾക്ക് അറിയില്ല. യുഗം കുറഞ്ഞത് ഒരു മില്ലിസെക്കൻഡെങ്കിലും നീണ്ടുനിൽക്കണമെന്ന് ആവശ്യപ്പെടുന്നതും യുക്തിസഹമായേക്കാം.

ഇത്തരത്തിലുള്ള നിയമങ്ങൾ ബിസിനസ്സ് ലോജിക്കിന്റെ പൊതുവായ ആശയത്തിന് സമാനമാണ്, അവ രണ്ടും സ്കോപ്പ് നിയമങ്ങളുടെ ഉദാഹരണങ്ങളാണ്. സ്കോപ്പ് നിയമങ്ങൾ അവയുടെ അവസ്ഥ സംഭരിക്കുന്ന ഒബ്‌ജക്റ്റുകളിൽ മികച്ച രീതിയിൽ സൃഷ്ടിക്കപ്പെടുന്നു: സ്കോപ്പ് ഒബ്‌ജക്റ്റുകൾ. ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്ന കോഡിൽ. 14 SmartEra ക്ലാസ് കാണിക്കുന്നു, IDataErrorInfo ഇന്റർഫേസ് വഴി ചെക്ക് വഴി കണ്ടെത്തിയ പിശകുകളെക്കുറിച്ചുള്ള സന്ദേശങ്ങൾ ഇത് നൽകുന്നു.

അരി. 14. ചെക്ക് വഴി കണ്ടെത്തിയ പിശകുകളെക്കുറിച്ചുള്ള സന്ദേശങ്ങൾ IDataErrorInfo നൽകുന്നു

പൊതു ക്ലാസ് SmartEra
: System.ComponentModel.IDataErrorInfo
{
പൊതു തീയതി സമയം ആരംഭ തീയതി ( നേടുക; സജ്ജമാക്കുക; )
പൊതു ടൈംസ്പാൻ ദൈർഘ്യം (നേടുക; സജ്ജമാക്കുക;)

#region IDataErrorInfo അംഗങ്ങൾ

പൊതു സ്ട്രിംഗ് പിശക്
{
നേടുക (ശൂന്യമായി മടങ്ങുക;)
}

ഇത് പൊതു സ്ട്രിംഗ്
{
ലഭിക്കും
{
സ്ട്രിംഗ് msg = null;
സ്വിച്ച് (സ്വത്ത്)
{
കേസ് "ആരംഭ തീയതി":
എങ്കിൽ (DateTime.Now< this.StartDate)
msg = "ആരംഭ തീയതി പഴയതായിരിക്കണം.";
ബ്രേക്ക്;

കേസ് "ദൈർഘ്യം":
എങ്കിൽ (this.Duration.Ticks == 0)
msg = "ഒരു യുഗത്തിന് ഒരു ദൈർഘ്യം ഉണ്ടായിരിക്കണം.";
ബ്രേക്ക്;

സ്ഥിരസ്ഥിതി:
പുതിയ വാദം ഒഴിവാക്കുക(
"അംഗീകാരമില്ലാത്ത സ്വത്ത്: " + സ്വത്ത്);
}
മടക്കസന്ദേശം;
}
}

#endregion // IDataErrorInfo അംഗങ്ങൾ
}

WPF ഉപയോക്തൃ ഇന്റർഫേസിൽ നിന്നുള്ള SmartEra-യുടെ ക്ലാസ് മൂല്യനിർണ്ണയ പിന്തുണ ഉപയോഗിക്കുന്നത് വളരെ എളുപ്പമാണ്. അവർ ബന്ധിപ്പിച്ചിരിക്കുന്ന ഒബ്‌ജക്‌റ്റിൽ IDataErrorInfo ഇന്റർഫേസ് സ്വീകരിക്കണമെന്ന് നിങ്ങൾ ബൈൻഡിംഗുകളോട് പറയേണ്ടതുണ്ട്. ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ രണ്ട് വഴികളിൽ ഒന്നിൽ ഇത് ചെയ്യാം. 15.

അരി. 15. മൂല്യനിർണ്ണയ യുക്തി ഉപയോഗിക്കുന്നു

ആരംഭിക്കുന്ന തീയതി:

കാലാവധി:
ഗ്രിഡ്.റോ="3"
വാചകം="(ബൈൻഡിംഗ്
പാത = ദൈർഘ്യം
UpdateSourceTrigger=PropertyChanged,
മൂല്യനിർണ്ണയം ഓൺഡാറ്റ പിശകുകൾ=ശരി,
ValidatesOnExceptions=True)"
/>

ഒരു ExceptionValidationRule ഒരു ബൈൻഡിംഗിന്റെ മൂല്യനിർണ്ണയനിയമങ്ങളുടെ ശേഖരത്തിലേക്ക് വ്യക്തമായോ പരോക്ഷമായോ ചേർക്കുന്നത് പോലെ, ഒരു DataErrorValidationRule നേരിട്ട് ഒരു ബൈൻഡിംഗിന്റെ മൂല്യനിർണ്ണയനിയമങ്ങളിലേക്ക് ചേർക്കാം, അല്ലെങ്കിൽ ValidatesOnDataErrors പ്രോപ്പർട്ടി ശരിയാക്കാം. രണ്ട് സമീപനങ്ങൾക്കും ഒരേ അന്തിമ ഫലമുണ്ട് - പരിശോധനയിലൂടെ കണ്ടെത്തിയ പിശകുകൾക്കായി ബൈൻഡിംഗ് സിസ്റ്റം ഡാറ്റ ഉറവിടത്തിന്റെ IDataErrorInfo ഇന്റർഫേസ് അന്വേഷിക്കുന്നു.

സംഗ്രഹിക്കുന്നു

പല ഡവലപ്പർമാരും തങ്ങളുടെ പ്രിയപ്പെട്ട WPF സവിശേഷത ഡാറ്റ ബൈൻഡിംഗിനുള്ള വിപുലമായ പിന്തുണയാണെന്ന് പറയുന്നതിന് ഒരു കാരണമുണ്ട്. WPF-ന്റെ ബൈൻഡിംഗ് കഴിവുകൾ വളരെ ശക്തവും വ്യാപകവുമാണ്, ഡാറ്റയും ഉപയോക്തൃ ഇന്റർഫേസും തമ്മിലുള്ള ബന്ധത്തെക്കുറിച്ച് അവർ ചിന്തിക്കുന്ന രീതി ക്രമീകരിക്കാൻ നിരവധി സോഫ്റ്റ്വെയർ ഡെവലപ്പർമാർ ആവശ്യപ്പെടുന്നു. ടെംപ്ലേറ്റുകൾ, ശൈലികൾ, അറ്റാച്ച് ചെയ്‌ത പ്രോപ്പർട്ടികൾ എന്നിവ പോലുള്ള സങ്കീർണ്ണമായ ഡാറ്റ ബൈൻഡിംഗിനെ പിന്തുണയ്ക്കുന്നതിന് WPF-ന്റെ പല പ്രധാന ഘടകങ്ങളും ഒരുമിച്ച് പ്രവർത്തിക്കുന്നു.

XAML കോഡിന്റെ താരതമ്യേന കുറച്ച് വരികൾ ഉപയോഗിച്ച്, ഒരു ശ്രേണിപരമായ ഡാറ്റാ ഘടന പ്രദർശിപ്പിക്കുന്നതിനും ഉപയോക്തൃ ഇൻപുട്ട് സാധൂകരിക്കുന്നതിനുമുള്ള നിങ്ങളുടെ ഉദ്ദേശ്യങ്ങൾ നിങ്ങൾക്ക് പ്രകടിപ്പിക്കാൻ കഴിയും. കൂടുതൽ സങ്കീർണ്ണമായ സാഹചര്യങ്ങളിൽ, ബൈൻഡിംഗ് സിസ്റ്റത്തിന്റെ എല്ലാ കഴിവുകളും പ്രോഗ്രമാറ്റിക്കായി ആക്സസ് ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് പ്രയോജനപ്പെടുത്താം. അത്തരം ശക്തമായ ഒരു അടിസ്ഥാന സൗകര്യം അവരുടെ പക്കലുള്ളതിനാൽ, ആധുനിക ബിസിനസ്സ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്ന ഡെവലപ്പർമാർക്ക് മികച്ച ഉപയോക്തൃ അനുഭവങ്ങളും ആകർഷകമായ ഡാറ്റാ ദൃശ്യവൽക്കരണവും നൽകാനുള്ള അവരുടെ പഴയ ലക്ഷ്യം കൈവരിക്കുന്നതിന് ഒടുവിൽ എത്തിച്ചേരാനാകും.

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 02/07/2016

WPF-ൽ, ഗുരുതരമായ ഒരു ആപ്ലിക്കേഷനും ഇല്ലാതെ ചെയ്യാൻ കഴിയാത്ത ഒരു ശക്തമായ പ്രോഗ്രാമിംഗ് ഉപകരണമാണ് ബൈൻഡിംഗ്.

ബൈൻഡിംഗിൽ രണ്ട് വസ്തുക്കളുടെ പ്രതിപ്രവർത്തനം ഉൾപ്പെടുന്നു: ഒരു ഉറവിടവും ലക്ഷ്യസ്ഥാനവും. ഡെസ്റ്റിനേഷൻ ഒബ്‌ജക്റ്റ് ഉറവിട ഒബ്‌ജക്റ്റിന്റെ ഒരു പ്രത്യേക പ്രോപ്പർട്ടിയുമായി ഒരു ബന്ധം സൃഷ്ടിക്കുന്നു. ഉറവിട ഒബ്‌ജക്‌റ്റിൽ മാറ്റം വരുത്തിയാൽ, ലക്ഷ്യസ്ഥാന വസ്തുവും പരിഷ്‌ക്കരിക്കപ്പെടും. ഉദാഹരണത്തിന്, ബൈൻഡിംഗ് ഉപയോഗിക്കുന്ന ഏറ്റവും ലളിതമായ ഫോം:

ഒരു ബൈൻഡിംഗ് നിർവചിക്കുന്നതിന്, ഇതുപോലുള്ള ഒരു പദപ്രയോഗം:

(Binding ElementName=Source object_name, Path=Source object_property)

അതായത്, ഈ സാഹചര്യത്തിൽ, TextBox ഘടകം ഉറവിടമാണ്, കൂടാതെ TextBlock ബൈൻഡിംഗിന്റെ ലക്ഷ്യസ്ഥാനമാണ്. ടെക്സ്റ്റ്ബ്ലോക്ക് മൂലകത്തിന്റെ ടെക്സ്റ്റ് പ്രോപ്പർട്ടി ടെക്സ്റ്റ്ബോക്സ് എലമെന്റിന്റെ ടെക്സ്റ്റ് പ്രോപ്പർട്ടിയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. ഫലമായി, നിങ്ങൾ ഒരു ടെക്സ്റ്റ് ഫീൽഡിൽ പ്രവേശിക്കുമ്പോൾ, ടെക്സ്റ്റ് ബ്ലോക്കിലെ മാറ്റങ്ങൾ സമന്വയത്തോടെ സംഭവിക്കും.

C#-ൽ ബൈൻഡിംഗുമായി പ്രവർത്തിക്കുന്നു

ഒരു ബൈൻഡിംഗ് സൃഷ്ടിക്കുമ്പോൾ പ്രധാന ഒബ്ജക്റ്റ് System.Windows.Data.Binding ഒബ്ജക്റ്റ് ആണ്. ഈ ഒബ്‌ജക്‌റ്റ് ഉപയോഗിച്ച്, മൂലകത്തിനായി ഇതിനകം നിലവിലുള്ള ബൈൻഡിംഗ് നമുക്ക് ലഭിക്കും:

ബൈൻഡിംഗ് ബൈൻഡിംഗ് = BindingOperations.GetBinding(myTextBlock, TextBlock.TextProperty);

ഈ സാഹചര്യത്തിൽ, myTextBlock എലമെന്റിന്റെ TextProperty ഡിപൻഡൻസി പ്രോപ്പർട്ടിക്കായി ഞങ്ങൾ ഒരു ബൈൻഡിംഗ് നേടുന്നു.

നിങ്ങൾക്ക് ബൈൻഡിംഗ് പൂർണ്ണമായും C# കോഡിൽ സജ്ജമാക്കാനും കഴിയും:

പൊതു MainWindow() ( InitializeComponent(); ബൈൻഡിംഗ് ബൈൻഡിംഗ് = പുതിയ ബൈൻഡിംഗ്(); binding.ElementName = "myTextBox"; // സോഴ്സ് എലമെന്റ് ബൈൻഡിംഗ്.പാത്ത് = പുതിയ പ്രോപ്പർട്ടിപാത്ത്("ടെക്സ്റ്റ്"); // സോഴ്സ് എലമെന്റ് പ്രോപ്പർട്ടി myTextBlock. SetBinding( TextBlock.TextProperty, ബൈൻഡിംഗ്); ​​// റിസീവർ ഘടകത്തിനായുള്ള ബൈൻഡിംഗ് സജ്ജീകരിക്കുന്നു)

ഭാവിയിൽ ഞങ്ങൾക്ക് ഒരു ബൈൻഡിംഗ് ആവശ്യമില്ലെങ്കിൽ, നമുക്ക് ബൈൻഡിംഗ് ഓപ്പറേഷൻസ് ക്ലാസും അതിന്റെ ClearBinding() (ഒരു ബൈൻഡിംഗ് നീക്കംചെയ്യുന്നു), ClearAllBindings() (ഒരു നിശ്ചിത ഘടകത്തിനായുള്ള എല്ലാ ബൈൻഡിംഗുകളും നീക്കംചെയ്യുന്നു) രീതികൾ ഉപയോഗിക്കാം.

BindingOperations.ClearBinding(myTextBlock, TextBlock.TextProperty);

BindingOperations.ClearAllBindings(myTextBlock);

ബൈൻഡിംഗ് ക്ലാസിന്റെ ചില സവിശേഷതകൾ:

ElementName : ബൈൻഡിംഗ് സൃഷ്ടിക്കപ്പെട്ട മൂലകത്തിന്റെ പേര്

IsAsync: True എന്ന് സജ്ജമാക്കിയാൽ, ഒബ്‌ജക്റ്റിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുന്നതിന് അസിൻക്രണസ് മോഡ് ഉപയോഗിക്കുന്നു. സ്ഥിരസ്ഥിതികൾ തെറ്റിലേക്ക്

മോഡ്: ബൈൻഡ് മോഡ്

TargetNullValue : ബൈൻഡിംഗ് ഉറവിടത്തിന്റെ ബൗണ്ട് പ്രോപ്പർട്ടി അസാധുവാണെങ്കിൽ ഡിഫോൾട്ട് മൂല്യം സജ്ജമാക്കുന്നു

ആപേക്ഷിക ഉറവിടം: നിലവിലെ ഒബ്‌ജക്‌റ്റുമായി ബന്ധപ്പെട്ട ഒരു ബൈൻഡിംഗ് സൃഷ്‌ടിക്കുന്നു

ഉറവിടം: ഉറവിട ഒബ്‌ജക്റ്റ് ഒരു നിയന്ത്രണമല്ലെങ്കിൽ അതിലേക്ക് പോയിന്റ് ചെയ്യുന്നു.

XPath : xml ഡാറ്റയിലേക്കുള്ള പാത വ്യക്തമാക്കുന്നതിന് പാത്ത് പ്രോപ്പർട്ടിക്ക് പകരം ഉപയോഗിക്കുന്നു

സ്നാപ്പ് മോഡുകൾ

ബൈൻഡിംഗ് മോഡിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു ബൈൻഡിംഗ് ഒബ്‌ജക്റ്റിന്റെ മോഡ് പ്രോപ്പർട്ടിക്ക് ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ എടുക്കാം:

വൺവേ: ഉറവിട ഒബ്‌ജക്‌റ്റിന്റെ പ്രോപ്പർട്ടി പരിഷ്‌ക്കരിച്ചതിന് ശേഷം ലക്ഷ്യസ്ഥാന ഒബ്‌ജക്റ്റിന്റെ പ്രോപ്പർട്ടി മാറുന്നു.

വൺടൈം: ലക്ഷ്യസ്ഥാന ഒബ്‌ജക്‌റ്റിന്റെ പ്രോപ്പർട്ടി, സോഴ്‌സ് ഒബ്‌ജക്‌റ്റിന്റെ പ്രോപ്പർട്ടിയിലേക്ക് ഒരിക്കൽ മാത്രം സജ്ജീകരിച്ചിരിക്കുന്നു. ഉറവിടത്തിലെ തുടർന്നുള്ള മാറ്റങ്ങൾ ലക്ഷ്യസ്ഥാന വസ്തുവിനെ ബാധിക്കില്ല.

ടുവേ: ആപ്ലിക്കേഷനും സോഴ്‌സ് ഒബ്‌ജക്‌റ്റുകൾക്കും പരസ്പരം ബൗണ്ട് പ്രോപ്പർട്ടികൾ മാറ്റാൻ കഴിയും.

OneWayToSource: ബൈൻഡിംഗ് പ്രഖ്യാപിച്ച ലക്ഷ്യസ്ഥാന ഒബ്‌ജക്റ്റ് ഉറവിട ഒബ്‌ജക്റ്റിനെ മാറ്റുന്നു.

സ്ഥിരസ്ഥിതി : സ്ഥിരസ്ഥിതിയായി (TextBox.Text പ്രോപ്പർട്ടി മാറുകയാണെങ്കിൽ, അതിന് TwoWay എന്ന മൂല്യമുണ്ട്, അല്ലാത്തപക്ഷം OneWay).

സ്നാപ്പ് മോഡ് പ്രയോഗിക്കുന്നു:

ബൈൻഡിംഗ് അപ്ഡേറ്റ്. UpdateSourceTrigger

ഉറവിടത്തിൽ നിന്ന് റിസീവറിലേക്കുള്ള വൺ-വേ ബൈൻഡിംഗ് റിസീവറിന്റെ സ്വത്ത് ഏതാണ്ട് തൽക്ഷണം മാറ്റുന്നു. ടെക്സ്റ്റ് ഫീൽഡുകളുടെ കാര്യത്തിൽ നമ്മൾ ടു-വേ ബൈൻഡിംഗ് ഉപയോഗിക്കുകയാണെങ്കിൽ (മുകളിലുള്ള ഉദാഹരണത്തിലെന്നപോലെ), ലക്ഷ്യസ്ഥാനം മാറുമ്പോൾ, ഉറവിട സ്വത്ത് തൽക്ഷണം മാറില്ല. അതിനാൽ, മുകളിലുള്ള ഉദാഹരണത്തിൽ, സോഴ്സ് ടെക്സ്റ്റ് ഫീൽഡ് മാറുന്നതിന്, ലക്ഷ്യസ്ഥാന ടെക്സ്റ്റ് ഫീൽഡിൽ നിന്ന് ഫോക്കസ് മാറ്റേണ്ടതുണ്ട്. ഈ സാഹചര്യത്തിൽ, ബൈൻഡിംഗ് ക്ലാസിന്റെ UpdateSourceTrigger പ്രോപ്പർട്ടി പ്രവർത്തിക്കുന്നു, ഇത് അപ്‌ഡേറ്റ് എങ്ങനെ സംഭവിക്കുമെന്ന് വ്യക്തമാക്കുന്നു. ഈ പ്രോപ്പർട്ടി UpdateSourceTrigger എണ്ണൽ മൂല്യങ്ങളിൽ ഒന്ന് എടുക്കുന്നു:

പ്രോപ്പർട്ടി മാറ്റി: സിങ്കിലെ പ്രോപ്പർട്ടി അപ്‌ഡേറ്റ് ചെയ്‌ത ഉടൻ തന്നെ ബൈൻഡിംഗ് ഉറവിടം അപ്‌ഡേറ്റ് ചെയ്യപ്പെടും

LostFocus: റിസീവറിന് ഫോക്കസ് നഷ്ടപ്പെട്ടതിനുശേഷം മാത്രമേ ആങ്കർ ഉറവിടം അപ്‌ഡേറ്റ് ചെയ്യുകയുള്ളൂ

വ്യക്തമായത്: BindingExpression.UpdateSource() രീതി വിളിക്കുന്നത് വരെ ഉറവിടം അപ്‌ഡേറ്റ് ചെയ്യില്ല

ഡിഫോൾട്ട്: ഡിഫോൾട്ട് മൂല്യം. മിക്ക പ്രോപ്പർട്ടികൾക്കും, ഇത് PropertyChanged ആണ്. TextBox മൂലകത്തിന്റെ ടെക്സ്റ്റ് പ്രോപ്പർട്ടിക്ക്, ഈ മൂല്യം LostFocus ആണ്

ഈ സാഹചര്യത്തിൽ, OneWayToSource അല്ലെങ്കിൽ TwoWay മോഡുകളിൽ ലക്ഷ്യസ്ഥാനം മാറ്റിയതിന് ശേഷം ബൈൻഡിംഗ് ഉറവിടം അപ്ഡേറ്റ് ചെയ്യുന്നതിനെക്കുറിച്ചാണ് ഞങ്ങൾ സംസാരിക്കുന്നത്. അതായത്, ടുവേ മോഡ് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്ന രണ്ട് ടെക്‌സ്‌റ്റ് ഫീൽഡുകളും അവയിലൊന്ന് മാറ്റിയതിന് ശേഷം തൽക്ഷണം അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നതിന്, ഞങ്ങൾ UpdateSourceTrigger.PropertyChanged മൂല്യം ഉപയോഗിക്കേണ്ടതുണ്ട്:

ഉറവിട സ്വത്ത്

WPF നിയന്ത്രണങ്ങളല്ലാത്ത ഒബ്‌ജക്‌റ്റുകൾക്ക് പോലും ഒരു ബൈൻഡിംഗ് സജ്ജമാക്കാൻ ഉറവിട പ്രോപ്പർട്ടി നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നമുക്ക് ഫോൺ ക്ലാസ് നിർവചിക്കാം:

ക്ലാസ് ഫോൺ (പബ്ലിക് സ്ട്രിംഗ് തലക്കെട്ട് (ഗെറ്റ്; സെറ്റ്;) പബ്ലിക് സ്ട്രിംഗ് കമ്പനി (ഗെറ്റ്; സെറ്റ്; ) പബ്ലിക് ഇൻറ്റ് പ്രൈസ് (ഗെറ്റ്; സെറ്റ്;) )

ഇനി നമുക്ക് ഈ ക്ലാസിന്റെ ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ച് അതിനോട് ഒരു ബൈൻഡിംഗ് നിർവചിക്കാം:

TargetNullValue പ്രോപ്പർട്ടി

ബൈൻഡിംഗ് ഉറവിടത്തിലെ ഒരു പ്രോപ്പർട്ടിക്ക് പെട്ടെന്ന് മൂല്യം അസാധുവാണെങ്കിൽ, അതായത്, അത് സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, നമുക്ക് കുറച്ച് ഡിഫോൾട്ട് മൂല്യം സജ്ജമാക്കാം. ഉദാഹരണത്തിന്:

ഈ സാഹചര്യത്തിൽ, nexusPhone റിസോഴ്സിന് ഒരു ടൈറ്റിൽ പ്രോപ്പർട്ടി സെറ്റ് ഇല്ല, അതിനാൽ TargetNullValue പാരാമീറ്ററിൽ വ്യക്തമാക്കിയിട്ടുള്ള സ്ഥിരസ്ഥിതി മൂല്യം ടെക്സ്റ്റ് ബ്ലോക്ക് ഔട്ട്പുട്ട് ചെയ്യും.

ആപേക്ഷിക ഉറവിട സ്വത്ത്

ഡെസ്റ്റിനേഷൻ എലമെന്റുമായി ഏതെങ്കിലും തരത്തിലുള്ള ബന്ധമുള്ള ഒരു സോഴ്സ് എലമെന്റുമായി ബന്ധപ്പെട്ട് ഒരു ബൈൻഡിംഗ് സജ്ജീകരിക്കാൻ RelativeSource പ്രോപ്പർട്ടി നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഉറവിട ഘടകം ലക്ഷ്യസ്ഥാന ഘടകത്തിനായുള്ള ബാഹ്യ കണ്ടെയ്‌നറുകളിൽ ഒന്നായിരിക്കാം. അല്ലെങ്കിൽ ഉറവിടവും ലക്ഷ്യസ്ഥാനവും ഒരേ ഘടകമാകാം.

ഈ പ്രോപ്പർട്ടി സജ്ജീകരിക്കാൻ, അതേ പേരിലുള്ള റിലേറ്റീവ് സോഴ്സ് ഒബ്ജക്റ്റ് ഉപയോഗിക്കുക. ഈ വസ്തുവിന് ഒരു മോഡ് പ്രോപ്പർട്ടി ഉണ്ട്, അത് ബൈൻഡിംഗ് രീതി വ്യക്തമാക്കുന്നു. ഇത് RelativeSourceMode എണ്ണൽ മൂല്യങ്ങളിൽ ഒന്ന് എടുക്കുന്നു:

സ്വയം: ഒരേ മൂലകത്തിന്റെ ഒരു വസ്തുവിലേക്ക് ബൈൻഡിംഗ് നടത്തുന്നു. അതായത്, ബൈൻഡിംഗിന്റെ ഉറവിട ഘടകം അതേ സമയം ബൈൻഡിംഗിന്റെ റിസീവർ ആണ്.

FindAncestor: കണ്ടെയ്‌നർ മൂലകത്തിന്റെ വസ്തുവിലേക്ക് ബൈൻഡിംഗ് നടത്തുന്നു.

ഉദാഹരണത്തിന്, മൂലകത്തിൽ തന്നെ ഉറവിടവും ലക്ഷ്യസ്ഥാന ബൈൻഡിംഗും സംയോജിപ്പിക്കുക:

ഇവിടെ ടെക്‌സ്‌റ്റ് ബോക്‌സിന്റെ വാചകവും പശ്ചാത്തല നിറവും ഒരു ടു-വേ ബൈൻഡിംഗ് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്നു. തൽഫലമായി, ഫീൽഡിലെ നിറത്തിന്റെ സംഖ്യാ മൂല്യം നമുക്ക് കാണാൻ കഴിയും, അത് മാറ്റുക, ഒപ്പം ഫീൽഡിന്റെ പശ്ചാത്തലവും അതോടൊപ്പം മാറും.

കണ്ടെയ്നർ ഗുണങ്ങളുമായി ബന്ധിപ്പിക്കുന്നു:

FindAncestor മോഡ് ഉപയോഗിക്കുമ്പോൾ, അതായത്, ഒരു കണ്ടെയ്‌നറുമായി ബന്ധിപ്പിക്കുമ്പോൾ, നിങ്ങൾ AncestorType പാരാമീറ്റർ വ്യക്തമാക്കുകയും AncestorType=(x:Type Container_element_type) എന്ന പദപ്രയോഗത്തിന്റെ രൂപത്തിൽ കണ്ടെയ്‌നർ തരം നൽകുകയും വേണം. ഈ സാഹചര്യത്തിൽ, മൂലകങ്ങളുടെ ട്രീയിലെ ഏത് കണ്ടെയ്നറും ഒരു കണ്ടെയ്നറായി നമുക്ക് തിരഞ്ഞെടുക്കാം; പ്രത്യേകിച്ചും, ഈ സാഹചര്യത്തിൽ, ഗ്രിഡിന് പുറമേ, അത്തരമൊരു കണ്ടെയ്നർ വിൻഡോ മൂലകവുമാണ്.

ഡാറ്റാ സന്ദർഭ പ്രോപ്പർട്ടി

നിയന്ത്രണങ്ങൾ പാരമ്പര്യമായി ലഭിക്കുന്ന ഫ്രെയിംവർക്ക് എലമെന്റ് ഒബ്‌ജക്റ്റിന് രസകരമായ ഒരു ഡാറ്റാ കോൺടെക്‌സ് പ്രോപ്പർട്ടി ഉണ്ട്. ഒരു എലമെന്റിനും അതിന്റെ നെസ്റ്റഡ് എലമെന്റുകൾക്കുമായി കുറച്ച് ഡാറ്റ സന്ദർഭം സജ്ജമാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. നെസ്റ്റഡ് എലമെന്റുകൾക്ക് ആ സന്ദർഭത്തിന്റെ പ്രത്യേക ഗുണങ്ങളുമായി ബന്ധിപ്പിക്കാൻ ബൈൻഡിംഗ് ഒബ്ജക്റ്റ് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, നമുക്ക് മുമ്പ് നിർവ്വചിച്ച ഫോൺ ക്ലാസ് ഉപയോഗിക്കുകയും ഈ ക്ലാസിലെ ഒബ്‌ജക്റ്റിൽ നിന്ന് ഒരു ഡാറ്റ സന്ദർഭം സൃഷ്ടിക്കുകയും ചെയ്യാം:

ഈ രീതിയിൽ ഞങ്ങൾ DataContext പ്രോപ്പർട്ടി ചില ഡൈനാമിക് അല്ലെങ്കിൽ സ്റ്റാറ്റിക് റിസോഴ്സിലേക്ക് സജ്ജമാക്കുന്നു. തുടർന്ന് ഞങ്ങൾ ഈ വിഭവവുമായി ബന്ധിപ്പിക്കുന്നു.