
| ||
| auteur : abelman | ||
Voici la définition du .NET framework, communément appelé dotnet telle qu'elle apparait dans MSDN :
.NET Framework est le modèle de programmation de la plate-forme .NET. Les principaux composants de .NET Framework sont le Common Language Runtime et la bibliothèque de classes .NET Framework, qui contient ADO.NET, ASP.NET et Windows Forms. .NET Framework fournit un environnement d'exécution managé, un développement et un déploiement simplifiés et l'intégration à une grande variété de langages de programmation.
Il existe aujourd'hui deux versions du .NET framework : la 1.0 et la 1.1. La prochaine version 2.0 est prévue pour 2005. |
| ||
| auteur : abelman | ||
Visual Basic .NET (VB.NET) est la nouvelle génération du langage Visual Basic. Bien que les syntaxes de Visual Basic .NET et Visual basic restent sensiblement proche, Visual Basic .NET constitue une rupture totale avec Visual Basic. . Il intègre de nouvelles fonctionnalités telles que l'héritage, les interfaces, la surcharge des fonctions, ce qui en fait un langage orienté objet à part entière.
Par ailleurs, Visual Basic .NET dispose avec Visual Studio d'un IDE et d'assisants générateurs de code avancés. C'est à ce jour, un des langages les plus simples pour construire des applications .NET |
| ||
| auteurs : abelman, Webman | ||
Pour développer des applications en Visual Basic .Net vous avez le choix entre différentes solutions,
et cela quelque soit la dimension de votre projet. Voici ce que vous propose Microsoft pour créer
des applications Windows Form, Console, ASP.Net ou encore des Web Services.
Les versions gratuites et illimitées :
Les versions Express sont entièrement gratuites et disponibles au téléchargement, à l'adresse
suivante : cliquez-ici
Les versions payantes :
Toutes ces versions s'appuiyent sur le Framework .Net dans sa version 2.0, vous pouvez cependant
utiliser les anciennes versions de Visual Studio 2003 et antérieures qui elles utilisent
le Framework .Net en version 1.0 et 1.1.
Enfin, il est possible de développer des applications Visual Basic .NET en utilisant
n'importe quel éditeur de texte pour écrire le code de son application.
Le compilateur (vbc.exe) en ligne de commande du framework.NET SDK peut ensuite être utilisé pour générer les binaires. Noter que les Framework .NET SDK en version 1.1 ou 2.0 sont téléchargeables gratuitement aux adresses indiquées plus bas. | ||
lien : .Net Framework 1.1 SDKlien : .Net Framework 2.0 SDK |
| ||
| auteur : abelman | ||
Les systèmes d'exploitation suivants supportent la conception et le déploiement d'applications .NET développées avec VB.NET.
Vous pouvez déployer des applications dans les environnements de plates-formes Windows 98 et Windows ME, Microsoft Windows NT 4.0 (Service Pack 6a requis). L'installation du runtime Framework.NET est indispensable sur le poste cible. | ||
lien : Runtime Framework.NET 1.1 |
| ||
| auteur : abelman | ||
Avec Visual Basic .NET, il est possible de créer différents types d'applications .NET telles que :
|
| ||||||
| auteur : abelman | ||||||
Note à l'attention des utilisateurs de VB6 : - L'indice de la borne inférieure d'un tableau vaut toujours 0 en VB.NET - Le chiffre dans la parenthèse lors de la déclaration représente toujours l'indice de la borne supérieure du tableau - Lors de l'allocation de la mémoire pour le tableau, les accolades contiennent les éléments du tableau. Si le tableau est vide, alors les accolades sont vides. - Le nombre de dimensions d'un tableau est fixé à la déclaration et n'est pas modifiable par la suite Voici quelques exemples de déclarations et initialisations de tableaux Déclaration d'un tableau dont les dimensions sont inconnues au départ
Déclaration d'un tableau unidimensionnel non initialisé de 10 entiers
Déclaration d'un tableau unidimensionnel initialisé de 10 entiers
Déclaration d'un tableau bidimensionnel non initialisé de 3x6 entiers
Déclaration d'un tableau bidimensionnel initialisé de 3x2 entiers
Et enfin on peut déclarer un tableau de tableaux comme ceci
|
| ||
| auteur : abelman | ||
Pour mettre une seule instruction sur plusieurs lignes il faut utiliser le caractère _ comme ceci
Pour mettre plusieurs instructions sur la même ligne
|
| ||
| auteur : neguib | ||
Suite à une action utilisateur sur le clavier, nous devons parfois effectuer un long traitement.
Et nous souhaiterions que les actions clavier ne soient pas enregistrées pendant ce traitement.
Cette suspension peut être implémentée de la façon suivante
|
| |||
| auteur : Cyrilange | |||
Bien souvent, il est nécessaire de limiter le type de caractères qu'un
utilisateur peut saisir. On ne voudrait pas, par exemple, qu'il puisse saisir des
lettres dans un TextBox prévu pour un code postal ou un numéro de téléphone.
Néanmoins, on doit pouvoir autoriser la saisie de certains caractères spéciaux comme
la virgule dans un nombre décimal par exemple.
Dans l'exemple suivant, nous allons créer une méthode qui permet la saisie d'un nombre
décimal dans un TextBox en autorisant la saisie d'une virgule.
Commençons par créer la méthode :
Pour appeler cette méthode nous allons utiliser l'événement KeyPress de notre TextBox :
Pour la saisie d'une date au format jj/mm/aa nous aurions pu appeler la méthode de cette façon :
|
| ||
| auteur : neo.51 | ||
Rien de tel qu'un exemple concret pour voir comment formater une date pour l'affichage :
Voici les différents résultats que l'on obtient suivant la valeur de param :
Et pour les formats personnalisés:
Donnera : Jeudi, le 18 05 1978
|
| ||
| auteur : Webman | ||
Tout d'abord, ajoutez en entête de votre classe:
Un exemple vaut mieux qu'un long discours:
|
| ||
| auteur : dev01 | ||
Une classe partielle est tout simplement une classe dont la définition est
séparée dans plusieurs fichiers sources distincts.
Exemple :
|
| ||
| auteur : Webman | ||
Tout d'abord, ajoutez en entête de votre classe:
Ensuite, ajoutez ceci dans la partie de code qui vous intéresse:
|
| ||
| auteur : Samuel Beauvois | ||
Voici une méthode permettant de convertir un tableau de bytes en image :
|
| ||
| auteur : Samuel Beauvois | ||
Voici une méthode permettant de convertir une image (ici au format Jpeg) en un tableau de bytes :
|
| |||
| auteur : Bidou | |||
FlagsAttribute permet de définir si une énumération peut être traitée comme un champ de bits.
Généralement, les éléments d'une énumération sont mutuellement exclusifs.
Dans certain cas, ils peuvent être combinés dans un masque de bits que l'on obtient
par combinaison à l'aide de OR.
Toutefois attention. C'est à vous de définir des valeurs permettant de traiter correctement un masque de bits. Prenons l'exemple suivant :
Module Module1
Dans ce cas la console renvoie PosTrois, ce qui est faux puisque le fait de mettre les bits 1 et 2 à vrai n'induit pas que le bit 3 l'est.
Vous devez déclarer l'énumération telle que :
Pour que la console renvoie bien PosUn, PosDeux.
Si vous n'avez pas l'habitude de manipuler des masques de bits, le FrameWork met à votre disposition une structure BitVector32 plus facile à appréhender.
|
| ||||||||
| auteur : Bidou | ||||||||
Pour manipuler les évènements dans Visual Basic, il faut procéder aux étapes suivantes
Je souhaite qu'un évènement se déclenche si c'est l'anniversaire de mon objet personne.
Dans cet exemple, je vais créer un argument particulier HappyBirthDayEventArgs
qui contiendra l'âge de la personne. Cet argument sera de la forme
Au début de la classe 'Personne' je dois ajouter un délégué.
Un délégué est un pointeur de fonction qui doit reprendre exactement la signature
de la fonction qu'il cible. Pour schématiser, c'est le délégué qui permet de faire
la liaison entre l'évènement et le gestionnaire d'évènement.
Je dois aussi déclarer l'évènement dans ma classe. J'aurais donc :
Je vais modifier ma propriété Age de la classe personne pour lever l'évènement :
Je peux alors consommer l'évènement, par exemple :
|
| |||||
| auteur : Bidou | |||||
En VB.NET il existe deux méthodes pour gérer la gestion d'évènements.
L'utilisation du mot clé WithEvents et de la clause Handles permet un abonnement statique
au gestionnaire d'évènements. Il est statique dans le sens qu'il a lieu lors de la compilation
et qu'il n'est pas possible de se désabonner.
Dans le principe on déclare l'objet avec le mot clé WithEvents
Et on s'abonne à l'évènement par la clause Handles
Notez que l'on peut abonner plusieurs objets à un même évènement en séparant ceux-ci par une virgule
dans la clause Handles, tel que :
Les instructions AddHandler et RemoveHandler sont une approche dynamique des gestionnaires d'évènements.
L'abonnement par AddHandler a lieu lors de l'exécution et il est possible de se désabonner avec RemoveHandler.
Imaginons comme exemple, un bouton qui ne marcherait qu'une fois :
|
| ||||
| auteur : Bidou | ||||
Comme toute autre classe, vous pouvez créer vos propres Exception.
De l'ancêtre Exception, héritent deux classes, SystemException et ApplicationException.
Par convention, vous devez hériter d'ApplicationException.
Par exemple, je veux lever une exception si on attribue une chaîne vide à une valeur de clés.
Je crée l'exception :
Puis pour la lever j'utilise :
|
| ||
| auteur : neguib | ||
En premier lieu, il faut savoir que le decimal possède une limite d'affichage
de 28 digits significatifs. Au delà, le chiffre sera arrondi à cette limite.
En second lieu, l'utilisation de la méthode surchargée ToString() prend un paramètre format (par exemple ici de type "N") fixe. Ce qui est ennuyeux lorsqu'on ne peut anticiper le nombre de chiffres après la virgule. Nous proposons ici l'implémentation d'une méthode qui permet de déterminer le format N de façon dynamique. Et par là même, nous montrons l'utilisation de la classe NumberFormatInfo.
| ||
lien : NumberFormatInfo |
| ||
| auteur : StormimOn | ||
Depuis l'arrivée du Framework 2.0, la classe ConfigurationSettings est devenue obsolète.
Il faut utiliser à la place la classe ConfigurationManager.
Le Framework 2.0 possède un nouveau fichier System.Configuration.dll qui n'est
pas inclus par défaut dans les références.
Il ne faut donc pas oublier d'ajouter cette librairie dans la liste des
références de votre projet.
| ||
lien : Classe ConfigurationManager |
| ||
| auteur : Olivier Delmotte | ||
Afin d'avoir une variable accessible de n'importe quel endroit de son application il faut la déclarer Shared.
Ce code permet d'avoir une variable globale et un accès "propre" et sécurisé.
|
| ||
| auteur : Olivier Delmotte | ||
Une propriété est définie ainsi :
|
| ||
| auteur : StormimOn | ||
Nous avons vu dans cette FAQ comment lire un fichier avec les classes XPath. Dans
le cas de la présence de namespace dans le fichier Xml, nous avons utilisé la
classe XmlNamespaceManager pour gérer ces espaces de noms. Le seul défaut c'est
que nous alimentions manuellement ces données, nous allons donc maintenant créer
ce XmlNamespaceManager de manière automatique.
Fichier Xml utilisé pour l'exemple
Son implémentation :
|
| ||
| auteur : dev01 | ||
Une propriété est une façon d'accéder à une variable de manière simple en lecture et/ou écriture.
Elles sont utilisées dans les cas où l'accès est fait sans traitement "lourd". D'après les bonnes
pratiques de Microsoft, elles ne doivent pas renvoyer de collection ( par exemple : string() )
|
| ||
| auteur : dev01 | ||
Il suffit d'utiliser la variable prédéfinie par le framework
|
| ||
| auteur : neguib | ||
Lors du chargement d'une image dans un PictureBox avec la fonction
Image.FromFile, le fichier sous-jacent se trouve en utilisation et
donc non disponible jusqu'à la fermeture de l'application. Il est
ainsi par exemple impossible de le supprimer.
Pour pallier ce problème, il faut en conséquence pouvoir libérer la ressource du flux sur ce fichier. Plusieurs solutions permettent d'atteindre cet objectif. Nous vous proposons ici celui de gérer directement le flux et notamment par l'implémentation de la méthode Image.FromStream. L'exemple suivant charge une image via un FileStream, l'affecte à un PictureBox (appelé pictureBox1) par Image.FromStream, puis libère les ressources du flux (appelé photoStream) sur le fichier pour pouvoir le supprimer :
| ||
lien : System.IO.FileStream |
| ||
| auteur : dev01 | ||
Il faudra tout d'abord importer l'assembly System.Management. Pour récupérer une valeur,
il faudra utiliser la méthode GetPropertyValue associée à un nom de propriété.
L'exemple suivant commence par lister toutes les propriétés existantes puis récupère la valeur de la propriété VolumeSerialNumber.
|
| ||
| auteur : neguib | ||
L'intérêt est ici d'implémenter de façon appropriée la récursivité. L'espace de
noms privilégié est System.IO, notamment sa classe Directory. Pour l'exemple
nous allons explorer le répertoire particulier des "Favoris", ce qui nous
permet à ce propos de nous inspirer de la Q/R d'abelman :
Comment obtenir la liste des fichiers et des sous-répertoires d'un répertoire ?
| ||
lien : System.Environmentlien : System.IO.Directorylien : System.IO.Path |
| ||
| auteur : nico-pyright(c) | ||
Il peut être intéressant de faire en sorte que ses classes personnelles puissent
être parcourues grâce au mot clé for each.
Pour ceci, il faut que la classe soit en mesure de fournir un objet IEnumerator et implémente l'interface IEnumerable afin de surcharger les méthodes MoveNext et Reset tout en permettant l'accès à la propriété Current. Une solution est d'avoir une classe implémentant les interfaces IEnumerable et IEnumerator. Voici l'exemple d'une classe MyString, qui en l'occurence permet le parcours d'une chaîne avec for each (ce qui sert bien sur uniquement d'exemple, dans la mesure où la classe String le permet déjà).
On remarquera la méthode GetEnumerator qui renvoie Me.
Une autre solution pourrait être d'utiliser une structure Nested implémentant IEnumerator. |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
On utilise le mot réservé ParamArray pour passer un nombre variable d'arguments à une fonction. Pour ce qui est de pouvoir passer des types différents, il suffit d'utiliser Object étant donné que tout type dérive de cette classe :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
On utilise le mot réservé params pour passer un nombre variable d'arguments à une fonction :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Il suffit d'utiliser const devant la déclaration de la variable. L'initialisation devra se faire en même temps que la déclaration car il ne sera plus possible de modifier la valeur de la variable par après :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La classe Interlocked fournit des méthodes afin d'effectuer des opérations mathématiques de manière atomique lorsque plusieurs threads se partagent des variables.
A noter que les membres de cette classe ne lèvent pas d'exception. | ||
lien : Documentation MSDN sur la classe Interlocked |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La ligne suivante permet de mettre un terme à la tranche de temps que le Thread a pour utiliser le processeur :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Il suffit de la qualifier du mot réservé NotInheritable.
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La classe Stack vous permet de stocker une liste d'objets et les récupérer avec la technique LIFO (Last In First Out) – Dernier arrivé, premier retiré – tout simplement comme une pile.
| ||
lien : Documentation MSDN sur la classe Stack |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
En VB.Net, il est possible d'accéder aux membres de l'objet courant par l'intermédiaire du mot réservé Me :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La classe Monitor permet à un thread de mettre un verrou sur des objets. Ainsi, aucun autre thread ne pourra mettre son verrou sur les objets déjà verrouillés.
| ||
lien : Documentation MSDN sur la classe Monitor |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La classe Type est la base de la réflexion. Elle permet d'obtenir des informations concernant un type donné comme les constructeurs, méthodes, champs, évènements, ...
Le mot clé GetType, quant à lui, permet de récupérer une instance de la classe Type par rapport au type de la classe passé en paramètre.
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Il existe 2 solutions pour déterminer si un objet est d'un type donné :
La première est d'utiliser le mot clé is Ce dernier renvoie vrai si la condition est vérifiée :
La seconde solution est d'utiliser as La différence est que as va faire le casting en même temps. Si le casting n'est pas possible, null sera renvoyé :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Avec la version 2 du Framework, il est apparu la classe StopWatch qui permet de mesurer un intervalle de temps avec grande précision :
| ||
lien : Article sur la classe StopWatch par Webmanlien : Documentation MSDN sur la classe StopWatch |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La classe Queue vous permet de stocker une liste d'objets et les retirer avec la technique FIFO (First In First Out) – Premier arrivé, premier retiré – tout simplement comme une file.
| ||
lien : Documentation MSDN sur la classe Queue |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La méthode Main est le point d'entrée de tout programme. Il existe 4 signatures différentes :
Contrairement à ce que vous pourriez penser, il n'y a pas 6 signatures possibles mais bien 4 car il n'est pas possible d'utiliser la classe de base Object à la place de String. |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Grâce à la redéfinition de l'opérateur – (mais aussi de +, ==, !=, >, >=, <, <=) avec la classe TimeSpan, il est possible de faire la différence entre 2 objets DateTime
Calculons le nombre de jours écoulés depuis la création de cette question :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
const et readonly permettent tout deux de mettre en constante un champ à la différence que const oblige à faire la déclaration et l'initialisation en une fois alors que readonly permet de faire l'initialisation du champ dans le constructeur de la classe.
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Cette définition est tirée de MSDN
Le Common Language Runtime recourt à une implémentation avancée de l'interface graphique (GDI, Graphics Design Interface) Windows, appelée GDI+. GDI+ vous permet de créer des graphiques, de dessiner du texte et de manipuler des images graphiques en tant qu'objets. Cette interface est conçue pour allier performances et simplicité d'utilisation. Vous pouvez l'utiliser en vue du rendu des images graphiques sur des Windows Forms et des contrôles. GDI+ a entièrement remplacé GDI et constitue aujourd'hui la seule option disponible pour le rendu des graphiques par programme dans les applications Windows Forms. | ||
lien : Documentation MSDN sur les graphiques GDI+ |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Vous pouvez effectuer un décalage à gauche ou droite d'un certain nombre de bits de la manière suivante :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
La classe BitArray permet de stocker une liste de « vrai » - « faux » :
| ||
lien : Documenation MSDN de System.Collections.BitArray |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Il suffit d'utiliser this dans le header du constructeur (c'est-à-dire juste après la liste des paramètres) :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Cette définition est tirée de MSDN
Le .NET Compact Framework est un environnement indépendant du matériel permettant d'exécuter des programmes sur divers périphériques informatiques à ressources limitées : assistants numériques personnels (PDA, Personal Data Assistant) tels que le Pocket PC, téléphones mobiles, décodeurs, périphériques informatiques automobiles et périphériques personnalisés intégrés au système d'exploitation Windows CE .NET. Le .NET Compact Framework est un sous-ensemble de la bibliothèque de classes du .NET Framework, mais contient également des classes spécialement conçues à son intention. Il hérite la totalité de l'architecture de Common Language Runtime et d'exécution de code managé du .NET Framework. | ||
lien : .NET Compact Framework |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Pour instancier une classe à partir d'un type, il vous faudra utiliser la classe Activator :
| ||
lien : System.Activator |
| ||
| auteur : dev01 | ||
.NET 3.0 est la dernière version en date du framework .NET de microsoft. Il n'apporte pas de changement au niveau des langages eux-mêmes mais introduit un ensemble de nouvelles technologies qui ont fait leur apparition avec Windows Vista Le framework 3.0 est constitué de :
|
| ||
| auteur : dev01 | ||
Le XAML (eXtensible Application Markup Language) est un langage de description d'élément d'application basé sur le XML (eXtensible Markup Langage). Il est utilisé par exemple dans les nouvelles interfaces graphiques WPF, ou dans WF. |
| ||
| auteur : dev01 | ||
Windows Presentation Foundation (WPF) est la nouvelle technologie de création des interfaces graphiques. Elle permet de séparer la conception des interfaces graphiques de l'ajout du code logique grâce à l'introduction du XAML (eXtensible Application Markup Language) pour la description de l'interface graphique. WPF repose sur un nouveau moteur de rendu: le Graphics Processing Unit. Ce moteur permet un rendu vectoriel améliorant ainsi la qualité finale. De plus les fonctionnalités de lecture de média comme de la vidéo ou du son sont directement prises en charge par WPF |
| ||
| auteur : dev01 | ||
Windows CardSpace (WC) est le système de gestion des identités numériques introduit par le framework 3.0. Ce système permet une gestion sécurisé des diverses identités numériques qu'un utilisateur peut être amené à avoir. De plus WC doit permettre aux applications d'accéder aux informations de l'utilisateur sans que celui-ci ait besoin d'intervenir. Cela permet par exemple de remplir certain champs d'état civil automatiquement. |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Par défaut en VB.Net, les casting implicites sont autorisés. Ce qui veut dire que vous pouvez faire ceci :
Pour interdire ce genre de pratique et donc s'obliger à faire un casting explicite :
Il suffit d'aller dans les propriétés du projet, allez dans l'onglet Compile, puis mettez Option Strict à On. Il est également possible de définir Option Strict au niveau de chaque fichier de code en ajoutant Option Strict On au début de celui. |
| ||
| auteurs : Jérôme Lambert (Cardi), Aspic | ||
|
| ||
| auteurs : Jérôme Lambert (Cardi), Aspic | ||
La classe Graphics possède une méthode MeasureString permettant de connaître la taille exacte d'une chaîne de caractères en fonction de la Font utilisée :
| ||
lien : System.Graphics.MeasureString |
| ||
| auteurs : Jérôme Lambert (Cardi), Aspic | ||
Les classes WebRequest et WebResponse vous permettent respectivement de créer des requêtes HTTP et récupérer les résultats de celles-ci.
| ||
lien : System.Net.WebRequestlien : System.Net.WebResponse |
| ||
| auteurs : Jérôme Lambert (Cardi), Aspic | ||
Grâce à la réflexion, il est possible d'obtenir énormément d'information à partir du type d'une classe. Pour vérifier si une classe implémente une interface, il vous suffira d'utiliser la méthode GetInterface de la classe Type :
| ||
lien : System.Type |
| ||
| auteur : Jérôme Lambert (Cardi) | ||
Pour instancier une classe à partir d'une chaîne de caractères, il vous faudra dans un premier temps transformer cette chaîne en un objet de type Type. A partir de l'objet Type obtenu, vous pourrez créer une instance grâce à la classe Activator :
| ||
lien : System.Activatorlien : System.Type |
| ||||
| auteur : Jérôme Lambert (Cardi) | ||||
Prenons le cas de deux classes, classA et classB :
Comme vous pouvez le voir, classA a une référence vers classB et classB a une référence vers classA. Si nous essayons de sérialiser un objet de type classA ou classB (et à condition que les références correspondantes ne soient pas NULL), nous aurons une erreur de référence circulaire et la sérialisation s'avèrera impossible :
Le code ci-dessus génèrera le message d'erreur suivant à l'exécution :
Afin de retirer les références circulaires, il suffira d'exclure les objets en question de la sérialisation en utilisant l'attribut System.Xml.Serialization.XmlIgnore sur les propriétés concernées :
|
| ||
| auteur : Jérôme Lambert (Cardi) | ||
L'objet application offre la possibilité de s'abonner à l'évènement ThreadException permettant d'être notifié lorsqu'un thread génère une exception non interceptée. Etant donné que la fenêtre est gérée par un thread, vous pourrez ainsi éviter tout "plantage" de votre application ou effectuer un traitement adapté avant la fermeture de votre application.
|
| ||
| auteur : Merlin | ||
Pour cela, rien de plus simple :
|
| ||
| auteurs : nico-pyright(c), Smyley | ||
Tout est dans le titre ... Il faut rajouter dans les usings
et voici le code ...
|
| ||
| auteur : nico-pyright(c) | ||
il faut mettre en préambule l'attribut KeyPreview de la form à true, pour dire que la form doit traiter tous les événements clavier en premier et ensuite surcharger le KeyDown de la form. Exemple pour faire un raccourci CTRL+M :
|
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2006 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Cette page est déposée.
Copyright © 2000-2012 - www.developpez.com