माप की इकाइयों तक पहुंचने के लिए डेटा संरचना

17

टीएल; डीआर - मैं माप की एक इकाई के भीतर इकाइयों को परिभाषित करने के लिए एक इष्टतम डेटा संरचना डिजाइन करने की कोशिश कर रहा हूं।

A Unit of measureअनिवार्य रूप से a value(या मात्रा) a से जुड़ा है unit। SI इकाइयों के सात आधार या आयाम हैं। अर्थात्: लंबाई, द्रव्यमान, समय, विद्युत प्रवाह, तापमान, पदार्थ की मात्रा (मोल्स), और चमकदार तीव्रता।

यह काफी सरल होगा, लेकिन कई व्युत्पन्न इकाइयाँ और दरें भी हैं जिनका हम अक्सर उपयोग करते हैं। एक संयुक्त इकाई न्यूटन होगी: kg * m / s^2और एक उदाहरण दर होगी tons / hr।

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

कोडप्लेक्स और अन्य सहयोगी वातावरण पर कई समाधान हैं। परियोजनाओं के लिए लाइसेंस देने योग्य है, लेकिन परियोजना आमतौर पर बहुत हल्के या बहुत भारी होने के कारण समाप्त हो जाती है। हम "बस सही है" के अपने गेंडा का पीछा कर रहे हैं।

आदर्श रूप में, मैं इस तरह से कुछ का उपयोग करके माप की एक नई इकाई को परिभाषित कर सकता हूं:

UOM myUom1 = नया UOM (10, वोल्ट);
UOM myUom2 = नया UOM (43.2, न्यूटन);

बेशक, हम अपने ग्राहकों की जरूरतों के आधार पर इंपीरियल और एसआई इकाइयों के मिश्रण का उपयोग करते हैं।

हमें भविष्य के डेटाबेस टेबल के साथ इकाइयों की इस संरचना को भी संतुलित रखने की आवश्यकता है ताकि हम अपने डेटा के भीतर भी समान स्थिरता प्रदान कर सकें।

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

मेरी कुछ चिंताओं को दर्शाने वाले उदाहरण:

myUnits.Volt
myUnits.Newton
myUnits.meter

SIUnit.meter
ImpUnit.foot DrvdUnit.Newton
DrvdUnitSI.Newton
DrvdUnitImp.FtLbs

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

मैंने जिन पुस्तकालयों को देखा उनमें से एक में स्ट्रिंग के माध्यम से इकाइयों के मुफ्त-फॉर्म इनपुट की अनुमति है। उनके UOM वर्ग ने तब स्ट्रिंग को पार किया और उसी के अनुसार चीजों को स्लेट किया। इस दृष्टिकोण के साथ चुनौती यह है कि यह डेवलपर को यह सोचने और याद रखने के लिए मजबूर करता है कि सही स्ट्रिंग प्रारूप क्या हैं। और मैं रनटाइम त्रुटि / अपवाद के जोखिम को चलाता है अगर हम कंस्ट्रक्टर में पारित होने वाले तार को मान्य करने के लिए कोड के भीतर अतिरिक्त चेक नहीं जोड़ते हैं।

एक अन्य पुस्तकालय ने अनिवार्य रूप से बहुत सारे वर्ग बनाए, जिन्हें डेवलपर के साथ काम करना होगा। एक बराबर UOM के साथ-साथ यह एक प्रदान की DerivedUnitऔर RateUnitऔर इतने पर। अनिवार्य रूप से, समस्याओं को हल करने के लिए कोड अत्यधिक जटिल था। वह पुस्तकालय अनिवार्य रूप से किसी भी: किसी भी संयोजन (जो कि इकाइयों की दुनिया में वैध है) को अनुमति देगा, लेकिन हम हर संभव संयोजन की अनुमति नहीं देकर हमारे मुद्दे (हमारे कोड को सरल बनाने) की गुंजाइश के लिए खुश हैं।

अन्य पुस्तकालय हास्यास्पद रूप से सरल थे और उदाहरण के लिए ऑपरेटर को ओवरलोडिंग भी नहीं मानते थे।

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

c# design naming data-structures

क्या आप बता सकते हैं कि जिन पुस्तकालयों में आप अपनी ज़रूरतों के लायक नहीं हैं, उन्हें कैसे समझा जा सकता है?

— svick

1

यह भी देखें stackoverflow.com/q/348853/240613

— आर्सेनी मौरज़ेंको

1

@MainMa - उस लिंक के लिए धन्यवाद। हमें आयामी विश्लेषण करने की आवश्यकता नहीं है क्योंकि हमारी समस्या का स्थान इतना छोटा है कि हम केवल स्वीकृत रूपांतरणों की घोषणा करेंगे। यह उत्पन्न करने के लिए एक नारा होगा लेकिन यह एक बार की लागत है।

1

क्या आप बता सकते हैं कि आपको किस प्रकार के रूपांतरणों की आवश्यकता है? क्या यह केवल स्केलिंग रूपांतरण (जैसे मीटर से सेंटीमीटर) या क्रॉस-डायमेंशनल रूपांतरण (जैसे बल के लिए द्रव्यमान) है?

— बार्ट वैन इनगेन शेनॉ

1

क्या आपने F # के कोड का मूविंग पार्ट माना है? उस भाषा की माप बिल्ड इंट की इकाइयाँ हैं।

— पीट

11

C ++ के लिए बूस्ट पुस्तकालयों में आयामी विश्लेषण पर एक लेख शामिल है जो माप की हैंडलिंग इकाइयों का एक नमूना कार्यान्वयन प्रस्तुत करता है।

सारांशित करने के लिए: माप की इकाइयों को वैक्टर के रूप में दर्शाया जाता है, जिसमें वेक्टर का प्रत्येक तत्व एक मौलिक आयाम का प्रतिनिधित्व करता है:

typedef int dimension[7]; // m  l  t  ...
dimension const mass      = {1, 0, 0, 0, 0, 0, 0};
dimension const length    = {0, 1, 0, 0, 0, 0, 0};
dimension const time      = {0, 0, 1, 0, 0, 0, 0};

व्युत्पन्न इकाइयां इनमें से संयोजन हैं। उदाहरण के लिए, बल (द्रव्यमान * दूरी / समय ^ 2) का प्रतिनिधित्व किया जाएगा

dimension const force  = {1, 1, -2, 0, 0, 0, 0};

रूपांतरण कारक जोड़कर इंपीरियल बनाम एसआई इकाइयों को संभाला जा सकता है।

यह कार्यान्वयन C ++ - विशिष्ट तकनीकों (आसानी से अलग-अलग संकलन-प्रकारों में माप की विभिन्न इकाइयों को चालू करने के लिए टेम्पलेट मेटाप्रोग्रामिंग का उपयोग) पर निर्भर करता है, लेकिन अवधारणाओं को अन्य प्रोग्रामिंग भाषाओं में स्थानांतरित करना चाहिए।

— जोश केली
स्रोत

तो सभी व्युत्पन्न इकाइयाँ C ++ संख्‍या के समतुल्य हैं? मुझे लगता है कि वे प्रदूषणकारी चीजों से बचने के लिए एक नाम स्थान पर लिपटे हुए हैं?

1

@ GlenH7 - यह टेम्पलेट मेटाप्रोग्रामिंग सामान में मिलता है। वे वास्तव में अलग-अलग प्रकार (जैसे, mpl::vector_c<int,1,0,0,0,0,0,0>) को कब्ज के बजाय प्रतिनिधित्व करते हैं ; लेख स्पष्टीकरण के माध्यम से पहले दृष्टिकोण प्रस्तुत करता है (और मैं शायद यह अच्छी तरह से समझा नहीं था)। Const का उपयोग करना एक विकल्प के रूप में काम करेगा (आप कुछ संकलन-समय सुरक्षा खो देंगे)। नाम प्रदूषण से बचने के लिए नेमस्पेस का उपयोग करना निश्चित रूप से एक विकल्प है।

— जोश केली

8

मैं तो बस पर Units.NET जारी किया Github और पर NuGet ।

यह आपको सभी सामान्य इकाइयाँ और रूपांतरण देता है। यह लाइट-वेट, यूनिट परीक्षण और पीसीएल का समर्थन करता है।

अपने प्रश्न की ओर:

यह कार्यान्वयन के हल्के अंत पर है। फोकस माप की इकाइयों के अस्पष्ट प्रतिनिधित्व, रूपांतरण और निर्माण में सहायता करना है।
कोई समीकरण सॉल्वर नहीं है, यह गणनाओं से स्वचालित रूप से नई इकाइयों को प्राप्त नहीं करता है।
इकाइयों को परिभाषित करने के लिए एक बड़ी गणना।
इकाइयों के बीच गतिशील रूप से परिवर्तित करने के लिए UnitConverter वर्ग।
इकाइयों के बीच स्पष्ट रूप से परिवर्तित करने के लिए अपरिवर्तनीय डेटा संरचनाएं।
सरल अंकगणित के लिए अतिभारित ऑपरेटर।
नई इकाइयों और रूपांतरणों का विस्तार गतिशील रूपांतरण के लिए एक नई गणना और माप वर्ग की एक इकाई को जोड़ने के लिए है, लंबाई की तरह, स्पष्ट रूपांतरण गुणों और ऑपरेटर ओवरलोडिंग को परिभाषित करने के लिए।

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

स्पष्ट रूपांतरण

Length meter = Length.FromMeters(1);
double cm = meter.Centimeters; // 100
double yards = meter.Yards; // 1.09361
double feet = meter.Feet; // 3.28084
double inches = meter.Inches; // 39.3701

Pressure p = Pressure.FromPascal(1);
double kpa = p.KiloPascals; // 1000
double bar = p.Bars; // 1 × 10-5
double atm = p.Atmosphere; // 9.86923267 × 10-6
double psi = p.Psi; // 1.45037738 × 10-4

गतिशील रूपांतरण

// Explicitly
double m = UnitConverter.Convert(1, Unit.Kilometer, Unit.Meter); // 1000
double mi = UnitConverter.Convert(1, Unit.Kilometer, Unit.Mile); // 0.621371
double yds = UnitConverter.Convert(1, Unit.Meter, Unit.Yard); // 1.09361

// Or implicitly.
UnitValue val = GetUnknownValueAndUnit();

// Returns false if conversion was not possible.
double cm;
val.TryConvert(LengthUnit.Centimeter, out cm);

— angularsen
स्रोत

आपका उदाहरण अनिवार्य रूप से एक का उपयोग करने के लिए लगता हैTruple<T1, T2, T3>(x, y, z)

— Chef_Code

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

— कोणीयसेन

मुझे लगता है कि मुझे याद है और साथ ही निष्कर्ष पर कूद गया ... मेरा मतलब था Tuple। मैं आपकी UnitConverterकक्षा नहीं देख सकता , लेकिन IMO ऐसा प्रतीत होता है कि यह Tupleकक्षा के समान कार्यक्षमता साझा कर सकता है ।

— Chef_Code

अभी भी टपल तुलना के बारे में निश्चित नहीं है, लेकिन उपयोग पर अद्यतन उदाहरणों के लिए जीथब पृष्ठ देखें ।

— कोणीयसेन

3

यदि आप C # का उपयोग करने के बजाय F # पर स्विच करना खींच सकते हैं, तो F # में माप प्रणाली (मूल्यों पर मेटाडेटा का उपयोग करके) की एक इकाई है जो ऐसा दिखता है कि यह फिट होगा जो आप करने की कोशिश कर रहे हैं:

http://en.wikibooks.org/wiki/F_Sharp_Programming/Units_of_Measure

विशेष रूप से:

// Additionally, we can define types measures which are derived from existing measures as well:

[<Measure>] type m                  (* meter *)
[<Measure>] type s                  (* second *)
[<Measure>] type kg                 (* kilogram *)
[<Measure>] type N = (kg * m)/(s^2) (* Newtons *)
[<Measure>] type Pa = N/(m^2)       (* Pascals *)

— पॉल
स्रोत

अच्छा सुझाव है, और हमने इस पर विचार किया है। मेरा मानना है कि एफ # हमें यह नियंत्रित करने की क्षमता देता है कि इकाइयां उत्पादन पर प्रदर्शित होने के बावजूद कैसे समाप्त होती हैं।

2

@ GlenH7 मेरा मानना है कि आप सही हैं:

Important: Units of measure look like a data type, but they aren't. .NET's type system does not support the behaviors that units of measure have, such as being able to square, divide, or raise datatypes to powers. This functionality is provided by the F# static type checker at compile time, **but units are erased from compiled code**. Consequently, it is not possible to determine value's unit at runtime.

— पॉल

3

इस तथ्य के आधार पर कि सभी आवश्यक रूपांतरण रूपांतरण स्केल कर रहे हैं (सिवाय इसके कि आपको तापमान रूपांतरण का समर्थन करना है या नहीं। परिकलन जहां रूपांतरण में एक ऑफसेट बहुत अधिक जटिल होता है), मैं इस तरह से अपने 'माप की इकाई' को डिज़ाइन करूंगा:

unitस्केलिंग फैक्टर वाला एक वर्ग , यूनिट के शाब्दिक प्रतिनिधित्व के लिए एक स्ट्रिंग और एक संदर्भ जो किunit तराजू होता है। शाब्दिक प्रतिनिधित्व प्रदर्शन उद्देश्यों और आधार इकाई के संदर्भ के लिए है कि विभिन्न इकाइयों के साथ मूल्यों पर गणित करते समय किस इकाई का परिणाम है।

प्रत्येक समर्थित इकाई के लिए, unitकक्षा का एक स्थिर उदाहरण प्रदान किया जाता है।
एक वर्ग UOMजिसमें एक मान होता है और एक मान होता है unit। UOMवर्ग को जोड़ने / एक और घटाकर के लिए ऑपरेटरों अतिभारित प्रदान करता है UOMऔर गुणा / एक आयामरहित मूल्य के साथ विभाजित करने के लिए।

यदि जोड़ / घटाव एक UOMही के साथ दो पर किया जाता है unit, तो इसे सीधे किया जाता है। अन्यथा दोनों मानों को उनकी संबंधित आधार इकाइयों में जोड़ा जाता है और जोड़ा / घटाया जाता है। आधार में परिणाम बताया गया है unit।

उपयोग की तरह होगा

unit volts = new unit(1, "V"); // base-unit is self
unit Newtons = new unit(1, "N"); // base-unit is self
unit kiloNewtons = new unit(1000, "kN", Newtons);
//...
UOM myUom1 = new UOM(10, volts);
UOM myUom2 = new UOM(43.2, kiloNewtons);

चूंकि असंगत इकाइयों पर संचालन को एक मुद्दा नहीं माना जाता है, इसलिए मैंने उस संबंध में डिजाइन को सुरक्षित बनाने की कोशिश नहीं की है। यह पुष्टि करना संभव है कि दो इकाइयाँ एक ही आधार इकाई को देखें।

— बार्ट वैन इनगेन शेनौ
स्रोत

चूंकि आपने तापमान का उल्लेख किया है: क्या है 95F - 85F? क्या है 20C - 15C? दोनों उदाहरणों में, दोनों के UOMलिए समान होगा unit। क्या घटाव सीधे प्रदर्शन किया जाएगा?

@MattFenwick: परिणाम क्रमशः 10 Fऔर होगा 5 C। गणना सीधे यदि संभव हो तो प्रदर्शन किया जाता है, ताकि अनावश्यक रूपांतरणों से बचा जा सके। इकाई-रूपांतरण विधियों को जोड़ने के लिए यह काफी तुच्छ होगा UOM, लेकिन सेल्सियस-फ़ारेनहाइट रूपांतरण के लिए, unitवर्ग को स्केलिंग कारक के अलावा ऑफसेट की संभावना के साथ बढ़ाया जाना होगा।

— बार्ट वैन इनगेन शेनॉ

लेकिन 95F - 85F! = 10F।

1

@MattFenwick: कृपया मुझे बताएं। यदि आप का तापमान कम करते हैं तो यह कितना ठंडा होता 95Fहै 85F? मेरी जानकारी के लिए, फ़ारेनहाइट अभी भी एक रेखीय पैमाना है।

— बार्ट वैन इनगेन शेनॉ

2

चलो सेल्सियस उदाहरण देते हैं क्योंकि केल्विन में परिवर्तित करना आसान है: यदि हम कहते हैं 20C - 15C = 5C, तो हम कह रहे हैं 293.15K - 288.15K = 278.15K, जो स्पष्ट रूप से गलत है।

2

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

मैंने कुछ इसी तरह से एक बार किया था, और मेरे कार्यान्वयन में सार आधार कक्षाएं (लंबाई, वजन, आदि) थीं जो सभी लागू हुईं IUnitOfMeasure। प्रत्येक सार आधार वर्ग ने एक डिफ़ॉल्ट प्रकार को परिभाषित किया (वर्ग में कक्षा Lengthका एक डिफ़ॉल्ट कार्यान्वयन था Meter) जो इसे सभी रूपांतरण कार्य के लिए उपयोग करेगा। इसलिए IUnitOfMeasureदो अलग-अलग तरीकों को लागू किया गया, ToDefault(decimal)और FromDefault(decimal)।

मैं जिस वास्तविक संख्या को लपेटना चाहता था, वह एक सामान्य प्रकार था जो IUnitOfMeasureइसके सामान्य तर्क के रूप में स्वीकार करता है। ऐसा कुछ कहना Measurement<Meter>(2.0)आपको स्वचालित प्रकार की सुरक्षा प्रदान करता है। इन वर्गों पर उचित निहित रूपांतरण और गणित के तरीकों को लागू करने से आप चीजों को कर सकते हैं Measurement<Meter>(2.0) * Measurement<Inch>(12)और डिफ़ॉल्ट प्रकार ( Meter) में परिणाम वापस कर सकते हैं । मैंने न्यूटन जैसी व्युत्पन्न इकाइयों पर कभी काम नहीं किया; मैंने उन्हें केवल किग्रा * मीटर / सेकंड / सेकंड के रूप में छोड़ दिया।

— mgw854
स्रोत

मुझे वह तरीका पसंद है जो आप सामान्य प्रकारों के उपयोग के साथ सुझा रहे हैं।

1

मेरा मानना है कि उत्तर मारियोवीडब्ल्यू के ढेर अतिप्रवाह प्रतिक्रिया में निहित है:

प्रैक्टिकल उदाहरण। कहां 4-0 में ट्यूपल का उपयोग किया जा सकता है?

ट्यूपल्स के साथ आप आसानी से एक दो-आयामी शब्दकोश (या उस मामले के लिए एन-आयामी) को लागू कर सकते हैं। उदाहरण के लिए, आप मुद्रा विनिमय मानचित्रण को लागू करने के लिए इस तरह के शब्दकोश का उपयोग कर सकते हैं:

var forex = new Dictionary<Tuple<string, string>, decimal>();
forex.Add(Tuple.Create("USD", "EUR"), 0.74850m); // 1 USD = 0.74850 EUR
forex.Add(Tuple.Create("USD", "GBP"), 0.64128m);
forex.Add(Tuple.Create("EUR", "USD"), 1.33635m);
forex.Add(Tuple.Create("EUR", "GBP"), 0.85677m);
forex.Add(Tuple.Create("GBP", "USD"), 1.55938m);
forex.Add(Tuple.Create("GBP", "EUR"), 1.16717m);
forex.Add(Tuple.Create("USD", "USD"), 1.00000m);
forex.Add(Tuple.Create("EUR", "EUR"), 1.00000m);
forex.Add(Tuple.Create("GBP", "GBP"), 1.00000m);
decimal result;
result = 35.0m * forex[Tuple.Create("USD", "EUR")]; // USD 35.00 = EUR 26.20
result = 35.0m * forex[Tuple.Create("EUR", "GBP")]; // EUR 35.00 = GBP 29.99
result = 35.0m * forex[Tuple.Create("GBP", "USD")]; // GBP 35.00 = USD 54.58

मुझे अपने आवेदन की समान आवश्यकता थी। Tupleयह भी अपरिवर्तनीय है जो वजन और माप जैसी वस्तुओं के बारे में भी सच है ... जैसा कि कहा जाता है "एक पिंट एक पाउंड दुनिया है।"

— Chef_Code
स्रोत

0

मेरा प्रोटोटाइप कोड: http://ideone.com/x7hz7i

मेरे डिजाइन अंक:

संपत्ति प्राप्त / सेट के रूप में यूओएम (माप की इकाई) की पसंद
```
लंबाई लेन = नई लंबाई ();
len.Meters = 2.0;
Console.WriteLine (len.Feet);
```
यूओएम की पसंद के लिए नामित निर्माता
```
लंबाई लेन = लंबाई। फेरोमेटर्स (2.0);
```

यूओएम के लिए समर्थन का समर्थन

Console.WriteLine (len.ToString ( "फुट"));
Console.WriteLine (len.ToString ( "F15"));
Console.WriteLine (len.ToString ( "ftF15"));

राउंडट्रिप रूपांतरण (डबल परिशुद्धता द्वारा नगण्य राउंडिंग लॉस की अनुमति)
```
लंबाई lenRT = लंबाई। FromMeters (लंबाई ।romFeet (लंबाई ।romMeters (len.Meters) .Feet)। Meters);
```

ऑपरेटर ओवरलोडिंग (लेकिन कमी है आयामी प्रकार की )

// काफी गड़बड़, छोटी गाड़ी, असुरक्षित, और F # या C ++ MPL का उपयोग किए बिना संभव नहीं हो सकता है।
// यह कहना है कि पर चला जाता है आयामी विश्लेषण है एक वैकल्पिक सुविधा नहीं UoM के लिए -
// आप इसे सीधे उपयोग करते हैं या नहीं। इसकी आवश्यकता है ।

— rwong
स्रोत

0

मैगज़िन में एक अच्छा लेख है, जैसा कि जर्मन में है: http://www.dotnetpro.de/articles/onlinearticle1398.aspx

बेस विचार एक BaseMeasurement के साथ लंबाई की तरह एक इकाई वर्ग है। वर्ग में रूपांतरण कारक, ऑपरेटर अधिभार, ToString अधिभार, स्ट्रिंग के पार्सर और अनुक्रमणिका के रूप में कार्यान्वयन शामिल है। हमने आर्किटेक्चरल दृश्य भी लागू कर दिया है, लेकिन यह लाइब्रेरी के रूप में रिलीज़ नहीं हुआ है।

public class Length : MeasurementBase
    {
        protected static double[] LengthFactors = { 1, 100, 1000, 0.001, 100 / 2.54 };
        protected static string[] LengthSymbols = { "m", "cm", "mm", "km", "in" };
...
      public virtual double this[Units unit]
        {
            get { return BaseValue * LengthFactors[(int)unit]; }
            set { BaseValue = value / LengthFactors[(int)unit]; }
        }
...

        public static ForceDividedByLength operator *(Length length, Pressure pressure1)
        {
            return new ForceDividedByLength(pressure1[Pressure.Units.kNm2] * length[Units.m], ForceDividedByLength.Units.kNm);
        }

...

इसलिए आप प्रेशर ऑपरेटर के साथ या बस इसका उपयोग देखें:

var l = new Length(5, Length.Units.m)    
Area a = l * new Length("5 m");
a.ToString() // -> 25 m^2
double l2 = l[Length.Units.ft];

लेकिन जैसा कि आपने कहा, मुझे गेंडा या तो नहीं मिला :)

— KCT
स्रोत

-1

यह यूनिक्स कमांड का रायसन डीट्रे है units, जो रिश्तों को निर्दिष्ट करने के लिए डेटा-फ़ाइल-संचालित दृष्टिकोण का उपयोग करके यह सब करता है।

— रॉस पैटरसन
स्रोत

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

1

आप unitsडेटा फ़ाइल पर एक नज़र रखना चाहिए । यह मात्राओं के बीच संबंधों को परिभाषित करने का तरीका बहुत साफ है, और आपकी समस्या के लिए उपयोगी हो सकता है।

— रॉस पैटरसन