不使用函数直接将字符串限制为一定长度

Question

不与this 重复。

我想让一个字符串有一个最大长度。它不应该超过这个长度。让我们说一个20个字符的长度。如果提供的字符串 > 20，则取前 20 个字符串并丢弃其余字符串。

The 对该问题的回答显示了如何使用函数为字符串加盖，但我想在没有函数的情况下直接执行此操作。我希望每次写入字符串时都进行字符串长度检查。

以下是我不想想做的事情：

string myString = "my long string";
myString = capString(myString, 20); //<-- Don't want to call a function each time

string capString(string strToCap, int strLen)
{
    ...
}

我可以通过一个属性来实现这一点：

const int Max_Length = 20;
private string _userName;

public string userName
{
    get { return _userName; }
    set
    {
        _userName = string.IsNullOrEmpty(value) ? "" : value.Substring(0, Max_Length);
    }
}

然后我可以很容易地使用它来调用一个函数来限制它：

userName = "Programmer";

问题在于，我想限制的每个string 都必须为它们定义多个变量。在这种情况下，_userName 和 userName（属性）变量。

有什么聪明的方法可以做到这一点，而无需为每个字符串创建多个变量，同时不必在每次我想修改string 时调用函数？

Answer 1

创建一个具有string 属性的类，并将所有代码放在那里。然后，您可以在任何地方使用s.Value 作为具有所需特征的字符串。

类似：

class Superstring
{
    int max_Length = 20;
    string theString;

    public Superstring() { }
    public Superstring(int maxLength) { max_Length = maxLength; }
    public Superstring(string initialValue) { Value = initialValue; }
    public Superstring(int maxLength, string initialValue) { max_Length = maxLength; Value = initialValue; }

    public string Value { get { return theString; } set { theString = string.IsNullOrEmpty(value) ? value : value.Substring(0, Math.Min(max_Length, value.Length)); } }
}

并使用：

Superstring s = new Superstring("z");
s.Value = "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
string s2 = s.Value;

Answer 2

有趣的情况 - 我建议创建一个struct，然后为它定义一个implicit conversion operator，类似于在this Stack Overflow question 中所做的。

public struct CappedString
{
    int Max_Length;
    string val;

    public CappedString(string str, int maxLength = 20)
    {
        Max_Length = maxLength;
        val = (string.IsNullOrEmpty(str)) ? "" :
              (str.Length <= Max_Length) ? str : str.Substring(0, Max_Length);
    }

    // From string to CappedString
    public static implicit operator CappedString(string str)
    {
        return new CappedString(str);
    }

    // From CappedString to string
    public static implicit operator string(CappedString str)
    {
        return str.val;
    }

    // To making using Debug.Log() more convenient
    public override string ToString()
    {
        return val;
    }

    // Then overload the rest of your operators for other common string operations
}

以后你可以像这样使用它：

// Implicitly convert string to CappedString
CappedString cappedString = "newString";

// Implicitly convert CappedString to string
string normalString = cappedString;

// Initialize with non-default max length
CappedString cappedString30 = new CappedString("newString", 30);

注意：不幸的是，这不是完美的解决方案 - 因为隐式转换没有提供将现有值传输到新实例的方法，任何使用非默认长度值初始化的 CappedString 都需要分配给使用构造函数，否则其长度限制将恢复为默认值。