StringExtensions ToInvariantString Method (Object)Delta Engine Documentation
View code on GitHub

Namespace: DeltaEngine.Extensions
Assembly: DeltaEngine (in DeltaEngine.dll) Version: 1.1.1.0 (1.1.1)
Syntax
Copy to ClipboardPrint
public static string ToInvariantString(
	Object someObj
)

Return Value

Type: String
Remarks
Tests: DeltaEngine.Tests.Extensions.StringExtensionsTests
Examples
4 unit tests call DeltaEngine.Extensions.StringExtensions.ToInvariantString(System.Object)
Copy to ClipboardPrint
[Test]
public void ConvertFloatToInvariantString()
{
    Assert.AreEqual("2.5", 2.5f.ToInvariantString());
    Assert.AreNotEqual("3.5", 1.5f.ToInvariantString());
    Assert.AreEqual("01", 1.0f.ToInvariantString("00"));
    Assert.AreEqual("1.23", 1.2345f.ToInvariantString("0.00"));
    Assert.AreNotEqual("1.2345", 1.2345f.ToInvariantString("0.00"));
    Assert.AreEqual("1", StringExtensions.ToInvariantString(1));
}
Copy to ClipboardPrint
[Test]
public void ToInvariantString()
{
    Assert.AreEqual("null", StringExtensions.ToInvariantString(null));
    Assert.AreEqual("1", StringExtensions.ToInvariantString((object)1.0f));
    Assert.AreEqual("1.2", StringExtensions.ToInvariantString(1.2));
    Assert.AreEqual("1.4", StringExtensions.ToInvariantString(1.4m));
    Assert.AreEqual("abc", StringExtensions.ToInvariantString("abc"));
    Assert.AreEqual("01/01/2014 00:00:00",
        StringExtensions.ToInvariantString(new DateTime(2014, 1, 1)));
}
Copy to ClipboardPrint
    [Test]
    public void SplitIntoFloats()
    {
        var stringFloats = new[]
        { "1.0", "2.0", "0511.580254", Math.PI.ToString(CultureInfo.InvariantCulture) };
        var expectedFloats = new[] { 1.0f, 2.0f, 511.580261f, 3.14159274f };
        float[] floats = stringFloats.SplitIntoFloats();
        CollectionAssert.AreEqual(expectedFloats, floats);
    }

    [Test]
    public void SplitIntoFloatsWithSeparator()
    {
        const string StringFloats = "1.0, 2.0, 0511.580254";
        var expectedFloats = new[] { 1.0f, 2.0f, 511.580261f };
        CollectionAssert.AreEqual(expectedFloats, StringFloats.SplitIntoFloats(','));
        CollectionAssert.AreEqual(expectedFloats, StringFloats.SplitIntoFloats(", "));
    }

    [Test]
    public void Compare()
    {
        Assert.IsTrue("AbC1".Compare("aBc1"));
        Assert.IsTrue("1.23".Compare("1.23"));
        Assert.IsFalse("Hello".Compare("World"));
    }

    [Test]
    public void ContainsCaseInsensitive()
    {
        Assert.IsTrue("hallo".ContainsCaseInsensitive("ha"));
        Assert.IsTrue("1.23".ContainsCaseInsensitive("1.2"));
        Assert.IsTrue("Hello".ContainsCaseInsensitive("hel"));
        Assert.IsFalse("Banana".ContainsCaseInsensitive("Apple"));
        Assert.IsFalse(((String)null).ContainsCaseInsensitive("abc"));
    }

    [Test]
    public void IsFirstCharacterInLowerCase()
    {
        Assert.IsFalse("Banana".IsFirstCharacterInLowerCase());
        Assert.IsTrue("banana".IsFirstCharacterInLowerCase());
        Assert.IsTrue("".IsFirstCharacterInLowerCase());
    }

    [Test]
    public void ConvertFirstCharacterToUpperCase()
    {
        const string UpperCaseWord = "Banana";
        Assert.AreEqual(UpperCaseWord, UpperCaseWord.ConvertFirstCharacterToUpperCase());
        Assert.AreEqual(UpperCaseWord, "banana".ConvertFirstCharacterToUpperCase());
        Assert.AreEqual("", "".ConvertFirstCharacterToUpperCase());
    }

    [Test]
    public void SplitTextIntoWords()
    {
        var stringWords = "TestForSplittingAStringIntoWords".SplitWords(true);
        Assert.AreEqual(' ', stringWords[4]);
        Assert.AreEqual("Test for splitting a string into words", stringWords);
    }

    [Test]
    public void FromByteArray()
    {
        const string TestString = "TestString";
        Assert.AreEqual(TestString,
            StringExtensions.FromByteArray(StringExtensions.ToByteArray(TestString)));
    }

    [Test]
    public void StartsWith()
    {
        Assert.True(StringExtensions.StartsWith("Hi there, whattup?", "Hi"));
        Assert.False(StringExtensions.StartsWith("Hi there, whattup?", "what"));
        Assert.True(StringExtensions.StartsWith("bcdeuf", "bc"));
        Assert.False(StringExtensions.StartsWith("bcdeuf", "abc"));
        Assert.True("Hi there, whattup?".StartsWith(new[] { "Hi", "there", "what" }));
        Assert.False("Hi there, whattup?".StartsWith(new[] { "she", "there", "what" }));
        Assert.True(StringExtensions.StartsWith("ATI Radeon 9500+", "ati"));
        Assert.False(StringExtensions.StartsWith("A-t-i da gaga", "ati"));
        Assert.True(StringExtensions.StartsWith("NVidia Geforce3", "nvidia"));
    }

    [Test]
    public void SplitWordsWithEmptyWord()
    {
        const string TestString = "";
        Assert.AreEqual(TestString, TestString.SplitWords(true));
    }

    [Test]
    public void ConvertNotRecognizedType()
    {
        Assert.Throws<NotSupportedException>(() => "false,false".Convert<List<bool>>());
    }

    [Test]
    public void ConvertNullStringToDictionaryReturns()
    {
        const string ArrayOfStrings = null;
        var dictionary = ArrayOfStrings.Convert<Dictionary<string, string>>();
        Assert.IsInstanceOf<Dictionary<string, string>>(dictionary);
    }

    [Test]
    public void ConvertStringToDictionary()
    {
        const string ArrayOfStrings = "FirstKey;FirstValue;SecondKey;SecondValue";
        var dictionary = ArrayOfStrings.Convert<Dictionary<string, string>>();
        Assert.IsTrue(dictionary.ContainsKey("FirstKey"));
        Assert.IsTrue(dictionary.ContainsValue("SecondValue"));
    }

    [Test]
    public void ConvertDictionaryToString()
    {
        var dictionary = new Dictionary<string, string>();
        dictionary.Add("FirstKey","FirstValue");
        dictionary.Add("SecondKey","SecondValue");
        var arrayOfStrings = StringExtensions.ToInvariantString(dictionary);
        Assert.AreEqual(41, arrayOfStrings.Length);
        Assert.AreEqual(8, arrayOfStrings.IndexOf(';'));
        Assert.AreEqual(29, arrayOfStrings.LastIndexOf(';'));
    }

    [Test]
    public void CheckForCleanFileName()
    {
        Assert.AreEqual("", GetCleanFileName(null));
        Assert.AreEqual("", GetCleanFileName(""));
        Assert.AreEqual("", GetCleanFileName("   "));
        Assert.AreEqual("PureFilename", GetCleanFileName("PureFilename"));
        Assert.AreEqual("PureFilename", GetCleanFileName("Pure Filename"));
        Assert.AreEqual("FullFilename.ext", GetCleanFileName("FullFilename.ext"));
        Assert.AreEqual("File1.ext", GetCleanFileName("File#1.ext"));
        Assert.AreEqual("FileAB.ext", GetCleanFileName("FileA|B.ext"));
    }

    private static string GetCleanFileName(string filename)
    {
        return StringExtensions.GetFilenameWithoutForbiddenCharactersOrSpaces(filename);
    }
}
See Also
StringExtensions Class
ToInvariantString Overload
DeltaEngine.Extensions Namespace