Introduction détaillée à l'utilisation de C# in, out, ref, paras

Les 4 mots-clés fournis par C#.net, in, out, ref et paras sont souvent utilisés en développement, alors comment les utiliser quelle est la différence ?

1 in

in n'est utilisé que dans les délégués et les interfaces ;
exemple :

       //测试模型
       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的取值不变。

En analysant la raison, le paramètre de ForEach est la fonction délégué :

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

Le délégué est générique, et un mot-clé in est ajouté avant le type T. En raison du mot-clé in, T obj ne peut pas être modifié.

Essayez le test :

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

En conséquence, chaque élément est multiplié par 2, devenant 2,8,12. On voit que les propriétés de l'objet peuvent être modifiées.

2 out

notes d'utilisation du mot-clé out :
1) Pour les paramètres formels sans out, lors de la définition d'une fonction, il faut en attribuer un à la fonction avant le retour valeur.
2) Lors de l'appel d'une fonction, les paramètres sans out n'ont pas besoin de se voir attribuer une valeur initiale.
3) La valeur du paramètre formel out est passée par référence (par référence)

scénario d'utilisation out :
Lorsqu'une fonction renvoie plusieurs valeurs, out est généralement utilisé pour renvoyer l'une d'elles

🎜>

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未按照预想逻辑被赋值。

Il existe un type de fonction TryParse en C#.net, qui est une autre application importante de out. Si vous êtes intéressé, veuillez consulter : Grâce à Parse et TryParse : les modes Try-Parse et Tester-Doer

3 ref

le mot-clé ref est utilisé pour modifier le passage des paramètres, Changer par valeur en par référence. La valeur d'origine est passée par référence. L'effet est le même avec ou sans réf.

Par exemple :

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

Comment modifier l'attribut a dans le modèle objet pour le changer en 12 ?

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

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

Par conséquent, un résumé de l'utilisation du mot-clé ref :
ref est utilisé pour traiter les variables de valeur, telles que les types de base, les structures, etc. le transfert de valeur est basé sur la copie de valeur.

1) La variable après ref, si c'est un type valeur, alors après avoir ajouté ref, elle devient une valeur passée par référence

2) La variable après ref, si c'est Reference ; type (type de référence), alors il n'y a aucune différence entre ajouter ref ou non ;

3) La variable après ref doit se voir attribuer une valeur avant utilisation

4) La variable après ref ne peut pas être une référence Attributs de type

Ce qui précède est une analyse de base, qui suffit à l'usage. Si vous souhaitez analyser ce problème plus en profondeur, veuillez continuer.

4 Discussion approfondie sur les références hors

Analyser principalement l'utilisation des références hors et l'impact de leur non-utilisation.

1) Il existe une classe de méthodes en C# appelée Try..., telle que Int.TryParse. Elle renvoie une valeur booléenne et essaie d'analyser une chaîne si elle est analysée avec succès en un entier. renvoie vrai et l'entier obtenu est L'int est transmis comme deuxième sortie.
Voir l'article d'analyse
Directives de conception d'exceptions
Grâce à Parse et TryParse : modes Try-Parse et Tester-Doer
Comme le montre l'article, par rapport à la sous-méthode Parse sans paramètres , si analysé. Si la chaîne échoue, une exception d'erreur de paramètre sera levée.

Le code écrit à l'aide de la méthode Try... est plus concis que le code écrit à l'aide de la méthode try...catch, c'est donc devenu un scénario courant pour l'utilisation de paramètres.

2) Comparaison entre Java et C#

En Java, HashMap

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

mais val == null, il se peut qu'il n'y ait pas de clé pour cette clé dans la carte. La paire clé-valeur existe peut-être déjà mais sa valeur est nulle.
Pour distinguer les deux, HashMap fournit la méthode containKey(). Donc, la bonne façon de l'écrire est la suivante :

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

Les opérations internes de containKey() et get() sont presque exactement les mêmes. Elles doivent toutes deux effectuer une recherche par hachage, mais elles renvoient simplement. différentes parties des résultats de recherche. En d’autres termes, si vous l’écrivez selon cette « méthode d’écriture correcte », accéder une fois à HashMap coûtera le double. Des tasses !

C# propose de nombreuses conceptions détaillées qui sont plus attentionnées que Java. Découvrez comment C# utilise le mot-clé out pour améliorer ce problème.

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

En utilisant cette méthode, la version C# correspondant au code Java ci-dessus peut être écrite comme :

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

Ceci is La sémantique de ContainsKey et Item[Key] est combinée pour renvoyer toutes les informations pouvant être trouvées dans une recherche de hachage en une seule fois, évitant ainsi l'opération redondante de "deux recherches" à partir de la source, ce qui est bénéfique pour les performances du programme.

C#.net fournit un mot-clé params. Je ne savais pas que ce mot-clé existait auparavant, après qu'un collègue ait vu plusieurs versions de mes fonctions surchargées, il m'a dit calmement, mon frère, ouais, tu peux utiliser params. . Je l'ai vérifié plus tard et maintenant j'y suis habitué, je viens de supprimer toutes les versions précédentes et de le refactoriser en utilisant les paramètres.

5 Paras

Ensuite, je parlerai de l'utilisation des paramètres et du processus que j'ai suivi.

5.1 Exigences du problème
Côté client, les clients modifient souvent les champs de requête. Il y a quelques jours, ils se sont rendus sur le serveur pour interroger plusieurs modèles en fonction de quatre champs clés. pour ajouter un champ de requête supplémentaire.

Méthode de requête basée sur 4 champs clés :

        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);

        }

La méthode getPlansWithCondition appelée est

        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);
        }
        }

Le problème survient lorsqu'un de plus est ajouté au champ de requête, est-ce que tu recharges toujours une version ?

5.2 Application des paramètres

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

Lorsque C# fournit des paramètres, bien sûr, il n'est pas nécessaire de réécrire directement getMPartPlansWithCondition comme suit

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

   sqlQuery(dict);
}

Ajoutez des champs de requête à votre guise à l'avenir, tant qu'il suffit de modifier cette fonction, pas besoin d'ajouter ou de supprimer la version surchargée ! ! !

Appel client, ajoutez simplement un champ directement

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

Résumé 5.3

queryFun(params object[] objs), une fonction avec ce paramètre ne nécessite qu'une seule version, ce qui résout le problème de plusieurs versions surchargées en raison de nombres incohérents
Lorsqu'ils sont appelés par le client, les paramètres d'attribut peuvent être répertoriés. un par un.

Les 4 mots-clés fournis par C#.net, in, out, ref et paras sont souvent utilisés en développement, alors comment les utiliser

Ce qui précède est en C# ? Une introduction détaillée à l'utilisation de in, out, ref, paras. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !