C# 列表上的属性访问器<；T>；在.NET中

我有一个名为水果的属性，它包含一个逗号分隔的字符串，格式为“apples，bananase，peaches”

我想在同一个类中创建一个列表，使Fruits属性更易于操作。访问器不起作用，因为它们在列表上不受支持，或者看起来是这样

基本上，我想要一个名为“水果列表”的属性，它基于水果属性自动填充，并且在添加项目或操作水果列表时，它应该自动填充水果属性

---

我需要实体框架的Fruits属性。

实现这一点的唯一现实方法是使用可以观察到更改的集合，处理更改时引发的事件，并更新属性

像这样的东西很合适

例如：

public class MyObject
{
    public string Fruits{get;set;}

    public IList<string> FruitList 
    {
        get
        {
            var list = new ObservableCollection<string>(Fruits.Split(','));
            list.CollectionChanged += (s,ea) => {
               var items = (IList<string>)s;
               Fruits = String.Join(",",items);
            };
            return list;
        }
    }
}

实例：

看到这里的概念起作用后，值得注意的是，上面的实现有点危险。每次调用

get

访问器时，它都会创建一个新的

observeCollection

，这可能会产生一些意外的后果

例如，如果您在my original

Console.WriteLine

之前添加以下行：

Console.WriteLine("{0}", obj.FruitList == list);

它输出

false

，这可能看起来很奇怪，正如您可能（理论上应该）期望

list

和

obj.FruitList

指向同一个列表一样

您可以通过将实现更改为仅创建ever 1

ObservableCollection

并始终从

get

访问器返回该值来解决此问题：

public class MyObject
{
    private string fruits;
    private ObservableCollection<string> fruitList;
    public string Fruits
    {
        get{ return this.fruits; }
        set
        {
            this.fruits = value;
            this.fruitList = CreateFruitList();
        }
    }

    private ObservableCollection<string> CreateFruitList()
    {
        var list = new ObservableCollection<string>(this.fruits.Split(','));
        list.CollectionChanged += (s,ea) => {
           var items = (IList<string>)s;
           this.fruits = String.Join(",",items);
        };
        return list;
    }


    public IList<string> FruitList 
    {
        get
        {

            return fruitList;
        }
    }
}

公共类MyObject
{
私人串果；
私有可观测收集结果表；
公共串果
{
获取{返回this.fruits；}
设置
{
这个。水果=价值；
this.fruitList=CreateFruitList（）；
}
}
私有ObservableCollection CreateFruchtList（）
{
var list=newobserveCollection（this.fruits.Split（'，'）；
list.CollectionChanged+=（s，ea）=>{
var项目=（IList）s；
this.fruits=String.Join（“，”，items）；
};
退货清单；
}
公共列表
{
得到
{
返回结果列表；
}
}
}

---

现在世界又好了

唯一可行的方法是使用一个可以观察到更改的集合，处理更改时引发的事件，并更新属性

像这样的东西很合适

例如：

public class MyObject
{
    public string Fruits{get;set;}

    public IList<string> FruitList 
    {
        get
        {
            var list = new ObservableCollection<string>(Fruits.Split(','));
            list.CollectionChanged += (s,ea) => {
               var items = (IList<string>)s;
               Fruits = String.Join(",",items);
            };
            return list;
        }
    }
}

实例：

看到这里的概念起作用后，值得注意的是，上面的实现有点危险。每次调用

get

访问器时，它都会创建一个新的

observeCollection

，这可能会产生一些意外的后果

例如，如果您在my original

Console.WriteLine

之前添加以下行：

Console.WriteLine("{0}", obj.FruitList == list);

它输出

false

，这可能看起来很奇怪，正如您可能（理论上应该）期望

list

和

obj.FruitList

指向同一个列表一样

您可以通过将实现更改为仅创建ever 1

ObservableCollection

并始终从

get

访问器返回该值来解决此问题：

public class MyObject
{
    private string fruits;
    private ObservableCollection<string> fruitList;
    public string Fruits
    {
        get{ return this.fruits; }
        set
        {
            this.fruits = value;
            this.fruitList = CreateFruitList();
        }
    }

    private ObservableCollection<string> CreateFruitList()
    {
        var list = new ObservableCollection<string>(this.fruits.Split(','));
        list.CollectionChanged += (s,ea) => {
           var items = (IList<string>)s;
           this.fruits = String.Join(",",items);
        };
        return list;
    }


    public IList<string> FruitList 
    {
        get
        {

            return fruitList;
        }
    }
}

公共类MyObject
{
私人串果；
私有可观测收集结果表；
公共串果
{
获取{返回this.fruits；}
设置
{
这个。水果=价值；
this.fruitList=CreateFruitList（）；
}
}
私有ObservableCollection CreateFruchtList（）
{
var list=newobserveCollection（this.fruits.Split（'，'）；
list.CollectionChanged+=（s，ea）=>{
var项目=（IList）s；
this.fruits=String.Join（“，”，items）；
};
退货清单；
}
公共列表
{
得到
{
返回结果列表；
}
}
}

---

现在世界又好了

下面是您可以做的，为逗号分隔的列表创建代理：

public class MyClass
{
    public string Fruits {get;set;}

    public string [] FruitList {
        get { return Fruits.Split(new [] {','}); }
        //warning, the setter is dangerous
        set { Fruits = string.Join(',', value); }
    }
}

---

当我说setter是危险的时，我的意思是如果你改变数组中的一个元素，结果将不会被更新。只有在推送新阵列时，它才会更新。如果需要这种行为，请考虑使用VelababelCopys< /P> < P>实现它。这里可以做的是，为逗号分隔的列表创建代理：

public class MyClass
{
    public string Fruits {get;set;}

    public string [] FruitList {
        get { return Fruits.Split(new [] {','}); }
        //warning, the setter is dangerous
        set { Fruits = string.Join(',', value); }
    }
}

---

当我说setter是危险的时，我的意思是如果你改变数组中的一个元素，结果将不会被更新。只有在推送新阵列时，它才会更新。如果你需要这个行为，考虑使用一个SaveabelCopys< /P> < P>实现它，你可以颠倒逻辑：

List<string> fruitsList = new List<string>();
public List<string> FruitsList
{
    get
    {
        return fruitsList;
    }
}

public string Fruits
{
    get
    {
        return string.Join(',', fruitsList);
    }
    set
    {
        // Incomplete, does not handle null
        FruitsList.Clear();
        FruitsList.AddRange(value.Split(','));
    }
}

List水果列表=新列表（）；
公开名单
{
得到
{
返回水果列表；
}
}
公共串果
{
得到
{
返回string.Join（“，”，水果列表）；
}
设置
{
//不完整，不处理null
水果列表；
exportsList.AddRange（value.Split（'，'））；
}
}

---

如果通过查看

水果列表

确定了

水果

，则无需担心更新

水果

。您提到需要将

水果

作为实体框架的

字符串

属性，但EF不关心它是否由

字符串

字段支持。

您可以反转逻辑：

List<string> fruitsList = new List<string>();
public List<string> FruitsList
{
    get
    {
        return fruitsList;
    }
}

public string Fruits
{
    get
    {
        return string.Join(',', fruitsList);
    }
    set
    {
        // Incomplete, does not handle null
        FruitsList.Clear();
        FruitsList.AddRange(value.Split(','));
    }
}

List水果列表=新列表（）；
公开名单
{
得到
{
返回水果列表；
}
}
公共串果
{
得到
{
返回string.Join（“，”，水果列表）；
}
设置
{
//不完整，不处理null
水果列表；
exportsList.AddRange（value.Split（'，'））；
}
}

如果通过查看

水果列表

确定了

水果

，则无需担心更新

水果

。您提到您需要

水果作为