StringExtensions SplitIntoFloats Method (String)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 float[] SplitIntoFloats(
	this string value
)

Return Value

Type:  Single 

Usage Note

In Visual Basic and C#, you can call this method as an instance method on any object of type String. When you use instance method syntax to call this method, omit the first parameter. For more information, see Extension Methods (Visual Basic) or Extension Methods (C# Programming Guide).
Remarks
Tests: DeltaEngine.Tests.Extensions.StringExtensionsTests
Examples
2 unit tests call DeltaEngine.Extensions.StringExtensions.SplitIntoFloats(System.String)
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);
    }
}
Copy to ClipboardPrint
[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(", "));
}
See Also
StringExtensions Class
SplitIntoFloats Overload
DeltaEngine.Extensions Namespace