പതിപ്പ് 8.3.10.2168-ൽ നടപ്പിലാക്കി.

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

ബൈനറി ഡാറ്റ വ്യത്യസ്ത ഫോർമാറ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള പുതിയ പ്രവർത്തനങ്ങൾ

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

തരത്തിന് സമാനമായ പരിവർത്തനങ്ങൾ പിന്തുണയ്ക്കുന്നു ബഫർബൈനറി ഡാറ്റ. കൂടാതെ, നിങ്ങൾക്ക് ഒരു ബൈനറി ഡാറ്റ ബഫർ ബൈനറി ഡാറ്റയിലേക്കും തിരിച്ചും പരിവർത്തനം ചെയ്യാനാകും.

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

ഫയലുകൾ വിഭജിക്കുന്നതിനും ലയിപ്പിക്കുന്നതിനുമുള്ള ആശയത്തിൽ ഈ പ്രവർത്തനങ്ങൾ സമാനമാണ്, എന്നാൽ മിക്ക കേസുകളിലും അവ കൂടുതൽ കാര്യക്ഷമമാണ്. ബൈനറി ഡാറ്റ ആദ്യം ഒരു ഫയലിലേക്ക് സേവ് ചെയ്യേണ്ട ആവശ്യമില്ലാത്തതിനാലും, വിഭജിക്കുമ്പോൾ ഡാറ്റ അനാവശ്യമായി പകർത്തുന്നതിനാലും.

ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്ന ഒബ്‌ജക്‌റ്റുകളിലേക്ക് സ്ട്രീമുകൾക്കൊപ്പം പ്രവർത്തിക്കാനുള്ള കഴിവ് ചേർക്കുന്നു

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

തൽഫലമായി, ഇനിപ്പറയുന്നതുപോലുള്ള ഒബ്‌ജക്റ്റുകൾ ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾക്ക് ഇപ്പോൾ വായിക്കാനും എഴുതാനുമുള്ള സ്ട്രീമുകൾ തുറക്കാനാകും:

• വായനാ വാചകംഒപ്പം എഴുത്ത് വാചകം;
• റീഡിംഗ് ഫാസ്റ്റ് ഇൻഫോസെറ്റ്ഒപ്പം എൻട്രിഫാസ്റ്റ് ഇൻഫോസെറ്റ്;
• ReadingHtmlഒപ്പം PostHtml;
• JSON വായിക്കുന്നുഒപ്പം JSON എൻട്രി;
• XML വായിക്കുന്നുഒപ്പം XML എൻട്രി;
• Zip ഫയൽ വായിക്കുന്നുഒപ്പം സിപ്പ് ഫയൽ രേഖപ്പെടുത്തുക.

HTTP-യിൽ പ്രവർത്തിക്കുമ്പോൾ നിങ്ങൾക്ക് ബോഡി ഒരു സ്ട്രീം ആയി സ്വീകരിക്കാം:

• HTTPഅഭ്യർത്ഥനഒപ്പം HTTP പ്രതികരണം;
• HTTPserviceRequestഒപ്പം HTTPserviceResponse.

• ടെക്സ്റ്റ് ഡോക്യുമെന്റ്;
• ടാബുലാർ ഡോക്യുമെന്റ്;
• ഫോർമാറ്റ് ചെയ്ത ഡോക്യുമെന്റ്;
• ഭൂമിശാസ്ത്രപരമായ പദ്ധതി;
• ഗ്രാഫിക് സ്കീം;
• FTP കണക്ഷൻ.

തരങ്ങൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ സ്ട്രീമിലേക്ക് എഴുതുന്നത് ഇപ്പോൾ ലഭ്യമാണ് ചിത്രംഒപ്പം ConvertToCanonicalXML. കൂടാതെ, സ്ട്രീമുകളിൽ പ്രവർത്തിക്കുന്നത് ഇപ്പോൾ തരങ്ങളിലുള്ള വിവിധ രീതികളിൽ പിന്തുണയ്ക്കുന്നു XSL പരിവർത്തനം, ക്രിപ്‌റ്റോഗ്രഫി മാനേജർ, സർട്ടിഫിക്കറ്റ് ക്രിപ്‌റ്റോഗ്രഫിഒപ്പം ഹാഷിംഗ് ഡാറ്റ.

ഡാറ്റ വായിച്ചും എഴുതിയും കാര്യക്ഷമമായ പകർത്തൽ

ഞങ്ങൾ നടപ്പിലാക്കിയ ബൈനറി ടൂളുകൾ സ്ട്രീമുകൾ പകർത്തുന്നത് സാധ്യമാക്കി. എന്നാൽ വലിയ അളവിലുള്ള ഡാറ്റയിൽ ഈ പ്രവർത്തനം വളരെ കാര്യക്ഷമമായി നടത്തിയില്ല.

അതിനാൽ, തരം റീഡ്ഡാറ്റഞങ്ങൾ ഒരു പുതിയ രീതി നടപ്പിലാക്കി കോപ്പിബി(). ഇത് ഈ പ്രശ്നം ഇല്ലാതാക്കുക മാത്രമല്ല, വാചകം ലളിതമാക്കുകയും ചെയ്യുന്നു, ഇത് കൂടുതൽ മനസ്സിലാക്കാവുന്നതേയുള്ളൂ.

ഉദാഹരണത്തിന്, മുമ്പ് ഒരു സ്ട്രീമിൽ നിന്ന് ബൈനറി ഡാറ്റ സ്വീകരിക്കാനും മറ്റൊരു സ്ട്രീമിലേക്ക് എഴുതാനും സാധിച്ചിരുന്നു.

ഇപ്പോൾ ബൈനറി ഡാറ്റ സ്വീകരിക്കേണ്ട ആവശ്യമില്ല; ഡാറ്റ റീഡിംഗ് ഘട്ടത്തിലാണ് പകർത്തുന്നത്.

നിങ്ങൾക്ക് ഒരു സ്ട്രീമിലേക്ക് മാത്രമല്ല, ഒരു വസ്തുവിലേക്കും പകർത്താനാകും എന്നതാണ് നല്ല കാര്യം ഡാറ്റ എഴുതുക. ഉറവിട സ്ട്രീമിൽ നിന്നുള്ള ഡാറ്റ കൂടാതെ, ഔട്ട്പുട്ട് സ്ട്രീമിലേക്ക് നിങ്ങളുടെ സ്വന്തം ഡാറ്റയിൽ ചിലത് എഴുതേണ്ടിവരുമ്പോൾ ഈ ഓപ്ഷൻ സൗകര്യപ്രദമാണ്.

ഒരു ബൈനറി ഡാറ്റ ബഫറിൽ ബിറ്റ്വൈസ് ലോജിക്കൽ പ്രവർത്തനങ്ങൾ

ബൈനറി ഡാറ്റ ബഫറുകളിൽ പ്രവർത്തിക്കുമ്പോൾ നിങ്ങൾക്ക് ഇപ്പോൾ ബിറ്റ്വൈസ് ലോജിക്കൽ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാം. ഈ പ്രവർത്തനങ്ങളുടെ ഫലമായി, നൽകിയിരിക്കുന്ന ബഫറിലെ സോഴ്സ് ബൈറ്റുകളുടെയും ബൈറ്റുകളുടെയും ബിറ്റ്വൈസ് സംയോജനത്തിന്റെ ഫലം തിരഞ്ഞെടുത്ത ലോജിക്കൽ ഓപ്പറേഷന്റെ നിയമങ്ങൾ അനുസരിച്ച് ഉറവിട ബഫറിലേക്ക് എഴുതപ്പെടും. ഞങ്ങൾ ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ നടപ്പിലാക്കി:

• WriteBitAnd();
• WriteBitOr();
• WriteBitExclusiveഅല്ലെങ്കിൽ();
• WriteBitIn();
• വിപരീതം().

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

• ബിറ്റുകൾ 0-2: നികുതി നിരക്ക്;
• ബിറ്റ് 3: 0 - കഷണം സാധനങ്ങൾ, 1 - തൂക്കമുള്ള സാധനങ്ങൾ;
• ബിറ്റ് 4: 0 - വിൽപ്പന അനുവദിക്കുക, 1 - വിൽപ്പന നിരോധിക്കുക;
• ബിറ്റ് 5: 0 - അളവ് എണ്ണൽ പ്രവർത്തനക്ഷമമാക്കുക, 1 - അളവ് എണ്ണൽ പ്രവർത്തനരഹിതമാക്കുക;
• ബിറ്റ് 6: 0 - ഒറ്റ വിൽപ്പന നിരോധിച്ചിരിക്കുന്നു, 1 - ഒറ്റ വിൽപ്പന അനുവദനീയമാണ്;
• ബിറ്റ് 7: റിസർവ് ചെയ്‌തത്.

തുടർന്ന് ഈ വിവരങ്ങൾ എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്‌ത് കൂടുതൽ പ്രോസസ്സിംഗിന് സൗകര്യപ്രദമായ ഒരു ഫോമിൽ അവതരിപ്പിക്കുന്ന കോഡ് ഇതുപോലെയായിരിക്കാം.

ഹെക്സാഡെസിമൽ, ബൈനറി ലിറ്ററലുകളിൽ നിന്ന് ഒരു സംഖ്യ ലഭിക്കുന്നു

• NumberFromHexString();
• NumberFromBinaryString().

ബിറ്റ്വൈസ് ഓപ്പറേഷനുകൾക്കൊപ്പം ഉപയോഗിക്കുമ്പോൾ മാസ്കുകൾ നിർവചിക്കുന്നതിന് ബൈനറി ലിറ്ററലുകൾ ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്, വാണിജ്യ ഉപകരണങ്ങൾ ഉപയോഗിച്ച് എക്സ്ചേഞ്ച് ഫോർമാറ്റിന്റെ വിശകലനത്തോടുകൂടിയ മുമ്പത്തെ ഉദാഹരണത്തിൽ, ദശാംശ സംഖ്യകൾ ഉപയോഗിച്ച് മാസ്കുകൾ വ്യക്തമാക്കുന്നു. ഇത് വളരെ സൗകര്യപ്രദമല്ല, കാരണം കോഡ് എഴുതുമ്പോഴും വായിക്കുമ്പോഴും നിങ്ങൾ ദശാംശ സംഖ്യയെ ബൈനറി സിസ്റ്റത്തിലേക്ക് നിരന്തരം മാനസികമായി വിവർത്തനം ചെയ്യേണ്ടതുണ്ട്.

പകരം ബൈനറി ലിറ്ററലുകൾ ഉപയോഗിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമാണ്. അതേ സമയം, കോഡ് കൂടുതൽ വ്യക്തമാവുകയും പിശകുകളുടെ സാധ്യത ഗണ്യമായി കുറയുകയും ചെയ്യുന്നു.

സാങ്കേതിക ഫോർമാറ്റുകൾ പാഴ്സ് ചെയ്യുമ്പോൾ ഹെക്സാഡെസിമൽ ലിറ്ററലുകൾ ഉപയോഗിക്കാൻ സൗകര്യപ്രദമാണ്: ഇമേജ്, ശബ്ദം, വീഡിയോ ഫോർമാറ്റുകൾ.

ബാഹ്യ നേറ്റീവ് എപിഐ ഘടകങ്ങളുടെ സാങ്കേതികവിദ്യയിലെ മാറ്റങ്ങൾ

മുമ്പ്, 1C: എന്റർപ്രൈസിനും ഒരു ബാഹ്യ ഘടകത്തിനും ഇടയിൽ ബൈനറി ഡാറ്റ കൈമാറുമ്പോൾ നിരവധി നിയന്ത്രണങ്ങൾ ഉണ്ടായിരുന്നു. ഉദാഹരണത്തിന്, ബൈനറി ഡാറ്റ ഒരു ബാഹ്യ ഘടകത്തിലേക്ക് കൈമാറുന്നത് അസാധ്യമായിരുന്നു, കൂടാതെ ഒരു വെബ് ക്ലയന്റിൽ പ്രവർത്തിക്കുമ്പോൾ, ബൈനറി ഡാറ്റ കൈമാറ്റം ചെയ്യുന്നത് പൊതുവെ അസാധ്യമായിരുന്നു.

ഇപ്പോൾ ഞങ്ങൾ ഈ നിയന്ത്രണങ്ങളെല്ലാം നീക്കം ചെയ്യുന്നു. നിങ്ങൾക്ക് രണ്ട് ദിശകളിലും വെബ് ക്ലയന്റിലും പോലും ബൈനറി ഡാറ്റ കൈമാറാൻ കഴിയും.

ഇത് നിലവിലുള്ള ബാഹ്യ ഘടകങ്ങളുടെ പ്രവർത്തനത്തെ ഒരു തരത്തിലും ബാധിക്കില്ല. അവർ പഴയതുപോലെ പ്രവർത്തിക്കും. എന്നാൽ പുതുതായി സൃഷ്ടിച്ച ഘടകങ്ങളിൽ നിങ്ങൾക്ക് ഇപ്പോൾ ഒബ്ജക്റ്റുകൾ പാരാമീറ്ററുകളായി കൈമാറാൻ കഴിയും ബൈനറി ഡാറ്റ.

മിക്കവാറും എല്ലാ വിവരങ്ങളും ഒരു മൂല്യ സ്റ്റോറിൽ സൂക്ഷിക്കാൻ കഴിയും, ഉദാ.

... ചിത്രങ്ങൾ (ഫോട്ടോകൾ):

CurrentImage.Object = SprFabric.Link; CurrentImage.DataType = Enumerations.Objects.Image-ന്റെ അധിക വിവരങ്ങളുടെ തരങ്ങൾ; സംഭരണം = NewValueStorage(NewPicture, NewDataCompression()); CurrentImage.Storage = Storage.Get();

// ഈ സ്ഥലത്ത് അത് എല്ലാം പ്രദർശിപ്പിക്കുന്നു... ഫോം എലമെന്റുകൾ.പിക്ചർഫീൽഡ്1.ചിത്രം = സ്റ്റോറേജ്.ഗെറ്റ്(); CurrentImage.Write();

...സ്പ്രെഡ്ഷീറ്റ് പ്രമാണം:

TabDoc=പുതിയ ടാബുലാർ ഡോക്യുമെന്റ്; TabDoc.Output(FormElements.TabularDocumentField1); സംഭരണം=NewValueStorage(TabDoc); എഴുതുക();

നടപടിക്രമത്തിന്റെ അവസാനം

സ്റ്റോറേജ് പ്രസ്സ് (ഘടകം) മുതൽ പുനഃസ്ഥാപിക്കൽ നടപടിക്രമം

TabDoc=Storage.Get(); TabDoc ആണെങ്കിൽ<>നിർവചിക്കാത്ത ThenFormElements.TabularDocumentField1.Output(TabDoc); അവസാനം എങ്കിൽ;

നടപടിക്രമത്തിന്റെ അവസാനം

...അനിയന്ത്രിതമായ ഫയലുകൾ (ബൈനറി ഡാറ്റ):

XZ = NewValueStorage(NewBinaryData(file));

സ്റ്റോറേജിൽ സ്ഥാപിച്ചിരിക്കുന്ന ഡാറ്റയുടെ കംപ്രഷൻ എട്ട് പിന്തുണയ്ക്കുന്നു:

XZ = NewValueStorage(NewBinaryData(file),NewDataCompression(9));

... ബാഹ്യ പ്രോസസ്സിംഗും റിപ്പോർട്ടിംഗും:

നടപടിക്രമം ലോഡ് പ്രോസസ്സിംഗ് സ്റ്റോറേജിലേക്ക് (പ്രോപ്സ് സ്റ്റോറേജ് ടൈപ്പ്)

CompressionRate = NewDataCompression(9); //9 പരമാവധി PropsStorageType = New StorageValues(New BinaryData("c:\reports\report.epf", Compression Rate));

നടപടിക്രമത്തിന്റെ അവസാനം

സ്റ്റോറേജിൽ നിന്ന് പ്രോസസ്സിംഗ് ആരംഭിക്കുക (പ്രോപ്സ് സ്റ്റോറേജ് ടൈപ്പ്)

TemporaryFileName = TemporaryFileDirectory()+"report.epf"; BinaryData = PropsStorageType.Get(); BinaryData.Write(TemporaryFileName); ExternalProcessing = ExternalProcessing.Create(TemporaryFileName); ExternalProcessing.GetForm().Open();

നടപടിക്രമത്തിന്റെ അവസാനം

സംഭരണവുമായി പ്രവർത്തിക്കുന്നു

ഇത് ബൈനറി ഡാറ്റ ആയിരുന്നെങ്കിൽ, അത് മൂല്യ സ്റ്റോറിൽ നിന്ന് ഗെറ്റ് രീതി ഉപയോഗിച്ച് പുനഃസ്ഥാപിക്കുകയും റൈറ്റ് () രീതി ഉപയോഗിച്ച് ഒരു ഫയലിലേക്ക് എഴുതുകയും ചെയ്യാം.

ടൈപ്പ് വാല്യൂ (സ്റ്റോറേജ്) ആണെങ്കിൽ<>തുടർന്ന് ("ബൈനറി ഡാറ്റ") ടൈപ്പ് ചെയ്യുക

BinaryData = Storage.Get();

ബൈനറി ഡാറ്റ = സംഭരണം;

അവസാനം എങ്കിൽ; BinaryData.Write(FileName);

ഉദാഹരണത്തിന്, ഇത് ഒരു വേഡ് ഡോക്യുമെന്റ് (ഡോക് ഫയൽ അല്ലെങ്കിൽ മറ്റ് രജിസ്റ്റർ ചെയ്ത ഫയൽ തരം) ആണെങ്കിൽ, അത് ഇതുപോലെ തുറക്കാൻ കഴിയും:

ലോഞ്ച് ആപ്ലിക്കേഷൻ (ഫയൽ നാമം);

മൂല്യ സംഭരണത്തിന്റെ ഒരു ഫീൽഡ് മായ്‌ക്കുന്നതിന്, നിങ്ങൾ അത് നിർവചിക്കാത്തത് നൽകേണ്ടതുണ്ട്:

PropsStorage = Undefined;

ബിൽറ്റ്-ഇൻ ഭാഷയായ 1C:Enterprise 8-ൽ ഫയലുകളും ചിത്രങ്ങളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

ഉദ്ദേശ്യം

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

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

രീതിയുടെ വ്യാപ്തി

താൽക്കാലിക സംഭരണം

ബൈനറി ഡാറ്റ സ്ഥാപിക്കാൻ കഴിയുന്ന വിവര അടിത്തറയുടെ ഒരു പ്രത്യേക മേഖലയാണ് താൽക്കാലിക സംഭരണം. ക്ലയന്റ്-സെർവർ ഇടപെടൽ സമയത്ത് വിവരങ്ങൾ ഡാറ്റാബേസിലേക്ക് മാറ്റുന്നതിന് മുമ്പ് താൽക്കാലികമായി സംഭരിക്കുക എന്നതാണ് പ്രധാന ലക്ഷ്യം.

ഉപയോക്താവ് തിരഞ്ഞെടുത്ത ഫയൽ ക്ലയന്റിലേക്ക് സംഭരിക്കാനുള്ള സാധ്യതയില്ലാതെ നേരിട്ട് സെർവറിലേക്ക് മാറ്റണമെന്ന് വെബ് ബ്രൗസർ ഓപ്പറേറ്റിംഗ് മോഡലിന് ആവശ്യമായതിനാൽ താൽക്കാലിക സംഭരണത്തിന്റെ ആവശ്യകത ഉയർന്നുവരുന്നു. ഒരു ഫയൽ കൈമാറ്റം ചെയ്യുമ്പോൾ, അത് താൽക്കാലിക സ്റ്റോറേജിൽ സ്ഥാപിക്കുകയും ഡാറ്റാബേസിലേക്ക് ഒരു ഒബ്ജക്റ്റ് എഴുതുമ്പോൾ ഉപയോഗിക്കുകയും ചെയ്യാം.

ഒബ്‌ജക്റ്റ് വിവര അടിത്തറയിൽ രേഖപ്പെടുത്തുന്നതിന് മുമ്പ് ഫയലുകളിലേക്കോ ചിത്രങ്ങളിലേക്കോ ആക്‌സസ് നൽകുന്നതാണ് താൽക്കാലിക സംഭരണം വഴി പരിഹരിക്കപ്പെട്ട ഏറ്റവും സാധാരണമായ ആപ്ലിക്കേഷൻ ടാസ്‌ക്, ഉദാഹരണത്തിന്, ഒരു ഘടകത്തിന്റെ രൂപത്തിൽ.

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

വിവര അടിസ്ഥാനം

മൂല്യ സംഭരണ ​​തരത്തിന്റെ ആട്രിബ്യൂട്ടുകളിൽ സംഭരിച്ചിരിക്കുന്ന ബൈനറി ഡാറ്റ ആക്സസ് ചെയ്യാൻ മെക്കാനിസം നിങ്ങളെ അനുവദിക്കുന്നു.

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

ഇൻഫോബേസ് വിശദാംശങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ ഫയലുകളിൽ പ്രവർത്തിക്കുന്നതിനുള്ള രീതികൾക്ക് പരിമിതികളുണ്ട്. അവർക്ക്, താൽക്കാലിക സംഭരണത്തിൽ നിന്ന് വ്യത്യസ്തമായി, വായന വിവരങ്ങൾ മാത്രമേ ലഭ്യമാകൂ, പക്ഷേ അത് എഴുതുകയോ ഇല്ലാതാക്കുകയോ ചെയ്യുന്നില്ല.

ഫയലുകളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള രീതികളുടെ വിവരണം

താൽക്കാലിക സംഭരണത്തിലേക്ക് ഡാറ്റ സംരക്ഷിക്കുന്നു

ഈ സംവിധാനം ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും സാധാരണമായ സാഹചര്യം തുടക്കത്തിൽ ഉപയോക്തൃ ഡാറ്റ താൽക്കാലിക സംഭരണത്തിൽ സ്ഥാപിക്കുന്നതാണ്. ഇതിന് രണ്ട് രീതികളുണ്ട്: PlaceFile() കൂടാതെ PlaceFileInTemporaryStorage().

ആദ്യ രീതി, PlaceFile(), ലോക്കൽ ഫയൽ സിസ്റ്റത്തിൽ നിന്ന് ഒരു ഫയൽ താൽക്കാലിക സംഭരണത്തിലേക്ക് സ്ഥാപിക്കുന്നു. സ്റ്റോറേജിൽ ഒരു ലക്ഷ്യ വിലാസം സ്വീകരിക്കാൻ ഈ രീതിക്ക് കഴിയും. ഇത് നിർവചിച്ചിട്ടില്ലെങ്കിലോ ഒരു ശൂന്യമായ സ്ട്രിംഗ് ആണെങ്കിലോ, ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കപ്പെടും, കൂടാതെ രീതി അതിന്റെ വിലാസം അനുബന്ധ പാരാമീറ്ററിലൂടെ തിരികെ നൽകും.

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

തൽഫലമായി, ഫയൽ തിരഞ്ഞെടുക്കൽ ഡയലോഗിൽ ഒരു പ്രവർത്തനം നടത്താൻ ഉപയോക്താവ് സംവേദനാത്മകമായി വിസമ്മതിച്ചാൽ രീതി തെറ്റ് നൽകുന്നു. ഈ രീതി ഉപഭോക്താവിന് മാത്രമേ ലഭ്യമാകൂ.

രണ്ടാമത്തെ രീതി, PlaceFileInTemporaryStorage(), മുമ്പത്തേതിന് സമാനമാണ്, അത് സെർവറിൽ ലഭ്യമാണ് എന്നതൊഴിച്ചാൽ, താൽക്കാലിക സ്റ്റോറേജിലേക്ക് എഴുതേണ്ട ഡാറ്റ ഫയൽ സിസ്റ്റത്തിലെ ഒരു പാഥായിട്ടല്ല, മറിച്ച് തരം വേരിയബിളായി പ്രതിനിധീകരിക്കുന്നു. ബൈനറി ഡാറ്റ. അതുപോലെ, ടാർഗെറ്റ് വിലാസം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, സ്റ്റോറേജിൽ ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കപ്പെടും. ഫംഗ്‌ഷന്റെ ഫലമായി അതിന്റെ വിലാസം തിരികെ നൽകുന്നു.

താൽക്കാലിക സംഭരണത്തിൽ നിന്ന് ഒരു ഫയൽ വീണ്ടെടുക്കുന്നു

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

താൽക്കാലിക സംഭരണത്തിൽ നിന്ന് ഒരു ഫയൽ ഇല്ലാതാക്കുന്നു

ഡാറ്റ വിശദാംശങ്ങളിൽ സംരക്ഷിച്ച ശേഷം, താൽക്കാലിക സംഭരണത്തിലുള്ള ഫയൽ ഇല്ലാതാക്കാൻ കഴിയും. ഈ ആവശ്യത്തിനായി, താൽക്കാലിക സംഭരണത്തിൽ നിന്ന് ഒരു ഫയൽ ഇല്ലാതാക്കുന്ന DeleteFileFromTemporaryStorage() എന്ന ഒരു രീതിയുണ്ട്. താൽക്കാലിക സംഭരണത്തിലുള്ള ഒരു ഫയലിന്റെ വിലാസം ഈ രീതി ഒരു പരാമീറ്ററായി എടുക്കുന്നു. സെർവറിൽ ലഭ്യമാണ്.

താൽക്കാലിക സംഭരണത്തിനായി വിലാസം പരിശോധിക്കുന്നു

ഫയൽ വിലാസത്തിന് ഇൻഫോബേസിലെ താൽക്കാലിക സംഭരണവും വിശദാംശങ്ങളും സൂചിപ്പിക്കാൻ കഴിയും. അതിന്റെ തരം പരിശോധിക്കാൻ, ഒരു രീതിയുണ്ട് This isTemporaryStorageAddress().

പാസ്സായ വിലാസം സ്റ്റോറിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന വിലാസമാണോ എന്ന് ഇത് പരിശോധിക്കുന്നു. വിലാസം താൽകാലിക സംഭരണത്തിലേക്ക് ചൂണ്ടിക്കാണിക്കുകയാണെങ്കിൽ True നൽകുന്നു. രീതി സെർവറിൽ ലഭ്യമാണ്.

പ്രോപ്സ് വിലാസം സ്വീകരിക്കുന്നു

ഇൻഫോബേസിലെ വിശദാംശങ്ങളിൽ ഡാറ്റ സ്ഥാപിച്ച ശേഷം, ഫയൽ രീതികൾ ഉപയോഗിച്ച് നിങ്ങൾ അത് ആക്സസ് ചെയ്യേണ്ടതായി വന്നേക്കാം.

എന്നാൽ നിങ്ങൾക്ക് ഡാറ്റ ലഭിക്കുന്നതിന് മുമ്പ്, ഉദാഹരണത്തിന് ഒരു പ്രോപ്പർട്ടിയിൽ നിന്ന്, ഈ വസ്തുവിന്റെ വിലാസം നിങ്ങൾക്ക് ലഭിക്കേണ്ടതുണ്ട്. ഈ ആവശ്യത്തിനായി, GetFileAddressInInformationBase() എന്ന ഒരു രീതിയുണ്ട്.

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

ഇൻഫോബേസിൽ നിന്ന് ഒരു ഫയൽ വീണ്ടെടുക്കുന്നു

GetFile() രീതി ഇൻഫോബേസിൽ നിന്ന് ഒരു ഫയൽ സ്വീകരിക്കുകയും അത് ഉപയോക്താവിന്റെ ലോക്കൽ ഫയൽ സിസ്റ്റത്തിലേക്ക് സംരക്ഷിക്കുകയും ചെയ്യുന്നു. പ്രോപ്പുകളിലോ താൽക്കാലിക ഫയൽ സംഭരണത്തിലോ ഫയലിന്റെ വിലാസം ആദ്യ പാരാമീറ്റർ വ്യക്തമാക്കുന്നു. തത്ഫലമായുണ്ടാകുന്ന ഫയലിന്റെ ലക്ഷ്യസ്ഥാനം രണ്ടാമത്തെ പാരാമീറ്റർ വ്യക്തമാക്കുന്നു. നോൺ-ഇന്ററാക്ടീവ് മോഡിൽ, നിങ്ങൾ പാത വ്യക്തമാക്കണം. ഇന്ററാക്ടീവ് മോഡിൽ, പാരാമീറ്റർ ഓപ്ഷണലാണ്.

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

ഫയൽ രീതികൾ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം

// ഇന്ററാക്ടീവ് മോഡിൽ ഡിസ്കിൽ നിന്ന് ഒരു ഫയൽ സ്വീകരിക്കുന്നു // അത് താൽക്കാലിക സംഭരണത്തിൽ സ്ഥാപിക്കുന്നു &ക്ലയന്റ് നടപടിക്രമത്തിൽ SelectDiskFileAndWrite()

വേരിയബിൾ തിരഞ്ഞെടുത്ത പേര്; വേരിയബിൾ ടെമ്പററി സ്റ്റോറേജ് വിലാസം; PutFile (TemporaryStorageAddress, SelectedName, True) ആണെങ്കിൽ Object.FileName = SelectedName; PlaceObjectFile(താത്കാലിക സംഭരണ ​​വിലാസം); അവസാനം എങ്കിൽ;

നടപടിക്രമത്തിന്റെ അവസാനം

// താൽക്കാലിക സംഭരണത്തിൽ നിന്ന് ഒരു ഡയറക്‌ടറിയിലേക്ക് ഒരു ഫയൽ പകർത്തുന്നു // ആട്രിബ്യൂട്ട്, ഒരു ഒബ്‌ജക്റ്റ് റെക്കോർഡുചെയ്യുന്നു, താൽക്കാലിക // സംഭരണത്തിൽ നിന്ന് ഒരു ഫയൽ ഇല്ലാതാക്കുന്നു // സംഭരണത്തിൽ നിന്ന് &സെർവർ നടപടിക്രമത്തിൽ ഒബ്‌ജക്റ്റ് ഫയൽ (താത്കാലിക സംഭരണ ​​വിലാസം)

ഡയറക്ടറി ഘടകം = ഫോം ആട്രിബ്യൂട്ടുകളുടെ മൂല്യം("വസ്തു"); BinaryData = GetFileFromTemporaryStorage(TemporaryStorageAddress); Directory Element.File Data = NewValueStorage(BinaryData); FilePathOnDisk = പുതിയ ഫയൽ (DirectoryItem.FileName); Directory Item.FileName = FilePathOnDisk.Name; ഡയറക്ടറി ഘടകം.എഴുതുക(); പരിഷ്കരിച്ച = False; താൽക്കാലിക സംഭരണത്തിൽ നിന്ന് ഫയൽ ഇല്ലാതാക്കുക (താത്കാലിക സംഭരണ ​​വിലാസം); മൂല്യം ഫോം ആട്രിബ്യൂട്ടുകൾ (ഡയറക്ടറി എലമെന്റ്, "ഒബ്ജക്റ്റ്");

നടപടിക്രമത്തിന്റെ അവസാനം

// പ്രോപ്പുകളിൽ നിന്ന് ഒരു ഫയൽ വായിച്ച് അത് സംരക്ഷിക്കുന്നു // സംവേദനാത്മക മോഡിൽ ലോക്കൽ ഡിസ്കിൽ & ക്ലയന്റ് നടപടിക്രമത്തിൽ ReadFileAndSaveToDisk()

വിലാസം = GetFileAddressInInformationBase(Object.Link, "FileData"); GetFile(വിലാസം, Object.FileName, True);

നടപടിക്രമത്തിന്റെ അവസാനം

ഇമേജ് ഫീൽഡിലെ വിലാസങ്ങൾക്കുള്ള പിന്തുണ

താൽക്കാലിക സംഭരണത്തിലോ ഡാറ്റാബേസിലോ ഒരു ഫയലിന്റെ വിലാസം വ്യക്തമാക്കിയ ചിത്രം പ്രദർശിപ്പിക്കുന്നതിനെ പിക്ചർ ഫീൽഡ് കൺട്രോൾ പിന്തുണയ്ക്കുന്നു.

ഇത് ചെയ്യുന്നതിന്, ഫോം എലമെന്റിന്റെ ഡാറ്റ പ്രോപ്പർട്ടിയിൽ നിങ്ങൾ ഒരു സ്ട്രിംഗ് തരം ആട്രിബ്യൂട്ട് സജ്ജീകരിക്കണം. ഈ ആട്രിബ്യൂട്ടിന്റെ മൂല്യം ചിത്രത്തിന്റെ വിലാസമായി വ്യാഖ്യാനിക്കപ്പെടും.

ഉദാഹരണം // ഇമേജ് ഫീൽഡ് താൽക്കാലിക // സ്റ്റോറേജിലെ ഇമേജ് വിലാസത്തിലേക്ക് ബന്ധിപ്പിക്കുന്നു. വിലാസചിത്രങ്ങൾ സ്ട്രിംഗ് തരത്തിന്റെ വിശദാംശങ്ങൾ രൂപപ്പെടുത്തുന്നു

പ്ലെയ്‌സ് ഫയൽ (ചിത്ര വിലാസം, ശരി)

ചിത്രം.ഡാറ്റ = വിലാസ ചിത്രങ്ങൾ

വെബ് ക്ലയന്റുമായി പ്രവർത്തിക്കുമ്പോൾ പരിമിതികൾ

വെബ് ക്ലയന്റ് ഉപയോഗിക്കുമ്പോൾ വിവരിച്ച മെക്കാനിസത്തിന്റെ പ്രവർത്തനത്തിന് ചില പരിമിതികളുണ്ട്. ഈ നിയന്ത്രണങ്ങൾ ബ്രൗസറിന്റെ സുരക്ഷാ മോഡലുമായി ബന്ധപ്പെട്ടതാണ്. അതിനാൽ, ഉദാഹരണത്തിന്, ക്ലയന്റിന് പ്രാദേശിക ഫയൽ സിസ്റ്റത്തിലേക്ക് ഒരു ഫയൽ സ്വതന്ത്രമായി സംരക്ഷിക്കാൻ കഴിയില്ല, അതായത്, ക്ലയന്റ് രീതികളുടെ സംവേദനാത്മക പതിപ്പ് മാത്രം ലഭ്യമാണ് PlaceFile() and GetFile(). നോൺ-ഇന്ററാക്ടീവ് മോഡ് ഉപയോഗിക്കാൻ ശ്രമിക്കുമ്പോൾ ഒരു ഒഴിവാക്കൽ എറിയപ്പെടുന്നു. സംവേദനാത്മകമായി ദൃശ്യമാകുന്ന ഡയലോഗ് ബോക്സുകൾ നിങ്ങളുടെ ബ്രൗസർ തരത്തിന് പ്രത്യേകമാണ്.

ക്ലയന്റിലെ മൂല്യ സംഭരണത്തിൽ പ്രവർത്തിക്കുമ്പോൾ സവിശേഷതകൾ

പ്രശ്നം:

ഒരു ഡോക്യുമെന്റിന് ടാബുലർ വിഭാഗത്തിൽ മൂല്യ സംഭരണ ​​തരത്തിന്റെ ആട്രിബ്യൂട്ട് ഉണ്ടെങ്കിൽ, ഈ ആട്രിബ്യൂട്ടിൽ വലിയ ഡാറ്റ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ അത് ഡോക്യുമെന്റ് ഫോം തുറക്കുന്നത് മന്ദഗതിയിലാക്കുന്നു.

അനുമാനിക്കപ്പെടുന്ന കാരണം:

ഒരുപക്ഷേ, ഒരു ഫോം തുറക്കുമ്പോൾ, അത് ക്ലയന്റിലേക്ക് അയയ്‌ക്കുന്ന മൂല്യ സ്റ്റോറിലെ ഡാറ്റയിലേക്കുള്ള ലിങ്കല്ല, മറിച്ച് ഡാറ്റ തന്നെ.

പരിഹാരം

• ഫോമിന്റെ പട്ടിക ആട്രിബ്യൂട്ടിന്റെ ഗുണങ്ങളിൽ "എപ്പോഴും ഉപയോഗിക്കുക" എന്ന ഫ്ലാഗ് ഉണ്ട്. ഇത് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഫീൽഡിലെ ഉള്ളടക്കങ്ങൾ എല്ലായ്പ്പോഴും സെർവറിനും ക്ലയന്റിനുമിടയിൽ കൈമാറ്റം ചെയ്യപ്പെടും - ഉദാഹരണത്തിന്, ഒരു ഫോം തുറക്കുമ്പോൾ. ഈ ഫ്ലാഗ് അപ്രാപ്തമാക്കിയിരിക്കണം, എന്നാൽ ഇത് കോഡിൽ കണക്കിലെടുക്കേണ്ടതാണ്, കാരണം ക്ലയന്റിലുള്ള ഈ ഫീൽഡിന് സ്ഥിരസ്ഥിതിയായി ഒരു മൂല്യവും ഉണ്ടാകില്ല. ഒരു ഉദാഹരണം 1C:ആർക്കൈവിൽ കാണാം.

ഉപയോഗിക്കുന്നതാണ് ഇതിലും നല്ലത് താൽക്കാലിക സംഭരണംക്ലയന്റിനും സെർവറിനുമിടയിൽ ഫയലുകൾ കൈമാറാൻ.

1C:Enterprise 8 ടെക്‌നോളജി പ്ലാറ്റ്‌ഫോം വിവര അടിത്തറയിൽ അനിയന്ത്രിതമായ ഫയലുകൾ സംരക്ഷിക്കാനും അവിടെ നിന്ന് അവ വീണ്ടെടുക്കാനും വിവിധ രീതികളിൽ ഉപയോഗിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് ഈ പ്രവർത്തനങ്ങൾ നോക്കാം.

1C ഇൻഫർമേഷൻ ബേസിലേക്ക് ഒരു ഫയൽ അപ്‌ലോഡ് ചെയ്യുന്നതിന് മുമ്പ്, ഡിസ്കിൽ ഫയലിന്റെ പൂർണ്ണ വിലാസം നിങ്ങൾ നേടേണ്ടതുണ്ട്. ഫയൽ തിരഞ്ഞെടുക്കൽ ഡയലോഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നത് വിവരിച്ചിരിക്കുന്നു.

ഫയലുകൾ സംഭരിക്കുന്നതിന്, തരം ഉപയോഗിച്ച് ഒരു ആട്രിബ്യൂട്ട് (അല്ലെങ്കിൽ റിസോഴ്സ് രജിസ്റ്റർ ചെയ്യുക) ഉപയോഗിക്കുക സംഭരണ ​​മൂല്യങ്ങൾ.

1C വിവര അടിത്തറയിലേക്ക് ഒരു അനിയന്ത്രിതമായ ഫയൽ അപ്‌ലോഡ് ചെയ്യുന്നു

ഏത് ഫയലും ബൈനറി ഡാറ്റയായി പ്രതിനിധീകരിക്കുകയും അതിൽ ലോഡ് ചെയ്യുകയും ചെയ്യാം മൂല്യ സംഭരണം.

ബൈനറി ഡാറ്റ ഒരു ഒബ്ജക്റ്റിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ സംഭരണ ​​മൂല്യങ്ങൾഉപയോഗിച്ച ഡിസൈൻ പുതിയ സംഭരണ ​​മൂല്യങ്ങൾ (ഡാറ്റ, കംപ്രഷൻ)രണ്ട് പാരാമീറ്ററുകൾക്കൊപ്പം:

1. ഡാറ്റ— സ്റ്റോറേജിൽ സൂക്ഷിക്കേണ്ട ബൈനറി ഡാറ്റ
2. കംപ്രഷൻ- ഡിഫ്ലേഷൻ അൽഗോരിതത്തിന്റെ കംപ്രഷൻ അനുപാതം. -1...9 ശ്രേണിയിലെ പൂർണ്ണസംഖ്യ. -1 എന്നത് ഡിഫോൾട്ട് കംപ്രഷൻ ലെവലാണ്. 0 - കംപ്രഷൻ ഇല്ല, 9 - പരമാവധി കംപ്രഷൻ. സ്ഥിര മൂല്യം: -1. പാരാമീറ്റർ ഓപ്ഷണൽ ആണ്; വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, കംപ്രഷൻ ഉപയോഗിക്കില്ല.

//ഫയൽ ബൈനറി ഡാറ്റയിലേക്ക് പരിവർത്തനം ചെയ്യുക
ഫയൽ = പുതിയ ബൈനറി ഡാറ്റ(പാത്ത്) ;

//ഒരു പുതിയ മൂല്യ സംഭരണ ​​ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുക

ഡാറ്റാ സ്റ്റോറേജ് = NewValueStorage(File, NewDataCompression(9) );

1C ഇൻഫോബേസിൽ നിന്ന് ഡിസ്കിലേക്ക് ഒരു ആർബിട്രറി ഫയൽ സംരക്ഷിക്കുന്നു

1C ഡാറ്റാബേസിൽ നിന്ന് ഡിസ്കിലേക്ക് ഒരു ഫയൽ സംരക്ഷിക്കുന്നതിന്, നിങ്ങൾ പാതയും ഫയലിന്റെ പേരും നിർണ്ണയിക്കേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ഒരു ഫയൽ സേവിംഗ് ഡയലോഗ് ഉണ്ട്, അതിൽ വിവരിച്ചിരിക്കുന്നു.

//സ്റ്റോറേജിൽ നിന്ന് ബൈനറി ഡാറ്റ നേടുക
//ഡാറ്റ സ്റ്റോറേജ് - മൂല്യ സംഭരണ ​​തരം ഉള്ള ഒരു വസ്തുവിന്റെ ആട്രിബ്യൂട്ട്

// ലഭിച്ച ഡാറ്റ ഡിസ്കിലേക്ക് എഴുതുക
//പാത്ത് വേരിയബിളിൽ ഡിസ്കിലെ ഫയലിന്റെ മുഴുവൻ വിലാസവും അടങ്ങിയിരിക്കുന്നു
ഡാറ്റ. എഴുതുക (പാത);

1C വിവര അടിത്തറയിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു ഫയൽ കാണുന്നു

ഡാറ്റാബേസിൽ സംരക്ഷിച്ചിരിക്കുന്ന ഒരു ഫയൽ കാണുന്നതിന്, ഫയൽ തുറക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ ഇൻസ്റ്റാൾ ചെയ്തിരിക്കണം.

//ആവശ്യമായ വിപുലീകരണത്തോടുകൂടിയ താൽക്കാലിക ഫയലിന്റെ പേര് നേടുക
//വിപുലീകരണ വേരിയബിളിൽ നിങ്ങൾ ഫയൽ എക്സ്റ്റൻഷൻ ഇടേണ്ടതുണ്ട്, ഉദാഹരണത്തിന് "pdf"
പാത = GetTemporaryFileName(വിപുലീകരണം) ;

//സ്റ്റോറേജിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുക
//ഡാറ്റ സ്റ്റോറേജ് - മൂല്യ സംഭരണ ​​തരം ഉള്ള ഒരു വസ്തുവിന്റെ ആട്രിബ്യൂട്ട്
ഡാറ്റ = ഡാറ്റസ്റ്റോർ. നേടുക();

//ഒരു താൽക്കാലിക ഫയലിലേക്ക് ഡാറ്റ എഴുതുക
ഡാറ്റ. എഴുതുക (പാത);

//ഉദ്ദേശിച്ച ആപ്ലിക്കേഷനിൽ ഫയൽ തുറക്കാൻ ശ്രമിക്കുന്നു
//അപ്ലിക്കേഷൻ കണ്ടെത്തിയില്ലെങ്കിൽ, സിസ്റ്റം ഡയലോഗ് "ഇത് ഉപയോഗിച്ച് തുറക്കുക..." ദൃശ്യമാകും.
ലോഞ്ച് ആപ്ലിക്കേഷൻ(പാത്ത്) ;

പ്രിന്റ് (Ctrl+P)

16.3 ബൈനറി ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

16.3.1. പൊതുവിവരം

ആപ്ലിക്കേഷൻ പരിഹാരങ്ങൾ നടപ്പിലാക്കുമ്പോൾ, വിവിധ ബൈനറി ഡാറ്റ വിശകലനം ചെയ്യേണ്ട സാഹചര്യങ്ങൾ ഉണ്ടാകാം. ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു ഒപ്പ് ഉപയോഗിച്ച് ഫയൽ തരം നിർണ്ണയിക്കേണ്ടതുണ്ട് അല്ലെങ്കിൽ ഒരു ചിത്രം ഉപയോഗിച്ച് ചില കൃത്രിമങ്ങൾ നടത്തേണ്ടതുണ്ട്. ബൈനറി ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ, 1C: എന്റർപ്രൈസ് പ്രത്യേക സോഫ്റ്റ്വെയർ ഇന്റർഫേസുകൾ നൽകുന്നു. അടുത്തതായി, ബൈനറി ഡാറ്റയുമായി പ്രവർത്തിക്കാനുള്ള സാധ്യതകൾ ഞങ്ങൾ നോക്കും.
ബൈനറി ഡാറ്റ ഉപയോഗിച്ചുള്ള എല്ലാ പ്രവർത്തനങ്ങളും ഒരു സ്ട്രീം എന്ന ആശയത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഒഴുക്ക്ഒരു അനിയന്ത്രിതമായ (പൊതുവായ സാഹചര്യത്തിൽ) ഡാറ്റാ ഉറവിടത്തിന്റെ (സ്ട്രീം ഒബ്ജക്റ്റ്) ലോജിക്കൽ സാമാന്യവൽക്കരണമാണ്. ഒരു സ്രോതസ്സുമായും ബന്ധമില്ലാത്ത ഒരു സ്വതന്ത്ര സ്ട്രീം ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാനുള്ള കഴിവ് സിസ്റ്റം നൽകുന്നില്ല. എന്നാൽ സൃഷ്ടിക്കാൻ കഴിയുന്ന ഒബ്‌ജക്‌റ്റുകൾ ഉണ്ട് - ഡിസ്കിലെ ഒരു ഫയലുമായി (ഫയൽസ്ട്രീം ഒബ്‌ജക്‌റ്റ്) അല്ലെങ്കിൽ മെമ്മറിയിൽ സൃഷ്‌ടിച്ച സ്‌ട്രീം (മെമ്മറി സ്‌ട്രീം ഒബ്‌ജക്‌റ്റ്) എന്നിവയുമായി ബന്ധപ്പെട്ട സ്‌ട്രീം. ഡാറ്റ വായിക്കാനും എഴുതാനും ഒരു സ്ട്രീം നിങ്ങളെ അനുവദിക്കുന്നു. ചില പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുള്ള സാധ്യത നിർണ്ണയിക്കാൻ, ഒരു സ്ട്രീമിന് (ഒപ്പം ഉരുത്തിരിഞ്ഞ ഒബ്‌ജക്റ്റുകൾക്കും) പ്രത്യേക രീതികളുണ്ട്, അത് ഏതെന്ന് നിർണ്ണയിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു
ഈ ത്രെഡ് ഉപയോഗിച്ച് പ്രവർത്തനങ്ങൾ ലഭ്യമാണ് (രീതികൾ ലഭ്യമായ റെക്കോർഡ്(), ലഭ്യമാണ് വായിക്കുക(), ലഭ്യമായ മാറ്റം സ്ഥാനം()).
നിങ്ങൾക്ക് ഉയർന്ന തലത്തിലുള്ള ഒരു സ്ട്രീമിൽ പ്രവർത്തിക്കണമെങ്കിൽ, പ്രത്യേകിച്ചും, ഒരു നമ്പർ (വ്യത്യസ്ത ബിറ്റ് ഡെപ്ത്) അല്ലെങ്കിൽ ഒരു സ്ട്രിംഗ് പോലുള്ള ഡാറ്റ വായിക്കുക/എഴുതുക, തുടർന്ന് DataRead/DataWrite ഒബ്‌ജക്റ്റുകൾ ഇതിനായി ഉദ്ദേശിച്ചുള്ളതാണ്. ഈ ഒബ്‌ജക്റ്റുകൾ ഉപയോഗിച്ച്, സ്ട്രീമിൽ സ്ഥിതിചെയ്യുന്ന ബൈനറി ഡാറ്റയിലേക്ക് നിങ്ങൾക്ക് കൂടുതൽ ഘടനാപരമായ സമീപനം സ്വീകരിക്കാം. അതിനാൽ, ഉദാഹരണത്തിന്, ഒരു ഫയലിന്റെ ഫോർമാറ്റ് അറിയുന്നതിലൂടെ, നിങ്ങൾക്ക് അത്തരമൊരു ഫയൽ വളരെ സുഖമായി വായിക്കാൻ കഴിയും, തലക്കെട്ടുകളിൽ നിന്ന് ആവശ്യമായ ഡാറ്റ നേടുക (ചട്ടം പോലെ, തരം നമ്പറും സ്ട്രിംഗും പ്രതിനിധീകരിക്കുന്നു), അനാവശ്യ ഡാറ്റ ബ്ലോക്കുകൾ ഒഴിവാക്കുക പ്രോസസ്സിംഗിന് ആവശ്യമായവ ലോഡ് ചെയ്യുന്നു.
ബൈനറി ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിനുള്ള പൊതു സ്കീം ഇനിപ്പറയുന്ന രീതിയിൽ പ്രതിനിധീകരിക്കാം:

1. സ്ട്രീം സ്വീകരിക്കൽ പുരോഗമിക്കുന്നു
2. ഒരു ഡാറ്റ റീഡർ അല്ലെങ്കിൽ ഡാറ്റ റൈറ്റർ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ചു.
3. ഘട്ടം 2-ൽ സൃഷ്ടിച്ച ഒബ്ജക്റ്റ് ഉപയോഗിച്ച്, ആവശ്യമായ പ്രവർത്തനങ്ങൾ നടത്തുന്നു.
4. ഘട്ടം 2-ൽ സൃഷ്ടിച്ച ഒബ്ജക്റ്റ് അടച്ചിരിക്കുന്നു.
5. കൂടുതൽ പ്രവർത്തനങ്ങൾ ആവശ്യമില്ലെങ്കിൽ, ഘട്ടം 1-ൽ ലഭിച്ച സ്ട്രീം അടച്ചു.
6. നിങ്ങൾക്ക് സ്ട്രീമിനൊപ്പം പ്രവർത്തിക്കുന്നത് തുടരണമെങ്കിൽ, നിങ്ങൾക്ക് സ്ട്രീമിൽ ഒരു പുതിയ സ്ഥാനം സജ്ജീകരിക്കാം (ഈ പ്രവർത്തനത്തെ പിന്തുണയ്‌ക്കുകയാണെങ്കിൽ) കൂടാതെ ഘട്ടം 2 മുതൽ പ്രവർത്തിക്കുന്നത് തുടരുക.

ഖണ്ഡികകൾ 1 ഉം 2 ഉം സംയോജിപ്പിക്കാൻ കഴിയുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാനുള്ള കഴിവ് സിസ്റ്റം നൽകുന്നു ഡാറ്റ വായിക്കുക/ഡാറ്റ എഴുതുകഉദാഹരണത്തിന്, ഒരു ബൈനറിഡാറ്റ ഒബ്‌ജക്റ്റിൽ നിന്ന് നേരിട്ട്.
ബൈനറി ഡാറ്റ ഉപയോഗിച്ച് വിവിധ പ്രവർത്തനങ്ങൾ നടത്താൻ, ക്രമരഹിതമായ (ബൈറ്റ്-ബൈ-ബൈറ്റ്) ആക്‌സസ് (ഒബ്‌ജക്റ്റ്) ഉപയോഗിച്ച് സ്ട്രീമിന്റെ ഒരു ഭാഗം പ്രത്യേക ശകലമായി നേടാനുള്ള കഴിവ് സിസ്റ്റം നൽകുന്നു. ബഫർബൈനറി ഡാറ്റ). സൃഷ്ടിക്കുമ്പോൾ ബഫർ വലുപ്പം സജ്ജീകരിച്ചിരിക്കുന്നു, പിന്നീട് മാറ്റാൻ കഴിയില്ല. ഒരു ബൈനറി ഡാറ്റ ബഫറിൽ പ്രവർത്തിക്കുമ്പോൾ, വ്യത്യസ്ത ബിറ്റ് ഡെപ്‌ത്സിന്റെ നമ്പറുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയും
ഒരു മൊത്തത്തിൽ. ഈ സാഹചര്യത്തിൽ, വാക്കുകളിൽ ബൈറ്റ് ക്രമം വ്യക്തമാക്കാൻ സാധിക്കും: "ലിറ്റിൽ എൻഡിയൻ" അല്ലെങ്കിൽ "ബിഗ് എൻഡിയൻ" (ബിഗ് എൻഡിയൻ). ഒരു ബഫറിനെ പലതാക്കി വിഭജിക്കാനും നിരവധി ബൈനറി ഡാറ്റ ബഫറുകൾ സംയോജിപ്പിച്ച് ഒരു തത്ഫലമായ ബഫറായി മാറ്റാനും കഴിയും.
ബൈനറി ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ക്ലയന്റ് ആപ്ലിക്കേഷൻ സൈഡിൽ അസിൻക്രണസ് മോഡിൽ നടപ്പിലാക്കുകയാണെങ്കിൽ, ഒരു ബൈനറി ഡാറ്റ ബഫറുമായി പ്രവർത്തിക്കുന്നത് നിർവ്വഹണത്തെ ഗണ്യമായി ലളിതമാക്കും എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഈ സാഹചര്യത്തിൽ, ബഫറിലേക്ക് ഡാറ്റ വായിക്കുന്നത് ഒരു അസിൻക്രണസ് പ്രവർത്തനമായി നടപ്പിലാക്കും, കൂടാതെ ബഫർ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നത് സിൻക്രണസ് ആയിരിക്കും.
ബൈനറി ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ആപ്ലിക്കേഷന്റെ ക്ലയന്റ് ഭാഗത്തും (വെബ് ക്ലയന്റ് ഉൾപ്പെടെ) സെർവർ വശത്തും സിൻക്രണസ്, അസിൻക്രണസ് വർക്ക് സ്കീമുകളിലും ലഭ്യമാണ്. കൂടുതൽ ഉദാഹരണങ്ങൾ ഒരു സിൻക്രണസ് വർക്ക് സ്കീം ഉപയോഗിക്കും.

16.3.2. ബൈനറി ഡാറ്റ വായിക്കുന്നു

ബൈനറി ഡാറ്റ വായിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണമായി, കൂടുതൽ ഉപയോഗത്തിനായി സിസ്റ്റത്തിൽ തിരഞ്ഞെടുത്ത ശരിയായ ഫയൽ ഫോർമാറ്റ് നിർണ്ണയിക്കുന്നതിനുള്ള ചുമതല ഞങ്ങൾ പരിഗണിക്കും. പരിശോധിക്കുന്ന ഫയലായി ഓഡിയോ ഡാറ്റയുള്ള ഒരു .wav ഫയൽ ഉപയോഗിക്കും. .wav ഫയലുകൾ സംഭരിക്കുന്നതിന്, റിസോഴ്സ് ഇന്റർചേഞ്ച് ഫയൽ ഫോർമാറ്റ് (RIFF) ഉപയോഗിക്കുന്നു, അതിന്റെ ഒരു വിവരണം ലിങ്കിൽ നൽകിയിരിക്കുന്നു:

https://msdn.microsoft.com/enus/library/windows/desktop/ee415713.aspx (ഇംഗ്ലീഷിൽ). വായനാ ഉദാഹരണത്തിനായി ഇനിപ്പറയുന്ന ഫോർമാറ്റ് വിവരങ്ങൾ ഉപയോഗിക്കും:
1. ഫയലിന്റെ ആദ്യ 4 ബൈറ്റുകളിൽ ഫോർമാറ്റ് ഐഡന്റിഫയർ അടങ്ങിയിരിക്കുന്നു: RIFF.
2. അടുത്ത 4 ബൈറ്റുകളിൽ യഥാർത്ഥ ഓഡിയോ ഡാറ്റയുടെ വലിപ്പം ലിറ്റിൽ-എൻഡിയൻ ബൈറ്റ് ക്രമത്തിൽ അടങ്ങിയിരിക്കുന്നു.
3. അടുത്ത 4 ബൈറ്റുകളിൽ ഉപയോഗിച്ച വാചക തരം ഡാറ്റ അടങ്ങിയിരിക്കുന്നു: WAVE.
ഈ പ്രവർത്തനങ്ങൾ നടത്താൻ നിങ്ങൾക്ക് അന്തർനിർമ്മിത ഭാഷയിൽ ഇനിപ്പറയുന്ന കോഡ് ആവശ്യമാണ്:

വായിക്കുക = പുതിയത് ReadData(ഫയൽ നാമം, ByteEndian.LittleEndian);
ഫയൽ ഫോർമാറ്റ് = Read.ReadCharacters(4);
DataSize = Read.ReadInteger32();
FileType = Read.ReadCharacters(4);
ഫയൽ ഫോർമാറ്റ് ആണെങ്കിൽ<>"RIFF" പിന്നെ
റിപ്പോർട്ട് ("ഇതൊരു RIFF ഫയൽ അല്ല");
മടക്കം ;
EndIf ;
FileType = “WAVE” ആണെങ്കിൽ
റിപ്പോർട്ട് (“ഇത് ഡാറ്റ, വലുപ്പം ” + ഡാറ്റാസൈസ് + ”ബൈറ്റുകൾ” ഉള്ള ഒരു WAV ഫയലാണ്);
അല്ലെങ്കിൽ
റിപ്പോർട്ട് ("ഇതൊരു WAV ഫയൽ അല്ല");
മടങ്ങുക;
അവസാനം എങ്കിൽ;

ഉദാഹരണം കൂടുതൽ വിശദമായി നോക്കാം.
ആദ്യം, ഫയൽ നെയിം വേരിയബിളിൽ പേര് അടങ്ങിയിരിക്കുന്ന ഫയൽ തുറക്കുന്നു, ഫയൽ വായിക്കാൻ തുറക്കുന്നു ( FileOpenMode.Open), ഫയലിൽ നിന്ന് മാത്രമേ വായിക്കൂ ( ഫയൽ ആക്സസ്.വായിക്കുക) കൂടാതെ വായനയ്ക്കായി 16-ബൈറ്റ് ബഫർ ഉപയോഗിക്കും.
തുടർന്ന് ഡാറ്റ റീഡുചെയ്യുന്നതിനായി ഒരു സ്ട്രീം ജനറേറ്റുചെയ്യുന്നു, അത് നമ്പർ തരത്തിന്റെ ഡാറ്റയ്ക്ക് ഏറ്റവും കുറഞ്ഞ പ്രാധാന്യമുള്ള ബൈറ്റ് ക്രമം ഉണ്ടായിരിക്കും. ഫലമായുണ്ടാകുന്ന സ്ട്രീമിൽ നിന്ന് 4 പ്രതീകങ്ങളും ഒരു 32-ബിറ്റ് പൂർണ്ണസംഖ്യയും 4 പ്രതീകങ്ങളും കൂടി വായിക്കുന്നു. തത്ഫലമായുണ്ടാകുന്ന ഡാറ്റ വിശകലനം ചെയ്യുകയും വിശകലനത്തിന്റെ ഫലങ്ങളെ അടിസ്ഥാനമാക്കി, തിരഞ്ഞെടുത്ത ഫയൽ .wav ഫയലാണോ അല്ലയോ എന്ന് തീരുമാനിക്കുകയും ചെയ്യുന്നു.

16.3.3. ബൈനറി ഡാറ്റ എഴുതുന്നു

ഒരു ഫയലിലേക്ക് ബൈനറി ഡാറ്റ എഴുതുന്നത്, ലളിതമായ സാഹചര്യത്തിൽ, ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യുന്നു:

പ്രവേശനം = പുതിയത് WriteData(ഫയലിന്റെ പേര്);
സൂചികയ്ക്ക് = 0 മുതൽ 255 വരെ സൈക്കിൾ
Write.WriteByte(ഇൻഡക്സ്);
എൻഡ് സൈക്കിൾ;
Record.Close() ;

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

16.3.4. ഒരു ബൈനറി ഡാറ്റ ബഫറുമായി പ്രവർത്തിക്കുന്നു

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ബൈനറി ഡാറ്റ ബഫർ ബൈനറി ഡാറ്റയുടെ ശകലങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള സൗകര്യപ്രദമായ മാർഗം നൽകുന്നു.
ഡാറ്റ വായിക്കുന്നത് മാത്രമല്ല, എഴുത്തും പിന്തുണയ്ക്കുന്നു.
ഒരു ഉദാഹരണമായി, ഡാറ്റ റീഡിംഗ് ഉദാഹരണത്തിൽ നിന്ന് RIFF ഫയൽ ഹെഡർ പാഴ്‌സ് ചെയ്യുന്നത് ഞങ്ങൾ പരിഗണിക്കും (ഇവിടെ കാണുക). ഉദാഹരണം നിർമ്മിക്കുന്നതിന്, ഫയൽ ഫോർമാറ്റിനെക്കുറിച്ചുള്ള അതേ വിവരങ്ങൾ ഉപയോഗിക്കും. അതിനാൽ, സോഴ്സ് ഫയലിൽ നിന്ന് ഫയൽ ഹെഡറിന്റെ വലുപ്പമുള്ള ഒരു ബഫർ വായിക്കേണ്ടത് ആവശ്യമാണ്. തലക്കെട്ടിൽ മൂന്ന് 4-ബൈറ്റ് ഫീൽഡുകൾ അടങ്ങിയിരിക്കുന്നു. അങ്ങനെ, 12 ബൈറ്റുകൾ വായിക്കേണ്ടതുണ്ട്.

ബഫർ = പുതിയത് ബഫർബൈനറി ഡാറ്റ(12);
ഫയൽ = FileStreams.ഓപ്പൺ(താത്കാലിക ഫയലുകൾ ഡയറക്ടറി() + “Windows Logon.wav”, FileOpenMode.Open, ഫയൽ ആക്സസ്.വായിക്കുക);
File.Read(ബഫർ, 0, 12);
വലിപ്പം = ബഫർ.ReadInteger32(4);
StreamString = newStreamInMemory(Buffer);
StreamRows.Go(0, PositionInStream.Start);

ഫയൽ ഫോർമാറ്റ് = ReadLines.ReadCharacters(4, "വിൻഡോസ്-1251");
റീഡ്‌ലൈനുകൾ.അടയ്ക്കുക();
StreamRows.Go(8, PositionInStream.Start);
RowReader = പുതിയ DataReader(RowStream);
ഫയൽ തരം = ReadLines.ReadCharacters( 4, "വിൻഡോസ്-1251");
റീഡ്‌ലൈനുകൾ.അടയ്ക്കുക();

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

16.3.5. ഉപയോഗത്തിന്റെ സവിശേഷതകൾ

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

ഫംഗ്ഷൻ സ്‌ട്രിംഗിൽ നിന്ന് ബൈനറി ഡാറ്റ നേടുക(മൂല്യം StrParameter, മൂല്യ എൻകോഡിംഗ് = "UTF-8")
MemoryThread = NewMemoryThread;
എഴുത്തുകാരൻ = പുതിയത് WriteData(StreamMemory);
എഴുത്തുകാരൻ. സ്ട്രിംഗ് എഴുതുക(StrParameter, എൻകോഡിംഗ്);
എഴുത്തുകാരൻ.അടുത്തു();
തിരികെ StreamMemory.CloseAndGetBinaryData();
എൻഡ്ഫംഗ്ഷൻ

ഫംഗ്‌ഷന്റെ ഫലമായി ലഭിക്കുന്ന ബൈനറിഡാറ്റ ഒബ്‌ജക്റ്റിലെ Size() ഫംഗ്‌ഷനെ വിളിക്കുന്നതിലൂടെ ബൈറ്റുകളിലെ യഥാർത്ഥ വലുപ്പം ലഭിക്കും.
വസ്തുക്കളുടെ ഒരേസമയം ഉപയോഗിക്കുന്നത് ശുപാർശ ചെയ്യുന്നില്ല ഡാറ്റ വായിക്കുക/ഡാറ്റ എഴുതുകസ്ട്രീം ഒബ്ജക്റ്റുകളും. ReadData-യിൽ നിന്നുള്ള തുടർച്ചയായ രണ്ട് റീഡിംഗ് ഓപ്പറേഷനുകൾക്കിടയിലോ അല്ലെങ്കിൽ WriteData-ലേക്കുള്ള തുടർച്ചയായ രണ്ട് റൈറ്റ് ഓപ്പറേഷനുകൾക്കിടയിലോ Ch ഒബ്ജക്റ്റുകൾ പ്രവർത്തിക്കുന്ന സ്ട്രീമിലെ സ്ഥാനത്ത് മാറ്റമുണ്ടായാൽ ഷാഡോഡാറ്റ/റൈറ്റ്ഡാറ്റ- ഒരു അപവാദം സൃഷ്ടിക്കപ്പെടുന്നു. അതിനാൽ, ഒരു സ്ട്രീമിലേക്ക് ഡാറ്റ എഴുതുമ്പോൾ ഒരു സ്ട്രീമിലെ സ്ഥാനത്തിന്റെ ശരിയായ മാറ്റം ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു:

സ്ട്രീം = newStreamInMemory();

WriteData.WriteString("ഹലോ വേൾഡ്!");
WriteData.Close();
Stream.Go (0, PositionInStream.Start);
DataWrite = newDataWrite(Stream);
WriteData.WriteString("ബൈ!");
WriteData.Close();
ഒരു അപവാദം എറിയപ്പെടുന്നതിന് ഇനിപ്പറയുന്ന ഉദാഹരണം ഹായ്:

സ്ട്രീം = NewStreamInMemory();

WriteData.WriteString("ഹലോ, വേൾഡ്!");
Stream.Go(0, PositionInStream.Start);
// അടുത്ത വരി ഒരു അപവാദം ഇടും
WriteData.WriteString("ബൈ!");
അതേ സമയം, സിസ്റ്റം സ്വഭാവം തെറ്റാകുമ്പോൾ സാഹചര്യങ്ങൾ സാധ്യമാണ്, പക്ഷേ പിശകുകളൊന്നും ഉണ്ടാകില്ല:

സ്ട്രീം = GetStream();
ReadData = പുതിയ ReadData(സ്ട്രീം);
TestString = ReadData.Read();
InitialPosition = Stream.CurrentPosition();
DataWrite = newDataWrite(Stream);
WriteData.WriteString ("അപ്രതീക്ഷിതമായ സ്ട്രിംഗ്");
WriteData.Close();
Stream.Go(InitialPosition, PositionInStream.Start);
// പൊതുവേ, TestString2 വേരിയബിളിൽ എന്ത് മൂല്യം സ്ഥാപിക്കുമെന്ന് നിർണ്ണയിക്കുന്നത് അസാധ്യമാണ്
TestLine2 = ReadData.ReadLine();

ഈ വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്ന പെരുമാറ്റം കാരണമാണ് o ഡാറ്റ റീഡർ/ഡാറ്റ റൈറ്റർ ഒബ്‌ജക്റ്റുകൾ ഒരു സ്ട്രീമിൽ പ്രവർത്തിക്കുമ്പോൾ സ്വന്തം ബഫറുകൾ ഉപയോഗിക്കുന്നു. തൽഫലമായി, ത്രെഡിന്റെ യഥാർത്ഥ സ്ഥാനം ലോജിക്കൽ സ്ഥാനത്ത് നിന്ന് വ്യത്യസ്തമാണ്, ഇത് പൂർത്തിയാക്കിയ പ്രവർത്തനങ്ങളുടെ ഫലമായി രൂപം കൊള്ളുന്നു.
കൂടാതെ, ഡാറ്റ റീഡറിന്റെയും ഡാറ്റാ റൈറ്റർ ഒബ്‌ജക്റ്റുകളുടെയും ഒരേസമയം ഉപയോഗിക്കുന്നത്, അവയുടെ പ്രവർത്തനത്തിനായി ഒരു ത്രെഡ് ഉപയോഗിക്കുന്നതിനെ പിന്തുണയ്‌ക്കുന്നില്ല.