एक स्ट्रिंग अपर केस का पहला अक्षर बनाओ (अधिकतम प्रदर्शन के साथ)

448

मेरे पास एक DetailsViewहै TextBox और मैं चाहता हूं कि इनपुट डेटा को हमेशा FIRST LETTER IN CAPITAL के साथ सहेजा जाए ।

उदाहरण:

"red" --> "Red"
"red house" --> " Red house"

मैं इस अधिकतम प्रदर्शन को कैसे प्राप्त कर सकता हूं ?

नोट :
उत्तर और उत्तरों के तहत टिप्पणियों के आधार पर, बहुत से लोग सोचते हैं कि यह स्ट्रिंग के सभी शब्दों को कैपिटल करने के बारे में पूछ रहा है । उदाहरण के लिए => Red House यह नहीं है, लेकिन है कि यदि आप क्या चाहते हैं है , जवाब है कि का उपयोग करता है में से एक के लिए देखो TextInfoकी ToTitleCaseविधि। (नोट: उन उत्तरों को वास्तव में पूछे गए प्रश्न के लिए गलत हैं ।) TextInfo
देखें । ToTitleCase caveats के लिए डॉक्टर (सभी- कैपेस शब्दों को नहीं छूते हैं - उन्हें समरूप माना जाता है; शब्दों के बीच में अक्षरों को कम कर सकते हैं जो "नहीं होना चाहिए" हो सकता है) कम किया गया, उदाहरण के लिए "मैकडॉनल्ड" => "मैकडोनाल्ड"; सभी संस्कृति-विशिष्ट सूक्ष्मताओं को पुन: पूंजीकरण नियमों को संभालने की गारंटी नहीं है।)

नोट :
यह प्रश्न अस्पष्ट है कि क्या पहले के बाद के अक्षरों को निचले मामले में मजबूर किया जाना चाहिए । स्वीकृत उत्तर मानता है कि केवल पहले अक्षर को बदल दिया जाना चाहिए । यदि आप पहले अक्षर को छोड़कर सभी अक्षरों को जबरदस्ती कम करना चाहते हैं , तो किसी उत्तर वाले प्रश्न को देखें , न कि ToTititCase युक्त ।ToLower

c#  performance 
— Dylan-मायर्स
स्रोत
7
@ लॉबी: यह डुप्लिकेट नहीं है: ओपी एक स्ट्रिंग के पहले अक्षर को कैपिटल करने के लिए कहता है, लिंक में प्रश्न प्रत्येक शब्द के पहले अक्षर को कैपिटल करता है।
— GvS
1
@GvS: पहला उत्तर बहुत विस्तृत है और पहला कोड-ब्लॉक वास्तव में वही है जिसकी उसे तलाश है। इसके अलावा, प्रत्येक शब्द को कैपिटलाइज़ करने और केवल पहले शब्द के बीच केवल एक लूप अंतर है।
— बॉबी
क्या आपने कभी इसे सफलतापूर्वक हल किया? क्या आपको अभी भी इसके लिए मदद की ज़रूरत है?
— jcolebrand
1
लेकिन आपने कहा था, और मैं बोली, "प्रत्येक शब्द का पहला अक्षर बनाओ ऊपरी मामला"। इसलिए, "लाल घर" -> "लाल घर" क्यों? "हाउस" का "ज" कैपिटल लेटर क्यों नहीं है?
— गिलर्मो Gutiérrez
एक उत्तर जोड़ा गया क्योंकि अधिकांश उत्तर विफल हो जाएंगे यदि आपके पास प्रारंभ में एक सफेद स्थान है। प्रत्येक उत्तर पर इसे पोस्ट करने से बचने के लिए, मैं इसे एक बार यहाँ पोस्ट करूँगा।
— नॉक्टिस

जवाबों:

583

C # 8 को अपडेट किया गया

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input) =>
        input switch
        {
            null => throw new ArgumentNullException(nameof(input)),
            "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
            _ => input.First().ToString().ToUpper() + input.Substring(1)
        };
}

सी # 7

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input)
    {
        switch (input)
        {
            case null: throw new ArgumentNullException(nameof(input));
            case "": throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input));
            default: return input.First().ToString().ToUpper() + input.Substring(1);
        }
    }
}

वास्तव में पुराने जवाब

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + String.Join("", input.Skip(1));
}

संपादित करें : यह संस्करण छोटा है। तेजी से समाधान के लिए Equiso के जवाब पर एक नज़र डालें

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + input.Substring(1);
}

EDIT 2 : संभवत: सबसे तेज़ समाधान डैरेन है (वहाँ भी एक मानदंड है) हालांकि मैं इसे string.IsNullOrEmpty(s)अपवाद को बदलने के लिए मान्य करूँगा क्योंकि मूल आवश्यकता पहले अक्षर के अस्तित्व में आने की उम्मीद करती है इसलिए इसे अपरकेस किया जा सकता है। ध्यान दें कि यह कोड सामान्य स्ट्रिंग के लिए काम करता है और विशेष रूप से मान्य मानों पर नहीं Textbox।

— कार्लोस मुअनोज़
स्रोत
2
क्योंकि पहला पैरामीटर String.Joinविभाजक है जिसके साथ दूसरे पैरामीटर के साथ दिए गए तार जुड़ने हैं।
— डायलेक्टिकस
27
मुझे वास्तव में आपका उत्तर पसंद है, लेकिन var arr = input.ToCharArray(); arr[0] = Char.ToUpperInvariant(arr[0]); return new String(arr);संभवत: कुछ गति प्राप्त होगी क्योंकि आप कम अपरिवर्तनीय वस्तुओं का निर्माण कर रहे हैं (और विशेष रूप से आप स्किप कर रहे हैं String.Join)। यह कोर्स स्ट्रिंग की लंबाई पर निर्भर करता है।
— फ्लिंडेबर्ग
3
बहुत बढ़िया - Linq का उपयोग यह बहुत स्पष्ट करता है कि यह कोड क्या करता है।
— डैनियल जेम्स ब्रायर्स
7
हम्म् ... तकनीकी रूप से, यह ऊपरी केस फर्स्ट लेटर नियम के "Argh!"साथ वापस आ जाना चाहिए । ;)
— jp2code
2
@ jp2code एक अशक्त या खाली स्ट्रिंग में किसी भी पहले अक्षर को बड़ा करने के बाद से गर्भवती डॉल्फिंग द्वारा थप्पड़ मारने की तरह है, तो सभी कैप ARGH! सही वर्तनी है। urbandfox.com/define.php?term=ARGH&defid=67839
— कार्लोस मुनोज़
319 
public string FirstLetterToUpper(string str)
{
    if (str == null)
        return null;

    if (str.Length > 1)
        return char.ToUpper(str[0]) + str.Substring(1);

    return str.ToUpper();
}

पुराना उत्तर: यह ऊपरी मामले में हर पहले पत्र को बनाता है

public string ToTitleCase(string str)
{
    return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
}
— डिएगो टोरेस
स्रोत
लेकिन यह एक शब्द के हर पहले अक्षर को अपरकेस में परिवर्तित करता है, न कि एक स्ट्रिंग के पहले वर्ण को।
— GvS
@ जीवीएस, यही सवाल आपसे करने को कहता है।
— thattolleyguy
17
वह "लाल घर" => "लाल घर" पूछता है। ToTitleCase आपको "रेड हाउस" देगा।
— GvS
1
मेरे लिए मददगार। महान
— एहसान सज्जाद
1
इस बारे में निश्चित नहीं है लेकिन char + string बॉक्सिंग का कारण बनती है। बस के मामले में अधिकतम प्रदर्शन की आवश्यकता है।
— नवाफाल
164

संस्कृति का उपयोग करने का सही तरीका है:

System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(word.ToLower())

नोट: यह प्रत्येक शब्द को एक स्ट्रिंग के भीतर कैपिटल करेगा, उदाहरण के लिए "रेड हाउस" -> "रेड हाउस"। समाधान शब्दों के भीतर भी कम पूंजीकरण करेगा, उदाहरण के लिए "पुराना मैकडॉनल्ड्स" -> "ओल्ड मैकडोनाल्ड"।

— पियरे-यवेस गुइलेट
स्रोत
4
यह पहिया को सुदृढ़ करने के बजाय इसे करने का सबसे उचित तरीका है और आपको इसका खुद का संस्करण लिखने का प्रयास करना है।
— अलेक्सी श्वेलेव
12
इसके साथ मेरा मुद्दा यह है कि यह मध्य-स्ट्रिंग वाले संभावित वैध पूंजी पत्रों को मिटा देगा। उदा। मैकनेम
— जेकॉम
29
यह इस कारण के लिए एक गलत उत्तर है कि "रेड हाउस" "रेड हाउस" बन जाता है (नोटिस "एच")!
— स्पाकार
21
प्रश्न पूछे जाने के छह साल बाद, कृपया मौजूदा उत्तरों और उनकी टिप्पणियों को पढ़ने का अधिक गहन कार्य करें । यदि आप आश्वस्त हैं कि आपके पास एक बेहतर समाधान है, तो उन स्थितियों को दिखाएं जिनमें आपका जवाब इस तरह से व्यवहार करता है जैसा आपको लगता है कि बेहतर है, और विशेष रूप से यह कि मौजूदा उत्तरों से अलग कैसे है। 1) इक्विको ने पहले ही इस विकल्प को कवर कर दिया था, उनके उत्तर के दूसरे भाग में। 2) कई स्थितियों के लिए, ToLowerएक गलती है, क्योंकि यह शब्द के बीच में पूंजीकरण को मिटा देता है, जैसे "मैकडॉनल्ड्स"। 3) प्रश्न के बारे में है स्ट्रिंग का सिर्फ पहला शब्द बदल रहा है , नहीं TitleCase के बारे में।
— टूलमेकरसेव
10
यह इनपुट को "टाइटल केस" में बदल देता है - इसलिए यह "रेड हॉर्स" को "रेड हॉर्स" में बदल देता है - जबकि व्यक्ति स्पष्ट रूप से पूछ रहा है कि इसे ऐसा नहीं करना चाहिए (और "लाल घोड़ा" लौटाएं)। यह सही तरीका नहीं है।
— हेक्करीक
68

मैंने http://www.dotnetperls.com/uppercase-first-letter से सबसे तेज़ तरीका निकाला और एक्सटेंशन विधि में परिवर्तित कर दिया:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase, or mutates any nulls passed into string.Empty
    /// </summary>
    public static string FirstLetterToUpperCaseOrConvertNullToEmptyString(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

नोट: उपयोग करने का कारण ToCharArrayविकल्प की तुलना में तेज है char.ToUpper(s[0]) + s.Substring(1), यह है कि केवल एक स्ट्रिंग आवंटित की जाती है, जबकि Substringदृष्टिकोण सबस्ट्रिंग के लिए एक स्ट्रिंग आवंटित करता है, फिर अंतिम परिणाम बनाने के लिए एक दूसरा स्ट्रिंग।

EDIT : यहाँ यह दृष्टिकोण कैसा दिखता है, इसे कार्लोसमुनाज़ के प्रारंभिक परीक्षण के साथ स्वीकार कर लिया गया है :

    /// <summary>
    /// Returns the input string with the first character converted to uppercase
    /// </summary>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrEmpty(s))
            throw new ArgumentException("There is no first letter");

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }
— डैरेन
स्रोत
वाह, प्रदर्शन मैट्रिक्स खोजने के लिए धन्यवाद, एक बेहतर प्रदर्शन समाधान दिखाने के लिए!
— टूलमेकरसेव
@ToolmakerSteve, मुझे यह समाधान पसंद है क्योंकि यह वास्तव में दूसरों की तुलना में तेज़ लगता है लेकिन इसके साथ थोड़ी समस्या है। यदि आप अशक्त हो जाते हैं तो आपको आउटपुट के रूप में खाली स्ट्रिंग नहीं मिलनी चाहिए। वास्तव में मैं यह तर्क दूंगा कि ओपी के पहले पूछने के बाद से एक खाली स्ट्रिंग को भी पास करना चाहिए पत्र के । साथ ही, आप उन्हें संपादित करने से पहले अन्य लोगों के उत्तर पर टिप्पणी कर सकते हैं।
— कार्लोस मुनोज़
@ CarlosMuñoz - यह मेटा में चर्चा की गई है, कि क्या अन्य लोगों के उत्तरों को "सुधार" करना है। सर्वसम्मति थी "यदि आप किसी उत्तर को बेहतर बना सकते हैं, तो ऐसा करें - कोई भी एक उत्तर का मालिक नहीं है, मूल लेखक का भी नहीं - लक्ष्य के लिए सर्वोत्तम संभव उत्तर है"। आप संपादित करने या रोलबैक करने के लिए निश्चित रूप से स्वतंत्र हैं। किस मामले में, आम शिष्टाचार मूल लेखक के संस्करण को अंतिम परिणाम देगा, और मैं टिप्पणी करने के लिए तय करूंगा। आम तौर पर मैं भी एक टिप्पणी परिवर्तन मैं बनाने हूँ में डाल; अगर मैंने नहीं किया तो मैं माफी मांगता हूं।
— टूलमेकरसेव
@ कार्लोसमुनाज़ - विशेष रूप से, एसओ में कई, कई जवाब हैं, जो सक्रिय रूप से बनाए नहीं हैं। यदि कोई परिवर्तन एक उत्तर को बेहतर बनाता है, तो उसे एक टिप्पणी में दफन क्यों छोड़ दें? यदि लेखक सक्रिय रूप से उनके उत्तरों की निगरानी कर रहा है, तो वे बदलाव के साथ करेंगे जैसा कि वे फिट देखते हैं। यदि वे नहीं हैं, तो जवाब में सुधार किया गया है, हर किसी के लाभ के लिए। यह सिद्धांत विशेष रूप से सच है, पुराने प्रश्नोत्तर के लिए, जैसे कि यह।
— टूलमेकरसेव
BTW, मैं विधि की शुरुआत में परीक्षण के बारे में @ CarlosMuñoz से सहमत हूं - उस परीक्षण का उसका संस्करण बेहतर प्रोग्रामिंग शैली है - return string.Emptyयहां विधि के लिए "खराब" कॉल छिपा होगा।
— टूलमेकरसेव
46

आप "ToTitleCase विधि" का उपयोग कर सकते हैं

string s = new CultureInfo("en-US").TextInfo.ToTitleCase("red house");
//result : Red House

यह विलोपन विधि हर शीर्षक समस्या को हल करती है।

उपयोग में आसान

string str = "red house";
str.ToTitleCase();
//result : Red house

string str = "red house";
str.ToTitleCase(TitleCase.All);
//result : Red House

विस्तार विधि

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace Test
{
    public static class StringHelper
    {
        private static CultureInfo ci = new CultureInfo("en-US");
        //Convert all first latter
        public static string ToTitleCase(this string str)
        {
            str = str.ToLower();
            var strArray = str.Split(' ');
            if (strArray.Length > 1)
            {
                strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                return string.Join(" ", strArray);
            }
            return ci.TextInfo.ToTitleCase(str);
        }
        public static string ToTitleCase(this string str, TitleCase tcase)
        {
            str = str.ToLower();
            switch (tcase)
            {
                case TitleCase.First:
                    var strArray = str.Split(' ');
                    if (strArray.Length > 1)
                    {
                        strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                        return string.Join(" ", strArray);
                    }
                    break;
                case TitleCase.All:
                    return ci.TextInfo.ToTitleCase(str);
                default:
                    break;
            }
            return ci.TextInfo.ToTitleCase(str);
        }
    }

    public enum TitleCase
    {
        First,
        All
    }
}
— İbrahim Özbölük
स्रोत
आपके समाधान में समस्या यह है कि "रेड हाउस" को "रेड हाउस" में बदल दिया जाएगा, न कि "रेड हाउस" को, जैसा कि प्रश्न में पूछा गया था।
— वादिम
3
@ टैक्टिन यह काम करेगा लेकिन निम्नलिखित कोड को पढ़ने में आसान है और बेहतर char.ToUpper (पाठ [0]) + ((text.Length> 1)? Text.Substring (1) .ToLower (): string.Empty) करने के लिए आसान है। ; आप और अधिक पढ़ें @ vkreynin.wordpress.com/2013/10/09/…
— वादिम
1
मुझे यह समाधान पसंद नहीं है, क्योंकि यह दो अलग-अलग स्थितियों को एक लंबी विधि में जोड़ता है। मुझे वैचारिक लाभ भी नहीं दिख रहा है। और सिर्फ पहले अक्षर को बड़े पैमाने पर लागू करना हास्यास्पद है। यदि आप पहले अक्षर को कैपिटलाइज़ करना चाहते हैं, तो स्पष्ट कार्यान्वयन पहले अक्षर को केवल कैपिटलाइज़ (ToUpper) करना है । इसके बजाय, मेरे पास दो अलग तरीके होंगे। FirstLetterToUpperईक्विओ के उत्तर में (या गुइलेरनेट के नए उत्तर में), और ToTitleCaseयहां, लेकिन दूसरे पैरामीटर के बिना। फिर जरूरत नहीं है enum TitleCase।
— टूलमेकरसेव
31

पहले पत्र के लिए, त्रुटि जाँच के साथ:

public string CapitalizeFirstLetter(string s)
{
    if (String.IsNullOrEmpty(s))
        return s;
    if (s.Length == 1)
        return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
}

और यहाँ एक आसान विस्तार के रूप में ही है

public static string CapitalizeFirstLetter(this string s)
    {
    if (String.IsNullOrEmpty(s)) return s;
    if (s.Length == 1) return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
    }
— कोबी
स्रोत
स्वच्छ दृष्टिकोण। धन्यवाद!
— फिलिप
11 
public static string ToInvarianTitleCase(this string self)
{
    if (string.IsNullOrWhiteSpace(self))
    {
        return self;
    }

    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(self);
}
— बिग टी
स्रोत
6

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

public static string ToUpperFirst(this string str) {
  if( !string.IsNullOrEmpty( str ) ) {
    StringBuilder sb = new StringBuilder(str);
    sb[0] = char.ToUpper(sb[0]);

    return sb.ToString();

  } else return str;
}
— डैनियल हैलन
स्रोत
3
यह char[]एक StringBuilderरैप के सभी बुनियादी ढांचे के बजाय एक सरल के साथ किया जा सकता है । इसके बजाय new StringBuilder(str), उपयोग करें str.ToCharArray(), और इसके बजाय sb.ToString(), उपयोग करें new string(charArray)। StringBuilderअनुक्रमण के प्रकार का अनुकरण करता है जो एक वर्ण सरणी मूल रूप से उजागर करता है, इसलिए वास्तविक .ToUpperरेखा अनिवार्य रूप से समान हो सकती है। :-)
— जोनाथन गिल्बर्ट
डैरेन (एक साल बाद) दिखाता है कि यह कैसे करना है ToCharArray, जैसा कि @
— जोनाथन गिल्बर्ट
6

सबसे तेज़ विधि।

  private string Capitalize(string s){
        if (string.IsNullOrEmpty(s))
        {
            return string.Empty;
        }
        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
}

टेस्ट अगले परिणाम दिखाते हैं (इनपुट के रूप में 10000 प्रतीकों के साथ स्ट्रिंग): टेस्ट परिणाम

— Александр Иванов
स्रोत
1
मैं sअशक्त या खाली होने पर रिटर्निंग पैरामीटर की सलाह देता हूं ।
— MatrixRonny
4

इसे इस्तेमाल करे:

static public string UpperCaseFirstCharacter(this string text) {
    return Regex.Replace(text, "^[a-z]", m => m.Value.ToUpper());
}
— JoelFan
स्रोत
2
या शायद कुछ अन्य चरित्र वर्ग (यानी अल्फ़ान्यूमेरिक \ w), ताकि फ़ंक्शन यूनिकोड-अवगत हो
— दिमित्री लेडेंटसोव
@ DmitryLedentsov- C # स्ट्रिंग क्लास UTF-16 अक्षरों पर बनाया गया है। स्ट्रिंग क्लास "UTF-16 कोड इकाइयों के अनुक्रम के रूप में पाठ का प्रतिनिधित्व करता है।"
— टूलमेकरसेव
4

यदि आप केवल पहले अक्षर के कैपिटल होने की परवाह करते हैं और यह बाकी स्ट्रिंग से कोई फर्क नहीं पड़ता है, तो आप केवल पहले वर्ण का चयन कर सकते हैं, इसे ऊपरी मामला बना सकते हैं और इसे मूल पहले वर्ण के बिना बाकी स्ट्रिंग के साथ संक्षिप्त कर सकते हैं।

String word ="red house";
word = word[0].ToString().ToUpper() + word.Substring(1, word.length -1);
//result: word = "Red house"

हमें पहले चरित्र ToString () को बदलने की आवश्यकता है क्योंकि हम इसे एक चार सरणी के रूप में पढ़ रहे हैं, और चार प्रकार में ToUpper () विधि नहीं है।

— विक्टर गार्सिया
स्रोत
3

इसे विस्तार विधि के रूप में करने का एक तरीका है:

static public string UpperCaseFirstCharacter(this string text)
{
    if (!string.IsNullOrEmpty(text))
    {
        return string.Format(
            "{0}{1}",
            text.Substring(0, 1).ToUpper(),
            text.Substring(1));
    }

    return text;
}

तब कहा जा सकता है:

//yields "This is Brian's test.":
"this is Brian's test.".UpperCaseFirstCharacter();

और यहाँ इसके लिए कुछ यूनिट परीक्षण हैं:

[Test]
public void UpperCaseFirstCharacter_ZeroLength_ReturnsOriginal()
{
    string orig = "";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual(orig, result);
}

[Test]
public void UpperCaseFirstCharacter_SingleCharacter_ReturnsCapital()
{
    string orig = "c";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("C", result);
}

[Test]
public void UpperCaseFirstCharacter_StandardInput_CapitalizeOnlyFirstLetter()
{
    string orig = "this is Brian's test.";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("This is Brian's test.", result);
}
— bingles
स्रोत
1
string.Formatओवरकिल है; बस करो text.Substring(0, 1).ToUpper() + text.Substring(1)।
— टूलमेकरसेव
3

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

public static string CaptalizeFirstLetter(this string data)
{
    var chars = data.ToCharArray();

    // Find the Index of the first letter
    var charac = data.First(char.IsLetter);
    var i = data.IndexOf(charac);

    // capitalize that letter
    chars[i] = char.ToUpper(chars[i]);

    return new string(chars);
}

मुझे यकीन है कि इसे थोड़ा सा अनुकूलित या साफ करने का एक तरीका है।

— CAOakley
स्रोत
3

मुझे यहां कुछ मिला है http://www.dotnetperls.com/uppercase-first-letter :

static string UppercaseFirst(string s)
{
// Check for empty string.
if (string.IsNullOrEmpty(s))
{
    return string.Empty;
}
// Return char and concat substring.
return char.ToUpper(s[0]) + s.Substring(1);
}

शायद यह मदद करता है !!

— मोहम्मद ज़मीर
स्रोत
यह 4 साल पहले इक्विओ के जवाब पर कैसे सुधार है?
— टूलमेकरसेव
3

जांचें कि यदि स्ट्रिंग अशक्त नहीं है, तो पहले चरित्र को ऊपरी मामले में और बाकी हिस्सों को निचले मामले में परिवर्तित करें: 

public static string FirstCharToUpper(string str)
{
    return str?.First().ToString().ToUpper() + str?.Substring(1).ToLower();
}
— mbadeveloper
स्रोत
कोड की कुछ पंक्तियों के बजाय केवल एक छोटे शब्द के लिए छोटे समाधान के लिए धन्यवाद!
— इमरान फारुकी
2

यह ऐसा करेगा, हालांकि यह भी सुनिश्चित करेगा कि कोई गलत राजधानियां नहीं हैं जो शब्द की शुरुआत में नहीं हैं।

public string(string s)
{
System.Globalization.CultureInfo c = new System.Globalization.CultureInfo("en-us", false)
System.Globalization.TextInfo t = c.TextInfo;

return t.ToTitleCase(s);
}
— जेफ हॉर्नी
स्रोत
2
sToTitleCase पर कॉल करने से पहले एक अशक्त जांच की आवश्यकता है ।
— तारास अलीनिन
@ CarlosMuñoz tlhIngan Hol के पास इसकी स्क्रिप्ट में लेटर केसिंग नहीं है। :-)
— जोनाथन गिल्बर्ट
2

जब आप सभी की आवश्यकता होती है तो यहां बहुत जटिलता प्रतीत होती है:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase if a letter
    /// </summary>
    /// <remarks>Null input returns null</remarks>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrWhiteSpace(s))
            return s;

        return char.ToUpper(s[0]) + s.Substring(1);
    }

उल्लेखनीय बिंदु:

  1. इसका एक विस्तार तरीका है।

  2. यदि इनपुट शून्य है, तो रिक्त या व्हाट्सएप इनपुट के रूप में वापस आ गया है।

  3. String.IsNullOrWhiteSpace .NET फ्रेमवर्क 4 के साथ पेश किया गया था। यह पुराने फ्रेमवर्क के साथ काम नहीं करेगा।

— स्टीफन कैनेडी
स्रोत
1
मैं नहीं देखता कि यह चार साल पहले के मूल स्वीकृत उत्तर पर कैसे सुधार है। वास्तव में, यह असंगत है (हानिरहित तो, लेकिन चार साल देर से, मेरे पास एक नया उत्तर जोड़ने के लाभ के लिए उच्च मानक हैं): नए का उपयोग करने के IsNullOrWhiteSpaceबजाय एकमात्र लाभ यह है IsNullOrEmpty, यदि आप पहले गैर को खोजने और बदलने जा रहे हैं- सफेद स्थान । लेकिन आप नहीं करते - आप हमेशा काम करते हैं s[0]। तो इसका व्यर्थ [अर्थ और प्रदर्शन दोनों] उपयोग करने के लिए IsNullOrWhiteSpace।
— टूलमेकरसेव
... IsNullOrWhiteSpaceमुझे परेशानियों का यह उपयोग क्यों है, एक लापरवाह पाठक सोच सकता है "उसने सफेद स्थान की जांच की, इसलिए निम्न कोड वास्तव में एक पत्र को ढूंढता है और बदल देता है, भले ही वह सफेद स्थान से पहले हो"। चूंकि आपका कोड सफेद स्थान से पहले "पहले" अक्षर को बदलने में विफल होगा, इसलिए IsNullOrWhiteSpaceकेवल एक पाठक को भ्रमित कर सकता है ।
— टूलमेकरसेव
... उफ़, मेरा मतलब स्वीकार किए गए उत्तर से नहीं है, मेरा मतलब है कि उसी समय की अवधि से इक्विओ का जवाब ।
— टूलमेकरसेव
1 
string emp="TENDULKAR";
string output;
output=emp.First().ToString().ToUpper() + String.Join("", emp.Skip(1)).ToLower();
— शैलेश
स्रोत
क्यों पूंछ पर ()? अन्य अक्षरों के लिए कोई आवश्यकता नहीं है लेकिन पहले वाला है।
— कार्लोस मुनोज़
Stringकुछ भी हो सकता है Upperया Lowerसभी स्ट्रिंग के लिए इसका एक सामान्य समाधान है।
— शैलेश
Joinइसके बजाय क्यों emp.First().ToString().ToUpper() + emp.Substring(1);? संभवतः अधिक रक्षात्मक होने की भी आवश्यकता है output = string.IsNullOrEmpty(emp) ? string.Empty : [...]:। इसके अलावा, fwiw, @ CarlosMuñoz से सहमत हैं - आपको ToLower()ओपी के प्रश्न की आवश्यकता नहीं है ।
— रफिन
@ रफ़िन -> Substring कोड की अच्छी लेखन शैली का भी उपयोग कर रहा है, मैं आपके समाधान को एक कोड ट्रिम करने के लिए सहमत हूं लेकिन इस मामले में लिखना एक ToLower()अच्छा प्रोग्रामिंग अभ्यास है। stringकुछ भी हो सकता है यदि Upperमामला या Lowerमामला उपयोगकर्ता इनपुट पर निर्भर करता है, तो मैं एक सामान्य समाधान देता हूं।
— शैलेश
@ शीलेश - हालाँकि, इस सवाल का अनुरोध नहीं किया गया था कि केवल पहला अक्षर ही पूँजी होगा। इसने पूछा कि पहले अक्षर को पूंजी में बदल दिया जाए। लेखक से और अधिक स्पष्टीकरण के बिना, सबसे स्वाभाविक धारणा यह है कि स्ट्रिंग के शेष अपरिवर्तित रहें। यह देखते हुए कि आप तीन साल बाद जवाब दे रहे हैं , कृपया मान लें कि स्वीकृत उत्तर वही करता है जो पूछने वाले ने अनुरोध किया है। केवल एक अलग उत्तर दें यदि इसे अलग तरीके से करने के लिए कुछ तकनीकी कारण है।
— टूलमेकरसेव
1

मैं "मैक्सिमम परफ़ॉर्मेंस" उत्तर देना चाहता था। मेरे दिमाग में, एक "मैक्सिमम प्रदर्शन" उत्तर सभी परिदृश्यों को पकड़ता है और उन परिदृश्यों के लिए प्रश्न लेखांकन का उत्तर प्रदान करता है। तो, यहाँ मेरा जवाब है। इन कारणों के साथ:

  1. IsNullOrWhiteSpace स्ट्रिंग्स के लिए खाते हैं जो केवल रिक्त स्थान या रिक्त / रिक्त हैं।
  2. .Trim () स्ट्रिंग के सामने और पीछे से व्हाट्सएप को हटाता है।
  3. .First () एक ienumerable (या स्ट्रिंग) का पहला चरित्र लेता है।
  4. हमें यह देखना चाहिए कि क्या यह एक पत्र है जो अपरकेस हो सकता है / होना चाहिए।
  5. हम फिर बाकी स्ट्रिंग जोड़ते हैं, केवल अगर लंबाई इंगित करती है कि हमें चाहिए।
  6. .Net सर्वोत्तम अभ्यास द्वारा, हमें System.Globalization.CultureInfo के तहत एक संस्कृति प्रदान करनी चाहिए।

  7. हर बार चुनी गई संस्कृति को टाइप किए बिना, उन्हें वैकल्पिक मापदंडों के रूप में प्रदान करना इस पद्धति को पूरी तरह से पुन: प्रयोज्य बनाता है।

    public static string capString(string instring, string culture = "en-US", bool useSystem = false)
{
    string outstring;
    if (String.IsNullOrWhiteSpace(instring))
    {
        return "";
    }
    instring = instring.Trim();
    char thisletter = instring.First();
    if (!char.IsLetter(thisletter))
    {
        return instring;   
    }
    outstring = thisletter.ToString().ToUpper(new CultureInfo(culture, useSystem));
    if (instring.Length > 1)
    {
        outstring += instring.Substring(1);
    }
    return outstring;
}
— पैट्रिक नॉट
स्रोत
2
हालांकि यह ज्यादातर मामलों को कवर करता है, लेकिन क्या यह प्रत्येक ऑपरेशन के साथ पैदा होने वाले तारों की संख्या को देखते हुए धीमा नहीं होगा? यहां एक टन स्ट्रिंग आवंटन हो रहा है। अधिमानतः यह एक बार आवंटित किया जाएगा, और केवल एक बार।
— डगलस गस्केल
1

हाल ही में मुझे एक समान आवश्यकता थी और याद आया कि LINQ फ़ंक्शन सेलेक्ट () एक इंडेक्स प्रदान करता है:

string input;
string output;

input = "red house";
output = String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
//output = "Red house"

चूँकि मुझे बहुत बार जरूरत है कि मैंने स्ट्रिंग प्रकार के लिए एक विस्तार विधि बनाई:

public static class StringExtensions
{
    public static string FirstLetterToUpper(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return string.Empty;
        return String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
    }
}

कृपया ध्यान दें कि केवल पहला अक्षर ऊपरी मामले में बदल जाता है - सभी शेष वर्णों को छुआ नहीं जाता है। यदि आपको अन्य वर्णों के निचले मामले की आवश्यकता है, तो आप पहली बार पूरे स्ट्रिंग पर ToLower () को Index> 0 के लिए Char.ToLower (currentChar) भी कह सकते हैं।

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

— ग्रिम
स्रोत
मैं सोच रहा था कि मैं इस समस्या को कैसे हल करूंगा, अपना स्वयं का समाधान काम किया, फिर वापस आ गया केवल इसे खोजने के लिए कि आप ठीक उसी समाधान के साथ आए थे जो मैं पहले से ही था। आप को +1!
— ब्लूफिजाइटिंग
आपका बहुत बहुत धन्यवाद।
— ग्रिम
1

मुझे लगता है कि नीचे दी गई विधि सबसे अच्छा समाधान है

    class Program
{
    static string UppercaseWords(string value)
    {
        char[] array = value.ToCharArray();
        // Handle the first letter in the string.
        if (array.Length >= 1)
        {
            if (char.IsLower(array[0]))
            {
                array[0] = char.ToUpper(array[0]);
            }
        }
        // Scan through the letters, checking for spaces.
        // ... Uppercase the lowercase letters following spaces.
        for (int i = 1; i < array.Length; i++)
        {
            if (array[i - 1] == ' ')
            {
                if (char.IsLower(array[i]))
                {
                    array[i] = char.ToUpper(array[i]);
                }
            }
        }
        return new string(array);
    }

    static void Main()
    {
        // Uppercase words in these strings.
        const string value1 = "something in the way";
        const string value2 = "dot net PERLS";
        const string value3 = "String_two;three";
        const string value4 = " sam";
        // ... Compute the uppercase strings.
        Console.WriteLine(UppercaseWords(value1));
        Console.WriteLine(UppercaseWords(value2));
        Console.WriteLine(UppercaseWords(value3));
        Console.WriteLine(UppercaseWords(value4));
    }
}

Output

Something In The Way
Dot Net PERLS
String_two;three
 Sam

संदर्भ

— D.JCode
स्रोत
1

जैसा कि यह सवाल प्रदर्शन को अधिकतम करने के बारे में है, मैंने एस का उपयोग करने के लिए डैरेन के संस्करण को अपनाया Span, जो कचरा कम करता है और लगभग 10% की गति में सुधार करता है।

        /// <summary>
        /// Returns the input string with the first character converted to uppercase
        /// </summary>
        public static string ToUpperFirst(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            Span<char> a = stackalloc char[s.Length];
            s.AsSpan(1).CopyTo(a.Slice(1));
            a[0] = char.ToUpper(s[0]);
            return new string(a);
        }

प्रदर्शन

|  Method |      Data |      Mean |     Error |    StdDev |
|-------- |---------- |----------:|----------:|----------:|
|  Carlos |       red | 107.29 ns | 2.2401 ns | 3.9234 ns |
|  Darren |       red |  30.93 ns | 0.9228 ns | 0.8632 ns |
| Marcell |       red |  26.99 ns | 0.3902 ns | 0.3459 ns |
|  Carlos | red house | 106.78 ns | 1.9713 ns | 1.8439 ns |
|  Darren | red house |  32.49 ns | 0.4253 ns | 0.3978 ns |
| Marcell | red house |  27.37 ns | 0.3888 ns | 0.3637 ns |

पूर्ण परीक्षण कोड

using System;
using System.Linq;

using BenchmarkDotNet.Attributes;

namespace CorePerformanceTest
{
    public class StringUpperTest
    {
        [Params("red", "red house")]
        public string Data;

        [Benchmark]
        public string Carlos() => Data.Carlos();

        [Benchmark]
        public string Darren() => Data.Darren();

        [Benchmark]
        public string Marcell() => Data.Marcell();
    }

    internal static class StringExtensions
    {
        public static string Carlos(this string input) =>
            input switch
            {
                null => throw new ArgumentNullException(nameof(input)),
                "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
                _ => input.First().ToString().ToUpper() + input.Substring(1)
            };

        public static string Darren(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            char[] a = s.ToCharArray();
            a[0] = char.ToUpper(a[0]);
            return new string(a);
        }

        public static string Marcell(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            Span<char> a = stackalloc char[s.Length];
            s.AsSpan(1).CopyTo(a.Slice(1));
            a[0] = char.ToUpper(s[0]);
            return new string(a);
        }
    }

}

संपादित करें: एस [0] के बजाय एक टाइपो था, एक [0] था - यह समान, खाली स्थान के लिए आवंटित स्पैन ए के साथ परिणाम है।

— मार्सेल टोथ
स्रोत
0

यह इस पहले अक्षर को और प्रत्येक अक्षर को एक स्थान के बाद कैपिटल करता है और किसी अन्य अक्षर को कम करता है।

public string CapitalizeFirstLetterAfterSpace(string input)
{
    System.Text.StringBuilder sb = new System.Text.StringBuilder(input);
    bool capitalizeNextLetter = true;
    for(int pos = 0; pos < sb.Length; pos++)
    {
        if(capitalizeNextLetter)
        {
            sb[pos]=System.Char.ToUpper(sb[pos]);
            capitalizeNextLetter = false;
        }
        else
        {
            sb[pos]=System.Char.ToLower(sb[pos]);
        }

        if(sb[pos]=' ')
        {
            capitalizeNextLetter=true;
        }
    }
}
— thattolleyguy
स्रोत
1
या यदि आप कोड की दीवारें लिखना नहीं चाहते हैं - CultureInfo.CurrentCulture.TextInfo.ToTitleCase (TheString); वही काम करता है।
— चेव
हाँ ... मुझे उस बारे में पता नहीं था :) और मेरे बड़े पैमाने पर कोड होने के कारण, बाकी सभी के उत्तर पॉप-अप हो गए जबकि मैं अभी भी टाइप कर रहा था।
— thattolleyguy 15
UPVOTED: 1) इस उत्तर और ToTitleCase के बीच एक मामूली अंतर, यह है कि यह उत्तर उन शब्दों को बल देता है, जो सभी शीर्षक होते हैं। यह वांछित है या नहीं हो सकता है। इस तरह का कोड उदाहरण होने का एक फायदा यह है कि इसे इच्छानुसार संशोधित किया जा सकता है। 2) यह '' के अलावा सफेद स्थान को सही ढंग से नहीं संभालेगा। रिक्त स्थान को सफेद स्थान परीक्षण से बदलना चाहिए।
— टूलमेकरसैट
0

निम्नलिखित कोड का उपयोग करें:

string  strtest ="PRASHANT";
strtest.First().ToString().ToUpper() + strtest.Remove(0, 1).ToLower();
— प्रशांत बनवाली
स्रोत
इसकी वजह से इस उत्तर को वर्षों बाद जोड़ने के मेरे निरसन के बिंदु के लायक भी नहीं है, यह स्पष्ट रूप से पहले से मौजूद उत्तरों के बराबर है। यदि आप किसी प्रश्न के नए उत्तर को कई उत्तरों के साथ जोड़ने जा रहे हैं, तो कृपया बताएं कि आप जो मानते हैं वह आपके उत्तर के बारे में बेहतर है , या किन परिस्थितियों में आपका उत्तर अन्य उत्तरों की तुलना में अधिक उपयोगी होगा। विशिष्ट होना।
— टूलमेकरसेव
0

यहां दिए गए समाधानों में से कोई भी ऐसा नहीं है जो स्ट्रिंग से पहले एक सफेद स्थान से निपटेगा।

बस इसे एक विचार के रूप में जोड़ना:

public static string SetFirstCharUpper2(string aValue, bool aIgonreLeadingSpaces = true)
{
    if (string.IsNullOrWhiteSpace(aValue))
        return aValue;

    string trimmed = aIgonreLeadingSpaces 
           ? aValue.TrimStart() 
           : aValue;

    return char.ToUpper(trimmed[0]) + trimmed.Substring(1);
}

इसे संभालना चाहिए this won't work on other answers(उस वाक्य में शुरुआत में एक जगह है), और अगर आपको अंतरिक्ष ट्रिमिंग पसंद नहीं है, तो बस एक falseदूसरे पैरामीटर के रूप में पास करें (या डिफ़ॉल्ट को बदलें false, और trueयदि आप अंतरिक्ष से निपटना चाहते हैं तो पास करें )

— Noctis
स्रोत
0

एफआईआर पत्र को कैपिटलाइज़ करने का सबसे आसान तरीका है:

1 - Sytem.Globalization का उपयोग करना;

  // Creates a TextInfo based on the "en-US" culture.
  TextInfo myTI = new CultureInfo("en-US",false).

  myTI.ToTitleCase(textboxname.Text)

`

— साद खालिद
स्रोत
1
यह उत्तर अनिवार्य रूप से वर्षों पहले दिए गए उत्तरों के समान है । यह चर्चा के लिए कुछ भी नहीं जोड़ता है।
— टूलमेकरसेव
यह भी गलत है, दूसरे में टिप्पणी की तरह, यह सभी पहले अक्षर को सभी शब्दों में बदल देता है न कि रेड हाउस के बजाय रेड हाउस।
— डेडलीचैम्बर्स 18
0

निम्नलिखित फ़ंक्शन सभी तरीकों के लिए सही है:

static string UppercaseWords(string value)
{
    char[] array = value.ToCharArray();
    // Handle the first letter in the string.
    if (array.Length >= 1)
    {
        if (char.IsLower(array[0]))
        {
            array[0] = char.ToUpper(array[0]);
        }
    }
    // Scan through the letters, checking for spaces.
    // ... Uppercase the lowercase letters following spaces.
    for (int i = 1; i < array.Length; i++)
    {
        if (array[i - 1] == ' ')
        {
            if (char.IsLower(array[i]))
            {
                array[i] = char.ToUpper(array[i]);
            }
        }
    }
    return new string(array);
}

मैंने उसे यहां पाया

क्यों? जब पहले से ही इतने सारे उत्तर मिलते हैं तो एक और उत्तर क्यों जोड़ें ? सभी मौजूदा उत्तरों में क्या गलत है, जिसने आपको एक और जोड़ने के लिए प्रेरित किया?
— टूलमेकरसेव
क्योंकि यह answare सभी तरीकों के लिए सही है। आराम से।
मुझे क्षमा करें; मैं अनावश्यक रूप से कठोर था। मैं तथ्यों के रह सकते हैं: 1) यह अनिवार्य रूप से एक ही है के रूप में thattolleyguy के जवाब देने के सात साल पहले। 2) यह उस उत्तर के समान दोष है: रिक्त स्थान के अलावा सफेद स्थान को संभालता नहीं है। 3) यह ओपी की तुलना में थोड़ा अलग सवाल का जवाब था। इस तरह से एक उत्तर का उपयोग करें यदि आप चाहते हैं कि सभी शब्द पहले अक्षर को कैपिटल में लाएं। 4) आमतौर पर, यह पूरा करने का सबसे सरल तरीका है कि TitleInfo.ToTitleCase का उपयोग करें। (दूसरी ओर, कोड नमूने का एक लाभ वांछित के रूप में अनुकूलित किया जा सकता है।)
— टूलमेकरसैट
अपने आप को सही करना: यह थेटोलेगुगी के दृष्टिकोण से अलग है: यह अछूता हुआ अक्षर छोड़ देता है जो शब्द का पहला अक्षर नहीं है। इसके बजाय, यह ज़मोल्डार के जवाब का एक डुप्लिकेट है । अनुकूल रूप से, स्रोत को लिंक देने के लिए डारियन को कुदोस - ऐसा लगता है कि ज़ामोल्डर ने क्रेडिट दिए बिना साहित्यिक चोरी की। उस स्रोत लिंक प्रदान करने, और इस तरह चर्चा में सुधार करने के कारण , मैं इसकी आलोचना के बावजूद, इस उत्तर को बढ़ा रहा हूं।
— टूलमेकरसेव
1
Darian, दो सुधार जो किए जा सकते हैं: 1) के char.IsWhiteSpace( array[ i -1 ] )बजाय .. == ' 'सभी सफेद स्थान को संभालने के लिए उपयोग करें । 2) ऐसा करने वाले दो स्थानों को हटा दें if (char.isLower(..))- वे बिना किसी उद्देश्य के सेवा करते हैं। ToUpperअगर चरित्र कम नहीं है तो बस कुछ नहीं करता।
— टूलमेकरसैट
0

उपरोक्त कार्लोस के प्रश्न पर विस्तार करते हुए, यदि आप इस कोड का उपयोग करने वाले कई वाक्यों को भुनाना चाहते हैं: 

    /// <summary>
    /// Capitalize first letter of every sentence. 
    /// </summary>
    /// <param name="inputSting"></param>
    /// <returns></returns>
    public string CapitalizeSentences (string inputSting)
    {
        string result = string.Empty;
        if (!string.IsNullOrEmpty(inputSting))
        {
            string[] sentences = inputSting.Split('.');

            foreach (string sentence in sentences)
            {
                result += string.Format ("{0}{1}.", sentence.First().ToString().ToUpper(), sentence.Substring(1)); 
            }
        }

        return result; 
    }
— जमीर
स्रोत
0

आपकी समस्या का समाधान संभव समाधान। 

   public static string FirstToUpper(this string lowerWord)
   {
       if (string.IsNullOrWhiteSpace(lowerWord) || string.IsNullOrEmpty(lowerWord))
            return lowerWord;
       return new StringBuilder(lowerWord.Substring(0, 1).ToUpper())
                 .Append(lowerWord.Substring(1))
                 .ToString();
   }
— कहह इमद
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.