C # के लिए आपकी पसंदीदा एक्सटेंशन विधियाँ क्या हैं? (Codeplex.com/extensionoverflow)


478

आइए उन उत्तरों की एक सूची बनाएं जहां आप अपनी उत्कृष्ट और पसंदीदा एक्सटेंशन विधियों को पोस्ट करते हैं ।

आवश्यकता यह है कि पूर्ण कोड पोस्ट किया जाना चाहिए और एक उदाहरण और इसका उपयोग करने के तरीके पर एक स्पष्टीकरण।

इस विषय में उच्च रुचि के आधार पर, मैंने एक ओपन सोर्स प्रोजेक्ट सेटअप किया है जिसे कोडप्लेक्स पर विस्तारकप्रवाह कहा जाता है ।

कोडप्लेक्स प्रोजेक्ट में कोड डालने की स्वीकृति के साथ कृपया अपने उत्तरों को चिह्नित करें।

कृपया पूर्ण सोर्सकोड पोस्ट करें न कि लिंक।

कोडप्लेक्स समाचार:

24.08.2010 कोडप्लेक्स पृष्ठ अब यहाँ है: http://extensionoverflow.codeplex.com/

11.11.2008 XmlSerialize / XmlDeserialize अब कार्यान्वित और यूनिट टेस्टेड है

11.11.2008 अधिक डेवलपर्स के लिए अभी भी जगह है। ;-) अब सम्मिलित हों!

11.11.2008 तीसरा कंट्रीब्यूटर ExtensionOverflow में शामिल हो गया , BKristensen में आपका स्वागत है

11.11.2008 फॉर्मविट को अब कार्यान्वित और यूनिट टेस्ट किया गया है

09.11.2008 दूसरा कंट्रीब्यूटर ExtensionOverflow में शामिल हुआ । चक्री में आपका स्वागत है ।

09.11.2008 हमें और अधिक डेवलपर्स चाहिए। ;-)

09.11.2008 अब ThrowIfArgumentIsNull कोडप्लेक्स में कार्यान्वित और यूनिट टेस्ट किया गया।


अब पहला कोड कोडप्लेक्स साइट के लिए प्रतिबद्ध है।
बोवियम

एरिक दुर्भाग्य से सब कुछ अब कोडप्लेक्स पर शुरू किया गया है। कृपया किसी भी तरह से शामिल हों।
२३:४३ पर बोवियम

3
बहुत अच्छा लग रहा है। मेरे पास स्थैतिक वर्गों के नामकरण के बारे में एक टिप्पणी है। उनका नामकरण <टाइप> एक्सटेंशन बहुत जानकारीपूर्ण नहीं है। उदाहरण के लिए StringExtensions दोनों स्वरूपण और xml सामान रखता है। मुझे लगता है कि आप उस प्रकार का विस्तार क्यों कर रहे हैं, इसके साथ कक्षा का नाम देना बेहतर है। उदाहरण के लिए UnixDateTimeConversions। आप यथोचित अनुमान लगा सकते हैं कि यह यूनिक्स के समय से और उसके लिए परिवर्तित करने के तरीके हैं। सिर्फ एक विचार!
15

सी # एक्सटेंशन के तरीके के बारे में अधिक के लिए इस URL की जाँच करें planetofcoders.com/c-extension-methods
गौरव अग्रवाल

जवाबों:


232
public static bool In<T>(this T source, params T[] list)
{
  if(null==source) throw new ArgumentNullException("source");
  return list.Contains(source);
}

मुझे प्रतिस्थापित करने की अनुमति देता है:

if(reallyLongIntegerVariableName == 1 || 
    reallyLongIntegerVariableName == 6 || 
    reallyLongIntegerVariableName == 9 || 
    reallyLongIntegerVariableName == 11)
{
  // do something....
}

and

if(reallyLongStringVariableName == "string1" || 
    reallyLongStringVariableName == "string2" || 
    reallyLongStringVariableName == "string3")
{
  // do something....
}

and

if(reallyLongMethodParameterName == SomeEnum.Value1 || 
    reallyLongMethodParameterName == SomeEnum.Value2 || 
    reallyLongMethodParameterName == SomeEnum.Value3 || 
    reallyLongMethodParameterName == SomeEnum.Value4)
{
  // do something....
}

साथ में:

if(reallyLongIntegerVariableName.In(1,6,9,11))
{
      // do something....
}

and

if(reallyLongStringVariableName.In("string1","string2","string3"))
{
      // do something....
}

and

if(reallyLongMethodParameterName.In(SomeEnum.Value1, SomeEnum.Value2, SomeEnum.Value3, SomeEnum.Value4)
{
  // do something....
}

2
अच्छी तरह से यह संकलित करता है यदि आप System.Linq का उपयोग कर रहे हैं;
Ryu

11
हो सकता है कि "EqualsAnyOf" "In" से बेहतर नाम होगा?
टॉम बुशेल

10
मुझे यकीन नहीं है कि मुझे यह पसंद है - मुझे इसकी संक्षिप्तता पसंद है In, लेकिन शायद IsInबेहतर होगा।
विंस्टन स्मिथ

50
एक ही सामग्री विधि का उपयोग करना: (नया [] {१, २, ३}}। इसमें शामिल हैं (ए)
मैक्स टोरो

4
मैंने इसके बारे में सोचा In<T>(...)और इसे मानक पुस्तकालय के बाहर सबसे उपयोगी विस्तार विधि माना। लेकिन मैं नाम के साथ हूं In। एक विधि का नाम यह बताता है कि यह क्या करता है, लेकिन Inऐसा नहीं करता है। मैंने इसे बुलाया है IsAnyOf<T>(...), लेकिन मुझे लगता है IsIn<T>(...)कि यह पर्याप्त होगा।
JBSnorro

160

मेरी MiscUtil परियोजना में मेरे पास विभिन्न विस्तार विधियाँ हैं (पूरा स्रोत वहाँ उपलब्ध है - मैं इसे यहाँ दोहराने नहीं जा रहा हूँ)। मेरा पसंदीदा, जिनमें से कुछ अन्य वर्गों को शामिल करते हैं (जैसे पर्वतमाला):

तारीख और समय सामान - ज्यादातर यूनिट परीक्षणों के लिए। मुझे यकीन नहीं है कि मैं उन्हें उत्पादन में उपयोग करूँगा :)

var birthday = 19.June(1976);
var workingDay = 7.Hours() + 30.Minutes();

रेंजर्स और स्टेपिंग - मार्क ग्रेवेल को अपने ऑपरेटर के सामान के लिए बड़े पैमाने पर धन्यवाद यह संभव बनाने के लिए:

var evenNaturals = 2.To(int.MaxValue).Step(2);
var daysSinceBirth = birthday.To(DateTime.Today).Step(1.Days());

तुलना:

var myComparer = ProjectionComparer.Create(Person p => p.Name);
var next = myComparer.ThenBy(p => p.Age);
var reversed = myComparer.Reverse();

तर्क की जाँच:

x.ThrowIfNull("x");

LINQ to XML पर लागू होता है अनाम प्रकार (या उपयुक्त गुणों के साथ अन्य प्रकार):

// <Name>Jon</Name><Age>32</Age>
new { Name="Jon", Age=32}.ToXElements();
// Name="Jon" Age="32" (as XAttributes, obviously)
new { Name="Jon", Age=32}.ToXAttributes()

Push LINQ - यहाँ समझाने में बहुत समय लगेगा, लेकिन इसके लिए खोज करें।


1
यह अच्छा है! आपको इसे Google Code या CodePlex पर रखना चाहिए ताकि मैं आपको कुछ पैच भेज
सकूं

3
@ बोवियम: आप पहले से ही कोड देख सकते हैं। पहले वाक्य में लिंक का पालन करें - पूर्ण स्रोत है।
जॉन स्कीट

1
@bovium: यदि आप कोई आपत्ति नहीं रखते हैं, तो मैं इसे स्वयं करूँगा। code.google.com पर डालकर और स्वयं प्रोजेक्ट का प्रबंधन करें। स्पष्ट रूप से आप लाइसेंस के भीतर इसे कोडप्लेक्स पर रखने के लिए हैं यदि आप उपयुक्त एट्रिब्यूशन रखते हैं, लेकिन जब तक आप हताश नहीं होते तब तक मैं इसे खुद ही सुलझा लूंगा
जॉन स्कीट

1
@ जोंन स्कीट इसका उपयोग MIT लाइसेंस के तहत हर किसी के लिए मुफ्त है। व्यावसायिक या खुला स्रोत। क्यों नहीं सेना में शामिल हों और जनता के लिए एक विस्तार विधियाँ पुस्तकालय बनायें।
बोवियम

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

147

string.Format शॉर्टकट:

public static class StringExtensions
{
    // Enable quick and more natural string.Format calls
    public static string F(this string s, params object[] args)
    {
        return string.Format(s, args);
    }
}

उदाहरण:

var s = "The co-ordinate is ({0}, {1})".F(point.X, point.Y);

त्वरित कॉपी-एंड-पेस्ट के लिए यहां जाएं

क्या आपको "some string".F("param")इसके बजाय टाइप करना अधिक स्वाभाविक लगता है string.Format("some string", "param")?

अधिक पठनीय नाम के लिए, इनमें से किसी एक सुझाव को आजमाएँ:

s = "Hello {0} world {1}!".Fmt("Stack", "Overflow");
s = "Hello {0} world {1}!".FormatBy("Stack", "Overflow");
s = "Hello {0} world {1}!".FormatWith("Stack", "Overflow");
s = "Hello {0} world {1}!".Display("Stack", "Overflow");
s = "Hello {0} world {1}!".With("Stack", "Overflow");

..


11
यह निश्चित रूप से छोटा है - लेकिन आपकी टीम के किसी भी नए सदस्य के लिए अपठनीय होगा।
जॉन स्कीट

3
मुझे लगता है कि कुछ शॉर्टहैंड स्टेटमेंटों की तुलना में आपके कोड की अनुदान योजना में पठनीयता अधिक मायने रखती है, जिसे जल्दी देखा / पूछा जा सकता है।
चक्र

6
व्यक्तिगत रूप से मुझे एक अलग फॉर्मेट ऑब्जेक्ट चाहिए, जिसे बीसीएल एक बार और पुन: उपयोग के पैटर्न को पार्स कर सके। इससे पठनीयता और प्रदर्शन बढ़ेगा। मैंने BCL टीम से पूछा है - हम देखेंगे ...
जॉन स्कीट

3
यह एक विस्तार विधि है, निश्चित रूप से यह टीम के नए सदस्यों के लिए अपठनीय होने वाली है। मैंने सोचा कि इस मजाकिया सामान के साथ क्या विचार था? नए सदस्यों को कैसे पता चलेगा कि हम कितने चतुर हैं?
MarkJ

17
ठीक है ... मैं बस इसे कार्रवाई में डाल दिया और साथ चला गया। इसके साथ-साथ आपको "यह एक {0}" है। साथ ("परीक्षण") और यह बहुत पठनीय है और समझ में आता है। FYI करें
klkitchens

89

क्या ये कोई उपयोग हैं?

public static bool CoinToss(this Random rng)
{
    return rng.Next(2) == 0;
}

public static T OneOf<T>(this Random rng, params T[] things)
{
    return things[rng.Next(things.Length)];
}

Random rand;
bool luckyDay = rand.CoinToss();
string babyName = rand.OneOf("John", "George", "Radio XBR74 ROCKS!");

यह मिक्स अजगर यादृच्छिक यादृच्छिक (seq) फ़ंक्शन। अच्छा।
डैरन थॉमस

6
युगल बातें: मैं सलाह दूंगा कि किसीOneOf को भी स्वीकार करना चाहिए IList<T>। तो फिर तुम हमेशा सकता भी एक अधिभार है कि एक लेता है paramsआर्ग और सिर्फ इतना है कि गुजरता में IList<T>अधिभार। मैंने NextBoolआपके समान एक विधि के साथ एक उत्तर दिया (नीचे तल पर अभी) CoinToss, लेकिन एक अधिभार के साथ जो एक probabilityपैरामीटर लेता है (क्या होगा यदि मैं चाहता हूं कि 75% समय हो?)। इसके अलावा, बस एक नाइट पिक: आपका उदाहरण कोड फेंक देगा NullReferenceExceptionक्योंकि randकभी भी आरंभिक नहीं है।
दान ताओ

3
+1 मुझे वास्तव में यह पसंद है, लेकिन मैं CoinTossइसे लागू करना पसंद करता हूं rng.NextDouble() < .5क्योंकि आंतरिक रूप .Next(int)से बनाया गया है .NextDouble()ताकि आप एक डाली, एक * और एक चेक को बचा सकें।
लासे एस्पेहॉल्ट

76
public static class ComparableExtensions
{
  public static bool Between<T>(this T actual, T lower, T upper) where T : IComparable<T>
  {
    return actual.CompareTo(lower) >= 0 && actual.CompareTo(upper) < 0;
  }
}

उदाहरण:

if (myNumber.Between(3,7))
{
  // ....
}

19
मुझे यह बहुत पसंद है, लेकिन मैं यह तय करने की कोशिश कर रहा हूं कि क्या यह न्यूनतम है कि न्यूनतम मूल्य पर चेक को सम्मिलित किया जाए लेकिन अधिकतम मूल्य पर अनन्य। मुझे आश्चर्य है कि अगर यह भ्रामक होगा। ५.बेटन (५,१०) सच है लेकिन ५.बेटन (१,५) गलत है। यह भी सुनिश्चित नहीं है कि विधि के भीतर एक साथी मदद करेगा। Thougts?
स्टीव हेनर

12
नाम "IsBetween" अधिक समझ नहीं होगा? शायद यह भी एक IsBetweenInclusive और IsBetweenExclusive बनाते हैं। हालांकि कोई विचार नहीं है कि डिफ़ॉल्ट रूप से कौन लेना है।
fretje

2
@ समय: यह अधिक समझ में आता है अगर यह एक डेटाइम एक्सटेंशन था।
जोएल कोएहॉर्न

16
मेरे लिए इसका तात्पर्य है: ५.बेटन (५,१०) झूठे, और १०.बेटन (५,१०) झूठे हैं। वह सिर्फ मुझे स्वाभाविक लगता है।
एलेक्स बारानोस्की

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

58

विस्तार विधि:

public static void AddRange<T, S>(this ICollection<T> list, params S[] values)
    where S : T
{
    foreach (S value in values)
        list.Add(value);
}

विधि सभी प्रकारों के लिए लागू होती है और आपको मापदंडों के रूप में एक सूची में कई मदों को जोड़ने की सुविधा देती है।

उदाहरण:

var list = new List<Int32>();
list.AddRange(5, 4, 8, 4, 2);

15
इस IList <T> के रूप में बेहतर होगा

21
बस संग्रह आरम्भक => का उपयोग करेंvar list = new List<int>{5,4,8,4,2};
अर्निस लैप्स

सिर्फ अपने तरीके के भीतर लिस्ट <T> .AddRange (IEnumerable <T> कलेक्शन) क्यों नहीं?
रूहोतज़

8
@Will: वास्तव में, यह स्वीकार करना सबसे अच्छा होगा ICollection<T>; तो यह भी उदाहरण के लिए, LinkedList<T>और HashSet<T>, न केवल अनुक्रमित संग्रह पर इस्तेमाल किया जा सकता है ।
दान ताओ


55

हर तरह से इसे कोडप्लेक्स प्रोजेक्ट में डालें।

XML के लिए वस्तुओं का वर्णन / वर्णन करना:

/// <summary>Serializes an object of type T in to an xml string</summary>
/// <typeparam name="T">Any class type</typeparam>
/// <param name="obj">Object to serialize</param>
/// <returns>A string that represents Xml, empty otherwise</returns>
public static string XmlSerialize<T>(this T obj) where T : class, new()
{
    if (obj == null) throw new ArgumentNullException("obj");

    var serializer = new XmlSerializer(typeof(T));
    using (var writer = new StringWriter())
    {
        serializer.Serialize(writer, obj);
        return writer.ToString();
    }
}

/// <summary>Deserializes an xml string in to an object of Type T</summary>
/// <typeparam name="T">Any class type</typeparam>
/// <param name="xml">Xml as string to deserialize from</param>
/// <returns>A new object of type T is successful, null if failed</returns>
public static T XmlDeserialize<T>(this string xml) where T : class, new()
{
    if (xml == null) throw new ArgumentNullException("xml");

    var serializer = new XmlSerializer(typeof(T));
    using (var reader = new StringReader(xml))
    {
        try { return (T)serializer.Deserialize(reader); }
        catch { return null; } // Could not be deserialized to this type.
    }
}

8
मैं पहले एक ToXml()(जैसे ToString()) को फोन करने का लालच
करूंगा

1
ओपी से माफी मांगता है अगर उसने जानबूझकर इसे इस तरह लिखा है, लेकिन मेमोरीस्ट्रीम और एक्सएमएलआरडर / एक्सएमएलविटर का उपयोग ओवरकिल था। StringReader और StringWriter वर्ग इस ऑपरेशन के लिए एकदम सही हैं।
पोर्टमैन

2
खबरदार, यह सूत्र नहीं है। आपको निश्चित रूप से अपनी पहुंच को स्थिर धारावाहिकों के शब्दकोश में समकालित करना चाहिए।
यन श्वार्ट्ज

2
यदि आप "थ्रेड स्टैटिक" विशेषता को जोड़ते हैं, तो @ यन, @ टी, यह बहुत आसान है। फिर प्रति थ्रेड एक नया कैश बनाया जाएगा। सिंक्रनाइज़ेशन के लिए कोई ज़रूरत नहीं है।
फ्रैंक क्रुएगर

1
@ जोनाथन सी डिकिंसन: यह MSDN डॉक्स से प्रकट होता है यहाँ msdn.microsoft.com/en-us/library/… है कि जो कंस्ट्रक्टर उपयोग किया जाता है (नया XmlSerializer (प्रकार)) में मेमोरी की समस्या नहीं होती है। तो शायद कैशिंग कोड की आवश्यकता नहीं है?
slolife

46

IEnumerables के लिए ForEach

public static class FrameworkExtensions
{
    // a map function
    public static void ForEach<T>(this IEnumerable<T> @enum, Action<T> mapFunction)
    {
        foreach (var item in @enum) mapFunction(item);
    }
}

उदाहरण उदाहरण:

var buttons = GetListOfButtons() as IEnumerable<Button>;

// click all buttons
buttons.ForEach(b => b.Click());

अच्छा उदाहरण:

// no need to type the same assignment 3 times, just
// new[] up an array and use foreach + lambda
// everything is properly inferred by csc :-)
new { itemA, itemB, itemC }
    .ForEach(item => {
        item.Number = 1;
        item.Str = "Hello World!";
    });

ध्यान दें:

यह ऐसा नहीं है Selectक्योंकि यह Select उम्मीद करता है कि आपका फ़ंक्शन किसी अन्य सूची में बदलने के लिए कुछ वापस कर देगा।

फॉरएच आपको बिना किसी परिवर्तन / डेटा हेरफेर के प्रत्येक आइटम के लिए कुछ निष्पादित करने की अनुमति देता है।

मैंने ऐसा किया इसलिए मैं अधिक कार्यात्मक शैली में कार्यक्रम कर सकता हूं और मुझे आश्चर्य हुआ कि सूची में एक फॉरएच है जबकि IEnumerable नहीं है।

इसे कोडप्लेक्स प्रोजेक्ट में डालें


13
LINQ के IEnumerable <T> एक्सटेंशन में फॉरएच क्यों शामिल नहीं है पर पोस्ट करें: stackoverflow.com/questions/317874/…
नील

13
मैं विधि का उपयोग करने से पहले इसे पढ़ने की सलाह देता हूं: blogs.msdn.com/ericlippert/archive/2009/05/18/…
jpbochi

2
@jpbochi: यह सिर्फ Microsoft
जनसांख्यिकी है

1
@abatishchev और आपकी टिप्पणी Microsoft के खिलाफ सिर्फ पूर्वाग्रह है। यह एरिक द्वारा लिखे गए किसी भी शब्द को अमान्य नहीं करता है। जिस कंपनी के लिए वह काम करता है, उसके लिए किसी के तर्क को वैध या अमान्य नहीं बनाया जाता है।
jpbochi

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

43

मेरे रूपांतरण एक्सटेंशन जो आपको करने की अनुमति देते हैं:

int i = myString.To<int>();

यहाँ यह TheSoftwareJedi.com पर पोस्ट किया गया है

public static T To<T>(this IConvertible obj)
{
  return (T)Convert.ChangeType(obj, typeof(T));
}

public static T ToOrDefault<T>
             (this IConvertible obj)
{
    try
    {
        return To<T>(obj);
    }
    catch
    {
        return default(T);
    }
}

public static bool ToOrDefault<T>
                    (this IConvertible obj,
                     out T newObj)
{
    try
    {
        newObj = To<T>(obj); 
        return true;
    }
    catch
    {
        newObj = default(T); 
        return false;
    }
}

public static T ToOrOther<T>
                       (this IConvertible obj,
                       T other)
{
  try
  {
      return To<T>obj);
  }
  catch
  {
      return other;
  }
}

public static bool ToOrOther<T>
                         (this IConvertible obj,
                         out T newObj,
                         T other)
{
    try
    {
        newObj = To<T>(obj);
        return true;
    }
    catch
    {
        newObj = other;
        return false;
    }
}

public static T ToOrNull<T>
                      (this IConvertible obj)
                      where T : class
{
    try
    {
        return To<T>(obj);
    }
    catch
    {
        return null;
    }
}

public static bool ToOrNull<T>
                  (this IConvertible obj,
                  out T newObj)
                  where T : class
{
    try
    {
        newObj = To<T>(obj);
        return true;
    }
    catch
    {
        newObj = null;
        return false;
    }
}

आप विफलता के लिए डिफ़ॉल्ट (रिक्त कंस्ट्रक्टर या "0" कॉल) के लिए पूछ सकते हैं, "डिफ़ॉल्ट" मान निर्दिष्ट करें (मैं इसे "अन्य" कहता हूं), या अशक्त (जहां टी: वर्ग) के लिए पूछें। मैंने दोनों मूक अपवाद मॉडल भी प्रदान किए हैं, और एक विशिष्ट TryParse मॉडल जो एक बूल देता है जो कार्रवाई का संकेत देता है, और एक आउट परम नया मूल्य रखता है। तो हमारा कोड इस तरह की चीजें कर सकता है

int i = myString.To<int>();
string a = myInt.ToOrDefault<string>();
//note type inference
DateTime d = myString.ToOrOther(DateTime.MAX_VALUE);
double d;
//note type inference
bool didItGiveDefault = myString.ToOrDefault(out d);
string s = myDateTime.ToOrNull<string>();

मैं पूरी तरह से बहुत सफाई से रोल करने के लिए अशक्त प्रकार प्राप्त नहीं कर सका। मैंने तौलिया में फेंकने से पहले लगभग 20 मिनट तक कोशिश की।


64
व्यक्तिगत रूप से, मैं कोड का प्रशंसक नहीं हूं जो परिणाम निर्धारित करने के लिए कोशिश / पकड़ लेता है। प्रयास / कैच का उपयोग उन त्रुटियों के लिए किया जाना चाहिए जो इच्छित तर्क के बाहर होती हैं, IMO। hmmmmm
Pure.Krome

अगर मैं आपको कोड का उपयोग नहीं करना चाहता था, तो मैंने इसे पोस्ट नहीं किया होगा! :)
TheSoftwareJedi

अंत में कुछ अनदेखी। मुझें यह पसंद है। :)
लैप्सा

8
आपको कम से कम यह बदलना चाहिए कि "कैच" क्लॉज केवल उन अपवादों को पकड़ता है जो चेंज टाइप () तब उठाएंगे जब यह संदर्भ को "कन्वर्ट" नहीं कर सकता है। मुझे लगता है कि आप किसी भी OutOfMemoryException, ExecutionEngineException, ThreadAbortException, या एक जैसे को रूपांतरण त्रुटि के रूप में नहीं मान सकते हैं। अन्यथा उन चीजों को त्रुटियों को ट्रैक करने के लिए बहुत कठिन होगा।
क्रिश्चियन.के

2
मेरा मानना ToOrNullहै कि ठीक वैसा ही व्यवहार है ToOrDefault(जैसे, यदि आप ToOrDefaultएक असफल रूपांतरण वाले संदर्भ प्रकार पर कॉल करते हैं, तो यह वापस आ जाएगा null)। लेकिन इससे भी महत्वपूर्ण बात यह है कि यह मेरे लिए एक तरह से बेमानी लगता है क्योंकि var s = myObject as stringएक ही चीज को पूरा करता है var s = myObject.ToOrNull<string>()- लेकिन संभवतः बिना किसी को पकड़ने के InvalidCastException। क्या मैं कुछ भूल रहा हूँ?
दान ताओ

43

मेरे पास अपवादों को लॉग करने के लिए एक एक्सटेंशन विधि है:

public static void Log(this Exception obj)
{
  //your logging logic here
}

और इसका उपयोग इस तरह किया जाता है:

try
{
    //Your stuff here
}
catch(Exception ex)
{
    ex.Log();
}

[दो बार पोस्ट करने के लिए खेद है; दूसरा एक बेहतर डिज़ाइन किया गया है :-)]


2
सार्वजनिक स्थैतिक शून्य लॉग (इस अपवाद obj) {} शायद पढ़ना चाहिए?
क्रिस एस

मुझे लगता है कि यह बीसीएल या तीसरे पक्ष के अपवादों के लिए अच्छा है, लेकिन यदि आप अपने स्वयं के अपवाद प्रकारों को रोल करते हैं, तो आप लॉगिंग को अपने अपवाद अपवाद वर्ग में रख सकते हैं। इस तरह आपको लॉग () कॉल करने के लिए याद रखने की ज़रूरत नहीं है।
si618

38
public static class StringExtensions {

    /// <summary>
    /// Parses a string into an Enum
    /// </summary>
    /// <typeparam name="T">The type of the Enum</typeparam>
    /// <param name="value">String value to parse</param>
    /// <returns>The Enum corresponding to the stringExtensions</returns>
    public static T EnumParse<T>(this string value) {
        return StringExtensions.EnumParse<T>(value, false);
    }

    public static T EnumParse<T>(this string value, bool ignorecase) {

        if (value == null) {
            throw new ArgumentNullException("value");
        }

        value = value.Trim();

        if (value.Length == 0) {
            throw new ArgumentException("Must specify valid information for parsing in the string.", "value");
        }

        Type t = typeof(T);

        if (!t.IsEnum) {
            throw new ArgumentException("Type provided must be an Enum.", "T");
        }

        return (T)Enum.Parse(t, value, ignorecase);
    }
}

एक Enum में एक स्ट्रिंग पार्स करने के लिए उपयोगी।

public enum TestEnum
{
    Bar,
    Test
}

public class Test
{
    public void Test()
    {
        TestEnum foo = "Test".EnumParse<TestEnum>();
    }
 }

इसका श्रेय स्कॉट डोरमैन को जाता है

--- कोडप्लेक्स परियोजना के लिए संपादन ---

मैंने स्कॉट डोरमैन से पूछा है कि क्या वह हमें कोडप्लेक्स प्रोजेक्ट में अपना कोड प्रकाशित करने के लिए कहेंगे। यह वह उत्तर है जो मुझे उससे मिला है:

एसओ पद और कोडप्लेक्स परियोजना दोनों के प्रमुखों के लिए धन्यवाद। मैंने सवाल पर आपके जवाब को गलत ठहराया है। हां, कोड सार्वजनिक रूप से वर्तमान में कोडप्रोजेक्ट ओपन लाइसेंस ( http://www.codeproject.com/info/cpol10.aspx ) के तहत प्रभावी रूप से है ।

मुझे CodePlex प्रोजेक्ट में शामिल होने में कोई समस्या नहीं है, और यदि आप मुझे प्रोजेक्ट में जोड़ना चाहते हैं (उपयोगकर्ता नाम sdorman है) तो मैं उस विधि को जोड़ूंगा और कुछ अतिरिक्त एनम हेल्पर विधियों को जोड़ूंगा।


यह enum-parsing परिदृश्य हर समय आता है ... यह मेरे काम में डाल होगा :-)
chakrit

वाह, मैं स्ट्रिंग को मैप करने के तरीके लिख रहा हूं (बस .NET का उपयोग करना शुरू कर दिया)। धन्यवाद, यह बिल्कुल मदद करेगा!
केविन

4
आप इस ToEnum <> () को नाम देने पर भी विचार कर सकते हैं, क्योंकि यह ऑब्जेक्ट के बाद आता है।
नील

ध्यान दें कि Enum.TryParse <T> को नेट 4.0 में जोड़ा गया है - blogs.msdn.com/bclteam
Dan Diplo

1
मुझे नहीं लगता कि इस विधि को ट्रिम का उपयोग करना चाहिए। इनपुट को ट्रिम करना कॉलर की जिम्मेदारी होनी चाहिए।
कोडइन्चोस

32

मुझे यह बहुत उपयोगी लगता है:

public static class PaulaBean
{
    private static String paula = "Brillant";
    public static String GetPaula<T>(this T obj) {
        return paula;
    }
}

आप इसे कोडप्लेक्स पर उपयोग कर सकते हैं।


2
क्या कोई इतना दयालु हो सकता है कि वह हमें कम गिफ्ट में बताए?
21

हाहा बस लेख पढ़ें (ऊपर जोएल की टिप्पणी) - मजेदार सच है, लेकिन बहुत ज्यादा एक ही नाव में हो रहा है (पुनरावर्ती अंत पर, पाउला अंत नहीं) यह केवल मजेदार लग रही है! एक बार एक ठेकेदार को एक प्रोजेक्ट पर काम करने के लिए लाया गया था जिसे मैं डिज़ाइनर / लीड देव था - वह मेरे सीधे नियंत्रण में नहीं था, लेकिन मेरी टीमों की कार्य सूची से काम सौंपा गया था। बॉस ने उसकी तारीफ करते हुए उसे शानदार (यहां तक ​​कि बाद में एक देव लीड के रूप में फिर से काम पर रखने) के रूप में सराहा। यह उन पर कभी नहीं आया कि उसने जो भी कोड लिखा या डिज़ाइन किया था, उसने उसे उत्पादन करने के लिए नहीं बनाया था और मेरी टीम द्वारा सभी को खरोंच से पूरी तरह से फिर से लिखना पड़ा था!
वुल्फ 5370

31

DateTimeExtensions

उदाहरण:

DateTime firstDayOfMonth = DateTime.Now.First();
DateTime lastdayOfMonth = DateTime.Now.Last();
DateTime lastFridayInMonth = DateTime.Now.Last(DayOfWeek.Friday);
DateTime nextFriday = DateTime.Now.Next(DayOfWeek.Friday);
DateTime lunchTime = DateTime.Now.SetTime(11, 30);
DateTime noonOnFriday = DateTime.Now.Next(DayOfWeek.Friday).Noon();
DateTime secondMondayOfMonth = DateTime.Now.First(DayOfWeek.Monday).Next(DayOfWeek.Monday).Midnight();

5
मैं "सेटटाइम" का नाम बदलकर "विथटाइम" करने का सुझाव दूंगा क्योंकि यह वास्तव में इसे मौजूदा मूल्य में सेट नहीं कर रहा है। हालांकि अच्छा है।
जॉन स्कीट

28
DateTime.Now.First () - पहले क्या? यह केवल नमूना कोड से स्पष्ट है।
मैकेंनियर

2
बहुत अच्छा। लेकिन सहमत हैं कि नाम बहुत बेहतर हो सकते हैं।
बोवियम

डेटटाइम.नॉ। यदि इंटेलीजेंस विधि अच्छी तरह से प्रलेखित है, तो यह पर्याप्त नहीं होगा।
रयान ल्यूडी

29

gitorious.org/cadenza कुछ सबसे उपयोगी एक्सटेंशन विधियों की एक पूरी लाइब्रेरी है जो मैंने देखी है।


12 काफी बुनियादी विस्तार के तरीके। मैं मोनो-चट्टानों से थोड़ा अभिभूत हूं।
मैकेंनियर

(मैं रिलीज़ किए गए संस्करण के बारे में बात कर रहा हूं, न कि जिसे आपको प्राप्त करने के लिए स्रोत-नियंत्रण का उपयोग करने की आवश्यकता है)
मैकेनिक

28

यहाँ एक है जिसे मैं प्रस्तुति स्वरूपण के लिए अक्सर उपयोग करता हूं।

public static string ToTitleCase(this string mText)
{
    if (mText == null) return mText;

    System.Globalization.CultureInfo cultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture;
    System.Globalization.TextInfo textInfo = cultureInfo.TextInfo;

    // TextInfo.ToTitleCase only operates on the string if is all lower case, otherwise it returns the string unchanged.
    return textInfo.ToTitleCase(mText.ToLower());
}

वाह, पोकेमॉन अपवाद हैंडलिंग थ्रेडबोर्ट एक्ससेप्शन जैसे मुद्दों को छिपाने वाला है, आदि कृपया कुछ विशिष्ट पकड़ें।
JBRWilkinson

28

यहाँ रोमन अंकों के लिए एक-से-एक है। अक्सर उपयोग नहीं किया जाता है, लेकिन काम किया जा सकता है। उपयोग:

if ("IV".IsValidRomanNumeral())
{
   // Do useful stuff with the number 4.
}

Console.WriteLine("MMMDCCCLXXXVIII".ParseRomanNumeral());
Console.WriteLine(3888.ToRomanNumeralString());

स्रोत:

    public static class RomanNumeralExtensions
    {
        private const int NumberOfRomanNumeralMaps = 13;

        private static readonly Dictionary<string, int> romanNumerals =
            new Dictionary<string, int>(NumberOfRomanNumeralMaps)
            {
                { "M", 1000 }, 
                { "CM", 900 }, 
                { "D", 500 }, 
                { "CD", 400 }, 
                { "C", 100 }, 
                { "XC", 90 }, 
                { "L", 50 }, 
                { "XL", 40 }, 
                { "X", 10 }, 
                { "IX", 9 }, 
                { "V", 5 }, 
                { "IV", 4 }, 
                { "I", 1 }
            };

        private static readonly Regex validRomanNumeral = new Regex(
            "^(?i:(?=[MDCLXVI])((M{0,3})((C[DM])|(D?C{0,3}))"
            + "?((X[LC])|(L?XX{0,2})|L)?((I[VX])|(V?(II{0,2}))|V)?))$", 
            RegexOptions.Compiled);

        public static bool IsValidRomanNumeral(this string value)
        {
            return validRomanNumeral.IsMatch(value);
        }

        public static int ParseRomanNumeral(this string value)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            value = value.ToUpperInvariant().Trim();

            var length = value.Length;

            if ((length == 0) || !value.IsValidRomanNumeral())
            {
                throw new ArgumentException("Empty or invalid Roman numeral string.", "value");
            }

            var total = 0;
            var i = length;

            while (i > 0)
            {
                var digit = romanNumerals[value[--i].ToString()];

                if (i > 0)
                {
                    var previousDigit = romanNumerals[value[i - 1].ToString()];

                    if (previousDigit < digit)
                    {
                        digit -= previousDigit;
                        i--;
                    }
                }

                total += digit;
            }

            return total;
        }

        public static string ToRomanNumeralString(this int value)
        {
            const int MinValue = 1;
            const int MaxValue = 3999;

            if ((value < MinValue) || (value > MaxValue))
            {
                throw new ArgumentOutOfRangeException("value", value, "Argument out of Roman numeral range.");
            }

            const int MaxRomanNumeralLength = 15;
            var sb = new StringBuilder(MaxRomanNumeralLength);

            foreach (var pair in romanNumerals)
            {
                while (value / pair.Value > 0)
                {
                    sb.Append(pair.Key);
                    value -= pair.Value;
                }
            }

            return sb.ToString();
        }
    }

यही कारण है कि मुझे अजगर पीईपी 313 है, जो अजगर में रोमन अंक शाब्दिक शामिल करने के लिए एक अप्रैल फूल मजाक था की याद दिलाता है: python.org/dev/peps/pep-0313
torial

25

आकारों से निपटने का एक सुविधाजनक तरीका:

public static class Extensions {
    public static int K(this int value) {
        return value * 1024;
    }
    public static int M(this int value) {
        return value * 1024 * 1024;
    }
}

public class Program {
    public void Main() {
        WSHttpContextBinding serviceMultipleTokenBinding = new WSHttpContextBinding() {
            MaxBufferPoolSize = 2.M(), // instead of 2097152
            MaxReceivedMessageSize = 64.K(), // instead of 65536
        };
    }
}

मेरी राय में यह वास्तव में खराब कोडिंग शैली है। इसके बजाय स्थिरांक का इस्तेमाल किया जाना चाहिए, न कि तर्क-वितर्क से।
xxbbcc

24

विजेता नियंत्रण के लिए:

/// <summary>
/// Returns whether the function is being executed during design time in Visual Studio.
/// </summary>
public static bool IsDesignTime(this Control control)
{
    if (LicenseManager.UsageMode == LicenseUsageMode.Designtime)
    {
        return true;
    }

    if (control.Site != null && control.Site.DesignMode)
    {
        return true;
    }

    var parent = control.Parent;
    while (parent != null)
    {
        if (parent.Site != null && parent.Site.DesignMode)
        {
            return true;
        }
        parent = parent.Parent;
    }
    return false;
}

/// <summary>
/// Sets the DropDownWidth to ensure that no item's text is cut off.
/// </summary>
public static void SetDropDownWidth(this ComboBox comboBox)
{
    var g = comboBox.CreateGraphics();
    var font = comboBox.Font;
    float maxWidth = 0;

    foreach (var item in comboBox.Items)
    {
        maxWidth = Math.Max(maxWidth, g.MeasureString(item.ToString(), font).Width);
    }

    if (comboBox.Items.Count > comboBox.MaxDropDownItems)
    {
        maxWidth += SystemInformation.VerticalScrollBarWidth;
    }

    comboBox.DropDownWidth = Math.Max(comboBox.Width, Convert.ToInt32(maxWidth));
}

IsDesignTime उपयोग:

public class SomeForm : Form
{
    public SomeForm()
    {
        InitializeComponent();

        if (this.IsDesignTime())
        {
            return;
        }

        // Do something that makes the visual studio crash or hang if we're in design time,
        // but any other time executes just fine
    }
}

SetDropdownWidth उपयोग:

ComboBox cbo = new ComboBox { Width = 50 };
cbo.Items.Add("Short");
cbo.Items.Add("A little longer");
cbo.Items.Add("Holy cow, this is a really, really long item. How in the world will it fit?");
cbo.SetDropDownWidth();

मैं उल्लेख करना भूल गया, कोडप्लेक्स पर इनका उपयोग करने के लिए स्वतंत्र महसूस ...


1
जैसा कि उल्लेख किया गया है, यह केवल WinForms के लिए है। यह WPF के साथ काम कर सकता है लेकिन इसमें समस्याएं हैं ( msdn.microsoft.com/en-us/library/… पर WPF के बारे में टिप्पणी में वर्णित है )। WPF मैंने मिली लिए सबसे अच्छा समाधान में वर्णन किया गया geekswithblogs.net/lbugnion/archive/2009/09/05/... (हालांकि, के रूप में यह एक स्थिर संपत्ति है, यह वास्तव में काम एक विस्तार पद्धति के रूप में करता है।)
scobi

23

ThrowIfArgumentIsNull यह करने के लिए एक अच्छा तरीका है कि हम सभी को करना चाहिए।

public static class Extensions
{
    public static void ThrowIfArgumentIsNull<T>(this T obj, string parameterName) where T : class
    {
        if (obj == null) throw new ArgumentNullException(parameterName + " not allowed to be null");
    }
}

नीचे इसका उपयोग करने का तरीका है और यह आपके नाम स्थान पर या जहाँ भी आप इसके नाम का उपयोग करते हैं, सभी वर्गों पर काम करता है।

internal class Test
{
    public Test(string input1)
    {
        input1.ThrowIfArgumentIsNull("input1");
    }
}

कोडप्लेक्स प्रोजेक्ट पर इस कोड का उपयोग करना ठीक है ।


मुझे यह भी पसंद है, जॉन के पास यह है, और मैं छाता से कुछ इसी तरह का उपयोग करता हूं, "ArgumentIs" भाग को छोड़ने के लिए खड़ा हो सकता है।
cfeduke

हाँ! यह एक kewl एक्सटेंशन विधि है :)
Pure.Krome

3
यदि आप केवल 1 स्ट्रिंग-तर्क के साथ ArgumentNullException-constructor का उपयोग करते हैं, तो उस तर्क को केवल पैरामीटर नाम होना चाहिए, न कि त्रुटि संदेश। तो आपका कोड इस तरह दिखना चाहिए: अगर (obj == null) नए ArgumentNullException (पैरामीटर नाम) को फेंक दें;
टॉमी कार्लाइल

मैं इसके लिए उपयोग करूँगा default(T)और कक्षा की आवश्यकता को हटा दूँगा।
जोएल कोएहॉर्न

1
@Joel: मूल प्रकारों के लिए गैर-डिफ़ॉल्ट मान शून्य मानों की तुलना में अधिक बार वैध तर्क होते हैं। अशक्त के खिलाफ जांच करने से डिफ़ॉल्ट के खिलाफ जांच करने की तुलना में मेरे लिए अधिक समझ में आता है। बेशक, मैं सिर्फ Require.ThatArgument(input != null)या कहकर पूरे विचार को सामान्य करता हूं Require.ThatArgument(personId > 0)। यह इतना अधिक कोड नहीं लेता है, यह बहुत अधिक लचीला है, और यह अच्छी तरह से पढ़ता है। मेरे पास अतिरिक्त ओवरराइड्स हैं जो जब आप त्रुटि संदेश या स्वयं अपवाद को अनुकूलित करना चाहते हैं, तो फ़ंक्शंस लेते हैं।
स्ट्रिपिंगवर्यर

22

मुझे C # पर जाते समय विजुअल बेसिक के स्टेटमेंट की याद आती है , इसलिए यहां यह दिया गया है:

public static void With<T>(this T obj, Action<T> act) { act(obj); }

और यहाँ C # में इसका उपयोग कैसे करना है:

someVeryVeryLonggggVariableName.With(x => {
    x.Int = 123;
    x.Str = "Hello";
    x.Str2 = " World!";
});

बहुत टाइपिंग बचाता है!

इसकी तुलना करें:

someVeryVeryLonggggVariableName.Int = 123;
someVeryVeryLonggggVariableName.Str = "Hello";
someVeryVeryLonggggVariableName.Str2 = " World!";

कोडप्लेक्स प्रोजेक्ट में डालें


4
बस एक अनुमान है, लेकिन सोचें कि अगर आपका टी एक संरचना है तो क्या होगा।
रौहोतज़

5
मैं भी समान परिणाम प्राप्त करने के लिए जहाँ भी संभव हो c # 3.0 प्रॉपर्टी इनिशियलाइज़र सिंटैक्स का उपयोग करता हूँ।
स्टीव

3
@ आचार्य, यहाँ एक उदाहरण है। यह केवल तब लागू होता है जब ऑब्जेक्ट बटन n = नया बटन {Name = "Button1", चौड़ाई = 100, ऊंचाई = 20, सक्षम = सत्य} बनाते हुए;
स्टीव

1
यह तब उपयोगी होगा जब आपके पास बहुत सारी घटनाओं को हुक करने के लिए हो, क्योंकि C # की प्रॉपर्टी इनिशियलाइज़र सिंटैक्स घटनाओं का समर्थन नहीं करती है।
गाबे

1
यह प्रॉपर्टी इनिशियलाइज़र्स के बाहर भी उपयोगकर्ता के अनुकूल है, क्योंकि आप केवल एक नई ऑब्जेक्ट बनाते समय उनका उपयोग कर सकते हैं। यह एक्सटेंशन पहले से बनाई गई वस्तुओं पर काम कर सकता है।
ब्रैडी मोरित्ज़

18

एक ऊंट कैस्केडॉर्ड या पास्कलकैडवर्क्स लेता है और "वर्डिफ़ाइ" करता है, यानी कैमल कैसवर्ड => ऊंट केस वर्ड

public static string Wordify( this string camelCaseWord )
{
    // if the word is all upper, just return it
    if( !Regex.IsMatch( camelCaseWord, "[a-z]" ) )
        return camelCaseWord;

    return string.Join( " ", Regex.Split( camelCaseWord, @"(?<!^)(?=[A-Z])" ) );
}

मैं अक्सर इसे Capitalize के साथ संयोजन में उपयोग करता हूं

public static string Capitalize( this string word )
{
    return word[0].ToString( ).ToUpper( ) + word.Substring( 1 );
}

उदाहरण उपयोग

SomeEntityObject entity = DataAccessObject.GetSomeEntityObject( id );
List<PropertyInfo> properties = entity.GetType().GetPublicNonCollectionProperties( );

// wordify the property names to act as column headers for an html table or something
List<string> columns = properties.Select( p => p.Name.Capitalize( ).Wordify( ) ).ToList( );

कोडप्लेक्स प्रोजेक्ट में उपयोग करने के लिए स्वतंत्र


कैपिटल में एग्रीगेट प्रदर्शन के लिए बहुत बुरा है, क्योंकि यह कई स्ट्रिंग इंस्टेंसेस बनाता है। इसके बजाय शब्द का उपयोग क्यों करें।
थॉमस लेवेस्क

17

मुझे यह एक मददगार लगा

public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> pSeq)
{
    return pSeq ?? Enumerable.Empty<T>();
}

यह कॉलिंग कोड में अशक्त चेक को हटा देता है। अब आप कर सकते हैं

MyList.EmptyIfNull().Where(....)

हां, अगर कोई "नल ऑब्जेक्ट पैटर्न" भूल गया, तो यह विधि इसे पैच करने के लिए उपयोगी है। संग्रह कभी भी अशक्त नहीं होना चाहिए।
पावेल होडेक

16

निर्दिष्ट संस्कृति का उपयोग करके एक डबल स्ट्रिंग को स्वरूपित में बदलें:

public static class ExtensionMethods 
{
  public static string ToCurrency(this double value, string cultureName)
  {
    CultureInfo currentCulture = new CultureInfo(cultureName);
    return (string.Format(currentCulture, "{0:C}", value));
  }
}

उदाहरण:

double test = 154.20;
string testString = test.ToCurrency("en-US"); // $154.20

13
आपको मुद्रा के लिए दशमलव का उपयोग करना चाहिए अन्यथा आपको गोलाई के मुद्दे मिलेंगे
एंड्रयू बुलॉक

सादे स्ट्रिंग के बजाय पैरामीटर में एक एनम का उपयोग करने के बारे में क्या है
रूल्स

15

नीचे एक विस्तार विधि है जो आपको रिक स्ट्राल के कोड (और टिप्पणियों को भी) को रोकती है, जिससे आपको अनुमान लगाने या बाइट सरणी या टेक्स्ट फ़ाइल के बाइट ऑर्डर मार्क को पढ़ने से रोकने के लिए हर बार जब आप इसे स्ट्रिंग में बदलते हैं।

स्निपेट आपको बस करने की अनुमति देता है:

byte[] buffer = File.ReadAllBytes(@"C:\file.txt");
string content = buffer.GetString();

यदि आपको कोई कीड़े मिलते हैं तो कृपया टिप्पणियों में जोड़ें। इसे कोडप्लेक्स प्रोजेक्ट में शामिल करने के लिए स्वतंत्र महसूस करें।

public static class Extensions
{
    /// <summary>
    /// Converts a byte array to a string, using its byte order mark to convert it to the right encoding.
    /// Original article: http://www.west-wind.com/WebLog/posts/197245.aspx
    /// </summary>
    /// <param name="buffer">An array of bytes to convert</param>
    /// <returns>The byte as a string.</returns>
    public static string GetString(this byte[] buffer)
    {
        if (buffer == null || buffer.Length == 0)
            return "";

        // Ansi as default
        Encoding encoding = Encoding.Default;       

        /*
            EF BB BF    UTF-8 
            FF FE UTF-16    little endian 
            FE FF UTF-16    big endian 
            FF FE 00 00 UTF-32, little endian 
            00 00 FE FF UTF-32, big-endian 
         */

        if (buffer[0] == 0xef && buffer[1] == 0xbb && buffer[2] == 0xbf)
            encoding = Encoding.UTF8;
        else if (buffer[0] == 0xfe && buffer[1] == 0xff)
            encoding = Encoding.Unicode;
        else if (buffer[0] == 0xfe && buffer[1] == 0xff)
            encoding = Encoding.BigEndianUnicode; // utf-16be
        else if (buffer[0] == 0 && buffer[1] == 0 && buffer[2] == 0xfe && buffer[3] == 0xff)
            encoding = Encoding.UTF32;
        else if (buffer[0] == 0x2b && buffer[1] == 0x2f && buffer[2] == 0x76)
            encoding = Encoding.UTF7;

        using (MemoryStream stream = new MemoryStream())
        {
            stream.Write(buffer, 0, buffer.Length);
            stream.Seek(0, SeekOrigin.Begin);
            using (StreamReader reader = new StreamReader(stream, encoding))
            {
                return reader.ReadToEnd();
            }
        }
    }
}

बहुत उपयोगी विधि है, लेकिन मुझे नहीं लगता कि यह होना चाहिए और विस्तार विधि।
पॉप कैटालिन

यदि आप एक टेक्स्ट एडिटर लिख रहे हैं, तो यह संभवतः एक एक्सटेंशन पद्धति को लागू करता है, लेकिन मैं ज्यादातर समय सहमत हूं कि यह शायद एक स्थिर निजी पद्धति से अधिक नहीं है
क्रिस एस

15

यहाँ एक है जिसे मैंने आज बनाया है।

// requires .NET 4

public static TReturn NullOr<TIn, TReturn>(this TIn obj, Func<TIn, TReturn> func,
        TReturn elseValue = default(TReturn)) where TIn : class
    { return obj != null ? func(obj) : elseValue; }

// versions for CLR 2, which doesn't support optional params

public static TReturn NullOr<TIn, TReturn>(this TIn obj, Func<TIn, TReturn> func,
        TReturn elseValue) where TIn : class
    { return obj != null ? func(obj) : elseValue; }
public static TReturn NullOr<TIn, TReturn>(this TIn obj, Func<TIn, TReturn> func)
        where TIn : class
    { return obj != null ? func(obj) : default(TReturn); }

यह आपको ऐसा करने देता है:

var lname = thingy.NullOr(t => t.Name).NullOr(n => n.ToLower());

जो अधिक धाराप्रवाह है और (IMO) इससे पढ़ने में आसान है:

var lname = (thingy != null ? thingy.Name : null) != null
    ? thingy.Name.ToLower() : null;

1
अगर मैं चाहता हूं thingy.NullOr(t => t.Count), तो Countइंट कहां है? आपको default(TReturn)अशक्त होने के बजाय वापस आना चाहिए , इस तरह से आपको classबाधा की आवश्यकता नहीं होगी और यह मूल्य प्रकारों के लिए भी काम करेगा
थॉमस लेवेस्क

2
TIn को एक वर्ग होना चाहिए, अन्यथा यह संपूर्ण विस्तार विधि कोई मायने नहीं रखती (मान प्रकार शून्य नहीं हो सकते)। और t.Count के साथ आपका उदाहरण उपरोक्त एक्सटेंशन विधि के साथ काम करता है। क्या आप दूसरा रूप ले सकते हैं?
स्कॉबी

@ संकेत: यह एक आम समस्या के लिए एक उपयोगी विधि है। हालाँकि, मेरा मानना TReturn elseValue = default(TReturn)है कि केवल .NET 4.0 ही उपलब्ध है? मेरे पास 3.5 SP1 है और मैंने कभी भी उस निर्माण को नहीं देखा है (न ही मेरा कंपाइलर है)। मैं इसे विधि के अंदर ले गया। हालाँकि, एक समस्या यह है कि विधि के साथ उपयोग के लिए ऑब्जेक्ट के लिए एक अशक्त प्रकार के बॉक्सिंग से अप्रत्याशित परिणाम प्राप्त होता है (0 बनाम अपेक्षित सुस्त)।
जिम स्कुबर्ट

@Jim: default(T)कीवर्ड VS2005 के बाद से है, लेकिन मुझे लगता है कि डिफ़ॉल्ट पैरामीटर एक नया .NET 4 फीचर है। इसके आस-पास का आसान तरीका दो वेरिएंट होना चाहिए, एक वह जो परम लेता है और दूसरा वह नहीं। मैं CLR 2.0 के संगत होने के उत्तर को अपडेट करूंगा। मुक्केबाजी के बारे में - यह बात है default। यह मान प्रकार के लिए 0-इनिशियलाइज्ड डेटा होगा, और सभी संदर्भ प्रकारों के लिए अशक्त होगा। फ़ंक्शन के माध्यम से सभी प्रकार के मूल्य का एक ट्रेसर्न अनबॉक्स किया जाना चाहिए।
स्कोबी

@ प्रश्न: मेरा प्रश्न डिफ़ॉल्ट पैरामीटर के बारे में था, जिसे मैंने केवल रूबी जैसी गतिशील भाषाओं में देखा है। x.Valueअशक्त प्रकारों के बारे में मेरी बात यह है कि वापस लौटने पर अशक्त होना चाहिए (यदि, उदाहरण के लिए, int?अशक्त था) या यदि int?मूल्य है। 0जब int? x = nullपास किया जाता है और ऑब्जेक्ट के लिए बॉक्सिंग किया जाता है, तो लौटना एक अजीब मामला है। मैंने इस विशिष्ट मामले के लिए पुस्तकालयों में अशक्त प्रकारों जैसे धाराप्रवाह निबर्नेट और लिनफू (मुझे लगता है) के लिए समान जांच देखी है, जिससे आपको पहले सुझाए गए अनुसार कक्षा की बाधा को छोड़ने की अनुमति मिलती है।
जिम स्कुबर्ट

14

"कोडप्लेक्स प्रोजेक्ट में कोड डालने की स्वीकृति के साथ कृपया अपने उत्तरों को चिह्नित करें।"

क्यों? CC-by-sa-2.5 के तहत इस साइट पर सभी सामग्री , इसलिए अपने लाइसेंस ओवरफ्लो प्रोजेक्ट को एक ही लाइसेंस के तहत डालें और आप स्वतंत्र रूप से इसका उपयोग कर सकते हैं।

वैसे भी, इस सवाल पर आधारित एक स्ट्रिंगर है ।

/// <summary>
/// Reverse a String
/// </summary>
/// <param name="input">The string to Reverse</param>
/// <returns>The reversed String</returns>
public static string Reverse(this string input)
{
    char[] array = input.ToCharArray();
    Array.Reverse(array);
    return new string(array);
}

क्या स्ट्रिंग पहले से ही IEnumerable <char> को लागू नहीं करता है? तो आपको बस नया स्ट्रिंग करने की आवश्यकता होगी।
इयान गैलोवे

StringBuilder का उपयोग करते हुए एक कार्यान्वयन तेज होना चाहिए।
कोडइन्चोस

1
में @CodeInChaos बेंचमार्किंग stackoverflow.com/questions/228038 मापा जाता है कि StringBuilder धीमी है।
माइकल Stum

आप सही हे। ऐसा लगता है कि थ्रेड सुरक्षा आवश्यकताओं (शायद ToString द्वारा लौटे स्ट्रिंग की अपरिवर्तनीयता सुनिश्चित करने के लिए) StringBuilder को बहुत नीचे गिरा दिया।
कोडइन्चोस

2
आशा है कि आप किसी भी सरोगेट या संयोजन पात्रों का सामना नहीं करेंगे।
dalle

14

MySqlDataReader से मान खींचते हुए मैं थकाऊ अशक्त जाँच से थक गया, इसलिए:

public static DateTime? GetNullableDateTime(this MySqlDataReader dr, string fieldName)
{
    DateTime? nullDate = null;
    return dr.IsDBNull(dr.GetOrdinal(fieldName)) ? nullDate : dr.GetDateTime(fieldName);
}

public static string GetNullableString(this MySqlDataReader dr, string fieldName)
{
    return dr.IsDBNull(dr.GetOrdinal(fieldName)) ? String.Empty : dr.GetString(fieldName);
}

public static char? GetNullableChar(this MySqlDataReader dr, string fieldName)
{
    char? nullChar = null;
    return dr.IsDBNull(dr.GetOrdinal(fieldName)) ? nullChar : dr.GetChar(fieldName);
}

बेशक यह किसी भी SqlDataReader के साथ इस्तेमाल किया जा सकता है।


हंगी और जो दोनों को यह करने के लिए कुछ अच्छी टिप्पणियां मिलीं, और मुझे तब से एक अलग संदर्भ में कुछ इसी तरह लागू करने का अवसर मिला है, इसलिए यहां एक और संस्करण है:

public static int? GetNullableInt32(this IDataRecord dr, int ordinal)
{
    int? nullInt = null;
    return dr.IsDBNull(ordinal) ? nullInt : dr.GetInt32(ordinal);
}

public static int? GetNullableInt32(this IDataRecord dr, string fieldname)
{
    int ordinal = dr.GetOrdinal(fieldname);
    return dr.GetNullableInt32(ordinal);
}

public static bool? GetNullableBoolean(this IDataRecord dr, int ordinal)
{
    bool? nullBool = null;
    return dr.IsDBNull(ordinal) ? nullBool : dr.GetBoolean(ordinal);
}

public static bool? GetNullableBoolean(this IDataRecord dr, string fieldname)
{
    int ordinal = dr.GetOrdinal(fieldname);
    return dr.GetNullableBoolean(ordinal);
}

2
यह भी IDataReader के लिए एक विस्तार विधि के रूप में काम करना चाहिए।
13

2
वास्तव में, अधिकतम संगतता के लिए IDataRecord का "यह" पैरामीटर बनाएं। इसके मेरे संस्करण में, मेरे पास एक अधिभार है जो एक अध्यादेश लेता है, जिसे फ़ील्डनाम संस्करण कहता है। "GetOrdinal" को नाम से देखने के बाद सहेजता है।
जोएल मुलर

एक उचित कार्यान्वयन है, जो किसी भी मूल्य प्रकार से निपट सकता है: rabdullin.com/journal/2008/12/6/…
Rinat Abdullin

धन्यवाद रिनैट, मुझे वास्तव में यह एक एकल सामान्य विधि के लिए मिला है - देखें stackoverflow.com/questions/303287
एडम लाससेक

ये सभी विधियाँ गैर-ज़रूरी प्रतीत होती हैं क्योंकि आप asशून्य का उपयोग करने वाले पाठक से मूल्य प्राप्त करने के लिए कीवर्ड का उपयोग कर सकते हैं । यदि आप अशक्त कोलेसिंग ??ऑपरेटर को ऑपरेटर के साथ जोड़ते हैं, तो आपके पास एक मान प्रकार पर सीधे जाने के लिए एक गैर-शून्य डिफ़ॉल्ट मान भी हो सकता है। देखें stackoverflow.com/questions/746767/…
स्टीववेवेल

14

इससे मुझे चिढ़ है कि LINQ मुझे एक ऑर्डरबाई देता है जो एक तर्क के रूप में IComparer को लागू करने वाला एक वर्ग लेता है, लेकिन एक साधारण अनाम तुलनाक फ़ंक्शन में पास होने का समर्थन नहीं करता है। मैंने उसे ठीक किया।

यह वर्ग आपके तुलनात्मक कार्य से एक IComparer बनाता है ...

/// <summary>
///     Creates an <see cref="IComparer{T}"/> instance for the given
///     delegate function.
/// </summary>
internal class ComparerFactory<T> : IComparer<T>
{
    public static IComparer<T> Create(Func<T, T, int> comparison)
    {
        return new ComparerFactory<T>(comparison);
    }

    private readonly Func<T, T, int> _comparison;

    private ComparerFactory(Func<T, T, int> comparison)
    {
        _comparison = comparison;
    }

    #region IComparer<T> Members

    public int Compare(T x, T y)
    {
        return _comparison(x, y);
    }

    #endregion
}

... और इन विस्तार विधियों ने प्रगणकों पर मेरे नए ऑर्डरबेली अधिभार को उजागर किया। मुझे शक है कि यह LINQ से SQL के लिए काम करता है, लेकिन यह LINQ से ऑब्जेक्ट्स के लिए बहुत अच्छा है।

public static class EnumerableExtensions
{
    /// <summary>
    /// Sorts the elements of a sequence in ascending order by using a specified comparison delegate.
    /// </summary>
    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
                                                                     Func<TKey, TKey, int> comparison)
    {
        var comparer = ComparerFactory<TKey>.Create(comparison);
        return source.OrderBy(keySelector, comparer);
    }

    /// <summary>
    /// Sorts the elements of a sequence in descending order by using a specified comparison delegate.
    /// </summary>
    public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
                                                                               Func<TKey, TKey, int> comparison)
    {
        var comparer = ComparerFactory<TKey>.Create(comparison);
        return source.OrderByDescending(keySelector, comparer);
    }
}

यदि आप चाहें तो इसे कोडप्लेक्स पर रखने के लिए आपका स्वागत है।


13

यह MVC के लिए है, यह <label />उस Htmlचर के लिए एक टैग उत्पन्न करने की क्षमता जोड़ता है जो हर में उपलब्ध हैViewPage । उम्मीद है कि समान एक्सटेंशन विकसित करने की कोशिश करने वाले दूसरों के लिए इसका उपयोग किया जाएगा।

उपयोग:

<%= Html.Label("LabelId", "ForId", "Text")%>

आउटपुट:

<label id="LabelId" for="ForId">Text</label>

कोड:

public static class HtmlHelperExtensions
{
    public static string Label(this HtmlHelper Html, string @for, string text)
    {
        return Html.Label(null, @for, text);
    }

    public static string Label(this HtmlHelper Html, string @for, string text, object htmlAttributes)
    {
        return Html.Label(null, @for, text, htmlAttributes);
    }

    public static string Label(this HtmlHelper Html, string @for, string text, IDictionary<string, object> htmlAttributes)
    {
        return Html.Label(null, @for, text, htmlAttributes);
    }

    public static string Label(this HtmlHelper Html, string id, string @for, string text)
    {
        return Html.Label(id, @for, text, null);
    }

    public static string Label(this HtmlHelper Html, string id, string @for, string text, object htmlAttributes)
    {
        return Html.Label(id, @for, text, new RouteValueDictionary(htmlAttributes));
    }

    public static string Label(this HtmlHelper Html, string id, string @for, string text, IDictionary<string, object> htmlAttributes)
    {
        TagBuilder tag = new TagBuilder("label");

        tag.MergeAttributes(htmlAttributes);

        if (!string.IsNullOrEmpty(id))
            tag.MergeAttribute("id", Html.AttributeEncode(id));

        tag.MergeAttribute("for", Html.AttributeEncode(@for));

        tag.SetInnerText(Html.Encode(text));

        return tag.ToString(TagRenderMode.Normal);
    }
}

MvcContrib.FluentHtml की जाँच करें
आर्निस Lapsa

इसकी जगह शायद साहित्य के साथ दोहराव होना चाहिए।
मार्क हर्ड

12

इसे चालू करें:

DbCommand command = connection.CreateCommand();
command.CommandText = "SELECT @param";

DbParameter param = command.CreateParameter();
param.ParameterName = "@param";
param.Value = "Hello World";

command.Parameters.Add(param);

... इस मामले में:

DbCommand command = connection.CreateCommand("SELECT {0}", "Hello World");

... इस विस्तार विधि का उपयोग:

using System;
using System.Data.Common;
using System.Globalization;
using System.Reflection;

namespace DbExtensions {

   public static class Db {

      static readonly Func<DbConnection, DbProviderFactory> getDbProviderFactory;
      static readonly Func<DbCommandBuilder, int, string> getParameterName;
      static readonly Func<DbCommandBuilder, int, string> getParameterPlaceholder;

      static Db() {

         getDbProviderFactory = (Func<DbConnection, DbProviderFactory>)Delegate.CreateDelegate(typeof(Func<DbConnection, DbProviderFactory>), typeof(DbConnection).GetProperty("DbProviderFactory", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(true));
         getParameterName = (Func<DbCommandBuilder, int, string>)Delegate.CreateDelegate(typeof(Func<DbCommandBuilder, int, string>), typeof(DbCommandBuilder).GetMethod("GetParameterName", BindingFlags.Instance | BindingFlags.NonPublic, Type.DefaultBinder, new Type[] { typeof(Int32) }, null));
         getParameterPlaceholder = (Func<DbCommandBuilder, int, string>)Delegate.CreateDelegate(typeof(Func<DbCommandBuilder, int, string>), typeof(DbCommandBuilder).GetMethod("GetParameterPlaceholder", BindingFlags.Instance | BindingFlags.NonPublic, Type.DefaultBinder, new Type[] { typeof(Int32) }, null));
      }

      public static DbProviderFactory GetProviderFactory(this DbConnection connection) {
         return getDbProviderFactory(connection);
      }

      public static DbCommand CreateCommand(this DbConnection connection, string commandText, params object[] parameters) {

         if (connection == null) throw new ArgumentNullException("connection");

         return CreateCommandImpl(GetProviderFactory(connection).CreateCommandBuilder(), connection.CreateCommand(), commandText, parameters);
      }

      private static DbCommand CreateCommandImpl(DbCommandBuilder commandBuilder, DbCommand command, string commandText, params object[] parameters) {

         if (commandBuilder == null) throw new ArgumentNullException("commandBuilder");
         if (command == null) throw new ArgumentNullException("command");
         if (commandText == null) throw new ArgumentNullException("commandText");

         if (parameters == null || parameters.Length == 0) {
            command.CommandText = commandText;
            return command;
         }

         object[] paramPlaceholders = new object[parameters.Length];

         for (int i = 0; i < paramPlaceholders.Length; i++) {

            DbParameter dbParam = command.CreateParameter();
            dbParam.ParameterName = getParameterName(commandBuilder, i);
            dbParam.Value = parameters[i] ?? DBNull.Value;
            command.Parameters.Add(dbParam);

            paramPlaceholders[i] = getParameterPlaceholder(commandBuilder, i);
         }

         command.CommandText = String.Format(CultureInfo.InvariantCulture, commandText, paramPlaceholders);

         return command;
      }
   }
}

अधिक ADO.NET एक्सटेंशन के तरीके: DbExtensions

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.