Class Text
Provides a vast collection of text processing functions.
Namespace: Stringier
Assembly: Stringier.Text.dll
Syntax
public static class Text : object
Methods
| Improve this Doc View SourceEquals(Char*, Int32, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 firstLength, Char*second, Int32 secondLength)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | firstLength | The length of the |
| Char* | second | The second text to compare. |
| Int32 | secondLength | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 firstLength, Char*second, Int32 secondLength, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | firstLength | The length of the |
| Char* | second | The second text to compare. |
| Int32 | secondLength | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char*, Int32, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(Char*first, Int32 length, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char* | first | The first text to compare. |
| Int32 | length | The length of the |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Char[], Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Char[] first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Char[] | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Memory<Char>, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Memory<Char> first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Memory<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlyMemory<Char>, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlyMemory<Char> first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlyMemory<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(ReadOnlySpan<Char>, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this ReadOnlySpan<Char> first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| ReadOnlySpan<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Span<Char>, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Span<Char> first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Span<Char> | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(String, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this String first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| String | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Char)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Char second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Char | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Char*, Int32)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Char*second, Int32 length)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Char*, Int32, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Char*second, Int32 length, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Char* | second | The second text to compare. |
| Int32 | length | The length of the |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Char, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Char second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Char | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Char[])
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Char[] second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Char[] | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Char[], Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Char[] second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Char[] | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Memory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Memory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Memory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Memory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Memory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, ReadOnlyMemory<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, ReadOnlyMemory<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, ReadOnlyMemory<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, ReadOnlyMemory<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| ReadOnlyMemory<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, ReadOnlySpan<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, ReadOnlySpan<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, ReadOnlySpan<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, ReadOnlySpan<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| ReadOnlySpan<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Span<Char>)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Span<Char> second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Span<Char>, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Span<Char> second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Span<Char> | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, String)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, String second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| String | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, String, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, String second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| String | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Rope)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Rope second)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Rope | second | The second text to compare. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |
Equals(Rope, Rope, Case)
Determines whether two text objects have the same content.
Declaration
public static Boolean Equals(this Rope first, Rope second, Case casing)
Parameters
| Type | Name | Description |
|---|---|---|
| Rope | first | The first text to compare. |
| Rope | second | The second text to compare. |
| Case | casing | The casing of the comparison. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the value of the |


Finally an Android App#
About the idea#
After a couple of years after writing android apps, I chose to write an android app again. I had used Android Studio before but never tired serious android development after the very first time I tried it in Eclipse (the old times when there was not android studio).
I chose a very old idea that I had before for voting. I thought I will make an app that accepts votes from people. This had to be something different from the regular apps. The main difference being that people should not have to install an app and/or should not have to open to a website to cast a vote. Hence, people should use the platform they are already using. Therefore I chose to go in for some messaging platform. The most popular platform out there is Whatsapp but again the problem with Whatsapp is that they don’t have any open APIs and moreover it’s illegal to reverse engineer the Whatsapp APIs. The other option is Telegram who have their APIs completely open. But the problem with doing it with Telegram is that they have very few users compared to Whatsapp. I had to settle somewhere in between the two choices. That’s the reason I chose traditional SMS over Telegram or Whatsapp.
Concept and design choices#
Now it was time to design the app for voting but directly jumping for voting was a bit too much for processing and adding too much to the design and in addition to that some extra time in the development of the project. I thought of making it very simple and just storing the SMSes. So I finalised with the idea of writing an app that will accept registrations through the means of SMSes. Hence the name SMServer, a Short Message Server, the server with which people can accept SMSes from the user and store them.
How the app worksː#
The basic idea is to accept the SMSes in a particular format . Suppose you are accepting the applications for a party that you are hosting it will be as follows. For example, let’s say I’m hosting an event and I want to accept the people’s names via SMS. So I will create a new form for accepting the people who are willing to join the event. Suppose the event is some music show, I will accept the applications in the following format.
MUSIC<space>NAME<space>AGE
Suppose John Doe is registering for an event, his message will be as follows:
MUSIC John 27
All the words that I’m accepting via the app are case insensitive. The reason being that there should be no mismatch between the words being just because of the case. At least the first word has to be kept case insensitive.
A screen to screen working for the app#
The name for the new form is the name that you want to give to the form which will accept registrations, the form name will be for your own reference
The starting date and time are the date and time when the form should start accepting the entries
Same goes for the ending time and date
The first word is the first word that you have to enter to enter to accept the entry as an entry for this particular form
The fields are the remaining words from the SMS that you will be accepting as fields in the form
The form will be saved when you click the save button

It will also list the phone numbers and date and time of the people who have just registered

Now that you have seen how the app works, you can download the app by clicking here Also, do test it on your own and report any bugs to me. You are also free to suggest any features to me if you want.


| < Day Day Up > |
8.2 Configuration IssuesTo route the connection to a server, the load balancer must select a target server. To do this, it takes two pieces of information into account. First, it needs to know which servers are available. At any time, one or more of the backend servers can be offline (for maintenance, as the result of a crash, etc.). To keep track of the servers, the load balancer periodically checks each one's health. Once the load balancer has a list of candidate servers, it must decide which should get the next connection. This process can take a number of factors into account, including past performance, load, client address, and so on. Let's look at both issues in more detail. 8.2.1 Health ChecksLoad balancers need to perform a health check for each real server to ensure that it's still alive, well, and willing to accept new connections. When load-balancing a web server, this is often a trivial matter. The load balancer is configured to connect to TCP port 80 and request a status file such as /health.html. If the server gets a 2xx response code back, it assumes the server is fine. If not, it may stop sending new requests to the server until it becomes healthy again. A nice side benefit of asking for a specific file, rather than simply looking for any response on port 80, is that a server can be removed from the cluster without taking it offline: simply remove or rename the file. Most load balancers provide a great deal of control over the parameters used when testing cluster hosts. Options may include the frequency of checks, the duration of check timeouts, and the number of unhealthy responses required to remove a server from the cluster. See your load balancer's documentation for details. <IP_ADDRESS> Determining healthSo what constitutes a good health check for MySQL? Unfortunately, there's no single answer to that question. It depends on how sophisticated your load balancer is. Some load balancers can verify only that each server is responding on the necessary TCP port. They'll generally connect to TCP port 3306 (or whichever port you're using) and assume the server is unhealthy if the connection is refused or if it has to wait too long for a response. Some load balancers are more flexible. They might give you the option of scripting a complicated health check or of running the health check against a different port than normal. This provides a lot of flexibility and control. For example, you can run a web server (such as Apache) on the server and configure the load balancer to check a status file, just as you would for standard HTTP load balancing. You can exploit this indirect kind of check by making the status file a script (PHP, Perl, etc.) or Java servlet that performs arbitrarily complex logic to decide whether the server is really healthy.[2] The arbitrarily complex logic can be as simple as running a SELECT 1 query, or as complicated as parsing the output of SHOW SLAVE STATUS to verify that the slave is reasonably up to date.
If your load balancer offers this degree of flexibility, we highly recommend taking advantage of it. By taking control over the decision-making process, you'll have a better idea of how your cluster will respond in various situations. And after testing, if you're not happy with the results, simply adjust the logic and try again. What types of things might you check for? This goes back to the question we're trying to answer: what makes a healthy MySQL server, from the load balancer's point of view? A good health check also depends on your application needs and what's most important. For example, on a nearly real-time dynamic web site like Yahoo! News, you might put more emphasis on replication. If a slave gets busy enough handling regular queries that it becomes sluggish and ends up more than 30 seconds behind on replication, your code can return an unhealthy status code. The load balancer then removes the slave from the list of available servers until the health check passes again. Presumably the reduced demand on the server will allow it to quickly catch up and rejoin the cluster. (See the "Monitoring" section in Chapter 7 for ideas about detecting slow slaves.) Of course, the success of this algorithm depends on how smart your scripts are. What if the slow server doesn't get caught up? And what if the additional demand that the remaining servers must bear causes them to fall behind? There's a very real chance that one by one, they'll start deciding they too are unhealthy. Before long, the problem cascades until you're left with a cluster of unhealthy servers sitting behind a load balancer that doesn't know where to send connections anymore. At Yahoo! Finance, we've seen individual servers that try to be smart and end up creating even bigger problems because they didn't have the whole picture. Anticipating the problem mentioned in the previous paragraph, the code that performed health checks introduced yet another level of checking. Each server knew all the other members of the cluster. The health check included code to make sure that there were enough servers left. If a server determined that too many other servers were already down, it would elect to keep handling requests.  But our implementation still wasn't smart enough; the servers still went down in a cascade. The reason turned out to be a simple race condition. The code performed a series of checks, but it did them in the wrong order. The code first checked to see that a sufficient number of other servers were healthy. It then went on to make sure MySQL wasn't too far behind on replication. The problem was that several servers could be doing the health check at exactly the same time. If that happened, it was possible for all servers to believe that all other servers were healthy and proceed to declare themselves unhealthy. There are numerous solutions to the problem. One is to add a simple sanity check. Each server can, after declaring itself unhealthy, check to make sure that the situation hasn't radically changed. Another option is to appoint a single server in each cluster as the authority for determining who is and isn't healthy. While it introduces a single point of failure (what if this server dies?), it means there are fewer chances for race conditions and similar problems. To summarize, some load balancers provide you with a lot of flexibility and power. Be careful how you use it. If you elect to take control of the decision-making process (and add complexity to it), be sure that the code is well tested. Ask a few peers to review it for you. Consider what will happen in unusual situations. <IP_ADDRESS> Connection limitsIn normal operations, the load balancer should distribute connections relatively evenly among your severs. If you have eight backend servers, any one of them will handle roughly one eighth of the connections at a given time. But what happens when several backend servers go down at the same time? Because the rest of the cluster must bear the load, you need to ensure that the se servers are configured to handle it. The most important setting to check is max_connections. In this circumstance, you'll find that if max_connections is set too low, otherwise healthy MySQL servers start refusing connections even if they're powerful enough to handle the load. Many installations don't set the max_connections option, so MySQL uses its built-in default of 100. Instead, set max_connections high enough that this problem can't happen. For example, if you find that each server typically handles 75 connections, a reasonable value for max_connections might be 150 or more. That way, even if half the backend servers failed, you're application won't fail to connect. 8.2.2 Next-Connection AlgorithmsDifferent load balancers implement different algorithms to decide which server should receive the next connection. Some call these scheduling algorithms. Each vendor has different terminology, but this list should provide an idea of what's available:
Which algorithm is right for MySQL? Again, it depends. There are several factors to consider and some pitfalls to avoid. One of the pitfalls is best illustrated with an example. <IP_ADDRESS> The consequences of poor algorithm choiceIn September 2002, Yahoo! launched a one-week memorial site for those affected by the September 11, 2001 terrorist attacks. This site was described in Chapter 6. The remember.yahoo.com site was heavily promoted on the Yahoo! home page and elsewhere. The entire site was built by a small group of Yahoo! employees in the two weeks before the site's launch on September 9. Needless to say, the site got a lot of traffic. So much, in fact, that Jeremy spent a couple of sleepless nights working to optimize the SQL queries and bring new MySQL servers online to handle the load. During that time the MySQL servers were running red hot. They weren't handling many queries per second (because they are poorly optimized) but they were either disk-bound, CPU-bound, or both. A server was slowest when it first came online because MySQL's key buffer hadn't yet been populated, and the operating system's disk cache didn't have any of the relevant disk blocks cached. They needed several minutes to warm up before taking their full query load. The situation was made worse by the fact that the load balancer hadn't been configured with this in mind, and nobody realized it until very late in the process. When a server was reconfigured and brought back online, it was immediately pounded with 30-50 new queries. The machine became completely saturated and needed several minutes to recover. During the recovery time, it was nearly unresponsive, with the CPU at 100%, a load average over 25, and the disk nearly maxed out. After quite a bit of theorizing and poking around, someone thought to question the load-balancer configuration. It turned out that it was set on a least-connections scheduling algorithm. That clearly explained why a new machine was bombarded with new connections and rendered useless for several minutes. Once the load balancer was switched to a random scheduling algorithm, it became much easier to bring down a slave, adjust the configuration, and put it back online without becoming completely overwhelmed. The moral of the story is that the connection algorithm you select may come back to bite you when you least expect it (and can least afford it). Consider how your algorithm will work in day-to-day operations as well as when you're under an unusually high load or have a higher than normal number of backend servers offline for some reason. We can't recommend the right configuration for your needs. You need to think about what will work best for your hardware, network, and applications. Furthermore, your algorithm choices are limited by the load balancing hardware or software you're using. When in doubt, test. |
| < Day Day Up > |


[Log in as a DCCD member]
[LoginPanel]
[forgottenpassword]
[Register]
[Members have more privileges on this site.]


|
Standard Reference Data Program |
Data Gateway |
Chemistry WebBook |
Go To: Top, Constants of diatomic molecules, References, Notes / Error Report
Data compilation copyright by the U.S. Secretary of Commerce on behalf of the U.S.A. All rights reserved.
Data compiled as indicated in comments:
B - J.E. Bartmess
LLK - S.G. Lias, R.D. Levin, and S.A. Kafafi
| EA (eV) | Method | Reference | Comment |
|---|---|---|---|
| 0.930 ± 0.050 | PD | Rackwitz, Feldman, et al., 1977 | B |
| IE (eV) | Method | Reference | Comment |
|---|---|---|---|
| 5.86 ± 0.09 | S | Kaving and Lindgren, 1974 | LLK |
| Quantity | Value | Units | Method | Reference | Comment |
|---|---|---|---|---|---|
| ΔrH° | 1476.1 ± 3.8 | kJ/mol | D-EA | Petrunin, Andersen, et al., 1996 | gas phase; B |
| Quantity | Value | Units | Method | Reference | Comment |
| ΔrG° | 1452. ± 4.2 | kJ/mol | H-TS | Petrunin, Andersen, et al., 1996 | gas phase; B |
Go To: Top, Gas phase ion energetics data, References, Notes / Error Report
Data compilation copyright by the U.S. Secretary of Commerce on behalf of the U.S.A. All rights reserved.
Data compiled by: K.P. Huber and G. Herzberg
| State | Te | ωe | ωexe | ωeye | Be | αe | γe | De | βe | re | Trans. | ν00 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| I (2Σ) | [(4.60)] | [(1.93)] | I ← X | (39477) | ||||||||
| Khan and Afridi, 1968 | ||||||||||||
| H (2Σ) | [(4.41)] | [(1.97)] | H ← X | (38798) | ||||||||
| Khan and Afridi, 1968 | ||||||||||||
| F 2Σ+ | 36705 | 1487 1 | 28 | [4.6867] | [0.0002017] | [1.9128] | F ← X V | 36979.05 Z | ||||
| Khan, 1962; missing citation; Khan and Afridi, 1968 | ||||||||||||
| M 2Δ (4d) | 2 | [4.89] 3 | [1.87] | M ← X | 35481.8 3 | |||||||
| missing citation | ||||||||||||
| State | Te | ωe | ωexe | ωeye | Be | αe | γe | De | βe | re | Trans. | ν00 |
| J 2Π (4d) | 2 | [4.898] 3 | [2.8] 3 | [1.871] | J ← X | 35068.53 3 | ||||||
| missing citation | ||||||||||||
| G 2Σ+ (4d) | (34735) 2 | [1458] 4 | [4.765] 3 | [1.17] 3 | [1.897] | G ← X | 34819.5 3 | |||||
| missing citation | ||||||||||||
| L 2Π (5p) | (32680) 5 | [1407.6] 6 | [4.6204] 6 | 0.1139 | [1.920] 6 7 | 1.9148 | L ← X | 32739.37 6 | ||||
| missing citation | ||||||||||||
| K 2Σ+ (5p) | (32640) | [(1391)] 6 | [4.601] 6 8 | (0.085) | [1.93] 6 9 | 1.922 | K ← X | 32691.1 6 | ||||
| missing citation | ||||||||||||
| State | Te | ωe | ωexe | ωeye | Be | αe | γe | De | βe | re | Trans. | ν00 |
| C 2Σ+ | 28276 | 1445 H | 25 | [4.58] 10 11 | [1.7] 10 | [1.94] | C ↔ X V | 28348 10 | ||||
| missing citation; missing citation; Grundstrom, 1935 | ||||||||||||
| D 2Σ+ | 22602 | 1150 Z | 33.0 | 2.50 12 | 0.01 | 2.62 | D → X R | 22524 Z | ||||
| Grundstrom, 1931; Grundstrom, 1932 | ||||||||||||
| E 2Π | 20418 13 | 1248.6 HQ | 21.8 | [4.284] | [2.2] | [2.001] | E → X 14 V | 20392 Z | ||||
| Watson and Weber, 1935 | ||||||||||||
| B 2Σ+ (4p) | 15762 | 1285 | 20 | [4.3410] 15 | 0.116 | [2.020] 15 16 | 1.9744 | B ↔ X V | 15754.96 15 | |||
| Hulthen, 1927; Watson and Bender, 1930; missing citation; Liberale and Weniger, 1969; Berg and Klynning, 1974; Berg and Klynning, 1974, 2 | ||||||||||||
| State | Te | ωe | ωexe | ωeye | Be | αe | γe | De | βe | re | Trans. | ν00 |
| A 2Πr (4p) | 14413 17 | 1333 | 20 | [4.34769] 15 | 0.106 | [1.883] 15 18 | 1.9740 | A ↔ X V | 14430.39 15 | |||
| Hulthen, 1927; Watson and Bender, 1930; Mulliken and Christy, 1931; Liberale and Weniger, 1969; Berg and Klynning, 1974; Berg and Klynning, 1974, 2 | ||||||||||||
| X 2Σ+ | 0 | 1298.34 Z | 19.10 | 4.2766 19 | 0.0970 | 1.837 20 | 2.0025 21 |
| 1 | From isotope relations Edvinsson, Kopp, et al., 1963. |
| 2 | A0 = +5.0. |
| 3 | Deperturbed constants for the three interacting states which form the d complex. The 2Δ5/2 component was not observed. Most of the lines are somewhat diffuse. The 2Π-2Σ band whose low J lines are sharp had been misinterpreted by Khan and Hasnain, 1973 in terms of two overlapping 2Σ-2Σ transitions. Small local perturbations. |
| 4 | From the proposed assignment of the 1-0 band by Khan and Afridi, 1968. Kaving and Lindgren, 1974 observe a diffuse single branch only. |
| 5 | A0= +18.8, A1= +19.3. |
| 6 | Deperturbed constants for the two interacting states which form the p complex. Small local perturbations. |
| 7 | D1 = 2.064E-4; H0 = +4.7E-9. |
| 8 | F1 levels not observed, presumably on account of predissociation. In v=1 both spin components seem to be predissociated. |
| 9 | H0= +2.5E-9. |
| 10 | Constants derived from high N values. At low N, v=0 is perturbed by a state of smaller B value. The observed origin of the 0-0 band is at 28352.5 cm-1. |
| 11 | At low pressure predissociation above v=0, N=10. |
| 12 | Strong perturbations for higher N values. |
| 13 | A ~ 9.3. |
| 14 | Two Q heads. |
| 15 | Deperturbed constants for the strongly interacting states A 2Π and B 2Σ+: see Berg and Klynning, 1974. For an extensive discussion of the rotational structure of the two states (including spin and Λ-type doubling) see also Veseth, 1971, Veseth, 1971, 2, Veseth, 1971, 3. |
| 16 | H0= +4.31E-9. |
| 17 | A0= +79.01; slight J dependence Berg and Klynning, 1974. See also Veseth, 1971. |
| 18 | H0= +5.08E-9. |
| 19 | Spin-splitting constant γv= +0.0429 - 0.0010(v+1/2). |
| 20 | He= +5.51E-9. |
| 21 | ESR sp. 24 |
| 22 | From the predissociation in C 2Σ+, assuming dissociation into Ca(3P) + H(2S). |
| 23 | From the observation of Rydberg states in the absorption spectrum Kaving and Lindgren, 1974. |
| 24 | In Ar matrix at 4 K Knight and Weltner, 1971. |
Go To: Top, Gas phase ion energetics data, Constants of diatomic molecules, Notes / Error Report
Data compilation copyright by the U.S. Secretary of Commerce on behalf of the U.S.A. All rights reserved.
Rackwitz, Feldman, et al., 1977
Rackwitz, R.; Feldman, D.; Kaiser, H.J.; Heincke, E.,
Photodetachment bei einigen zweiatomigen negativen hydridionen: BeH-, MgH-, CaH-, ZnH-, PH-, AsH-,
Z. Naturforsch. A:, 1977, 32, 594. [all data]
Kaving and Lindgren, 1974
Kaving, B.; Lindgren, B.,
Ultraviolet absorption spectrum of the CaH molecule. II. The structure of the d-complex around 2850 A,
Phys. Scr., 1974, 10, 81. [all data]
Petrunin, Andersen, et al., 1996
Petrunin, V.V.; Andersen, H.H.; Balling, P.; Andersen, T.,
Structural Properties of the Negative Calcium Ion: Binding Energies and Fine-structure Splitting,
Phys. Rev. Lett., 1996, 76, 744. [all data]
Khan and Afridi, 1968
Khan, M.A.; Afridi, M.K.,
A high dispersion study of some new absorption bands of CaH and CaD in the ultra-violet region,
J. Phys. B:, 1968, 1, 260. [all data]
Khan, 1962
Khan, M.A.,
A new band in CaH at 2720 Å and discussion of the hydrides of metals of group II,
Proc. Phys. Soc. London, 1962, 80, 593. [all data]
Grundstrom, 1935
Grundstrom, B.,
Die bandenspektra des calciumhydrids. III,
Z. Phys., 1935, 95, 574. [all data]
Grundstrom, 1931
Grundstrom, B.,
Die bandenspektra des calciumhydrids. I.,
Z. Phys., 1931, 69, 235. [all data]
Grundstrom, 1932
Grundstrom, B.,
Die bandenspektra des calciumhydrids. II,
Z. Phys., 1932, 75, 302. [all data]
Watson and Weber, 1935
Watson, W.W.; Weber, R.L.,
The E band system of calcium hydride,
Phys. Rev., 1935, 48, 732. [all data]
Hulthen, 1927
Hulthen, E.,
On the band spectrum of calcium hydride,
Phys. Rev., 1927, 29, 97. [all data]
Watson and Bender, 1930
Watson, W.W.; Bender, W.,
The Zeeman effect in the red CaH bands,
Phys. Rev., 1930, 35, 1513. [all data]
Liberale and Weniger, 1969
Liberale, G.; Weniger, S.,
Etude du spectre d'absorption des systemes A2Π-X2Σ et B2Σ-X2Σ de l'hydrure de calcium,
Physica (Amsterdam), 1969, 41, 47. [all data]
Berg and Klynning, 1974
Berg, L.-E.; Klynning, L.,
Rotational analysis of the A-X and B-X band systems of CaH,
Phys. Scr., 1974, 10, 331. [all data]
Berg and Klynning, 1974, 2
Berg, L.-E.; Klynning, L.,
New laboratory measurments of the A2Π-X2Σ and B2Σ-X2Σ transitions of CaH,
Astron. Astrophys. Suppl. Ser., 1974, 13, 325. [all data]
Mulliken and Christy, 1931
Mulliken, R.S.; Christy, A.,
Λ-type doubling and electron configurations in diatomic molecules,
Phys. Rev., 1931, 38, 87. [all data]
Edvinsson, Kopp, et al., 1963
Edvinsson, G.; Kopp, I.; Lindgren, B.; Aslund, N.,
Rotational analysis of an ultraviolet system of the hydrides and deuterides of Ca, Sr and Ba,
Ark. Fys., 1963, 25, 95. [all data]
Khan and Hasnain, 1973
Khan, M.A.; Hasnain, S.S.,
Two overlapping systems of CaH and CaD in the UV region,
Nuovo Cimento B, 1973, 18, 384. [all data]
Veseth, 1971
Veseth, L.,
Corrections to the spin-orbit splitting in 2Π states of diatomic molecules,
J. Mol. Spectrosc., 1971, 38, 228. [all data]
Veseth, 1971, 2
Veseth, L.,
An investigation of the interaction between close-lying 2Σ and 2Π states of diatomic molecules. I. Spin-splitting of the 2Σ levels,
Mol. Phys., 1971, 20, 1057. [all data]
Veseth, 1971, 3
Veseth, L.,
An investigation of the interaction between close-lying 2Σ and 2Π states of diatomic molecules. II. Λ-doubling of the 2Π levels,
Mol. Phys., 1971, 21, 287. [all data]
Knight and Weltner, 1971
Knight, L.B., Jr.; Weltner, W., Jr.,
Hyperfine interaction and chemical bonding in MgH, CaH, SrH, and BaH molecules,
J. Chem. Phys., 1971, 54, 3875. [all data]
Go To: Top, Gas phase ion energetics data, Constants of diatomic molecules, References
| EA | Electron affinity |
| ΔrG° | Free energy of reaction at standard conditions |
| ΔrH° | Enthalpy of reaction at standard conditions |
Copyright for NIST Standard Reference Data is governed by the Standard Reference Data Act.
|
Standard Reference Data Program |
Data Gateway |
Chemistry WebBook |
If you have comments or questions about this site, please contact us.


A brief walkthrough
Links Here
Show off Pictures
Talk about recommended activities
Practise Design
Use Cool Presentation Framework
And Why Not?
Navigate onwards to the restaurants to view and read about the restaurants and courses
Down Arrow for delicious Hungarian Cuisine
Including Michelin Bib Bourmand and Recommended Restaurants!
Located at the Lobby of Hotel Boscolo
Opposite our place of stay
Nope I could not afford to stay in Boscolo
Different Flavours, liked the pumpkin.
I believe it was duck based, that is not a caterpillar
Are we supposed to drink the egg like a shot?
Delicious Pork Trotters, over sorghum wheat
Poppy strudel, nothing to do with the Cafe
A different one above each table
New York, in Hungary, by an Italian Conglomeration
At least the slogans made more sense than some I have seen back home
Fun Stuff Here
Placehold
Placehold
Placehold
Placehold