मैं एक .NET स्ट्रिंग को कैसे काटूं?

406

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

उदाहरण के लिए, यह अच्छा होगा यदि मैं निम्नलिखित लिख सकता हूं:

string NormalizeLength(string value, int maxLength)
{
    return value.Substring(0, maxLength);
}

दुर्भाग्य से, यह एक अपवाद को जन्म देता है क्योंकि maxLengthआम तौर पर स्ट्रिंग की सीमाओं से अधिक होता है value। बेशक, मैं निम्नलिखित की तरह एक फ़ंक्शन लिख सकता था, लेकिन मैं उम्मीद कर रहा था कि ऐसा कुछ पहले से मौजूद है।

string NormalizeLength(string value, int maxLength)
{
    return value.Length <= maxLength ? value : value.Substring(0, maxLength);
}

इस कार्य को करने वाला मायावी एपीआई कहां है? वहाँ एक है?

c#  .net  string  truncate 
— स्टीव गाइडी
स्रोत
24
रिकॉर्ड के लिए, तार अपरिवर्तनीय हैं आप उन्हें काट नहीं सकते हैं आप केवल उनमें से एक छंटनी की प्रति वापस कर सकते हैं। नित्पिकी, मुझे पता है।
— जॉन वेल्डन
2
@ जॉन वेल्डन: शायद यही कारण है कि सदस्य फ़ंक्शन मौजूद नहीं है - यह डेटाटाइप के शब्दार्थ का पालन नहीं करता है। एक साइड नोट पर, StringBuilderआप लंबाई को छोटा करके छोटा कर सकते हैं, लेकिन आपको अभी भी स्ट्रिंग को चौड़ा करने से बचने के लिए लंबाई की जांच करने की आवश्यकता है।
— स्टीव गाइडी
1
जो भी समाधान आप चुनते हैं, वह रूट संपत्ति को कॉल या एक्सेस करने से पहले एक नल स्ट्रिंग के लिए एक चेक जोड़ना सुनिश्चित करें।
— रे
3
@SteveGuidi - यदि ऐसा होता, तो ट्रिम या रिप्लेस जैसे कार्य नहीं होते, जो समान अर्थ समस्याओं का सामना करते हैं
— क्रिस रोजर्स
1
@JohnWeldon Microsoft की तुलना में अधिक नाइटीकी स्वयं लगातार होते हैं, जैसा कि ऐसा होता है - वे दस्तावेज़ के लिए खुश हैं, उदाहरण के लिए, .Trim()एक तरीके से जो इसे भ्रामक रूप से ध्वनि बनाता है जैसे यह स्ट्रिंग को उत्परिवर्तित करता है: "सभी प्रमुख और अनुगामी श्वेत-रिक्त वर्णों को निकालता है वर्तमान स्ट्रिंग ऑब्जेक्ट। "
— मार्क अमेरी

जवाबों:

620

Truncate()दुर्भाग्य से स्ट्रिंग पर एक विधि नहीं है । इस तरह का तर्क आपको खुद लिखना होगा। हालांकि, आप क्या कर सकते हैं, इसे विस्तार विधि में लपेटें ताकि आपको इसे हर जगह डुप्लिकेट न करना पड़े:

public static class StringExt
{
    public static string Truncate(this string value, int maxLength)
    {
        if (string.IsNullOrEmpty(value)) return value;
        return value.Length <= maxLength ? value : value.Substring(0, maxLength); 
    }
}

अब हम लिख सकते हैं:

var someString = "...";
someString = someString.Truncate(2);
— LBushkin
स्रोत
5
ग्रेट सॉल्यूशन, लेकिन याद है कि यह केवल नेट 3.5 और अप में काम करता है। यह NET2.0 में कोशिश मत करो।
— जेडी मास्टर स्पूकी
7
जब तक आप वीएस 2008 में हैं, और संभवतः वीएस 2010, तब भी आप ऐसा कर सकते हैं, भले ही लक्ष्यीकरण। नेट 2.0। danielmoth.com/Blog/…
— मार्क
4
maxLengthनकारात्मक मान होने पर यह विफल हो जाएगा ।
— बर्नार्ड
42
@ बर्नार्ड, यह विफल माना जाता है यदि अधिकतम गति नकारात्मक है। कोई अन्य व्यवहार अप्रत्याशित होगा।
— बिंगोगो
12
आप अशक्त मूल्यों पर विस्तार विधियों को कॉल कर सकते हैं।
— जोएल मेलोन
127

या टर्नरी ऑपरेटर के बजाय, आप Math.min का उपयोग कर सकते हैं

public static class StringExt
{
    public static string Truncate( this string value, int maxLength )
    {
        if (string.IsNullOrEmpty(value)) { return value; }

        return value.Substring(0, Math.Min(value.Length, maxLength));
    }
}
— CaffGeek
स्रोत
10
चतुर! और मूल स्ट्रिंग का संदर्भ लौटाने के लिए निम्नलिखित अभिव्यक्ति को अनुकूलित किया गया है value.Substring(0, value.Length):।
— स्टीव गाइडी
4
दुर्भाग्य से यह उन मामलों के लिए अनुकूलित नहीं है, जहां मूल्य। मैक्सिमल से कम है। कुछ डेटा में एक सामान्य मामला हो सकता है। इसके अलावा स्ट्रिंग पर लंबाई की संपत्ति को पूंजीकृत किया जाना चाहिए।
— जिपरसन
1
maxLengthनकारात्मक मान होने पर यह विफल हो जाएगा ।
— बर्नार्ड
7
@ बर्नार्ड, इसलिए ढांचे में बहुत सारी चीजें होंगी ... लेकिन अगर मैं इसके लिए जांच करता हूं ... मुझे या तो डिफ़ॉल्ट maxLengthकरना होगा 0या value.Length; या मुझे फेंकने की जरूरत है ArgumentOutOfRangeException... जो इस मामले में अधिक समझ में आता है, और Substringकिसी भी तरह से पहले ही फेंक दिया जाता है ।
— कैफीक
2
थोड़ा छोटा:return string.IsNullOrEmpty(value) ? value : value.Substring(0, Math.Min(value.Length, maxLength));
— user1127860
43

मुझे लगा कि मैं अपने कार्यान्वयन में फेंक दूंगा क्योंकि मेरा मानना ​​है कि यह उन सभी मामलों को कवर करता है जो दूसरों के द्वारा छुआ गया है और ऐसा संक्षिप्त रूप में करता है जो अभी भी पठनीय है।

public static string Truncate(this string value, int maxLength)
{
    if (!string.IsNullOrEmpty(value) && value.Length > maxLength)
    {
        return value.Substring(0, maxLength);
    }

    return value;
}

यह समाधान मुख्य रूप से रे के समाधान पर बनाता है और इस कीवर्ड का उपयोग करके एक्सटेंशन विधि के रूप में उपयोग करने के लिए विधि को खोलता है, जैसा कि LBushkin अपने समाधान में करता है।

— jpierson
स्रोत
maxLengthनकारात्मक मान होने पर यह विफल हो जाएगा ।
— बर्नार्ड
15
@ बर्नार्ड - मैं अधिकतम गति तर्क के लिए एक नकारात्मक मान पारित नहीं करने की सलाह दूंगा क्योंकि यह एक अप्रत्याशित मूल्य है। सबस्ट्रिंग विधि एक ही दृष्टिकोण लेती है, इसलिए इसके फेंके जाने वाले अपवाद पर सुधार करने का कोई कारण नहीं है।
— जिपरसन
मुझे नहीं लगता कि IsNullOrEmpty चेक आवश्यक है? (1) यदि मान शून्य है, तो इस पर इस एक्सटेंशन विधि को कॉल करने का कोई तरीका नहीं होना चाहिए। (2) यदि मान रिक्त स्ट्रिंग है, तो मान ।ength> maxLength जाँच विफल हो जाएगी।
— जॉन श्नाइडर
8
@JonSchneider, IsNullOrEmpty की आवश्यकता है क्योंकि यह एक विस्तार विधि है। यदि आपके पास टाइप स्ट्रिंग का वैरिएबल है जिसे नल दिया गया है, तो कंपाइलर इस विधि को कॉल करने से पहले एक नल चेक सम्मिलित नहीं करता है। तकनीकी रूप से, यह अभी भी स्थैतिक वर्ग का एक स्थिर तरीका है। तो: stringVar.Truncate (2) संकलन इस प्रकार हैं: StringExt.Truncate (stringVar, 2);
— जेफ बी
40

क्योंकि प्रदर्शन परीक्षण मजेदार है: ( लाइनपैड विस्तार विधियों का उपयोग करके )

var val = string.Concat(Enumerable.Range(0, 50).Select(i => i % 10));

foreach(var limit in new[] { 10, 25, 44, 64 })
    new Perf<string> {
        { "newstring" + limit, n => new string(val.Take(limit).ToArray()) },
        { "concat" + limit, n => string.Concat(val.Take(limit)) },
        { "truncate" + limit, n => val.Substring(0, Math.Min(val.Length, limit)) },
        { "smart-trunc" + limit, n => val.Length <= limit ? val : val.Substring(0, limit) },
        { "stringbuilder" + limit, n => new StringBuilder(val, 0, Math.Min(val.Length, limit), limit).ToString() },
    }.Vs();

truncateविधि "काफी" तेजी से किया गया था। #microoptimization

जल्दी

  • truncate10 5788 टिक के साथ (0.5788 एमएस) [10K प्रतिनिधि में, 5.788E-05 एमएस में]
  • स्मार्ट- trunc10 8206 टिक बीता हुआ (0.8206 एमएस) [10K प्रतिनिधि में, 8.206E-05 एमएस में]
  • स्ट्रिंगर १०५५५s टिक टिक गए (१.०५५) एमएस) [१० के प्रतिनिधि में ०.०००१०५] per एमएस एमएस]
  • concat10 45495 टिके हुए (4.5495 एमएस) [10K प्रतिनिधि में, 0.00045495 एमएस]]
  • newstring10 72535 टिक गया (7.2535 एमएस) [10K प्रतिनिधि में, 0.000725 एमबी एमएस]

देर से

  • truncate44 8835 टिक्स समाप्त (0.8835 एमएस) [10K प्रतिनिधि में, 8.835E-05 एमएस में]
  • स्ट्रिंगराइडर44 13106 टिके हुए (1.3106 एमएस) [10K प्रतिनिधि में, 0.00013106 एमएस प्रति]।
  • स्मार्ट- trunc44 14821 टिक टिक गए (1.4821 एमएस) [10K प्रतिनिधि में, 0.000148 एमबी एमएस]
  • newstring44 144324 टिके हुए (14.4324 ms) [10K प्रतिनिधि में, 0.00144324 ms]
  • concat44 174610 टिक के साथ (17.461 एमएस) [10K प्रतिनिधि में, 0.0017461 एमएस प्रति]

बहुत लंबा

  • स्मार्ट-ट्रंक ६४४४ टिक टिक गए (०.६ ९ ४४ एमएस) [१० के रेप्स में, ६.९ ४४ ई-०५० प्रति]
  • truncate64 7686 टिके हुए (0.7686 एमएस) [10K प्रतिनिधि में, 7.686E-05 एमएस में]
  • स्ट्रिंगरोडर 643 133 टिक टिक गए (1.3314 एमएस) [10K प्रतिनिधि में, 0.00013314 एमएस प्रति]
  • newstring64 177481 टिक (17.7481 एमएस) 10K प्रतिनिधि में, 0.00177481 एमएस प्रति] समाप्त हुआ।
  • concat64 241601 टिक के साथ (24.1601 एमएस) [10K प्रतिनिधि में, 0.00241601 एमएस में]
— drzaus
स्रोत
सभी उपयोगी बेंचमार्क के लिए धन्यवाद! ... और लिंकपैड चट्टानें!
— सूर्यास्तक जूल
कभी नहीं सोचा था कि linqpad उन चीजों को कर सकता है
— jefissu
38

.NET 4.0 में आप Takeविधि का उपयोग कर सकते हैं :

string.Concat(myString.Take(maxLength));

दक्षता के लिए परीक्षण नहीं किया गया!

— डायलन निकोल्सन
स्रोत
27

आप LINQ का उपयोग कर सकते हैं ... यह स्ट्रिंग की लंबाई की जांच करने की आवश्यकता को समाप्त करता है। बेशक शायद सबसे कुशल नहीं है, लेकिन यह मजेदार है।

string result = string.Join("", value.Take(maxLength)); // .NET 4 Join

या

string result = new string(value.Take(maxLength).ToArray());
— Tames
स्रोत
2
यह स्वीकृत उत्तर क्यों नहीं है? क्या, सीधे आगे सबसे है अपने स्वयं के एक्सटेंशन विधि लिख है कि आप / दस्तावेज़, या कुछ का उपयोग कर .Take की तरह में निर्मित बनाए रखने की जरूरत
— डॉन चीडल
9
@mmcrae Linq अधिक सीधे आगे हो सकता है, लेकिन यह बहुत धीमा है। मेरा बेंचमार्क कहता है कि ~ लिनक के लिए 400ms और 1 मिलियन पुनरावृत्तियों के लिए केवल ~ 24ms के लिए।
— हेन आंद्रे गर्नस्टैड
इस समाधान का कभी उपयोग नहीं किया जाना चाहिए। जैसा कि ऊपर की दो टिप्पणियों में कहा गया है, हमेशा मेमोरी आवंटन होता है, तब भी जब मौजूदा स्ट्रिंग अधिकतम लंबाई से बड़ी नहीं होती है। इसके अलावा यह बहुत धीमी है।
— कामारेई
15

मैंने इस तरह से एक पंक्ति में मेरा काम किया

value = value.Length > 1000 ? value.Substring(0, 1000) : value;
— SeanMC
स्रोत
2
-1; यह उन सभी में कुछ भी नहीं जोड़ता है जो पहले से ही स्वीकृत उत्तर में नहीं थे।
— मार्क अमेरी
2
@markamery लिखने और अपडेट करने के लिए कम कोड के साथ यह एक छोटा विकल्प है जब आपको इसका उपयोग करने की आवश्यकता होती है। यह पसंद नहीं है? इसका उपयोग न करें
— SeanMC
त्वरित, सरल और तेज। यह वही है जो मुझे चाहिए था। धन्यवाद!
— पीटर
14

ऐसा लगता है कि किसी ने अभी तक पोस्ट नहीं किया है:

public static class StringExt
{
    public static string Truncate(this string s, int maxLength)
    {
        return s != null && s.Length > maxLength ? s.Substring(0, maxLength) : s;
    }
}

&& ऑपरेटर का उपयोग करना स्वीकार किए गए उत्तर की तुलना में इसे थोड़ा बेहतर बनाता है।

— डैरेन
स्रोत
13

.NET फ्रेमवर्क में इस तरह एक स्ट्रिंग को छोटा करने के लिए एक एपीआई है:

Microsoft.VisualBasic.Strings.Left(string, int);

लेकिन एक सी # ऐप में आप शायद Microsoft पर निर्भरता लेने की बजाय अपना खुद का रोल करना पसंद करेंगे।

— जो
स्रोत
".NET फ्रेमवर्क में एक एपीआई है" आप अपने आप का विरोध कर रहे हैं। यह एक VB.NET एपीआई है
— कैमिलो टेरेविंटो
9
@CamiloTerevinto - यह एक एपीआई है जिसे .NET फ्रेमवर्क के साथ शिप किया गया है, और इसे किसी भी प्रबंधित भाषा से कॉल किया जा सकता है।
— जो
1
वीबी डीएलएल में बहुत अच्छा सामान है। इसके खिलाफ इतने सारे # देव क्यों हैं?
— माइकल Z.
वर्तमान में कोई .NET कोर समर्थन नहीं है, दुर्भाग्य से। वास्तव में, Microsoft.VisualBasic.Strings.NET कोर में पूरा मॉड्यूल बहुत खाली है ।
— मार्क अमेरी
1
हालांकि मैं जो टिप्पणी से सहमत हूं, फिर भी मुझे अन्य भाषाओं से वीबी के लिए कुछ विशिष्ट कॉलिंग सही नहीं लगती है। यदि "वीबी डीएलएल" में बहुत अच्छे सामान हैं, तो इसे किसी साझा स्थान पर क्यों नहीं रखा जाए? कौन जानता है कि Microsoft इन सामानों के साथ कल क्या करेगा? समर्थन बंद करो या कुछ और ..
— Kamarey
6

मुझे पता है कि यह एक पुराना सवाल है, लेकिन यहाँ एक अच्छा समाधान है:

public static string Truncate(this string text, int maxLength, string suffix = "...")
{
    string str = text;
    if (maxLength > 0)
    {
        int length = maxLength - suffix.Length;
        if (length <= 0)
        {
            return str;
        }
        if ((text != null) && (text.Length > maxLength))
        {
            return (text.Substring(0, length).TrimEnd(new char[0]) + suffix);
        }
    }
    return str;
}

var myString = "hello world"
var myTruncatedString = myString.Truncate(4);

रिटर्न: हैलो ...

— कोई लोगो नहीं
स्रोत
@SarjanWebDev विशेष चरित्र "के रूप में दिखाता है।" cmd.exe में
— नील एहार्द
5

सी # 6 के नल प्रसार ऑपरेटर के साथ एक समान संस्करण

public static string Truncate(this string value, int maxLength)
{
    return value?.Length <= maxLength ? value : value?.Substring(0, maxLength);
}

कृपया ध्यान दें, हम अनिवार्य रूप से जाँच रहे हैं कि valueक्या यहां दो बार शून्य है।

— जेमी रीस
स्रोत
5

2016 में अभी भी C # स्ट्रिंग्स के लिए कोई ट्रंकट विधि नहीं है। लेकिन - C # 6.0 सिंटैक्स का उपयोग करना:

public static class StringExtension
{
  public static string Truncate(this string s, int max) 
  { 
    return s?.Length > max ? s.Substring(0, max) : s ?? throw new ArgumentNullException(s); 
  }
}

यह एक सम्मोहन की तरह काम करता है:

"Truncate me".Truncate(8);
Result: "Truncate"
— टोबियास शाइले
स्रोत
4

@CaffGeek लेना और इसे सरल बनाना:

public static string Truncate(this string value, int maxLength)
    {
        return string.IsNullOrEmpty(value) ? value : value.Substring(0, Math.Min(value.Length, maxLength));
    }
— एडविन बेल्ट्रान
स्रोत
4

Kndly ध्यान दें कि एक स्ट्रिंग को छोटा करने का मतलब केवल एक निर्दिष्ट लंबाई पर एक स्ट्रिंग को काटने का मतलब नहीं है, लेकिन ध्यान रखना है कि शब्द को विभाजित न करें।

जैसे स्ट्रिंग: यह एक परीक्षण स्ट्रिंग है।

मैं इसे 11 बजे काटना चाहता हूं। यदि हम परिणाम के ऊपर दी गई किसी भी विधि का उपयोग करेंगे

यह एक ते है

यह वह चीज नहीं है जो हम चाहते हैं

मैं जिस विधि का उपयोग कर रहा हूं वह भी इतनी सही नहीं है लेकिन यह अधिकांश स्थिति को संभाल सकती है

public string CutString(string source, int length)
{
        if (source== null || source.Length < length)
        {
            return source;
        }
        int nextSpace = source.LastIndexOf(" ", length);
        return string.Format("{0}...", input.Substring(0, (nextSpace > 0) ? nextSpace : length).Trim());
}
— सेन के। मैथ्यू
स्रोत
4

क्यों नहीं:

string NormalizeLength(string value, int maxLength)
{
    //check String.IsNullOrEmpty(value) and act on it. 
    return value.PadRight(maxLength).Substring(0, maxLength);
}

यानी इवेंट value.Length < maxLengthपैड स्पेस में अंत में या अतिरिक्त को छोटा कर देता है।

— श्री
स्रोत
आप कई स्ट्रिंग ऑब्जेक्ट्स के रूप में दो बार उत्पन्न करते हैं और यह PadRight कॉल से NullReferenceException को फेंक सकता है यदि मान शून्य है जो अनुचित है, तो यह एक ArgumentNullException होना चाहिए।
— जेरेमी
1
@ जेरेमी मुझे समझ में नहीं आता है कि "यदि मूल्य शून्य है तो यह PadRight कॉल से NullReferenceException को फेंक सकता है"; क्या मैंने "// check string.sNullOrEmpty (मान) और उस पर कार्य करने का उल्लेख नहीं किया है।"
— श्री
3

बस के मामले में यहाँ पर्याप्त जवाब नहीं है, यहाँ मेरा है :)

public static string Truncate(this string str, 
                              int totalLength, 
                              string truncationIndicator = "")
{
    if (string.IsNullOrEmpty(str) || str.Length < totalLength) 
        return str;

    return str.Substring(0, totalLength - truncationIndicator.Length) 
           + truncationIndicator;
}

उपयोग करने के लिए:

"I use it like this".Truncate(5,"~")
— के.आर.
स्रोत
2

(ओवर) जटिलता के लिए मैं अपने अतिभारित संस्करण को जोड़ दूंगा जो पिछले 3 वर्णों को अधिकतम गति पैरामीटर के संबंध में एक दीर्घवृत्त के साथ बदलता है।

public static string Truncate(this string value, int maxLength, bool replaceTruncatedCharWithEllipsis = false)
{
    if (replaceTruncatedCharWithEllipsis && maxLength <= 3)
        throw new ArgumentOutOfRangeException("maxLength",
            "maxLength should be greater than three when replacing with an ellipsis.");

    if (String.IsNullOrWhiteSpace(value)) 
        return String.Empty;

    if (replaceTruncatedCharWithEllipsis &&
        value.Length > maxLength)
    {
        return value.Substring(0, maxLength - 3) + "...";
    }

    return value.Substring(0, Math.Min(value.Length, maxLength)); 
}
— SoftDev
स्रोत
1

मैं जिपरसन के उत्तर को पसंद करता हूं, लेकिन यहां कोई भी उदाहरण जो मैं देख सकता हूं कि एक अमान्य अधिकतम गति पैरामीटर को संभाल रहा है, जैसे कि जब अधिकतम गति <0।

विकल्प या तो एक कोशिश / कैच में त्रुटि को संभालेंगे, अधिकतम गति पैरामीटर को 0 पर जकड़ें, या यदि अधिकतम तरंग 0 से कम है तो एक खाली स्ट्रिंग लौटाएं।

अनुकूलित कोड नहीं:

public string Truncate(this string value, int maximumLength)
{
    if (string.IsNullOrEmpty(value) == true) { return value; }
    if (maximumLen < 0) { return String.Empty; }
    if (value.Length > maximumLength) { return value.Substring(0, maximumLength); }
    return value;
}
— deegee
स्रोत
3
ध्यान दें, कि मेरे कार्यान्वयन में मैंने उस मामले को संभालने के लिए नहीं चुना, जहां अधिकतम गति 0 से कम है क्योंकि मुझे लगा कि मैं केवल एक चीज करूंगा जो एक ArgumentOutOfRangeExcpetion है जो अनिवार्य रूप से string.Substring () मेरे लिए करता है।
— जिपरसन
1

यहाँ एक vb.net समाधान है, यह चिह्नित करें कि यदि (हालांकि बदसूरत) कथन प्रदर्शन को बेहतर बनाता है क्योंकि हमें स्ट्रिंग कथन की आवश्यकता नहीं है, जब स्ट्रिंग पहले से ही अधिकतम गति से छोटा है ... इसे स्ट्रिंग के लिए एक एक्सटेंशन बनाकर उपयोग करना आसान है। ..

 <System.Runtime.CompilerServices.Extension()> _
    Public Function Truncate(String__1 As String, maxlength As Integer) As String
        If Not String.IsNullOrEmpty(String__1) AndAlso String__1.Length > maxlength Then
            Return String__1.Substring(0, maxlength)
        Else
            Return String__1
        End If
    End Function
— जीरो बम
स्रोत
VB.net में आप "String__1 <> कुछ नहीं" के साथ "Not String.IsNullOrEmpty (String__1)" को बदल सकते हैं। यह थोड़ा छोटा है। स्ट्रिंग के लिए डिफ़ॉल्ट मान एक रिक्त स्ट्रिंग है। "<> कुछ नहीं" का उपयोग करना अशक्त और खाली स्ट्रिंग मामलों की जाँच करता है। इसे बाहर का परीक्षण करें: Truncate ("", 50) और Truncate (कुछ नहीं, 50)
— jrjensen
VB में आप Left (string, maxlength)
— माइकल Z.
1

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

    public static string TruncateMiddle(string source)
    {
        if (String.IsNullOrWhiteSpace(source) || source.Length < 260) 
            return source;

        return string.Format("{0}...{1}", 
            source.Substring(0, 235),
            source.Substring(source.Length - 20));
    }

यह SharePoint URL बनाने के लिए है जिसकी अधिकतम लंबाई 260 वर्ण है।

मैंने लंबाई को एक पैरामीटर नहीं बनाया क्योंकि यह एक निरंतर 260 है। मैंने पहली सबस्ट्रिंग लंबाई को एक पैरामीटर नहीं बनाया क्योंकि मैं चाहता हूं कि यह एक विशिष्ट बिंदु पर टूट जाए। अंत में, दूसरा सबस्ट्रिंग स्रोत की लंबाई है - 20 जब से मैं फ़ोल्डर संरचना को जानता हूं।

यह आसानी से आपकी विशिष्ट आवश्यकताओं के अनुकूल हो सकता है।

— पॉल हैन
स्रोत
1

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

public static string Truncate(this string s, int length)
{
    return string.IsNullOrEmpty(s) || s.Length <= length ? s 
        : length <= 0 ? string.Empty 
        : s.Substring(0, length);
}
— एड बी
स्रोत
1

C # 8 में नए रेंज फ़ीचर का इस्तेमाल किया जा सकता है ...

value = value[..Math.Min(30, value.Length)];
— Sunsetquest
स्रोत
0

इसमें कुछ भी नहीं है। इसके लिए मुझे जानकारी है - यहाँ मेरा संस्करण है जो "..." जोड़ता है:

public static string truncateString(string originalString, int length) {
  if (string.IsNullOrEmpty(originalString)) {
   return originalString;
  }
  if (originalString.Length > length) {
   return originalString.Substring(0, length) + "...";
  }
  else {
   return originalString;
  }
}
— रे
स्रोत
2
आपका संस्करण वे तार देगा जो अनुरोधित लंबाई से 3 वर्ण अधिक लंबे हैं, यदि वे काट दिए गए हैं। इसके अलावा, ट्रिपल डॉट्स वास्तव में प्रतिनिधित्व में केवल सार्थक हैं, मैं इसे एक डेटाबेस में संग्रहीत नहीं करूंगा जो कि ओपी द्वारा दिया गया उपयोग मामला है।
— मारियोडीस
0

TruncateString

public static string _TruncateString(string input, int charaterlimit)
{
    int characterLimit = charaterlimit;
    string output = input;

    // Check if the string is longer than the allowed amount
    // otherwise do nothing
    if (output.Length > characterLimit && characterLimit > 0)
    {
        // cut the string down to the maximum number of characters
        output = output.Substring(0, characterLimit);
        // Check if the character right after the truncate point was a space
        // if not, we are in the middle of a word and need to remove the rest of it
        if (input.Substring(output.Length, 1) != " ")
        {
            int LastSpace = output.LastIndexOf(" ");

            // if we found a space then, cut back to that space
            if (LastSpace != -1)
            {
                output = output.Substring(0, LastSpace);
            }
        }
        // Finally, add the "..."
        output += "...";
    }
    return output;
}
— सूद
स्रोत
2
आप एक अंडरस्कोर के साथ अपनी सार्वजनिक विधि का नाम क्यों लेते हैं?
— माइकल जेड।
0

ऊपर चर्चा की गई संभावनाओं के अतिरिक्त मैं अपना समाधान साझा करना चाहता हूं। यह एक विस्तार विधि है जो अशक्त (वापसी string.Empty) की अनुमति देता है एक दीर्घवृत्त के साथ इसका उपयोग करने के लिए एक दूसरा .Truncate () भी है। खबरदार, यह प्रदर्शन अनुकूलित नहीं है।

public static string Truncate(this string value, int maxLength) =>
    (value ?? string.Empty).Substring(0, (value?.Length ?? 0) <= (maxLength < 0 ? 0 : maxLength) ? (value?.Length ?? 0) : (maxLength < 0 ? 0 : maxLength));
public static string Truncate(this string value, int maxLength, string ellipsis) =>
    string.Concat(value.Truncate(maxLength - (((value?.Length ?? 0) > maxLength ? ellipsis : null)?.Length ?? 0)), ((value?.Length ?? 0) > maxLength ? ellipsis : null)).Truncate(maxLength);
— रेमंड ओस्टरब्रिंक
स्रोत
-1 
public static string Truncate( this string value, int maxLength )
    {
        if (string.IsNullOrEmpty(value)) { return value; }

        return new string(value.Take(maxLength).ToArray());// use LINQ and be happy
    }
— TapiocaCom
स्रोत
यहाँ ToArray()कॉल सिर्फ अनावश्यक उपरि है; उदाहरण के लिए, String.Concatआप एक सरणी से गुजरने के बिना वर्णों के एक अक्षर से एक स्ट्रिंग का निर्माण कर सकते हैं।
— मार्क अमेरी
-3

ट्रंकट स्ट्रिंग

public static string TruncateText(string strText, int intLength)
{
    if (!(string.IsNullOrEmpty(strText)))
    {                                
        // split the text.
        var words = strText.Split(' ');

        // calculate the number of words
        // based on the provided characters length 
        // use an average of 7.6 chars per word.
        int wordLength = Convert.ToInt32(Math.Ceiling(intLength / 7.6));

        // if the text is shorter than the length,
        // display the text without changing it.
        if (words.Length <= wordLength)
            return strText.Trim();                

        // put together a shorter text
        // based on the number of words
        return string.Join(" ", words.Take(wordLength)) + " ...".Trim();
    }
        else
        {
            return "";
        }            
    }
— वीटी
स्रोत
यह ओपी के सवाल का जवाब नहीं देता है। सबसे पहले, यह एक सदस्य फ़ंक्शन होना चाहिए (हालांकि आपने इसे विस्तार विधि के रूप में लिखा है)। दूसरा, ओपी यह निर्दिष्ट नहीं करता है कि पाठ को विभाजित करना है और शब्दों को लगभग काट दिया गया है। प्रति शब्द 7.6 वर्ण।
— विचर विसर
7.6 सिर्फ एक संख्या है। आप अपनी इच्छानुसार कोई अन्य नंबर लिख सकते हैं। यह एक औसत अंग्रेजी शब्द की लंबाई थी। मुझे यह Google पर मिला। विभाजन का उपयोग करना शब्दों को अंतरिक्ष से तोड़ने का एक आसान तरीका है। मुझे नहीं लगता कि आप एक आधा शब्द प्रदर्शित करना चाहते हैं! इसलिए जब तक आप खाली जगह नहीं तलाशते हैं, जिसके लिए अधिक कोड की आवश्यकता होगी, यह एक स्ट्रिंग को कम करने और पूर्ण शब्दों को प्रदर्शित करने का एक आसान तरीका है। यह आपको सुनिश्चित करेगा कि एक स्ट्रिंग लंबी नहीं है तो दी गई लंबाई और आपके पास टूटे हुए शब्द नहीं होंगे।
— वीटी
-4

यह वह कोड है जो मैं आमतौर पर उपयोग करता हूं:

string getSubString(string value, int index, int length)
        {
            if (string.IsNullOrEmpty(value) || value.Length <= length)
            {
                return value;
            }
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            for (int i = index; i < length; i++)
            {
                sb.AppendLine(value[i].ToString());
            }
            return sb.ToString();
        }
— user3390116
स्रोत
5
कृपया ध्यान दें कि + के साथ तार को जोड़ना एक महंगा ऑपरेशन है, खासकर जब चरित्र द्वारा चरित्र का पुनर्निर्माण। .NET स्ट्रिंग्स अपरिवर्तनीय हैं, जिसका अर्थ है कि इस मामले में, आपके लूप में हर बार एक नया स्ट्रिंग बनाया जाता है।
— स्टीव गाईड
@SteveGuidi तार अपरिवर्तनीय नहीं हैं, वे बस अपरिवर्तनीय के रूप में बहाना करते हैं। काश तार सही अपरिवर्तनीय आदिम होते, तो मैं स्ट्रिंग और स्ट्रिंग हो सकता था?, लेकिन अफसोस कि वे आदिम नहीं हैं।
— क्रिस मैरिसिक
आप महंगा कहते हैं जैसे कि प्रदर्शन की लागत महत्वपूर्ण है, मैंने इसे स्ट्रिंगब्यूलर का उपयोग करने के लिए बदल दिया, लेकिन मुझे लगता है कि + = के साथ यह देखना आसान है कि क्या चल रहा है, मैं चाहता था कि ओपी आसानी से कोड को समझ सके।
— user3390116
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.