C# 如何忽略特定列表<；T>；序列化容器类时的项

我想知道如何忽略使用

XmlSerializer

序列化的

列表的特定项/索引

例如，考虑以下列表：
...
List<int> collection = new List<int>() {0, 1, 2};
...

谢谢

更新

以下代码是我问题的一个具体示例：

[Serializable]
public class Ball
{
    private static readonly XmlSerializer Serializer = new XmlSerializer(typeof(Ball));

    public Ball()
    {
        // value 1 is a default value which I don't want to be serialized.
        Points = new List<int>() { 1 };
        IsEnabled = false;
    }

    public List<int> Points { get; set; }
    public bool IsEnabled { get; set; }

    public void Save()
    {
        using (StreamWriter writer = new StreamWriter(FILENAME))
        {
            Serializer.Serialize(writer, this);
        }
    }

    public Ball Load()
    {
        using (StreamReader reader = new StreamReader(FILENAME))
        {
             return (Ball)Serializer.Deserialize(reader);
        }
    }
}

[可序列化]
公共班级舞会
{
私有静态只读XmlSerializer序列化程序=新XmlSerializer（typeof（Ball））；
公共舞会
{
//值1是我不希望序列化的默认值。
点=新列表（）{1}；
IsEnabled=false；
}
公共列表点{get；set；}
公共布尔值已启用{get；set；}
公共作废保存（）
{
使用（StreamWriter=newstreamwriter（文件名））
{
Serializer.Serialize（writer，this）；
}
}
公众球负荷（）
{
使用（StreamReader=新StreamReader（文件名））
{
返回（球）序列化程序。反序列化（读取器）；
}
}
}
更好的解决方案是使用LINQ查询创建一个新集合并传递给序列化程序，如

List<int> collection = new List<int>(){ 0, 1, 2, 3 };
using (var fs = new StreamWriter("serialized.txt"))
{
    XmlSerializer serializer = new XmlSerializer(collection.GetType());
    serializer.Serialize(fs, collection.Where(x => x != 0).ToList());
}

List collection=newlist（）{0,1,2,3}；
使用（var fs=newstreamwriter（“serialized.txt”））
{
XmlSerializer serializer=新的XmlSerializer（collection.GetType（））；
serializer.Serialize（fs，collection.Where（x=>x！=0.ToList（））；
}
更好的解决方案是使用LINQ查询创建一个新集合并传递给序列化程序，如

List<int> collection = new List<int>(){ 0, 1, 2, 3 };
using (var fs = new StreamWriter("serialized.txt"))
{
    XmlSerializer serializer = new XmlSerializer(collection.GetType());
    serializer.Serialize(fs, collection.Where(x => x != 0).ToList());
}

List collection=newlist（）{0,1,2,3}；
使用（var fs=newstreamwriter（“serialized.txt”））
{
XmlSerializer serializer=新的XmlSerializer（collection.GetType（））；
serializer.Serialize（fs，collection.Where（x=>x！=0.ToList（））；
}
我怀疑您实际上是在试图解决问题中所描述的问题：当您序列化和反序列化在构造函数中添加了默认项的集合属性时，默认项会重复，因为反序列化的默认项会添加到最新的默认项中

这个问题的答案提供了一种解决方法，即将默认集合项的初始化移出构造函数。如果不方便，可以引入代理数组属性并序列化该属性，而不是底层集合：

[Serializable]
public class Ball
{
    public Ball()
    {
        Points = new List<int>() { 1 };
        IsEnabled = false;
    }

    public bool IsEnabled { get; set; }

    [XmlIgnore]
    public List<int> Points { get; set; }

    [XmlArray("Points")]
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public int[] SerializablePoints
    {
        get
        {
            return (Points == null ? null : Points.ToArray());
        }
        set
        {
            Points = ListExtensions.Initialize(Points, value);
        }
    }
}

public static class ListExtensions
{
    public static List<T> Initialize<T>(List<T> list, T[] value)
    {
        if (value == null)
        {
            if (list != null)
                list.Clear();
        }
        else
        {
            (list = list ?? new List<T>(value.Length)).Clear();
            list.AddRange(value);
        }
        return list;
    }
}

[可序列化]
公共班级舞会
{
公共舞会
{
点=新列表（）{1}；
IsEnabled=false；
}
公共布尔值已启用{get；set；}
[XmlIgnore]
公共列表点{get；set；}
[XmlArray（“点”）]
[可浏览（false）、可编辑（EditorBrowsableState.Never）、可调试（DebuggerBrowsableState.Never）]
公共int[]可序列化点
{
得到
{
返回（Points==null？null:Points.ToArray（））；
}
设置
{
Points=ListExtensions.Initialize（点，值）；
}
}
}
公共静态类ListExtensions
{
公共静态列表初始化（列表列表，T[]值）
{
如果（值==null）
{
如果（列表！=null）
list.Clear（）；
}
其他的
{
（list=list？？新列表（value.Length））.Clear（）；
list.AddRange（值）；
}
退货清单；
}
}

有关为什么属性必须是数组的解释，请参见。
我怀疑您实际上是在试图解决问题中描述的问题：当您序列化和反序列化在构造函数中添加了默认项的集合属性时，默认项会重复，因为反序列化的默认项被添加到最新的默认项中

这个问题的答案提供了一种解决方法，即将默认集合项的初始化移出构造函数。如果不方便，可以引入代理数组属性并序列化该属性，而不是底层集合：

[Serializable]
public class Ball
{
    public Ball()
    {
        Points = new List<int>() { 1 };
        IsEnabled = false;
    }

    public bool IsEnabled { get; set; }

    [XmlIgnore]
    public List<int> Points { get; set; }

    [XmlArray("Points")]
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public int[] SerializablePoints
    {
        get
        {
            return (Points == null ? null : Points.ToArray());
        }
        set
        {
            Points = ListExtensions.Initialize(Points, value);
        }
    }
}

public static class ListExtensions
{
    public static List<T> Initialize<T>(List<T> list, T[] value)
    {
        if (value == null)
        {
            if (list != null)
                list.Clear();
        }
        else
        {
            (list = list ?? new List<T>(value.Length)).Clear();
            list.AddRange(value);
        }
        return list;
    }
}

[可序列化]
公共班级舞会
{
公共舞会
{
点=新列表（）{1}；
IsEnabled=false；
}
公共布尔值已启用{get；set；}
[XmlIgnore]
公共列表点{get；set；}
[XmlArray（“点”）]
[可浏览（false）、可编辑（EditorBrowsableState.Never）、可调试（DebuggerBrowsableState.Never）]
公共int[]可序列化点
{
得到
{
返回（Points==null？null:Points.ToArray（））；
}
设置
{
Points=ListExtensions.Initialize（点，值）；
}
}
}
公共静态类ListExtensions
{
公共静态列表初始化（列表列表，T[]值）
{
如果（值==null）
{
如果（列表！=null）
list.Clear（）；
}
其他的
{
（list=list？？新列表（value.Length））.Clear（）；
list.AddRange（值）；
}
退货清单；
}
}

有关为什么属性必须是数组的解释，请参阅。
是否有任何原因不能在序列化之前从列表中删除该项？如果您喜欢作弊，只需在序列化之前删除该项/索引..？据我所知，对于单个集合元素没有等效项/索引-可能是因为它会扰乱集合索引。您可能需要在实现筛选器的包含类上设置一个。你能告诉我你想什么时候怎么做吗？嘿，DavidL和KDecker谢谢你的回答，我已经考虑过你的建议，但考虑到将来我会有大量的默认值（不是指定的，也适用于其他列表）我认为这会影响序列化性能，并将大量临时对象分配给堆，这些临时对象具有非常临时的用法。dbc，我添加了一个具体的示例。有什么原因不能简单地删除