सी # बाइनरी शाब्दिक

Question

क्या 0 # के साथ हेक्साडेसिमल को उपसर्ग की तरह सी # में द्विआधारी शाब्दिक लिखने का एक तरीका है? 0 बी काम नहीं करता है।

यदि नहीं, तो इसे करने का एक आसान तरीका क्या है? किसी प्रकार का स्ट्रिंग रूपांतरण?

Comments

स्थिरांक का उपयोग करें और उन्हें उचित नाम दें, फिर तथ्य यह है कि आपको उन्हें दशमलव में लिखना होगा कोई फर्क नहीं पड़ता। व्यक्तिगत रूप से मैं इसके if (a == MaskForModemIOEnabled)बजाय पढ़ना चाहता हूँif (a == 0b100101)

— लेज़ वी। कार्लसन जू

: एक अन्य ध्यान दें: आप इस पोस्ट पाया है क्योंकि आप थोड़ा क्षेत्र चाहते हैं, झंडे-विशेषता पर विचार करें msdn.microsoft.com/en-us/library/cc138362.aspx#sectionToggle0

— toxvaerd

दोनों बहुत अच्छी सलाह, जब कहा गया कि बिटफिल्ड को परिभाषित करने के अलावा , जहां इन निरंतर परिभाषाओं को द्विआधारी शाब्दिक रूप से पढ़ना और लिखना आसान हो सकता है। [झंडे] enum मात्रा {कोई नहीं = 0, एक = 1, कुछ = 0b10, अधिकांश = 0b100, सभी = 0b111}

— brianary

रोसलिन के लिए द्विआधारी शाब्दिक समर्थन की योजना बनाई गई है ।

— जो व्हाइट

यह अभी भी C # 6.0 में समर्थित नहीं है, है ना? Vs2015 में द्विआधारी शाब्दिक का उपयोग नहीं कर सकते: /

— anhoppe

Answer 1

सी # 7.0 द्विआधारी शाब्दिक (और अंडरस्कोर वर्णों के माध्यम से वैकल्पिक अंक विभाजक) का समर्थन करता है ।

एक उदाहरण:

int myValue = 0b0010_0110_0000_0011;

आप Roslyn GitHub पृष्ठ पर अधिक जानकारी भी प्राप्त कर सकते हैं ।

Comments

@ D.Singh मैं इसे C # 7 सूची में देखता हूं। github.com/dotnet/roslyn/issues/2136

— दान 20

मिठाई! VS2017 / C # 7 में शानदार काम कर रहा है।

— STLDev

यह याद रखने में मदद करता है कि C # के बाइनरी लिटरल्स बड़े-एंडियन हैं, लेकिन x86 पूर्णांकों पर छोटे-एंडियन हैं, इसलिए Int16 = 0b0010_0110_0000_0011इसे { 0b0000_0011, 0b0010_0110 }भ्रामक के रूप में संग्रहीत किया जाएगा ।

— दाई

@Dai कि हेक्स शाब्दिक से अलग नहीं है। दूसरे शब्दों में, सभी स्थिरांक बड़े एंडियन हैं, लेकिन इंटेल / एएमडी और अधिकांश एआरएम पर थोड़ा एंडियन संग्रहीत हैं। 0xDEADBEEFके रूप में संग्रहीत किया जाएगा0xEF 0xBE 0xAD 0xDE

— कोल जॉनसन

Answer 2

अपडेट करें

C # 7.0 में अब द्विआधारी शाब्दिक है, जो कि कमाल है।

[Flags]
enum Days
{
    None = 0,
    Sunday    = 0b0000001,
    Monday    = 0b0000010,   // 2
    Tuesday   = 0b0000100,   // 4
    Wednesday = 0b0001000,   // 8
    Thursday  = 0b0010000,   // 16
    Friday    = 0b0100000,   // etc.
    Saturday  = 0b1000000,
    Weekend = Saturday | Sunday,
    Weekdays = Monday | Tuesday | Wednesday | Thursday | Friday
}

मूल पोस्ट

चूँकि इस विषय को लगता है कि एनम में बिट-आधारित फ्लैग वैल्यू की घोषणा की गई है, इसलिए मैंने सोचा कि यह इस तरह की चीज़ के लिए एक आसान ट्रिक को इंगित करने के लायक होगा। बाएं-शिफ्ट ऑपरेटर ( <<) आपको एक विशिष्ट बाइनरी स्थिति में थोड़ा धक्का देने की अनुमति देगा। एक ही वर्ग में अन्य मूल्यों के संदर्भ में enum मानों की घोषणा करने की क्षमता के साथ गठबंधन करें, और आपके पास बिट फ्लैग एनमों के लिए एक बहुत ही आसानी से पढ़ा जाने वाला घोषणात्मक वाक्यविन्यास है।

[Flags]
enum Days
{
    None        = 0,
    Sunday      = 1,
    Monday      = 1 << 1,   // 2
    Tuesday     = 1 << 2,   // 4
    Wednesday   = 1 << 3,   // 8
    Thursday    = 1 << 4,   // 16
    Friday      = 1 << 5,   // etc.
    Saturday    = 1 << 6,
    Weekend     = Saturday | Sunday,
    Weekdays    = Monday | Tuesday | Wednesday | Thursday | Friday
}

Comments

@ColeJohnson: कई डेवलपर्स इसे पसंद करते हैं। मैं अपने सिर में हेक्स को परिवर्तित करने में उतना अच्छा नहीं हूं जितना कि कुछ डेवलपर्स हैं, और कभी-कभी सबसे कम सामान्य भाजक को पूरा करना सबसे अच्छा है।

— स्ट्रिपिंगवर्यर

मुझे लगता है कि यह सबसे प्रभावी तरीका है क्योंकि एनमोंस को स्थिरांक के रूप में बनाया गया है। वैकल्पिक [झंडे] विशेषता के साथ उन्हें बिटवाइज़ ऑपरेशंस में इस्तेमाल किया जा सकता है (सीधे सवाल से संबंधित नहीं है, लेकिन विशेष रूप से उपयोगी है जब बाइनरी लिटल्स का वर्णन करते हुए)। एक और दिलचस्प संभावना है कि एनम प्रकार को एक अंतर्निहित प्रकार के रूप में मजबूर करना (इस उदाहरण में, 'डेज़' के बाद ': बाइट' जोड़ें); बिल्ट-इन बिट्स

— MKv42E

यह वास्तव में पढ़ने के लिए बहुत आसान है, हालांकि एक Enum पर 0 ध्वज की घोषणा करना काफी बुरा अभ्यास है

— माइक

@ माइक: क्या आप उस अंतिम विचार पर विस्तृत (या एक लिंक प्रदान कर सकते हैं)? मैं अक्सर "1" के साथ शुरू होने वाली दुश्मनी की घोषणा करता हूं क्योंकि मैं यह जानना चाहता हूं कि जब कोई मूल्य केवल आरंभिक रूप से निर्धारित नहीं किया गया था, तो मैं उसका पता लगा सकता हूं । लेकिन कुछ स्थितियाँ ऐसी होती हैं जहाँ एक डिफ़ॉल्ट मूल्य वास्तव में समझ में आता है, और मुझे लगता है कि उस मूल्य के लिए एक नाम जोड़ने में कुछ भी गलत नहीं होगा।

— स्ट्रिपिंगवर्यर

से @MikeT ca1008 : "। एक गणन कि FlagsAttribute है लागू किया परिभाषित करता है एक शून्य महत्वपूर्ण सदस्य, इसका नाम होना चाहिए 'कोई नहीं' से संकेत मिलता है कि कोई मान गणना में सेट किया गया है" इसलिए इसे डिफ़ॉल्ट मान के रूप में जोड़ने के लिए इसे पूरी तरह से मान्य है, अगर इसे "कोई नहीं" कहा जाता है। कुल मिलाकर यह सिर्फ मेरे लिए साफ-सुथरा लगता है, यदि डिफ़ॉल्ट-आरंभिक क्षेत्र में मूल्य वास्तव में दिखाने के लिए एक नाम है।

— Nyerguds

Answer 3

केवल पूर्णांक और हेक्स सीधे, मुझे डर है (ECMA 334v4):

9.4.4.2 पूर्णांक शाब्दिक शब्द पूर्णांक का उपयोग int, uint, long और ulong के मान लिखने के लिए किया जाता है। पूर्णांक शाब्दिक के दो संभावित रूप हैं: दशमलव और षोडश आधारी।

पार्स करने के लिए, आप उपयोग कर सकते हैं:

int i = Convert.ToInt32("01101101", 2);

Comments

इस उत्तर के अद्यतन के रूप में, नवीनतम अत्याधुनिक जानकारी (जुलाई, 2014) के साथ; सी # 6.0 द्विआधारी शाब्दिक परिचय। नीचे की ओर मेरे अपडेटेड जवाब को देखें

— ।yyyyyy

@BTownTKD आपका उत्तर वास्तव में सबसे ऊपर है :) क्योंकि यह स्वीकृत उत्तर है।

— RBT

Answer 4

Enums में बिट झंडे के बारे में @ StriplingWarrior के जवाब में जोड़ना, वहाँ एक आसान सम्मेलन है जो आप बिट शिफ्ट्स के माध्यम से ऊपर की ओर गिनती के लिए हेक्साडेसिमल में उपयोग कर सकते हैं। अनुक्रम 1-2-4-8 का उपयोग करें, एक कॉलम को बाईं ओर ले जाएं, और दोहराएं।

[Flags]
enum Scenery
{
  Trees   = 0x001, // 000000000001
  Grass   = 0x002, // 000000000010
  Flowers = 0x004, // 000000000100
  Cactus  = 0x008, // 000000001000
  Birds   = 0x010, // 000000010000
  Bushes  = 0x020, // 000000100000
  Shrubs  = 0x040, // 000001000000
  Trails  = 0x080, // 000010000000
  Ferns   = 0x100, // 000100000000
  Rocks   = 0x200, // 001000000000
  Animals = 0x400, // 010000000000
  Moss    = 0x800, // 100000000000
}

सही कॉलम से शुरू करते हुए स्कैन करें और पैटर्न 1-2-4-8 (शिफ्ट) 1-2-4-8 (शिफ्ट) पर ध्यान दें ...

---

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

यदि आपको स्रोत कोड में बाइनरी नंबर देखने की आवश्यकता है, तो मेरा सुझाव है कि मेरे पास ऊपर दिए गए द्विआधारी शाब्दिक के साथ टिप्पणी जोड़ना है।

Answer 5

आप हमेशा अर्ध-शाब्दिक, स्थिरांक बना सकते हैं, जिसमें आपके बाद के मूल्य होते हैं:

const int b001 = 1;
const int b010 = 2;
const int b011 = 3;
// etc ...
Debug.Assert((b001 | b010) == b011);

यदि आप उन्हें अक्सर उपयोग करते हैं तो आप उन्हें फिर से उपयोग के लिए एक स्थिर वर्ग में लपेट सकते हैं।

हालाँकि, थोड़ी-सी ऑफ-टॉपिक, यदि आपके पास बिट्स से जुड़ा कोई शब्दार्थ है (संकलन के समय जाना जाता है) तो मैं इसके बजाय एक Enum का उपयोग करने का सुझाव दूंगा:

enum Flags
{ 
    First = 0,
    Second = 1,
    Third = 2,
    SecondAndThird = 3
}
// later ...
Debug.Assert((Flags.Second | Flags.Third) == Flags.SecondAndThird);

Answer 6

यदि आप .NET कंपाइलर प्लेटफ़ॉर्म ("रोसलिन") की भाषा सुविधा कार्यान्वयन स्थिति को देखते हैं, तो आप स्पष्ट रूप से देख सकते हैं कि C # 6.0 में यह एक नियोजित सुविधा है, इसलिए अगली रिलीज़ में हम इसे सामान्य तरीके से कर सकते हैं।

Comments

क्या यह पारित करने के लिए आया था? नहीं सभी सुविधाओं है कि वास्तव में दृश्य स्टूडियो 2015 रिलीज के बारे में ब्लॉग किया गया है।

— कर्नल पैनिक ने

@ColonelPanic - दान बताता है कि यह "C # 7 सूची में अब" पर है - github.com/dotnet/roslyn/issues/2136

— Wai Ha Lee

Answer 7

string sTable="static class BinaryTable\r\n{";
string stemp = "";
for (int i = 0; i < 256; i++)
{
stemp = System.Convert.ToString(i, 2);
while(stemp.Length<8) stemp = "0" + stemp;
sTable += "\tconst char nb" + stemp + "=" + i.ToString() + ";\r\n";
}
sTable += "}";
Clipboard.Clear();
Clipboard.SetText ( sTable);
MessageBox.Show(sTable);

इसका उपयोग करते हुए, 8 बिट बाइनरी के लिए, मैं इसे एक स्थिर वर्ग बनाने के लिए उपयोग करता हूं और इसे क्लिपबोर्ड में डालता है .. फिर इसे परियोजना में चिपकाया जाता है और उपयोग अनुभाग में जोड़ा जाता है, इसलिए nb001010 के साथ कुछ भी एक तालिका से बाहर ले जाया जाता है, कम से कम स्थिर, लेकिन फिर भी ... मैं बहुत सारे PIC ग्राफिक्स कोडिंग के लिए C # का उपयोग करता हूं और हाई-टेक सी में 0b101010 बहुत का उपयोग करता हूं

- कोड आउट से सैंपल--

static class BinaryTable
{   const char nb00000000=0;
    const char nb00000001=1;
    const char nb00000010=2;
    const char nb00000011=3;
    const char nb00000100=4;
//etc, etc, etc, etc, etc, etc, etc, 
}

:-) NEAL

Answer 8

बाइनरी शाब्दिक सुविधा C # 6.0 और विज़ुअल स्टूडियो 2015 में लागू नहीं की गई थी, लेकिन 30-मार्च 2016 को Microsoft ने Visual Studio '15' पूर्वावलोकन के नए संस्करण की घोषणा की जिसके साथ हम बाइनरी शाब्दिक का उपयोग कर सकते हैं।

हम अंक विभाजकों के लिए एक या एक से अधिक अंडरस्कोर (_) वर्ण का उपयोग कर सकते हैं। इसलिए कोड स्निपेट कुछ इस तरह दिखाई देगा:

int x           = 0b10___10_0__________________00; //binary value of 80
int SeventyFive = 0B100_________1011; //binary value of 75

WriteLine($" {x} \n {SeventyFive}");

और हम उपरोक्त कोड स्निपेट में दिखाए गए अनुसार 0b और 0B दोनों में से किसी का भी उपयोग कर सकते हैं।

यदि आप अंक विभाजक का उपयोग नहीं करना चाहते हैं, तो आप इसे कोड विभाजक के बिना अंक विभाजक के बिना उपयोग कर सकते हैं

int x           = 0b1010000; //binary value of 80
int SeventyFive = 0B1001011; //binary value of 75

WriteLine($" {x} \n {SeventyFive}");

Answer 9

जबकि एक शाब्दिक का उपयोग करना संभव नहीं है, शायद एक बिटकॉइनरेटर भी एक समाधान हो सकता है?

Comments

BitConverter थोड़ा मुश्किल हो जाता है क्योंकि यह मशीन-एंडियन है; और आपके मानक इंटेल पर, जिसका अर्थ है कि छोटे-एंडियन। अधिकांश लोगों को कठिनाई पढ़ने थोड़ा-endian शाब्दिक है ...

— मार्क Gravell

आउच, अब मुझे याद क्यों मैं हमेशा के बारे में पता था, लेकिन कभी नहीं किया BitConverter ...

— माइकल Stum

BitConverter में वह फ़ील्ड होती है BitConverter.IsLittleEndian, जिसका उपयोग आप होस्ट एंड मशीन के छोटे एंडियन के परीक्षण के लिए (और एक बफर को रिवर्स करने के लिए) कर सकते हैं।

— लोमड़ी

Answer 10

हालांकि स्ट्रिंग पार्सिंग समाधान सबसे लोकप्रिय है, मुझे यह पसंद नहीं है, क्योंकि कुछ स्थितियों में पार्सिंग स्ट्रिंग एक शानदार प्रदर्शन हो सकता है।

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

लंबे बिटमैक्स = 1011001;

और बादमें

int bit5 = BitField.GetBit (bitMask, 5);

या

बूल फ्लैग 5 = BitField.GetFlag (bitMask, 5); `

जहां BitField class है

public static class BitField
{
    public static int GetBit(int bitField, int index)
    {
        return (bitField / (int)Math.Pow(10, index)) % 10;
    }

    public static bool GetFlag(int bitField, int index)
    {
        return GetBit(bitField, index) == 1;
    }
}

Comments

छी। क्यों न केवल एनम का उपयोग करें? ऑन्ट हज़ार का उपयोग करना मतलब 1-0-0-0 है बस परेशानी पूछ रहा है।

— क्लेमेंट

Answer 11

आप 0b000001Visual Studio 2017 (C # 7.0) के बाद से उपयोग कर सकते हैं

Answer 12

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

int someHexFlag = 0x010; // 000000010000
int someDecFlag = 8;     // 000000001000

दूसरों के जवाब यहां कई उपयोगी कार्य प्रस्तुत करते हैं, लेकिन मुझे लगता है कि वे बेहतर नहीं हैं तो सरल उत्तर। C # भाषा डिजाइनरों ने संभवतः '0b' उपसर्ग को अनावश्यक माना है। एचईएक्स बाइनरी में बदलना आसान है, और अधिकांश प्रोग्रामर को 0-8 किसी भी तरह के डीईसी समकक्षों को जानना होगा।

इसके अलावा, जब डिबगर में मूल्यों की जांच करते हैं, तो उन्हें प्रदर्शित किया जाएगा HEX या DEC।