C# 列表<；字符串>；在c中消失的项目#

我有一个简单的列表包装类：

class ExtensionList
{
    public List<string> Extensions;

    public ExtensionList()
    {
        Extensions = new List<string>();
    }

    public void push(params string[] ext)
    {
        // Add the * extension if "ALL__" is pushed.
        if (ext.Contains("ALL__"))
        {
            Extensions = new List<string>();
            Extensions.Add("*");
            return;
        }

        // Don't add duplicate if pushed extension is already in list.
        if (Extensions.Intersect(ext).Any())
            return;

        Extensions.AddRange(ext);
    }
}

---

ExtList

属性的getter返回值，如果为null，则返回新列表。然后调用对象的getter并修改该列表。该列表在任何时候都没有设置为

extList

属性。无论是属性getter，还是初始化

Rec

的代码，都不能设置该字段

---

令人惊讶的是，这实际上与你有一个可变结构没有任何关系，也就是说，可变结构仍然是邪恶的，你应该像瘟疫一样避免它们。您的

结构

应该是不可变的，或者是一个

类

我看不出使用

扩展列表

类的原因。如前所述，逻辑可以直接实现到

Rec

public struct Rec
{
    public Rec(string match) : this()
    {
        Match=match;
        Extensions=new List<string>();
    }
    public string Match { get; private set; }
    public List<string> Extensions { get; private set; }
    public void Push(params string[] ext)
    {
        if(ext.Contains("ALL__"))
        {
            Extensions=new List<string>() { "*" };
            return;
        }

        if(Extensions.Intersect(ext).Any())
        {
            return;
        }

        Extensions.AddRange(ext);
    }
}

公共结构记录
{
公共记录（字符串匹配）：this（）
{
匹配=匹配；
扩展=新列表（）；
}
公共字符串匹配{get；private set；}
公共列表扩展{get；private set；}
公共无效推送（参数字符串[]ext）
{
if（ext.Contains（“全部”））
{
扩展=新列表（）{“*”}；
返回；
}
if（Extensions.Intersect（ext.Any（））
{
返回；
}
Extensions.AddRange（ext）；
}
}

类似用法：

    public bool readAppConfig(string appConfigPath)
    {
        Recs=new Dictionary<string, List<Rec>>()
        {
            {"Headers",    new List<Rec>()},
            {"Ignores",    new List<Rec>()},
            {"Exceptions", new List<Rec>()}
        };

        foreach(string sectionName in Recs.Keys)
        {
            var recSection=ConfigurationManager.GetSection(sectionName) as NameValueCollection;
            foreach(string key in recSection.AllKeys)
            {
                Rec r=new Rec(key);
                r.Push(recSection[key].Split(';', ' '));
                Recs[sectionName].Add(r);
            }
        }

        return true;
    }

public bool readAppConfig（字符串appConfigPath）
{
Recs=新字典（）
{
{“Headers”，new List（）}，
{“忽略”，新列表（）}，
{“例外”，新列表（）}
};
foreach（记录键中的字符串sectionName）
{
var recSection=ConfigurationManager.GetSection（sectionName）作为NameValueCollection；
foreach（recSection.allkey中的字符串键）
{
Rec r=新Rec（键）；
r、 推（recSection[key].Split（'；'，''）；
记录[sectionName]。添加（r）；
}
}
返回true；
}

get{return extList？？new ExtensionList（）；}未分配给私有字段

public struct Rec
{
    public Rec(string match) : this()
    {
        Match=match;
        Extensions=new List<string>();
    }
    public string Match { get; private set; }
    public List<string> Extensions { get; private set; }
    public void Push(params string[] ext)
    {
        if(ext.Contains("ALL__"))
        {
            Extensions=new List<string>() { "*" };
            return;
        }

        if(Extensions.Intersect(ext).Any())
        {
            return;
        }

        Extensions.AddRange(ext);
    }
}

    public bool readAppConfig(string appConfigPath)
    {
        Recs=new Dictionary<string, List<Rec>>()
        {
            {"Headers",    new List<Rec>()},
            {"Ignores",    new List<Rec>()},
            {"Exceptions", new List<Rec>()}
        };

        foreach(string sectionName in Recs.Keys)
        {
            var recSection=ConfigurationManager.GetSection(sectionName) as NameValueCollection;
            foreach(string key in recSection.AllKeys)
            {
                Rec r=new Rec(key);
                r.Push(recSection[key].Split(';', ' '));
                Recs[sectionName].Add(r);
            }
        }

        return true;
    }