C#reference的3个思索细致引见【C#.Net教程】,C#，reference

1 值相称，对象便默许相称？

.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，如许在客户端是不可能修正私有字段的！

总结
对象的属性值都等，但对象援用不一定相称；
两个或多个对象都援用某个对象，若这个对象被修正，则一切援用者属性值也被修正；
成员返回封装的援用变量，会损坏封装。

以上就是C#reference的3个思索细致引见的内容，更多相关内容请关注ki4网（www.ki4.cn）！