C# String Manipulation: .NET Framework में System.String नाम की एक Utility Class Define की गई है। इस Class में String Manipulation से सम्बंधित विभिन्न Properties, Methods व Overloaded Operators Define किया गया है, जिन्हें हम हमारी जरूरत के अनुसार उपयोग में लेते हुए अपनी किसी Specific Requirement पूरा कर सकते हैं।

String Comparision

System.String Class में Compare() व Equals() Method के अलावा == व != Overloaded Operators भी हैं, जिनका प्रयोग दो Strings को आपस में Compare करने के लिए किया जा सकता है। इन Methods को अग्रानुसार उपयोग में लिया जा सकता है:

// File Name: StringCompareMethod.cs
using System;

namespace CSharpFundamentals
{
    class StringCompareMethod
    {
        private static void Main(string[] args)
        {
            string name = "C# is COOL too";
            Console.WriteLine("Total Characters of the String: {0}", name.Length);

            Console.WriteLine("Both Strings are Equal: {0}", String.Compare(name, name));
            Console.WriteLine("Both Strings are Equal: {0}", String.Compare("D#", name));
            Console.WriteLine("Both Strings are Equal: {0}", String.Compare(name, "D#"));
        }
    }
}

// Output:
   Total Characters of the String: 14
   Both Strings are Equal: 0
   Both Strings are Equal: 1
   Both Strings are Equal: -1

इस Program में हमने Length Property को Use किया है, जो कि उस String के कुल Characters की संख्‍या Return करता है, जिसके साथ इस Property को Use किया गया होता है।

चूंकि हमारी name नाम की String में Space सहित कुल 14 Characters हैं, इसलिए जब हमारे Program का निम्नानुसार Statement Execute होता है:

Console.WriteLine(“Total Characters of the String: {0}”, name.Length);

तो हमें निम्न Output प्राप्त होता है:

Total Characters of the String: 14

जो इसी बात को Indicate करता है कि name नाम की String में कुल 14 Characters हैं।

इसी तरह से जब हम Compare Method Use करते हैं, जो कि एक Static Method है, तो C# दोनों Compare होने वाली Strings को Character by Character Compare करता है। यदि दोनों Strings में सभी Characters एक समान हों, तो ये Method 0 Return करता है। इसीलिए उपरोक्त Program में जब निम्न Statement Execute होता है:

Console.WriteLine(“Both Strings are Equal: {0}”, String.Compare(name, name));

तब हमें निम्नानुसार Output प्राप्त होता है:

Both Strings are Equal: 0

लेकिन यदि पहली String का कोई Character दूसरी String के उसी Position के Character से बाद में आता हो, तो Compare Method 1 Return करता है। जबकि विपरीत स्थिति होने पर यही Compare Method -1 Return करता है। इसीलिए जब निम्न Statement Execute होता है:

Console.WriteLine(“Both Strings are Equal: {0}”, String.Compare(“D#”, name));

तब हमें निम्नानुसार Output प्राप्त होता है:

Both Strings are Equal: 1

जिसमें हम देख सकते हैं कि Compare Method 1 Return कर रहा है। क्योंकि पहले Argument के रूप में Specified String “D#” की शु:आत Character “D” से होती है, जो कि दूसरे Argument के रूप में Specified Argument name में Stored String, जिसकी शु:आत Character “C” से होती है, से बाद में आता है। जबकि अगले ही Statement में विपरीत स्थिति कर देने की वजह से Output के रूप में हमें -1 प्राप्त होता है।

हालांकि Compare() Method का प्रयोग करके हम दो Strings को Character-Wise Equality के लिए Test कर सकते हैं। लेकिन जब हम दो String Objects को आपस में Compare करके इस बात का पता लगाना चाहते हैं कि दोनों Strings एक समान हैं या हीं] तो हम String Class के Equals() Method का प्रयोग करते हैं, जो कि वास्तव में System.Object नाम की C# की Top Level Class में Defined Method है और .NET Framework की सभी Classes में Inherit होता है।

// File Name: StringCompareMethod.cs
using System;

namespace CSharpFundamentals
{
    class StringObjectEqualsMethod
    {
        private static void Main(string[] args)
        {
            String msg = "C# is COOL too";
            Console.WriteLine("Both Strings are Equal: {0}", msg.Equals(msg));
            Console.WriteLine("Both Strings are Equal: {0}", msg.Equals("D# is Cool"));
        }
    }
}

// Output:
	Both Strings are Equal: True
	Both Strings are Equal: False

इसी तरह से हम C# में Overload किए गए == व != Operators का प्रयोग करके भी Strings का Comparision कर सकते हैं। जैसे:

// File Name: StringObjectOverloadedEqualityOperators.cs
using System;
namespace CSharpFundamentals
{
    class StringObjectOverloadedEqualityOperators
    {
        private static void Main(string[] args)
        {
            String msg = "C# is COOL too";
            Console.WriteLine("Both Strings are Equal: {0}", msg == "C# is COOL too");
            Console.WriteLine("Both Strings are Equal: {0}", msg != "C# is COOL too");
        }
    }
}

// Output:
	Both Strings are Equal: True
	Both Strings are Equal: False

Compare() व Equals() दोनों ही Methods को Overload fdया गया है, इसलिए इन Methods को हम विभिन्न तरह के Arguments Pass करके कई तरीकों से उपयोग में ले सकते हैं।

Basic String Operation Methods

.NET Framework में कुछ Basic String Operations Perform करने के लिए भी Methods Provide किए गए हैं, जिनकी जरूरत विभिन्न प्रकार के String Related कामों को पूरा करने के लिए पडता है। इन्हें हम निम्न Program के अनुसार उपयोग में ले सकते हैं:

// File Name: BasicStringManipulationMethods.cs
using System;

namespace CSharpFundamentals
{
    class BasicStringManipulationMethods
    {
        private static void Main(string[] args)
        {
            String msg = "      C# is COOL too     ";
            Console.WriteLine("Message in Uppercase: {0}", msg.ToUpper());
            Console.WriteLine("Message in lowercase: {0}", msg.ToLower());
        }
    }
}

// Output:
	Message in Uppercase:       C# IS COOL TOO     
	Message in lowercase:       c# is cool too

Remove Unwanted Characters

.NET Framework हमें किसी String के Left, Right या दोनों ओर से Unwanted Characters को Remove करने के लिए Trim() नाम का एक Overloaded Method भी Provide करता है। इस Method को विभिन्न तरीकों से निम्नानुसार Use किया जा सकता है:

// File Name: StringTrimmingMethod.cs
using System;

namespace CSharpFundamentals
{
    class StringTrimmingMethod
    {
        private static void Main(string[] args)
        {
            String msg = "      C# is COOL too     ";
            Console.WriteLine("Trim Spaces from Both Side: {0}", msg.Trim());

            String msg1 = "===== C# is COOL too =====";
            Console.WriteLine("Trim Specified Character from Both Side: {0}", msg1.Trim('='));

            String msg2 = "===== C# is COOL too =====";
            Console.WriteLine("Trim Specified Character from Left Side:  {0}", msg2.TrimStart('='));
            Console.WriteLine("Trim Specified Character from Right Side: {0}", msg2.TrimEnd('='));
        }
    }
}

// Output:
Trim Spaces from Both Side: C# is COOL too
Trim Specified Character from Both Side:  C# is COOL too 
Trim Specified Character from Left Side:   C# is COOL too =====
Trim Specified Character from Right Side: ===== C# is COOL too

Trim() Method Default रूप से उस String के Left व Right दोनों Side के Spaces को Remove करके नया String Object Return कर देता है। जबकि यदि हम इस Method में Argument के रूप में किसी Character को Specify कर दें] तो जो Character Specify करते हैं, String के दोनों और से वह Character Remove हो जाता है, जैसाकि उपरोक्त Code के निम्न Statement द्वारा String के दोनों और से सभी ‘=’ Characters Remove हो रहे हैं:

String msg1 = “===== C# is COOL too =====”;
Console.WriteLine(“Trim Specified Character from Both Side: {0}”, msg1.Trim(‘=’));

और हमें निम्नानुसार Output प्राप्त हो रहा है:

Trim Specified Character from Both Side:  C# is COOL too

जबकि .NET Framework हमें TrimStart() व TrimEnd() नाम के दो और Methods Provide करता है, जिनका प्रयोग करके Specified String Object के Left या Right Side से Argument के रूप में Specified Characters को Remove किया जा सकता है। इन Methods को उपरोक्त Code में निम्नानुसार लिखा गया है:

String msg2 = “===== C# is COOL too =====”;
Console.WriteLine(“Trim Specified Character from Left Side:  {0}”, msg2.TrimStart(‘=’));
Console.WriteLine(“Trim Specified Character from Right Side: {0}”, msg2.TrimEnd(‘=’));

जिसके Execution के बाद हमें निम्नानुसार Output प्राप्त होता है:

Trim Specified Character from Left Side:   C# is COOL too =====
Trim Specified Character from Right Side: ===== C# is COOL too

String Concatenation

दो Strings को आपस में String की तरह Add करने के लिए .NET Framework हमें “+” Operator को Concatenate Operator की तरह Use करने की सुविधा Provide करता है। इसे हम निम्नानुसार Use करते हुए उपयोग में ले सकते हैं:

// File Name: StringConcatenation.cs
using System;

namespace CSharpFundamentals
{
    class StringConcatenation
    {
        private static void Main(string[] args)
        {
            String msg = "Hello! ";
            String afterConcatenation = msg + "Kuldeep Mishra";
            Console.WriteLine("After String Concatenation: {0}", afterConcatenation);

            afterConcatenation = String.Concat(msg, "Kuldeep Mishra");
            Console.WriteLine("After String Concatenation: {0}", afterConcatenation);
        }
    }
}

// Output:
	After String Concatenation: Hello! Kuldeep Mishra
	After String Concatenation: Hello! Kuldeep Mishra

दो Strings को आपस में जोडने के लिए .NET Framework हमें Concat() नाम का एक Static Method भी Provide करता है, जबकि हम “+” Operator को Use करके भी दो Strings को आपस में जोड सकते हैं और जैसाकि उपरोक्त Program के दोनों Output द्वारा हम समझ सकते हैं हम दोनों तरीकों में से किसी भी तरीके को Use करें] हमारे Output पर कोई प्रभाव नहीं पडता।

उपरोक्त Program में हमने afterConcatenation String Object को निम्नानुसार तरीके से Specify किया है:

String afterConcatenation = msg + “Kuldeep Mishra”;

जब हम इस तरह का कोई Statement लिखते हैं, जिसमें Object Create होते समय उसमें जो मान Initialize किया जाता है, वह मान किसी अन्‍य Expression के Execution के बाद Generate होने के बाद Initialize होता है, तो इस प्रकार के Initialization को Dynamic Initialization कहते हैं।

इस Statement में msg String Object में Stored String, “Kuldeep Mishra” String के साथ Append होने के बाद afterConcatenation नाम के नए Create होने वाले String Object में Initialize हो रहा है। इसलिए ये Initialization एक प्रकार का Dynamic Initialization है।

चूंकि String.Concat() Static Method व “+” Operator दोनों को ही Use करके String को समान प्रकार से जोडा जा सकता है और दोनों में से किसी एक को प्राथमिकता के साथ Use करने का कोई अलग Special महत्व नहीं है, इसलिए “+” Operator का प्रयोग करके ही दो Strings को आपस में जोडना चाहिए] ताकि Program में कम Typing करनी पडे।

कई बार हमें ऐसी जरूरत पडती है कि हमे इस बात का पता लगाना होता है कि किसी String में Particular कोई Sub-String Exist है या नहीं। इस बात का पता लगाने के लिए हम System.String Class के Contains() Method को निम्नानुसार तरीके से Use कर सकते हैं:

// File Name: StringContains.cs
using System;

namespace CSharpFundamentals
{
    class StringContains
    {
        private static void Main(string[] args)
        {
            String msg = "C# is COOL ";
            Console.WriteLine("Is # Exist in String: {0}", msg.Contains("#"));
        }
    }
}

// Output:
	Is # Exist in String: True

इस Program में msg.Contains() Method का प्रयोग करके इस बात का पता लगाया है कि क्या msg String Object के “#” Character Exist है या नहीं। चूंकि msg String Object में “#” Character Exist है, इसलिए msg.Contains() Method हमें Output में True Return करता है। (C# String Manipulation)