.NET Framework - résumé du code utilisé dans, out, ref, paras

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

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的取值不变。

Analyse de la raison, des paramètres de ForEach sont DelegateFonction :

//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 de la fonction, retourne Une valeur doit être affecté à la fonction auparavant.
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) paramètre formel out valeur transmise est 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 en renvoyer une d'entre eux

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);
//调用reviseModel
reviseModel(model.a); //model.a仍然=10；by-value
reviseMode(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 paire clé-valeur avec la clé dans la carte, ou il se peut que la paire clé-valeur existe déjà mais que sa valeur soit 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);
        }
        }

问题来了，当查询再新加1个字段时，你难道还再重载一个版本吗？

5.2 应用params

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

当C#提供了params后，当然不用，直接将getMPartPlansWithCondition改写为如下

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

   sqlQuery(dict);
}

以后随意添加查询字段，只要修改下这个函数就行了，不用增删重载版本！！！

客户端调用，直接加一个字段就行

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

5.3 总结

queryFun(params object[] objs)，带有这个参数的函数，只需要一个版本，这样解决了因为个数不一致而导致的多个重载版本，
在客户端调用时，将属性参数一一列数即可。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!