Detailed introduction to the use of C# in, out, ref, paras

C#.net provides 4 keywords, in, out, ref, paras, which are often used in development, so how to use them? What is the difference?

1 in

in is only used in delegates and interfaces;
Example:

       //测试模型
       class Model
        {            
        public int a { get; set; }            
        public Model(int a)
            {                
            this.a = a;
            }
        }//创建3个实例List<Model> modelList= new List<Model>() 
{ new Model(1), new Model(4), new Model(6) };//调用foreach接口，试着操作3个实例，赋值为nullmodelList.ForEach(e=>e=null); 

//查看结果：//modelList的取值不变。

Analysis of the reason, the parameter of ForEach is the delegate function:

//ForEach方法：public void ForEach(Action<T> action);//委托声明：public delegate void Action<in T>(T obj);

Delegation It is generic, and a keyword in is added before the type T. Because of the keyword in, T obj cannot be modified.

Try the test:

//修改元素e的属性amodelList.ForEach(e=>{e.a*=2;});

As a result, each element is multiplied by 2, becoming 2,8,12. It can be seen that the properties of the object can be modified.

2 out

Out keyword usage notes:
1) For formal parameters with out, when the function is defined, one must be assigned to the function before return value.
2) When calling a function, parameters with out do not need to be assigned an initial value.
3) The value of the out formal parameter is passed by reference (by reference)

out usage scenario:
When a function returns multiple values, out is usually used to return one of them

public bool Operation(out Model updateMod)
{
    updateMode = new Model(5);    try{     // my operation
     ...     //
     return true;
    }    catch{      //写入日志
      return false;
    }
}//使用Model um; //未初始化bool rtnMsg = Operation(out um); 
//如果初始化，传值通过reference//分析://返回um，如果rntMsg为ture，则um按照预想逻辑被赋值，
//如果rntMsg为false 则um未按照预想逻辑被赋值。

## There is a type of TryParse function in #C#.net, which is another important application of out. If you are interested, see: Through Parse and TryParse: Try-Parse and Tester-Doer patterns

3 ref

ref keyword is used to change parameter passing, Change by value to by reference. The original value is passed by reference. The effect is the same with or without ref.

For example:

public void reviseModel(int a)
{
  a = 12;
}

Model model = new Model(10);
//调用reviseModelreviseModel(model.a); 
//model.a仍然=10；by-valuereviseMode(ref model.a); 
//编译不过，提示ref后的参数不归类与变量int a;
reviseMode(ref a); 
//如果不给变量a赋一个初始值，
//编译器也是提示：调用前未被赋值的错误
//因此赋值int a= model.a; 
//变量a初始值为10；reviseMode(ref a);
//修改变量a=12；但是model.a的值仍然为10

How to modify the attribute a in the object model to change it to 12?

//直接将参数设为Model对象，则函数调用时，传值通过by referencepublic void reviseModel(Model md)
{
  md.a = 12;
}

reviseModel(model );//传值通过by reference

Therefore, a summary of the use of the ref keyword:

ref is used to process value variables, such as basic types, structures, etc. They do not need to be new, and value transfer is based on value copy.

1) The variable after ref, if it is a value type, then after adding ref, it becomes a value passed by reference;

2) The variable after ref, if it is Reference type (reference type), then there is no difference between adding ref or not;

3) The variable after ref must be assigned a value before use

4) The variable after ref cannot be a reference Type attributes

The above is a basic analysis, which is enough in use. If you want to analyze this issue more deeply, please continue.

4 In-depth discussion of out ref

Mainly analyze the use of out ref and what impact they will have if they are not used.

1) There is a class of methods in C# called Try..., such as Int.TryParse. It returns a bool value and tries to parse a string. If it is successfully parsed into an integer, it returns true and the resulting integer is The int is passed as the second out.

See analysis article
Exception design guidelines
Through Parse and TryParse: Try-Parse and Tester-Doer modes
It can be seen from the article that compared to the sub-method Parse without out parameters, if parsed If the string fails, a parameter error exception will be thrown.

The code written using the Try... method is

more concise than the code written using try...catch, so this has become a common scenario for using out parameters.

2) Comparison between Java and C

#In Java, HashMap

// HashMap<K, V> map;
// K key;
V val = map.get(key);if (val != null) {
  // ...}

but val == null, it may be that there is no key for the key in the map. Value pair, it is also possible that the key-value pair already exists but its value is null.

To distinguish between the two, HashMap provides the containsKey() method. So the correct way to write it is this:

// HashMap<K, V> map;
// K key;if (map.containsKey(key)) {
  V val = map.get(key);
  // ...}

The internal operations of containsKey() and get() are almost exactly the same. They both need to do a hash search, but they just return different parts of the search results. In other words, if you write it according to this "correct writing method", accessing HashMap once will have double the cost. Cups!

C# has many such detailed designs that are more considerate than Java. See how C# uses the out keyword to improve this problem.

System.Collections.Generic.Dictionary

TryGetValue：
Dictionary(TKey, TValue).TryGetValue Method (TKey, TValue) (System.Collections.Generic)public bool TryGetValue(
    TKey key,    out TValue value
)ParameterskeyType: TKey
The key of the value to get.

valueType: TValue

Using this method, the C# version corresponding to the above Java code can be written as:

// Dictionary<TKey, TValue> dict;
// TKey key;
TValue val;if (dict.TryGetValue(key, out val)) {
  // ...}

This combines ContainsKey and Item[ Key] semantics are combined to return all the information that can be found in a hash search at one go, avoiding the redundant operation of "two searches" from the source, which is beneficial to the performance of the program.

C#.net provides a keyword params. I didn’t know this keyword existed before. Once, after a colleague saw several versions of my overloaded functions, he calmly said to me, brother Yeah, you can use params. I checked it later and now I’m used to it. I just removed all the previous versions and refactored it using params.

5 Paras

So, I will talk about the use of params and the process I went through.

5.1 Requirements of the problem

On the client side, customers often change the fields they query. A few days ago, they went to the server to query several models based on four key fields. Today, they want to add one more Query field.

Query method based on 4 key fields:

        public void GetPlansByInputControl(string planState, string contactno,DatePair dp)
        {       
            string planStat = "";            
            switch (planState)
            {                case "...":
                    planStat = "...";                    
                    break;                
                    case "...":
                    planStat = "...";                    
                    break;
            }
                plans = getPlansWithCondition(Convert.ToDateTime(dp.startValue), 
                Convert.ToDateTime(dp.endValue), planStat, contactno);

        }

The getPlansWithCondition method called is

        private List<MPartPlan> getMPartPlansWithCondition(DateTime dateTime, DateTime dateEndTime, string planStat, string contactNo)
        {            var conditions = new CslSqlBaseSingleTable();
            conditions.AddCondition("RequireStartDate", dateTime, DataCompareType.GreaterOrEqual);
            conditions.AddCondition("RequireStartDate", dateEndTime, DataCompareType.LessOrEqual);
            conditions.AddCondition("OrderCode", contactNo, DataCompareType.Equal);            
            if (!string.IsNullOrEmpty(planStat))
            {
                conditions.AddCondition("PlanState", planStat, DataCompareType.Equal);
            }            return _cslMPartPlan.QueryListInSingleTable(typeof(MPartPlan), 
            conditions);
        }
        }

The problem comes, when the query adds a new field, you Is it necessary to reload another version?

5.2 Applying params

 private List<MPartPlan> getMPartPlansWithCondition(DateTime dateTime, DateTime dateEndTime, string planStat, 
 string contactNo,string newField);

When C# provides params, of course there is no need to directly rewrite getMPartPlansWithCondition as follows

private List<MPartPlan> getMPartPlansWithCondition(params object[] queryConditions);
{
   queryConditions[0]
   queryConditions[1]
   queryConditions[2]
   queryConditions[3]
   queryConditions[4]
   //放到字典中dict

   sqlQuery(dict);
}

In the future, you can add query fields at will, just modify this function That’s it, no need to add or delete overloaded versions! ! !

Client call, just add a field directly

_bsl.GetPlansByInputControl(field1, field2,field3,field4,field5);

5.3 Summary

queryFun(params object[] objs), a function with this parameter only requires one version, which solves the problem of multiple overloaded versions due to inconsistent numbers.
When called by the client, The attribute parameters can be listed one by one.

The 4 keywords provided by C#.net, in, out, ref, and paras are often used in development, so how to use them? What is the difference?

The above is C# A detailed introduction to the use of in, out, ref, paras. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!