c# - 在JavaScript稀疏数组和C#(稀疏)数组之间映射的推荐方法？

Question

我正在尝试将JavaScript稀疏数组映射到C＃表示形式。

建议这样做的方法是什么？

它正在考虑使用一个字典，该字典包含在原始数组中包含值的原始词列表。

还有其他想法吗？

谢谢！

Answer 1

注意

针对这种情况，我提出了两个.NET解决方案。因为两个解决方案都需要相同的JavaScript代码，所以我在此答案中仅包括了两个解决方案的JavaScript代码。

现在开始回答...



编辑说明：抱歉，您起初并未完全理解您的问题。我以前从没听过“稀疏数组”这个词，所以我不得不查一下它，发现教科书definition from Wikipedia，它与您所描述的完全不符，从那时起我在其他地方也见过这种用法，似乎与您描述的不一样。但是，以这种方式使用它确实有意义。

考虑这种情况，使我想出了一个解决方案。如您所述，C＃（通常是.NET）除undefined外没有null的概念。

据我了解，您正在寻求能够表示数组中的三个不同的东西：


数组元素的有效值
数组元素的空值
“未定义”数组元素的概念


正如您指出的那样，除了null，C＃没有“未定义”的概念。对于.NET，undefined与null相同，可能应该这样保存。但是，既然您显然仍然需要一种方法来表示这种情况（我假设是使用一些奇怪的业务规则），所以我试图提出一种可行的实现方式。我强烈建议您不要这样做！

JavaScript方面

第一个挑战是在JavaScript中序列化数组的行为。将数组转换为JSON格式时，数组中的undefined元素会自动转换为null。如果您调用JSON.stringify(...)，则会发生这种情况：

var array = [73,42,undefined,null,23];
var json = JSON.stringify(array);
if(json === "[73,42,null,null,23]")
    alert('I am always true!');

上面的示例显示了数组中未定义的元素被序列化为“ null”。如果确实需要存储未定义的内容，则必须编写一个转换方法，该方法将手动序列化数组以包​​含未定义的元素。理想的解决方案将产生以下JSON：

"[73,42,undefined,null,23]"

但是，这将不起作用。 .NET JavaScriptSerializer或 JSON.parse(...)都不能解析此字符串（尽管JavaScript的 eval(...)方法可以使用）。我们需要的是一种表示“ undefined”的方法，该方法将使用标准的JSON方法进行序列化，并且可以由.NET的 JavaScriptSerializer理解。这样做的技巧是提出一个实际对象来表示未定义的对象。为了表示这一点，我使用了以下JSON字符串：

"{undefined:null}"

一个对象，其唯一属性称为“未定义”，其值为 null。这很可能不会出现在JavaScript代码的任何对象中，因此我正在使用它，因为我认为它是一个“唯一”的足以表示我们不存在的“未定义”数组元素的标志。

要像这样序列化JSON，您需要提供一个可以完成这项工作的替换程序，因此，您可以按照以下方法进行操作：

var arr = [73,42,undefined,null,23];
var json = JSON.stringify(arr, function(key, value) {
    jsonArray = value;
    if(value instanceof Array) {    
        var jsonArray = "[";
        for(var i = 0; i < value.length; i++) {
            var val = value[i];
            if(typeof val === "undefined") {
                jsonArray += "{undefined:null}";
            } else {
                jsonArray += JSON.stringify(value[i]);
            }
            if(i < value.length - 1) {
                jsonArray += ",";
            }
        }
        jsonArray += "]";
        if(key != null && key != "") {
            return key + ":" + jsonArray;
        } else {
            return jsonArray;
        }
    }

    if(key != null && key != "") {
        return key + ":" + JSON.stringify(jsonArray);
    } else {
        return JSON.stringify(jsonArray);
    }
});

这将为您提供一个类似于以下内容的JSON字符串：

"[73,42,{undefined:null},null,23]"

不利之处在于，一旦将其反序列化， undefined数组元素就不再是 undefined，而是另一个对象。这意味着您的解析器将必须专门处理此问题。确保不要在不知道完全组成“ undefined”对象的任何JSON解析器中尝试使用此对象。下一步是在C＃中处理它。



C＃方面

这里的挑战是如何表示未定义的值。下面的解决方案选择将未定义的索引视为数组中的“不存在”。我的其他解决方案为结构创建类似于 Nullable<T>包装器的包装器。

创建一个 SparseArray<T>词典包装器

我创建了一个 SparseArray<T>类，可以像.NET中的普通数组一样使用。此类与普通数组之间的区别在于，当您访问未定义的数组元素时，它将引发自定义 IndexNotFoundException。您可以通过先调用 SparseArray<T>.ContainsIndex(index)检查元素是否具有该索引来检查是否定义了元素，从而避免抛出此异常。

正如您在问题中提到的，它在内部使用字典。初始化时，构造函数首先使用JSON字符串，然后通过JavaScriptSerializer运行它。

然后，它将采用反序列化的数组，并开始将每个数组元素添加到其 _Array字典中。当添加元素时，它会在我们对它进行“分类”时查找我们在JavaScript中定义的 {undefined:null}对象（不确定那里的过去式是否正确...）。如果看到此对象，则跳过索引。数组的长度将随着找到未定义的值而增加，但是它们的索引将被跳过。

由于该类的代码很长，因此我将使用示例放在首位：

string json = "[4,5,null,62,{undefined:null},1,68,null, 3]";
SparseArray<int?> arr = new SparseArray<int?>(json);

在 for { }循环中，您需要在访问数组之前检查该数组是否包含每个索引。在 foreach { }循环中，枚举器仅保存定义的值，因此您不必担心 undefined值的出现。

这是我的 SparseArray<T>类的代码：

[DebuggerDisplay("Count = {Count}")]
public class SparseArray<T>: IList<T>
{
    Dictionary<int, T> _Array = new Dictionary<int, T>();
    int _Length = 0;

    public SparseArray(string jsonArray)
    {
        var jss = new JavaScriptSerializer();
        var objs = jss.Deserialize<object[]>(jsonArray);

        for (int i = 0; i < objs.Length; i++)
        {
            if (objs[i] is Dictionary<string, object>)
            {
                // If the undefined object {undefined:null} is found, don't add the element
                var undefined = (Dictionary<string, object>)objs[i];
                if (undefined.ContainsKey("undefined") && undefined["undefined"] == null)
                {
                    _Length++;
                    continue;
                }
            }
            T val;
            // The object being must be serializable by the JavaScriptSerializer
            // Or at the very least, be convertible from one type to another
            // by implementing IConvertible.
            try
            {
                val = (T)objs[i];
            }
            catch (InvalidCastException)
            {
                val = (T)Convert.ChangeType(objs[i], typeof(T));
            }

            _Array.Add(_Length, val);
            _Length++;
        }
    }

    public SparseArray(int length)
    {
        // Initializes the array so it behaves the same way as a standard array when initialized.
        for (int i = 0; i < length; i++)
        {
            _Array.Add(i, default(T));
        }
        _Length = length;
    }

    public bool ContainsIndex(int index)
    {
        return _Array.ContainsKey(index);
    }


    #region IList<T> Members

    public int IndexOf(T item)
    {
        foreach (KeyValuePair<int, T> pair in _Array)
        {
            if (pair.Value.Equals(item))
                return pair.Key;
        }
        return -1;
    }

    public T this[int index]
    {
        get {
            if (_Array.ContainsKey(index))
                return _Array[index];
            else
                throw new IndexNotFoundException(index);
        }
        set { _Array[index] = value; }
    }              

    public void Insert(int index, T item)
    {
        throw new NotImplementedException();
    }

    public void RemoveAt(int index)
    {
        throw new NotImplementedException();
    }

    #endregion

    #region ICollection<T> Members

    public void Add(T item)
    {
        _Array.Add(_Length, item);
        _Length++;
    }

    public void Clear()
    {
        _Array.Clear();
        _Length = 0;
    }

    public bool Contains(T item)
    {
        return _Array.ContainsValue(item);
    }        

    public int Count
    {
        get { return _Length; }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public bool Remove(T item)
    {
        throw new NotImplementedException();
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        throw new NotImplementedException();
    }

    #endregion

    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()
    {
        return _Array.Values.GetEnumerator();
    }

    #endregion

    #region IEnumerable Members

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return _Array.Values.GetEnumerator();
    }

    #endregion
}

以及使用此类所需的异常：

public class IndexNotFoundException:Exception
{
    public IndexNotFoundException() { }
    public IndexNotFoundException(int index) 
          : base(string.Format("Array is undefined at position [{0}]", index)) 
    { 
    }
}