अंतर: फोरट्रान और सी #

जैसा कि आप जानते हैं, दुनिया में विरासत कोड की लाखों और लाखों लाइनें हैं। लिगेसी में पहला स्थान, बेशक, कोबोल का है, लेकिन फोरट्रान को भी बहुत कुछ मिला। इसके अलावा, मुख्य रूप से कंप्यूटिंग मॉड्यूल।

बहुत पहले नहीं, उन्होंने मुझे "उदाहरण के लिए, ग्राफिक्स और इंटरफ़ेस के लिए कुछ सुंदर करने" के कार्य के साथ एक छोटा कार्यक्रम (1000 से कम लाइनें, एक चौथाई से अधिक टिप्पणियां और रिक्त लाइनें) लाया। यद्यपि यह कार्यक्रम छोटा है, फिर भी मैं इसे फिर से नहीं करना चाहता - मेरे चाचा ध्यान से दो और महीनों के लिए समायोजन करेंगे।

कोड के कई टुकड़ों और एक पाठ कार के रूप में काम के परिणाम सावधानीपूर्वक कट के नीचे निर्धारित किए गए हैं।

समस्या का बयान

फोरट्रान पर एक कार्यक्रम है जो कुछ मायने रखता है। कार्य: इसे कम करने के लिए, अधिमानतः - काम के तर्क में शामिल किए बिना - और इनपुट मापदंडों को एक अलग मॉड्यूल में डाल दिया, साथ ही परिणामों का आउटपुट भी।

ऐसा करने के लिए, हमें यह जानने की जरूरत है कि निम्नलिखित चीजें कैसे करें:

• फोरलेन पर संकलन;
• dll से निर्यात की गई विधियाँ खोजें;
• निम्न प्रकार के मापदंडों को पास करें:
  • परमाणु ( int , double );
  • स्ट्रिंग ( string );
  • कॉलबैक ( Action<> );
  • सरणियाँ ( double[] );
• प्रबंधित वातावरण से कॉल विधि (हमारे मामले में, C #)।

हम सी # में फ्रंट-एंड करेंगे - सबसे पहले, डब्ल्यूपीएफ के कारण, अच्छी तरह से, क्रॉस-प्लेटफॉर्म आवश्यक नहीं है।

पर्यावरण

शुरू करने के लिए, पर्यावरण तैयार करें।

एक संकलक के रूप में, मैंने जीसीसी पैकेज से गैफरान का उपयोग किया (आप इसे यहां से प्राप्त कर सकते हैं )। ग्नू मेक हमारे लिए भी उपयोगी है (यह पास में स्थित है )। आप स्रोत कोड संपादक के रूप में कुछ भी उपयोग कर सकते हैं; मैंने ग्रहण को Photran plugin के साथ रखा।

ग्रहण पर प्लग-इन स्थापित करना मेनू आइटम "सहायता" / "नया सॉफ़्टवेयर स्थापित करें ..." के माध्यम से बेस जूनो रिपॉजिटरी (फ़िल्टर में फोटान दर्ज करें) के माध्यम से मानक रिपॉजिटरी से किया जाता है।

सभी सॉफ़्टवेयर को स्थापित करने के बाद, आपको पथ को गार्टरन में पंजीकृत करने और मानक पथ में बायनेरिज़ बनाने की आवश्यकता है।

सभी कार्यक्रम पुरानी फोरट्रान बोली में लिखे गए हैं, अर्थात, उन्हें प्रत्येक पंक्ति की शुरुआत में 6 रिक्त स्थान के अनिवार्य इंडेंट की आवश्यकता होती है। लाइनें 72 परिचितों तक सीमित हैं। फ़ाइल एक्सटेंशन के लिए है ऐसा नहीं है कि मैं इतना पुराना स्कूल हूं और कट्टर हूं, लेकिन हमारे पास जो है वह उसी के साथ काम कर रहा है।

सी # के साथ, सब कुछ स्पष्ट है - स्टूडियो। मैंने VS2010 में काम किया।

पहला कार्यक्रम

फोरट्रान

आरंभ करने के लिए, चलो एक सरल फोरट्रान कार्यक्रम बनाते हैं।

  module test contains subroutine hello() print *, "Hello, world" end subroutine end module test program test_main use test call hello() end program 

हम विवरणों को अलग नहीं करेंगे, हम यहां फोरट्रान नहीं सिखा रहे हैं, लेकिन मैं संक्षेप में उन क्षणों को कवर करूंगा जो हम मुठभेड़ करेंगे।

सबसे पहले, मॉड्यूल। आप उन्हें कर सकते हैं, आप उन्हें नहीं कर सकते। परीक्षण परियोजना में मैंने मॉड्यूल का उपयोग किया, इससे निर्यात विधियों के नाम प्रभावित हुए। मुकाबला मिशन में, सब कुछ एक टुकड़े में लिखा गया है, और वहां कोई मॉड्यूल नहीं हैं। संक्षेप में, यह इस बात पर निर्भर करता है कि विरासत के रूप में आपके पास क्या आया था।

दूसरे, फोरट्रान सिंटेक्स ऐसा है कि इसमें रिक्त स्थान वैकल्पिक हैं। आप endif लिख सकते हैं, आप end if लिख सकते हैं end if । आप do 1 i = 1, 10 कर सकते हैं, लेकिन आप मानवीय रूप से कर सकते हैं - do 1 i = 1, 10 । तो यह सिर्फ गलतियों का भंडार है। आधे घंटे के लिए मैं देख रहा था कि लाइन क्यों है

  callback() 

त्रुटि " _back() वर्ण नहीं मिली", जब तक मुझे _back() चल गया कि क्या लिखना है

  call callback() 

इसलिए सावधान रहें।

तीसरे, एफ 90 और एफ 95 की बोलियों को लाइनों की शुरुआत में इंडेंटेशन की आवश्यकता नहीं है। यहां, फिर से, सब कुछ इस बात पर निर्भर करता है कि आपके पास क्या आया है।

लेकिन ठीक है, वापस कार्यक्रम में। यह या तो ग्रहण से संकलन करता है (यदि मेकफाइल सही तरीके से कॉन्फ़िगर किया गया है), या कमांड लाइन से। आरंभ करने के लिए, कमांड लाइन से काम करते हैं:

 > gfortran -o bin\test.exe src\test.for 

लॉन्च की गई एक्स-फाइल को क) को फोरट्रान से रन-टाइम डीएल की आवश्यकता होगी, और बी) स्ट्रिंग "हैलो, वर्ल्ड" प्रदर्शित करेगा।

एक exe पाने के लिए जिसे रनटाइम की आवश्यकता नहीं है, संकलन को -static स्विच के साथ किया जाना चाहिए:

 > gfortran -static -o bin\test.exe src\test.for 

Dll प्राप्त करने के लिए, आपको एक और-कुंजी जोड़ने की आवश्यकता है:

 > gfortran -static -shared -o bin\test.dll src\test.for 

अभी के लिए, हम फोरट्रान के साथ समाप्त करते हैं और सी # पर चलते हैं।

C #

चलो पूरी तरह से मानक कंसोल एप्लिकेशन बनाते हैं। तुरंत एक और वर्ग जोड़ें - TestWrapper और कुछ कोड लिखें:

  public class TestWrapper { [DllImport("test.dll", EntryPoint = "__test_MOD_hello", CallingConvention = CallingConvention.Cdecl)] public static extern void hello(); } 

प्रक्रिया का प्रवेश बिंदु मानक dumpbin वीएस उपयोगिता का उपयोग करके निर्धारित किया जाता है:

 > dumpbin /exports test.dll 

यह आदेश एक लंबा डंप देता है जिसमें आप हमारे लिए ब्याज की लाइनें पा सकते हैं:

  3 2 000018CC __test_MOD_hello 

आप या तो grep साथ खोज कर सकते हैं, या किसी फाइल में dumpbin आउटपुट डंप कर सकते हैं, और इसके माध्यम से जा सकते हैं। मुख्य बात - हमने प्रवेश बिंदु का प्रतीकात्मक नाम देखा, जिसे हमारे कॉल में रखा जा सकता है।

आगे यह आसान है। मुख्य मॉड्यूल Program.cs में हम एक कॉल करते हैं:

  static void Main(string[] args) { TestWrapper.hello(); } 

कंसोल एप्लिकेशन को लॉन्च करके, आप फोरट्रान के माध्यम से प्रदर्शित हमारी लाइन "हैलो, दुनिया" देख सकते हैं। बेशक, हमें फोरट्रान में संकलित test.dll को bin/Debug (या bin/Release ) bin/Release रखना नहीं भूलना चाहिए।

परमाणु मापदंडों

लेकिन यह सभी निर्बाध, दिलचस्प है - वहां डेटा स्थानांतरित करने और कुछ वापस पाने के लिए। इसके लिए, हम दूसरी पुनरावृत्ति करेंगे। उदाहरण के लिए, एक प्रक्रिया जो पहले पैरामीटर में नंबर 1 को जोड़ती है, और दूसरे पैरामीटर को परिणाम पास करती है।

फोरट्रान

यह प्रक्रिया अपमानजनक है:

  subroutine add_one(inVal, retVal) integer, intent(in) :: inVal integer, intent(out) :: retVal retVal = inVal + 1 end subroutine 

फोरट्रान में, कॉल कुछ इस तरह दिखता है:

  integer :: inVal, retVal inVal = 10 call add_one(inVal, retVal) print *, inVal, ' + 1 equals ', retVal 

अब हमें इस कोड को संकलित करने और परीक्षण करने की आवश्यकता है। सामान्य तौर पर, आप कंसोल से संकलित करना जारी रख सकते हैं, लेकिन हमारे पास एक मेफाइल है। इसे व्यापार से जोड़ते हैं।

चूँकि हम exe करते हैं (परीक्षण के लिए) और dll ("उत्पादन संस्करण" के लिए), यह ऑब्जेक्ट कोड में पहले संकलित करने के लिए समझ में आता है, और फिर dll / exe का निर्माण करता है। ऐसा करने के लिए, ग्रहण में मेकफाइल खोलें और आत्मा में कुछ लिखें:

 FORTRAN_COMPILER = gfortran all: src\test.for $(FORTRAN_COMPILER) -O2 \ -c -o obj\test.obj \ src\test.for $(FORTRAN_COMPILER) -static \ -o bin\test.exe \ obj\test.obj $(FORTRAN_COMPILER) -static -shared \ -o bin\test.dll \ obj\test.obj clean: del /Q bin\*.* obj\*.* *.mod 

अब हम ग्रहण से एक बटन का उपयोग करके परियोजना को मानवीय रूप से संकलित और साफ कर सकते हैं। लेकिन इसके लिए आवश्यक है कि पर्यावरण चर में स्थापित करने का मार्ग।

C #

लाइन में अगला C # में हमारे शेल का शोधन है। सबसे पहले, हम परियोजना में dll से एक और विधि आयात करते हैं:

  [DllImport("test.dll", EntryPoint = "__test_MOD_add_one", CallingConvention = CallingConvention.Cdecl)] public static extern void add_one(ref int i, out int r); 

प्रवेश बिंदु dumpbin माध्यम से पहले की तरह निर्धारित किया जाता है। चूंकि हमारे पास चर हैं, इसलिए हमें एक कॉलिंग cdecl (इस मामले में, cdecl ) को निर्दिष्ट करने की आवश्यकता है। चर संदर्भ द्वारा पारित किए जाते हैं, इसलिए ref आवश्यकता होती है। अगर हम ref छोड़ देते हैं, तो जब हम कॉल करते हैं, तो हमें AV मिलता है: "अनहेल्दी अपवाद: System.AccessViolationException : संरक्षित मेमोरी में पढ़ने या लिखने का प्रयास किया गया। यह अक्सर इंगित करता है कि एक और स्मृति भ्रष्ट है। "

मुख्य कार्यक्रम में, निम्नलिखित कुछ लिखें:

  int inVal = 10; int outVal; TestWrapper.add_one(ref inVal, out outVal); Console.WriteLine("{0} add_one equals {1}", inVal, outVal); 

सामान्य तौर पर, सब कुछ, समस्या हल हो जाती है। यदि यह एक "लेकिन" के लिए नहीं था - फिर से, आपको फोरट्रान फ़ोल्डर से test.dll को कॉपी करने की आवश्यकता है। प्रक्रिया यांत्रिक है, इसे स्वचालित करने के लिए आवश्यक होगा। ऐसा करने के लिए, प्रोजेक्ट पर राइट-क्लिक करें, "गुण", "बिल्ड इवेंट्स" टैब का चयन करें, और निर्माण से पहले "कमांड कमांड ऑफ़ द इवेंट" स्पिरिट में कुछ लिखें।

 make -C $(SolutionDir)..\Test.for clean make -C $(SolutionDir)..\Test.for all copy $(SolutionDir)..\Test.for\bin\test.dll $(TargetDir)\test.dll 

बेशक, हमें अपने रास्ते खुद ही बदलने चाहिए।

कुल मिलाकर, संकलन और लॉन्च के बाद, अगर सब कुछ ठीक हो गया, तो हमें दूसरे संस्करण का काम करने का कार्यक्रम मिलेगा।

पंक्तियां

मान लीजिए कि लिखित पैरामीटर के प्रारंभिक dll मॉड्यूल को पास करने के लिए लिखित कोड हम पर्याप्त होंगे। लेकिन अक्सर आपको एक तरह से या किसी अन्य के अंदर एक स्ट्रिंग फेंकने की आवश्यकता होती है। एक घात है जो मुझे समझ में नहीं आया - एन्कोडिंग। इसलिए, मेरे सभी उदाहरण लैटिन वर्णमाला के लिए दिए गए हैं।

फोरट्रान

यहां सब कुछ सरल है (अच्छी तरह से, कट्टर श्रमिकों के लिए):

  subroutine progress(text, l) character*(l), intent(in) :: text integer, intent(in) :: l print *, 'progress: ', text end subroutine 

अगर हमने डीएलआर और अन्य इंटरऑपरेबिलिटी के बिना इंट्रा-फोरट्रान विधि लिखी, तो लंबाई प्रेषित नहीं की जा सकती थी। और चूंकि हमें मॉड्यूल के बीच डेटा स्थानांतरित करने की आवश्यकता है, इसलिए हमें दो चर, एक स्ट्रिंग के लिए एक संकेतक और इसकी लंबाई के साथ काम करना होगा।

एक विधि को कॉल करना भी सरल है:

  character(50) :: strVal strVal = "hello, world" call progress(strVal, len(trim(strVal))) 

len(trim()) को अंत में ट्रिम स्पेस के लिए निर्दिष्ट किया जाता है (क्योंकि 50 अक्षर प्रति पंक्ति आवंटित किए जाते हैं, और केवल 12 का उपयोग किया जाता है)।

C #

अब आपको C # से इस विधि को कॉल करने की आवश्यकता है। इसके लिए, हम TestWrapper को अंतिम रूप TestWrapper :

  [DllImport("test.dll", EntryPoint = "__test_MOD_progress", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] public static extern void progress([MarshalAs(UnmanagedType.LPStr)]string txt, ref int strl); 

एक और आयात विकल्प यहां जोड़ा गया है - CharSet द्वारा उपयोग किया जाता है। एक निर्देश भी संकलक को गुजरने के लिए दिखाई देता है - MarshalAs ।

एक ही समय में कॉल संदर्भ के द्वारा सभी मापदंडों को पारित करने की आवश्यकता के कारण क्रियात्मकता के अपवाद के साथ, गंभीर दिखाई देता है ( ref ):

  var str = "hello from c#"; var strLen = str.Length; TestWrapper.progress(str, ref strLen); 

कॉलबैक

हम सबसे दिलचस्प बात पर आए - कॉलबैक, या एक dll के अंदर गुजरने वाले तरीकों को ट्रैक करने के लिए कि क्या हो रहा है।

फोरट्रान

शुरू करने के लिए, हम एक पैरामीटर के रूप में कार्य करने वाले वास्तविक तरीके को लिखेंगे। फोरट्रान में, यह कुछ इस तरह दिखता है:

  subroutine run(fnc, times) integer, intent(in) :: times integer :: i character(20) :: str, temp, cs interface subroutine fnc(text, l) character(l), intent(in) :: text integer, intent(in) :: l end subroutine end interface temp = 'iter: ' do i = 1, times write(str, '(i10)') i call fnc(trim(temp)//trim(str), len(trim(temp)//trim(str))) end do end subroutine end module test 

यहां हमें हस्तांतरित विधि के प्रोटोटाइप का वर्णन करने वाले interface के नए अनुभाग पर ध्यान देना चाहिए। निष्पक्ष रूप से क्रिया, लेकिन, सामान्य तौर पर, कुछ भी नया नहीं है।

इस विधि का आह्वान बिलकुल सामान्य है:

  call run(progress, 10) 

नतीजतन, पिछले पुनरावृत्ति में लिखी गई progress विधि को 10 बार कहा जाएगा।

C #

C # पर जाएं। यहां हमें अतिरिक्त कार्य करने की आवश्यकता है - सही विशेषता के साथ TestWrapper वर्ग में एक प्रतिनिधि घोषित करें:

  [UnmanagedFunctionPointer(CallingConvention.Cdecl)] public delegate void Progress(string txt, ref int strl); 

उसके बाद, आप run विधि के प्रोटोटाइप को परिभाषित कर सकते हैं जिसे कहा जा रहा है:

  [DllImport("test.dll", EntryPoint = "__test_MOD_run", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] public static extern void run(Progress w, ref int times); 

प्रवेश बिंदु पारंपरिक रूप से dumpbin से निर्धारित होता है; बाकी भी हमसे परिचित है।

इस विधि को कॉल करना भी सीधा है। आप या तो देशी फोरट्रान विधि (जैसे कि TestWrapper.progress , अंतिम पुनरावृत्ति में वर्णित), या सी # लैम्ब्डा पास कर सकते हैं:

  int rpt = 5; TestWrapper.run(TestWrapper.progress, ref rpt); TestWrapper.run((string _txt, ref int _strl) => { var inner = _txt.Substring(0, _strl); Console.WriteLine("Hello from c#: {0}", inner); }, ref rpt); 

इसलिए, हमारे पास पहले से ही इस तरह से कोड को फिर से करने के लिए पर्याप्त उपकरण हैं, ताकि कैपेसिटिव ऑपरेशन की प्रगति को प्रदर्शित करने के लिए विधि के अंदर कॉलबैक पास किया जा सके। केवल एक चीज जिसे हम अभी तक नहीं जानते हैं वह है सरणियाँ पास करना।

सरणियों

उनके साथ तार की तुलना में थोड़ा अधिक जटिल है। यदि स्ट्रिंग के लिए कुछ विशेषताओं को लिखना पर्याप्त है, तो सरणियों के लिए आपको पेन के साथ थोड़ा काम करना होगा।

फोरट्रान

शुरू करने के लिए, हम एक सरणी को प्रिंट करने की प्रक्रिया लिखेंगे, जिसमें एक स्ट्रिंग स्थानांतरण के रूप में भविष्य के लिए एक छोटा रिजर्व होगा:

  subroutine print_arr(str, strL, arr, arrL) integer, intent(in) :: strL, arrL character(strL), intent(in) :: str real*8, intent(in) :: arr(arrL) integer :: i print *, str do i = 1, arrL print *, i, " elem: ", arr(i) end do end subroutine 

double (या real डबल परिशुद्धता) की एक सरणी घोषणा को जोड़ा जाता है, और इसके आकार को भी प्रसारित किया जाता है।
फोरट्रान से एक कॉल भी आम है:

  character(50) :: strVal real*8 :: arr(4) strVal = "hello, world" arr = (/1.0, 3.14159265, 2.718281828, 8.539734222/) call print_arr(strVal, len(trim(strVal)), arr, size(arr)) 

आउटपुट एक मुद्रित स्ट्रिंग और एक सरणी है।

C #

TestWrapper बारे TestWrapper कुछ खास नहीं है:

  [DllImport("test.dll", EntryPoint = "__test_MOD_print_arr", CallingConvention = CallingConvention.Cdecl)] public static extern void print_arr(string titles, ref int titlesl, IntPtr values, ref int qnt); 

लेकिन प्रोग्राम के अंदर आपको थोड़ा काम करना होगा और असेंबली System.Runtime.InteropServices उपयोग करना होगा।

  var s = "abcd"; var sLen = s.Length; var arr = new double[] { 1.01, 2.12, 3.23, 4.34 }; var arrLen = arr.Length; var size = Marshal.SizeOf(arr[0]) * arrLen; var pntr = Marshal.AllocHGlobal(size); Marshal.Copy(arr, 0, pntr, arr.Length); TestWrapper.print_arr(s, ref sLen, pntr, ref arrLen); 

यह इस तथ्य के कारण है कि सरणी के लिए एक सूचक को फोरट्रान कार्यक्रम के अंदर पारित किया जाना चाहिए, अर्थात प्रबंधित क्षेत्र से अप्रबंधित क्षेत्र के डेटा की प्रतिलिपि बनाना आवश्यक है, और, तदनुसार, इसमें मेमोरी आवंटित की जाती है। इस संबंध में, यह इस तरह से गोले लिखने के लिए समझ में आता है:

  public static void PrintArr(string _titles, double[] _values) { var titlesLen = _titles.Length; var arrLen = _values.Length; var size = Marshal.SizeOf(_values[0]) * arrLen; var pntr = Marshal.AllocHGlobal(size); Marshal.Copy(_values, 0, pntr, _values.Length); TestWrapper.print_arr(_titles, ref titlesLen, pntr, ref arrLen); } 

यह सब एक साथ रखना

सभी पुनरावृत्तियों का पूर्ण स्रोत कोड (और एक कॉलबैक फ़ंक्शन के लिए एक सरणी को स्थानांतरित करने के रूप में थोड़ा अधिक बोनस) बिटपकेट (एचजी) पर भंडार में हैं। यदि किसी के पास कोई जोड़ है - तो आपका टिप्पणी में स्वागत है।

परंपरागत रूप से, मैं हर किसी को धन्यवाद देता हूं जो अंत तक पढ़ता है, क्योंकि बहुत कुछ पाठ निकला।