वर्णों की अधिकतम संख्या सी printf में की तरह सी # प्रारूप तार में परिभाषित किया जा सकता है?

Question

कि कैसे करना है नहीं मिला। जो मैंने पाया वह इस (http://blog.stevex.net/string-formatting-in-csharp/) की लाइनों पर कम या कम था:

वास्तव में इसके संरेखण से परे स्ट्रिंग के भीतर कोई स्वरूपण नहीं है। संरेखण किसी स्ट्रिंग.फॉर्मेट कॉल में मुद्रित किसी भी तर्क के लिए काम करता है। नमूना उत्पन्न

String.Format(“->{1,10}<-”, “Hello”); // gives "->     Hello<-" (left padded to 10) 
String.Format(“->{1,-10}<-”, “Hello”); // gives "->Hello     <-" (right padded to 10) 

Answer 1

तुम क्या चाहते नहीं "मूल रूप से" सी # स्ट्रिंग स्वरूपण द्वारा समर्थित है, स्ट्रिंग वस्तु की String.ToString तरीकों सिर्फ स्ट्रिंग लौटाने खुद के रूप में है।

जब आप

string.Format("{0:xxx}",someobject); 

फोन someobject IFormattable इंटरफ़ेस लागू करता है, अधिभार ToString(string format,IFormatProvider formatProvider) विधि कहा जाता हो जाता है, format पैरामीटर के रूप में "xxx"।

तो, अधिक से अधिक, यह नेट स्ट्रिंग स्वरूपण के डिजाइन में एक दोष है, लेकिन सिर्फ स्ट्रिंग कक्षा में कार्यक्षमता की कमी है।

आप वास्तव में इस की जरूरत है, तो आप सुझाव दिया समाधान के किसी भी उपयोग करें, या IFormattable इंटरफेस को लागू करने के लिए अपने ही वर्ग बना सकते हैं।

Answer 2

तुम सिर्फ पैरामीटर के बजाय प्रारूप का उपयोग कर लंबाई तर्क लागू नहीं कर सकते हैं?

स्ट्रिंग.फॉर्मेट ("-> {0} < -", toFormat.PadRight (10)); // -> हैलो < -

या अपनी फ़ॉर्मेटर आपको ऐसा करने की अनुमति देने के लिए लिखना?

Answer 3

क्यों नहीं सिर्फ अपने स्ट्रिंग की लंबाई सीमित करने के लिए substr का उपयोग करें?

String s = "abcdefghijklmnopqrstuvwxyz"; 
String.Format("Character limited: {0}", s.Substr(0, 10)); 

Answer 4

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

public class StringFormatEx : IFormatProvider, ICustomFormatter 
{ 
    /// <summary> 
    /// ICustomFormatter member 
    /// </summary> 
    public string Format(string format, object argument, IFormatProvider formatProvider) 
    { 
     #region func-y town 
     Func<string, object, string> handleOtherFormats = (f, a) => 
     { 
      var result = String.Empty; 
      if (a is IFormattable) { result = ((IFormattable)a).ToString(f, CultureInfo.CurrentCulture); } 
      else if (a != null) { result = a.ToString(); } 
      return result; 
     }; 
     #endregion 

     //reality check. 
     if (format == null || argument == null) { return argument as string; } 

     //perform default formatting if arg is not a string. 
     if (argument.GetType() != typeof(string)) { return handleOtherFormats(format, argument); } 

     //get the format specifier. 
     var specifier = format.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture); 

     //perform extended formatting based on format specifier. 
     switch(specifier) 
     { 
      case "L": 
       return LengthFormatter(format, argument); 
      default: 
       return handleOtherFormats(format, argument); 
     } 
    } 

    /// <summary> 
    /// IFormatProvider member 
    /// </summary> 
    public object GetFormat(Type formatType) 
    { 
     if (formatType == typeof(ICustomFormatter)) 
      return this; 
     else 
      return null; 
    } 

    /// <summary> 
    /// Custom length formatter. 
    /// </summary> 
    private string LengthFormatter(string format, object argument) 
    { 
     //specifier requires length number. 
     if (format.Length == 1) 
     { 
      throw new FormatException(String.Format("The format of '{0}' is invalid; length is in the form of Ln where n is the maximum length of the resultant string.", format)); 
     } 

     //get the length from the format string. 
     int length = int.MaxValue; 
     int.TryParse(format.Substring(1, format.Length - 1), out length); 

     //returned the argument with length applied. 
     return argument.ToString().Substring(0, length); 
    } 
} 

प्रयोग

var result = String.Format(
    new StringFormatEx(), 
    "{0:L4} {1:L7}", 
    "Stack", 
    "Overflow"); 

Assert.AreEqual("Stac Overflo", result); 

Answer 5

है यह कैसे String.Format का उपयोग करने पर एक जवाब है, लेकिन एक स्ट्रिंग विस्तार तरीकों का उपयोग कर छोटा करने का एक और तरीका नहीं है। इस तरह से आप string.format के बिना भी स्ट्रिंग में अधिकतम लंबाई जोड़ सकते हैं।

public static class ExtensionMethods 
{ 
    /// <summary> 
    /// Shortens string to Max length 
    /// </summary> 
    /// <param name="input">String to shortent</param> 
    /// <returns>shortened string</returns> 
    public static string MaxLength(this string input, int length) 
    { 
     if (input == null) return null; 
     return input.Substring(0, Math.Min(length, input.Length)); 
    } 
} 

नमूना उपयोग:

string Test = "1234567890"; 
string.Format("Shortened String = {0}", Test.MaxLength(5)); 
string.Format("Shortened String = {0}", Test.MaxLength(50)); 

Output: 
Shortened String = 12345 
Shortened String = 1234567890