F6 : Générer la solution Ctrl+F6 : Générer le projet en cours F7 : Afficher code Shift+F7 : Afficher le concepteur de formulaire F5 : Démarrer le débogage Ctrl+F5 : Démarrer l'exécution (sans débogage) Shift+F5 : Arrêter le débogage Ctrl+Shift+F5 : Redémarrer le débogage F9 : Changer les points d'arrêt Ctrl+F9 : Activer/arrêter les points d'arrêt Ctrl+Shift+F9 : Supprimer tous les points d'arrêt F10 : Processus par processus Ctrl+F10 : Exécuter Aller à le curseur F11 : Instruction par instruction
Modifier les touches de raccourci
Maj+Alt+Entrée : Passer en édition plein écran
Ctrl+B,T / Ctrl +K, K : basculer le commutateur de signet Ctrl+B,N / Ctrl+K,N : passer au signet suivant Ctrl+B,P : passer au signet précédent Ctrl+B,C : Effacer toutes les balises
Ctrl+I : Recherche incrémentale Ctrl+Shift+I : Recherche progressive inversée Ctrl+F : Rechercher Ctrl+Shift+F : Rechercher dans les fichiers F3 : Rechercher suivant Maj+F3 : Rechercher précédent Ctrl+H : Remplacer Ctrl+Maj+H : Remplacer Alt+F12 : Rechercher le symbole (lister tous les résultats de recherche)
Ctrl+flèches gauche et droite : déplacer un mot à la fois Ctrl+flèches haut et bas : défilement de l'écran de code, mais ne déplace pas la position du curseur. Ctrl+Shift+L : Supprimer la ligne actuelle Ctrl+M,M : Masquer ou développer le pli imbriqué actuel État Ctrl+M,L : Définir tous les processus sur The même état masqué ou développé Ctrl+M,P : arrêter l'affichage du contour Ctrl+E,S : afficher l'espace vide Ctrl+E,W : retourner automatiquement Ctrl+G : accéder à spécifié Ligne Maj+Alt+touches fléchées : sélectionnez le texte rectangulaire Alt+souris gauchebouton : sélectionnez le texte rectangulaire
Ctrl+Maj+U : mettez tout en majuscule Ctrl +U : Tout mettre en minuscules
Touches de raccourci du code
Ctrl+J / Ctrl+K,L : Liste des membres Ctrl+Shift+Espace / Ctrl+K,P : Informations sur les paramètres Ctrl+K,I : Informations rapides
Ctrl+E,C / Ctrl+K,C : CommentaireContenu sélectionné Ctrl+E,U / Ctrl+K,U : désélectionner le contenu du commentaire
Ctrl+K,M : générer un stub de méthode Ctrl+K,X : insérer un segment de code Ctrl+K,S : insérer du code extérieur 🎜> F12 : Aller à la définition de la procédure appelée ou variable
Touche de raccourci fenêtre
Ctrl+W, W : Fenêtre du navigateur Ctrl +W,S : Gestionnaire de solutions Ctrl+W,C : ClasseVue Ctrl+W,E : Liste d'erreurs Ctrl+W,O : Vue de sortie Ctrl +W,P : PropriétésFenêtre Ctrl+W,T : Liste des tâches Ctrl+W,X : Boîte à outils Ctrl+W,B : Fenêtre des favoris Ctrl+ W,U : Plan du document
Ctrl+D,B : Fenêtre de point d'arrêt Ctrl+D,I : Fenêtre immédiate
Ctrl+Tab : Changement de fenêtre actif
Ctrl+Shift+N : Créer un nouveau projet Ctrl+Shift+O : Ouvrir le projet Ctrl+Shift+S : Tout enregistrer Shift+Alt+C : Créer une nouvelle classe Ctrl +Maj+A : Nouvel élément
3. Variable.ToString() conversion du type de caractère en String 12345.ToString("n"); //Générer 12 345,00 12345.ToString("C"); //Générer ￥12 345,00 12345.ToString("e") ; Générer 1.234500e+004 12345.ToString("f4"); //Générer 12345.0000 12345.ToString("x"); //Générer 3039 (hexadécimal) 12345. ToString("p"); ); //Générer 1 234 500,00 %
1.9 Obtenez l'affichage de la date chinoise - année, mois, jour, heure et minute string strY=currentTime. ToString("f"); //Ne pas afficher les secondes
1.10 Obtenir la date chinoise display_year et le mois string strYM=currentTime.ToString("y"); Date display_month day string strMD=currentTime.ToString("m");
1.12 Obtenir l'année, le mois et le jour chinois string strYMD=currentTime.ToString("D"); 1.13 Obtenez l'heure et les minutes actuelles, le format est : 14:24 string strT=currentTime.ToString("t");
1.14 Obtenez l'heure actuelle, le format est : 2003 -09-23T14:46 :48 string strT=currentTime.ToString("s");
1.15 Obtenez l'heure actuelle, le format est : 2003-09-23 14:48:30Z string strT=currentTime.ToString ("u");
1.16 Obtenez l'heure actuelle, le format est : 2003-09-23 14:48 string strT=currentTime.ToString("g ");
1.17 Obtenez l'heure actuelle au format : Tue, 23 Sep 2003 14:52:40 GMT string strT=currentTime.ToString("r");
1.18 Obtenez la date et l'heure n jours après l'heure actuelle
C#ProgrammationStandards Il est extrêmement nécessaire de développer un bon style de codage. Personne ne veut voir un tas de code désordonné que vous ou d'autres. sera maintenu à l'avenir. Alors, à partir de maintenant, développez de bonnes habitudes de codage, notamment la dénomination des variables, les commentaires, l'indentation du code... 1. Utilisez Pascal pour définir les types, les noms de méthodes et les constantes
public class SomeClass
public class SomeClass { const int DefaultSize=100; public SomeMethod() { } }
{
const int DefaultSize=100; public SomeMethod()
{
int number; void MyMethod(int someNumber) {}
}
}
tr>
2. Utilisez le nom de chameau pour les variables locales et les paramètres de méthode
int number ;
interface ImyInterface {…}
void MyMethod(int someNumber)
{ Ajouter I
interface ImyInterface /table>4 . Ajoutez m_ devant les variables membres privées. Pour le
public class SomeClass { private int m_Number; }
nom de la variable
après m_, utilisez la méthode de dénomination camel
classe publique SomeClass { private int m_Number; }
à la classe d'exception personnalisée 7. Utilisez la paire de verbes ---- object lorsque vous nommez la méthode, comme ShowDialog()
8. Les méthodes avec des valeurs de retour doivent être nommées avec une description de la valeur de retour, comme GetObjectState()
9. Utilisez des noms de variables descriptifs a) Évitez les variables à un seul caractère. noms, tels que I ou t, etc. Utilisez des noms significatifs comme index ou temp. b) Évitez d'utiliser la notation hongroise pour les variables de type public ou protégé. c) N'abrégez pas les mots (par exemple, utilisez num au lieu de nombre). 10． Utilisez toujours C# prédéfini au lieu des alias dans l'espace de noms Système, par exemple :
//正确 public class LinkedList {…}
//避免 public class LinkedList {….}
Utilisez un objet au lieu d'un objet
Utilisez une chaîne au lieu d'une chaîne Utilisez un int au lieu d'un int32
11. , la première lettre du type doit être en majuscule. Lorsque vous traitez des types Type dans .NET, conservez le suffixe Type. (Nouvelle fonctionnalité de C#2.0)
//Corriger public class LinkedList > // Évitez Public Class LinkedList & LT; KeyType, Datatype & GT; {….}
using System; using System.Collection.Generic; using System.ComponentModel; using System.Data; using MyCompany; using MyControls;
12 .Définissez l'espace de noms en utilisant noms significatifs, tels que des noms de produits ou des noms d'entreprises
13. Évitez d'utiliser des noms de types de manière pleinement qualifiée et utilisez le mot-clé using.
delegate void SomeDelegate(); public void SomeMethod() {…} SomeDelegate someDelegate=SomeMethod;
14. Évitez d'utiliser le mot-clé using dans un espace de noms 15. Organisez tous les espaces de noms fournis par le framework ensemble et utilisez les noms fournis par des tiers. l'espace sous l'espace de noms du système
using System using System.Collection.Generic using System; using System.Data ; using MyCompany ; using MyControls ; Ne pas instancier explicitement un délégué (nouvelle fonctionnalité en C# 2.0)
delegate void SomeDelegate(); public void SomeMethod()
17. Maintenez une indentation stricte du code. N'utilisez pas de tabulations ni d'indentations non standard, telles qu'un espace. L'indentation recommandée est de 3 à 4 espaces.
18. Ajoutez un commentaire pour cette ligne de code au même niveau que l'indentation de votre code.
19. Tous les commentaires doivent réussir la vérification orthographique. Les fautes d'orthographe dans les commentaires entraînent des retards dans la progression du développement.
20. Toutes les variables membres de la classe doivent être déclarées en haut de la classe et utiliser une ligne vide pour les séparer des déclarations de méthode et d'attribut
public void SomeMethod2(); 🎜>
public class MyClass { int m_Number; string m_Name; public void SomeMethod1(); public void SomeMethod2(); }
21. là où il est utilisé.
22. Un nom de fichier doit refléter le nom de classe auquel il correspond
23 Lorsque vous utilisez une classe partielle et que vous distribuez la classe à différents fichiers, dans chaque nom de fichier À la fin, le rôle. joué par la partie implémentation du fichier dans la classe globale est ajouté. Par exemple :
// Dans MyClass.cs classe partielle publique MyClass
// In MyClass.cs public partial class MyClass {…} //In MyClass.Designer.cs public partial class MyClass {…}
MyClass.Designer.cs
classe partielle publique MyClass » sur une nouvelle ligne Pratiques de codage :
Évitez de placer plusieurs classes dans le même fichier 2. . Un fichier ne doit définir que des types dans un espace de noms. Évitez d'utiliser plusieurs espaces de noms dans un fichier 3. Évitez d'écrire plus de 500 lignes de code dans un fichier (sauf le code généré automatiquement par la machine) 4. Évitez d'écrire plus de 25 lignes de code 5. Évitez d'écrire des méthodes avec plus de 5 paramètres. Si vous souhaitez transmettre plusieurs paramètres, utilisez une structure. 6. Une ligne ne doit pas dépasser 80 caractères 7. Ne modifiez manuellement aucun code généré par la machine a) Si vous modifiez le code généré par la machine, modifiez votre méthode d'encodage pour vous adapter à cette norme d'encodage. b) Utilisez autant que possible les fonctionnalités des classes partielles pour améliorer la maintenabilité. (Nouvelles fonctionnalités en C# 2.0) 8. Évitez de commenter du contenu très intuitif. Le code lui-même devrait être capable d’expliquer sa propre signification. Un bon code composé de noms de variables et de méthodes lisibles ne devrait pas nécessiter de commentaires. 9. Les commentaires ne doivent décrire que certaines hypothèses préalables au fonctionnement, les informations internes de l'algorithme, etc. 10. Évitez de commenter les méthodes a) Utiliser suffisamment de documentation externe pour décrire l'API
b) Seules les informations utiles aux autres développeurs doivent être placées dans les commentaires au niveau des méthodes 10. 🎜>11. Ne codez jamais en dur des valeurs autres que 0 et 1, en déclarant une constante à la place de la valeur 12. Utilisez uniquement la touche const pour les valeurs qui ne changent jamais de caractère , comme. le nombre de jours dans une semaine. 13. Évitez d'utiliser le mot-clé const pour les variables en lecture seule. Dans ce cas, utilisez directement le mot-clé en lecture seule
public class MyClass { public const int DaysInWeek=7; pubic readonly int Number; public MyClass(int someValue) { Number=someValue; } }
public class MyClass
public readonly int Number public MyClass( int someValue)
}
using System.Diagnostics; object GetObject() {…} object someObject=GetObject(); Debug.assert(someObject!=null);
}
tbody>
14. Faites une affirmation pour chaque hypothèse. En moyenne, il devrait y avoir une assertion toutes les 5 lignes.
en utilisant System.Diagnostics ; Debug.assert(someObject!=null);
15. Chaque ligne de code doit être examinée via des tests en boîte blanche. 16. N'interceptez que les exceptions que vous pouvez explicitement gérer vous-même. 17. Si vous devez lancer une exception dans le bloc d'instruction catch, lancez uniquement l'exception capturée par le catch (ou d'autres exceptions créées sur la base de l'exception), afin que l'erreur d'origine puisse être maintenu L'emplacement de la pile où elle se trouve.
18. Évitez d'utiliser la valeur de retour comme code d'erreur de la fonction. 19. Évitez les classes d'exception personnalisées. 20. Lors de la personnalisation des classes d'exception : a) Laissez votre classe d'exception personnalisée hériter de la classe Exception b) Fournissez un mécanisme de sérialisation personnalisé 21. Méthodes >Main() dans un seul assembly. 22. Définissez uniquement les méthodes qui sont absolument nécessaires comme publiques et définissez les autres comme internes. 23. Évitez les assemblages amis car cela augmenterait le couplage entre les assemblages. 24. Évitez de rendre votre code dépendant d'un assembly exécuté dans un endroit spécifique. 25. Minimisez la quantité de code dans l’assembly d’application (assemblys client EXE). Utilisez des bibliothèques de classes pour contenir la logique métier. 26. Évitez de spécifier explicitement des valeurs d'énumération
//Corriger public enum Color
//正确 public enum Color { Red,Green,Blue }
//避免 public enum Color { Red=1,Green=2,Blue=3 }
Rouge = 1, Vert = 2, Bleu = 3 >
27. Évitez de spécifier un type pour une énumération
//Éviter
//避免 public enum Color:long { Red,Green,Blue }
public enum Color:long
{ 🎜 >28. Pour les instructions if, utilisez toujours une paire de {} à inclure. le bloc d'instructions suivant, même s'il n'y a qu'une seule instruction. 29. Évitez d'utiliser l'opérateur conditionnel ternaire . 30. Évitez d'utiliser les valeurs booléennes renvoyées par les fonctions comme instructions conditionnelles. Attribuez la valeur de retour à une variable locale, puis testez-la.
public class MyClass {} const int ArraySize=100; MyClass[] array=new MyClass[ArraySize]; For (int index=0;index { array[index]=new MyClass(); }
classe publique MyClass<🎜> {}<🎜> const int ArraySize=100; =0;index
33. Utilisez des propriétés pour remplacer les variables membres de type public ou protégé. 34. N'utilisez pas l'opérateur new hérité, utilisez le mot-clé override pour remplacer l'implémentation de new. 35. Dans une classe non scellée, définissez toujours les méthodes publiques et protégées comme virtuelles. 36. N'utilisez jamais de code dangereux, sauf pour interagir avec d'autres langages. 37. Évitez d'afficher la conversion de type. Utilisez le mot-clé as pour une conversion sûre vers un autre type.
Chien dog=new GermanShepherd();
Dog dog=new GermanShepherd(); GermanShepherd shepherd=dog as GermanShepherd; if (shepherd!=null) {…}
GermanShepherd shepherd=dog as GermanShepherd; )
. 39. Ne fournissez pas de variables membres event publiques. Utilisez plutôt l'accesseur d'événement.
Classe publique MyPublisher
Public class MyPublisher { MyDelegate m_SomeEvent; Public event MyDelegate SomeEvent { add { m_SomeEvent+=value; } remove { m_SomeEvent-=value; } } }
40. Utilisez EventHandler ou GenericEventHandler. 41. Évitez d'afficher les événements déclencheurs. Utilisez EventsHelper pour publier des événements en toute sécurité. 42. Utilisez toujours des interfaces. 43. Le rapport entre les méthodes et les propriétés dans les interfaces et les classes doit être d'environ 2:1. 44. Évitez les interfaces avec un seul membre. 45. Essayez de vous assurer qu'une interface compte 3 à 5 membres. 46. Ne laissez pas le nombre de membres dans une interface dépasser 20, alors que 12 est une limite plus pratique. 47. Évitez d'inclure des événements dans les interfaces. 48. Lorsque vous utilisez une classe abstraite , fournissez une interface. 49. Exposez les interfaces dans les structures d’héritage de classe. 50. Il est recommandé d'utiliser une implémentation d'interface explicite. 51. Ne présumez jamais qu’un type prend en charge une interface. Demandez toujours avant d'utiliser.
SomeType obj1; ImyInterface obj2; /*Some code to initialize obj1,then:*/ obj2=obj1 as ImyInterface; if(obj2!=null) { obj2.Method1(); } else { //Handle erro in expected interface }
SomeType obj1;
ImyInterface obj2; obj2=obj1 comme if(obj2!=null) { > else
52. ne code pas en dur les chaînes affichées à l'utilisateur. Pour utiliser les ressources. 53. Ne codez pas en dur les chaînes qui peuvent changer avec l'environnement de publication, telles que les chaînes de connexion à la base de données. 54. Utilisez String.Empty pour remplacer ""
//Avoid //Corriger le nom de la chaîne =String.Empty;
55. Lorsque vous utilisez une longue chaîne, utilisez StringBuilder au lieu de string. 56. Évitez de fournir des méthodes dans les structures a) Les constructeurs paramétrés sont encouragés à être utilisés b) Vous pouvez surcharger les opérateurs 57. Lors de la déclaration les membres expressifs, fournissent toujours un constructeur expressif. 58. Essayez de ne pas utiliser la liaison tardive lorsqu'une liaison anticipée est possible. 59. Assurez-vous que votre application prend en charge le traçage et la journalisation. 60. N'utilisez pas le mot-clé goto sauf pour implémenter des sauts de code dans le bloc instruction switch . 61. Fournissez toujours une assertion dans le cas par défaut d'une instruction switch.
int number=SomeMethod(); Trace.Writeline ("cas 1 :")
int number=SomeMethod(); swith(number) { case 1: trace.WriteLine(“Case 1:”) break; case 2: trace.Writeline(“Case 2:”); break; default: debug.Assert(false); break; }
Break
Cas 2 : Trace.writeline ("Case 2:");
Break;
//Example of proper use of ‘this’ public class MyClass { public MyClass(string message) { } public MyClass():this(“Hello”) { } }
Defaut:
Assert(false); break;
//Exemple d'utilisation appropriée de 'this'
//Example of proper use of ‘base’ public class Dog { public Dog(string name) { } virtual public void Bark(int howlong) { } } public class GermanShepherd:Dog { public GermanShepherd(string name):base(name) { } override public void Bark(int howLong) { base.Bark(howLong) } }
public class MyClass
{ public MyClass(string message) > 63. N'utilisez pas le mot-clé base pour accéder aux membres d'une classe de base, sauf si vous devez résoudre un conflit de nom de sous-classe lors de l'appel d'un constructeur de classe de base
//Exemple d'utilisation appropriée de 'base' virtual public void Bark(int howlong)
Int CalcPower(int number,int power) { int result=1; for (int count=1;count<=power;count++) { checked { result*=number; } } return result; }
> 64. N'utilisez pas GC.AddMemoryPressure() <🎜>65. Ne comptez pas sur HandleCollector <🎜>66. Implémentez les méthodes Disponse() et Finalize() en fonction du contenu du chapitre 4 dans « Programmation des composants .NET ». 2/e. <🎜>67. Exécutez toujours le code dans un état non coché (pour des raisons de performances), mais pour éviter les opérations de débordement ou de sous-débordement, utilisez le mode vérifié de manière décisive. <🎜><🎜>
Int CalcPower(int number,int power) <🎜> count=1;count<=power;count++ } <🎜> 🎜>
68. Utilisez des méthodes conditionnelles pour remplacer le code d'exclusion d'appel de méthode explicite (#if...#endif)
classe publique MyClass.
public class MyClass { [Conditional(“MySpecialCondition”)] public void MyMethod() {} }
}
69. Ne définissez pas de contraintes dans les interfaces génériques. Les contraintes au niveau de l'interface peuvent souvent être remplacées par un typage fort.
Public class Customer {} //避免: public interface Ilist where T:Customer {}
//正确: public interface IcustomerList:Ilist
Client de classe publique
Client {}
//Correct :
interface publique IcustomerList:Ilist
70 . Ne définissez pas de contraintes liées à la méthode sur l'interface.
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!
Déclaration：
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
