.NET框架-引用陷阱的代码实例分享
.net 容器中判断某个引用类型存在的默认规则是什么？ 判断指针值是否相等。
private static List<int> list;
static void Main(string[] args)
{
//新建实例instance1
MyObject instance1 = new MyObject();
instance1.Value = 10;
//新建list
List<MyObject> list = new List<MyObject>();
//引用实例instance1
list.Add(instance1);
//新建实例：instance2
MyObject instance2 = new MyObject();
//赋值为instance1.Value
instance2.Value = instance1.Value;
}
}
用到的Model类：
public class MyObject
{
public int Value { get; set; }
}
下面做1个测试：
//即便Value相等，instance2与instance1的内存地址不相等！
bool isExistence1 = list.Contains(instance2); //isExistence1 : false;
这个测试结果是false，因为它们指向不同的内存地址，尽管值相等，这便是“值相等，对象不相等”的情况。
引用类型若是想根据其中的某个属性值判断是否相等，那么需要实现IEquatable接口！
若想继续看 根据值是否相等 判断对象是否相等，请参考文章：C# 容器，接口类，性能
2 引用陷阱？
一个对象引用另一个对象，某一个改变，另一个便改变。例如，合并两个字典，合并结果是对的，但是却意外改变了原对象。
在这里举一个例子：
var dict1 = new Dictionary<string, List<string>>();
dict1.Add("qaz",new List<string>(){"100"});//含有qaz键
dict1.Add("wsx",new List<string>(){"13"}); var dict2 = new Dictionary<string, List<string>>();
dict2.Add("qaz", new List<string>() { "11" });//也含有qaz键
dict2.Add("edc", new List<string>() { "17" }); //合并2个字典到dict
var dictCombine = new Dictionary<string, List<string>>();
foreach (var ele in dict1) //拿到dict1
{
dictCombine .Add(ele.Key,ele.Value);
}
foreach (var ele in dict2) //拿到dict2
{ if(dictCombine.ContainsKey(ele.Key))//检查重复
dictCombine [ele.Key].AddRange(ele.Value);
else
{
dictCombine .Add(ele.Key,ele.Value);
}
}
dictCombine的结果正确，{“qaz”, “100”和”11”}, {“wsx”,”13”}，{“edc”,”17”}
但是dict1的结果怎么样？ 被改变了！ dict1意外变为了 {“qaz”, “100”和”11”}, {“wsx”,”13”}。 正确的合并，不应该改变dict1！
分析原因
dictCombine首先添加了dict1的键值，也就是dictCombine的键值都引用了dict1的键值； 接下来，再合并dict2时，首先判断dictCombine中是否包含了dict2的键，如果包含，则再往dictCombine的键值中添加， 值又引用了同一个对象，也就是在dict1的键中添加了这个值。dictCombine[ele.Key]和dict1[ele.Key]引用是否相等的验证：
bool flag = object.ReferenceEquals(dictCombine[ele.Key], dict1[ele.Key]);//true
正解
避免dictCombine[ele.Key]和dict1[ele.Key]引用相等！！！
Dictionary<string, List<string>> dict = new Dictionary<string, List<string>>();
//先把键都合并到dictCombine中，值都是新创建的
foreach (var key in dict1.Keys)
{ if (!dictCombine.ContainsKey(key))
dictCombine.Add(key, new List<string>());
} foreach (var key in dict2.Keys)
{ if (!dictCombine.ContainsKey(key))
dictCombine.Add(key, new List<string>());
} //分别将值添加进去
foreach (var ele in dict1)
{
dictCombine[ele.Key].AddRange(ele.Value);
} foreach (var ele in dict2)
{
dictCombine[ele.Key].AddRange(ele.Value);
}
dictCombine合并结果是正确的，并且dict1，dict2都未改变！
总结
利用引用相等，带来了很多好处，比如函数间的引用传值（by reference）。但是，如果运用不当，也会给我们带来一些不必要的麻烦。
3 引用不当破坏封装？
如果将封装的类内私有字段作为接口方法的返回值，这种做法会破坏类的封装，是特别容易忽视的一个问题。如果忽视这个问题，可能会出现莫名其妙的问题。
如下面的代码所示，
public class TestPrivateEncapsulate
{
private List<object> _refObjs;
public List<object> GetRefObjs()
{
_refObjs = new List<object>(); ...
...
//其他逻辑处理计算出来的_refObjs={1,4,2};
return _refObjs; //返回私有字段
}
public object GetSumByIterRefObjs()
{ if (_refObjs == null) return null;
foreach (var item in _refObjs)
{ ...//处理逻辑
}
}
}
现在使用刚才写的类TestPrivateEncapsulate，我们先创建一个实例，
TestPrivateEncapsulate test = new TestPrivateEncapsulate();
然后调用：
List<object> wantedObjs = test.GetRefObjs();
返回的预期wantedObjs应该有3个整形类型的元素，1,4,2。
继续：
List<object> sol = wantedObjs; //我们将sol指向wantedObjssol.Add(5); //加入元素5
等我们想回过头来计算，原来wantedObjs的元素求和：
test.GetSum();
我们意外得到了12，而不是预想中的7。这是为什么呢？
仔细分析后发现，我们在客户端调用，sol.Add(5)后，间接的修改了TestPrivateEncapsulate内变量：_refObjs，它由{1,4,2}修改为了{1,4,2,5}。
私有变量在客户端被修改了！这便是接口返回私有变量带来的副作用！
正解：
// 将原来的公有变为私有
private List<object> getRefObjs()
{
_refObjs = new List<object>(); ...
...
//其他逻辑处理计算出来的_refObjs={1,4,2};
return _refObjs; //返回私有字段
}
//只带只读的属性
public RefObjs
{
get
{
getRefObjs();
return _refObjs;
}
}
设置一个公有字段，仅带有只读属性，将原来的公有方法GetRefObjs变为私有方法getRefObjs，这样在客户端是不可能修改私有字段的！
总结
对象的属性值都等，但对象引用不一定相等；
两个或多个对象都引用某个对象，若这个对象被修改，则所有引用者属性值也被修改；
成员返回封装的引用变量，会破坏封装。
以上就是.NET框架-引用陷阱的代码实例分享的详细内容，更多请关注其它相关文章！