我正在尝试将 JavaScript 稀疏数组映射到 C# 表示。
推荐的方法是什么？
它正在考虑使用包含原始数组中包含值的原始列表的字典。
还有其他想法吗？
谢谢！
问问题
1564 次
2 回答
1
笔记
针对这种情况，我提出了两个 .NET 解决方案。因为这两种解决方案都需要相同的 JavaScript 代码，所以我在这个答案中只包含了这两种解决方案的 JavaScript 代码。
现在来回答...
编辑说明：对于起初没有完全理解您的问题，我深表歉意。我以前从未听说过“稀疏数组”这个词，所以我不得不查找它并从 Wikipedia找到教科书定义，这与您所描述的不太一样，而且就我在其他地方看到的用法而言，从那时起, 好像不是你描述的那样。但是，以这种方式使用它确实有意义。
更多地考虑这种情况促使我想出一个解决方案。undefined正如您所提到的，C#（和一般的 .NET）除了 .NET之外没有 .NET 的概念null。
据我了解，您希望能够在数组中表示三种不同的事物：
- 数组元素的有效值
- 数组元素的空值
- “未定义”数组元素的概念
正如您所指出的，C# 没有“未定义”的概念，除了null. 对于 .NET，undefined将与 .NET 相同，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]"
但是，这将不起作用。.NETJavaScriptSerializer或.NET 都JSON.parse(...)不能解析这个字符串（尽管 JavaScript 的eval(...)方法可以工作）。我们需要的是一种表示“ undefined”的方法，该方法将使用标准 JSON 方法进行序列化，并且可以被 .NET 的 .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，而是另一个对象。这意味着您的解析器将不得不专门处理这个问题。确保不要尝试在任何不知道完全组成的“未定义”对象的 JSON 解析器中使用它。下一步是在 C# 中处理它。
C# 方面
这里的挑战是如何表示未定义的值。下面的解决方案选择将未定义的索引视为数组中的“不存在”。我的另一个解决方案创建了一个类似于Nullable<T>结构包装器的包装器。
创建SparseArray<T>字典包装器
我创建了一个SparseArray<T>可以像 .NET 中的普通数组一样使用的类。此类与普通数组之间的区别在于，当您访问未定义的数组元素时，它会抛出一个自定义的IndexNotFoundException. 您可以通过首先检查元素是否通过调用SparseArray<T>.ContainsIndex(index)来检查它是否具有该索引来定义来避免引发此异常。
正如您在问题中提到的那样，它在内部使用字典。初始化它时，构造函数首先获取 JSON 字符串并通过 JavaScriptSerializer 运行它。
然后它获取反序列化的数组并开始将每个数组元素添加到其_Array字典中。当它添加元素时，它会{undefined:null}在我们“字符串化”它时查找我们在 JavaScript 中定义的对象（不确定那是否是正确的过去时态......）。如果它看到这个对象，则跳过索引。当找到未定义的值时，数组的长度会增加，但是会跳过它们的索引。
由于类的代码比较长，我先放一个用法示例：
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))
{
}
}
于 2009-09-26T14:04:57.380 回答
0
笔记
针对这种情况，我提出了两个 .NET 解决方案。我将它们保存在单独的答案中，以便可以根据哪个解决方案更有利对它们进行投票，以便作者可以选择最有利的解决方案作为“接受的答案”。因为这两种解决方案都需要相同的 JavaScript 代码，所以我在另一个答案中只包含了这两种解决方案的 JavaScript 代码。如果此答案被标记为已接受，我将在此答案中包含我的 JavaScript 解决方案，以便将其包含在页面上逻辑上首先出现的答案中。
现在来回答...
首先，我想重复我在其他解决方案中提到的内容，因为重要的是要提到：
正如您所指出的，C# 没有“未定义”的概念，除了
null. 对于 .NET，undefined将与 .NET 相同，null并且可能应该保持这种方式。但是由于您显然需要一种方法来表示这一点（我假设一些奇怪的业务规则），我试图提出一个可行的实现。我强烈建议不要这样做！
对于这个解决方案，我创建了一个名为Undefined<T>. 它的工作方式类似于 .NET 的原生Nullable<T>. 这样做的缺点是，因为 .NET 没有“未定义”的概念，所以很难决定如何处理访问对象的值。如果您尝试undefined在undefined.
使用此解决方案，您将拥有一个实际数组，其中每个元素都存在。尽管每个元素都存在，但您实际上无法获得每个元素的值。我创建的类Nullable<T>在各个方面都表现得像，除了当您尝试强制转换未定义的对象或获取它Value时，该类会引发异常。在实际尝试使用它之前，您需要致电IsDefined以确保您可以使用它。Value
[DebuggerDisplay("IsDefined:{IsDefined}, Value:{_Value}")]
public sealed class Undefined<T>
{
public static Undefined<T>[] DeserializeArray(string jsonArray)
{
var jss = new JavaScriptSerializer();
var objs = jss.Deserialize<object[]>(jsonArray);
var undefinedArray = new Undefined<T>[objs.Length];
for (int i = 0; i < objs.Length; i++)
{
if (objs[i] is Dictionary<string, object>)
{
var undefined = (Dictionary<string, object>)objs[i];
if (undefined.ContainsKey("undefined") && undefined["undefined"] == null)
{
undefinedArray[i] = new Undefined<T>(default(T), false);
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));
}
undefinedArray[i] = new Undefined<T>(val, true);
}
return undefinedArray;
}
private Undefined(T value, bool isDefined)
{
Value = value;
IsDefined = isDefined;
}
public static explicit operator T(Undefined<T> value)
{
if (!value.IsDefined)
throw new InvalidCastException("Value is undefined. Unable to cast.");
return value.Value;
}
public bool IsDefined { get; private set; }
private T _Value;
public T Value
{
get
{
if (IsDefined)
return _Value;
throw new Exception("Value is undefined.");
}
private set { _Value = value; }
}
public override bool Equals(object other)
{
Undefined<T> o = other as Undefined<T>;
if (o == null)
return false;
if ((!this.IsDefined && o.IsDefined) || this.IsDefined && !o.IsDefined)
return false;
return this.Value.Equals(o.Value);
}
public override int GetHashCode()
{
if (IsDefined)
return Value.GetHashCode();
return base.GetHashCode();
}
public T GetValueOrDefault()
{
return GetValueOrDefault(default(T));
}
public T GetValueOrDefault(T defaultValue)
{
if (IsDefined)
return Value;
return defaultValue;
}
public override string ToString()
{
if (IsDefined)
Value.ToString();
return base.ToString();
}
}
于 2009-09-27T20:25:44.810 回答