ABAZE DevS Blog

La Développement une vie une Passion

APS.MVC Server sideValidating User Input with Data Annotations

Posted by abaze17 on avril 21st, 2017

You can use data annotations in MVC models to

set validation criteria for user input. Input

validation is the process by which MVC checks

data provided by a user or a web request to

ensure that it is in the right format. The following

example shows a webpage form that collects

some information from the user:

o Name. This is required input. The user

must enter some data in this field.

o Height. This must be an integer between

0 and 400.

o Email Address. This is required input. The value entered must be a valid email address.

[Required(ErrorMessage=”Please enter a name.”)]

public string Name { get; set; }

Custom validation

exemple de validation

public class CheckValidYear : ValidationAttribute

{

public override bool IsValid(object value)

{

int year = (int)value;

if (year

Posted in ASP.NET MVC | Réagir »

Crystall report erreure : Could not load file or assembly ‘file:///C:Program FilesSAP BusinessObjectsCrystal Reports for .NET Framework 4.0CommonSAP BusinessObjects Enterprise

Posted by abaze17 on avril 11th, 2017

Could not load file or assembly ‘file:///C:\Program Files\SAP BusinessObjects\Crystal Reports for .NET Framework 4.0\Common\SAP BusinessObjects Enterprise XI 4.0\win32_x86\dotnet1\crdb_adoplus.dll’ or one of its dependencies. The system cannot find the file specified.

Ce Message appaît le plus souvent quand nous avons ajouté  un état chrystal report dans la solution visual studio.

afin de le résoudre, il faut juste modifier le fichier de configuration (app.config/web.config

en ajoutant les balises de configuration suivantes

   

 

Posted in Uncategorized | Réagir »

GAC ( Global Assembly Cache

Posted by abaze17 on mars 19th, 2017

Chaque ordinateur sur lequel est installé la CLR( Common Language Runtime dispose d’un cache de code.

Le GAC  stocke des assemblys spécifiquement désignés pour être partagés par plusieurs applications sur l’ordinateur.

Il est necessaire  partager des assemblys en les installant dans le cache d’assembly global uniquement lorsque vous en avez besoin.

Il Est nécessare de  partager des ensemblys dans l’installation dans le cache d’assemblage global que Vous avez besoin. En règle générale, garder les dépendances d’assemblage privé et de localiser les assemblages dans le répertoire de l’application sinon le partage d’un ensemble est explicitement nécessaire. En outre, il est nécessaire d’installer des assemblages dans le cache de l’assemblée mondiale pour les rendre accessibles à COM Interop ou code non manage

Commanda afficher le GAC:  %windir%\Microsoft.NET\assembly., is %windir%\assembly.

Posted in .C# 4.5 | Réagir »

ASP.MVC 5 Model Binders

Posted by abaze17 on janvier 21st, 2017

Un model binder est un composant d’un ASP.NET Application MVC qui crée une instance d’une Classe de modèle, en fonction des données envoyées dans la demande À partir du navigateur Web. ASP.NET MVC comprend un

Model Binder par défaut qui répond aux besoins deLa plupart des applications Web. Cependant, vous devez savoir

Comment le defaultModelBinder  fonctionne avec d’autres Composants pour l’utiliser correctement.

De plus, vous pouvez  choisir de créer un Custom ModelBinder pour gérer des Situations avancées.

Un Model Binder garantit que les bonnes données sont envoyées Aux paramètres dans une méthode d’action du contrôleur. Cela permet à MVC de créer des instances de classes de modèles Qui répondent à la demande de l’utilisateur. Le classeur de le DefaultModelBinder, par exemple, examine à la fois la définition de

Les paramètres d’action du contrôleur et les paramètres de la requête pour déterminer les valeurs de la demande à transmettre

Quel paramètre d’action.

Ce processus de liaison avec le modèle permet d’économiser beaucoup de temps les développeurs et d’éviter de nombreuses erreurs d’exécution inattendues

Qui découlent de paramètres incorrects. MVC comprend un  DefaultModelBinder avec une logique sophistiquée qui

Passe correctement les paramètres dans presque tous les cas sans code personnalisé complexe

Exemple  de requette utilisateur : http://www.sergeope.com/produit/affiche/45

cette requette va identifier trois aspect suivant:

  • la classe du modèle concerné ici la classe produit
  • le type d’operation dans la classe, ici c’est afficher le produit
  • listance spécifique , ID=45

 la classe ControllerActionInvoker est invoker par defaut pour  utiliser le ModelBinder afin devaluer les paramètres passés et appeler l’action du controlleur approprié

Posted in Uncategorized | Réagir »

ASP.NET MVC 5 Error Pages and Error Logging

Posted by abaze17 on juin 13th, 2016

Les pages d’erreur personnalisées et l’enregistrement global des erreurs sont deux sujets élémentaires et pourtant très confus dans ASP.NET MVC 5.

Il existe de nombreuses façons de mettre en œuvre des pages d’erreur dans ASP.NET MVC 5 et lorsque vous recherchez des conseils, vous trouverez une douzaine de threads StackOverflow différents, chacun proposant une implémentation différente.

Vue d’ensemble

Quel est le but?

Typiquement bonne gestion des erreurs consiste à:

Pages d’erreur amicales humaines

Page d’erreur personnalisée par code d’erreur (par exemple: 404, 403, 500, etc.)

Préserver le code d’erreur HTTP dans la réponse pour éviter l’indexation des moteurs de recherche

Enregistrement des erreurs globales pour les exceptions non traitées

Pages d’erreur et enregistrement dans ASP.NET MVC 5

Il existe de nombreuses façons de mettre en œuvre la gestion des erreurs dans ASP.NET MVC 5. Généralement, vous trouverez des solutions qui impliquent au moins une ou une combinaison de ces méthodes:

HandleErrorAttribute

Méthode Controller.OnException

Événement Application_Error

Élément customErrors dans web.config

Élément httpErrors dans web.config

Custom HttpModule

Toutes ces méthodes ont une raison historique et un cas d’utilisation justifiable. Il n’y a pas de solution d’or qui fonctionne pour chaque application. Il est bon de connaître les différences afin de mieux comprendre laquelle est appliquée le mieux.

Avant de passer par chaque méthode plus en détail, je voudrais expliquer quelques fondamentaux fondamentaux qui nous l’espérons aider à comprendre le sujet beaucoup plus facile.

Principes fondamentaux d’ASP.NET MVC

Le cadre MVC n’est qu’un HttpHandler branché dans le pipeline ASP.NET. La façon la plus simple de l’illustrer est d’ouvrir Global.asax.cs:

Public class MvcApplication: System.Web.HttpApplication

La navigation vers la mise en œuvre de HttpApplication révélera les interfaces IHttpHandler et IHttpAsyncHandler sous-jacentes:

Public class HttpApplication: IComponent, IDisposable, IHttpAsyncHandler, IHttpHandler

ASP.NET lui-même est un cadre plus large pour traiter les demandes entrantes. Bien qu’il puisse traiter les demandes entrantes de différentes sources, il est presque exclusivement utilisé avec IIS. Il peut être étendu avec HttpModules et HttpHandlers.

HttpModules sont branché dans le pipeline pour traiter une demande à tout moment du cycle de vie ASP.NET. Un HttpHandler est responsable de produire une réponse / sortie pour une requête.

IIS (technologie du serveur Web de Microsoft) créera une demande entrante pour ASP.NET, qui commencera par la suite à traiter la requête et éventuellement à initialiser HttpApplication (qui est le gestionnaire par défaut) et à créer une réponse:

 

IIS, ASP.NET and MVC architecture

Le point  clé est de savoir que ASP.NET ne peut traiter que les requêtes que IIS envoie à lui. Cela est déterminé par les HttpHandlers enregistrés (par exemple, par défaut, une demande à un fichier .htm n’est pas gérée par ASP.NET).

Et enfin, MVC n’est qu’un des potentiellement nombreux gestionnaires enregistrés dans le pipeline ASP.NET.

Ceci est crucial pour comprendre l’impact des différentes méthodes de gestion des erreurs.

Briser les options

HandleErrorAttribute

Le HandleErrorAttribute est un MVC FilterAttribute, qui peut être appliqué à une classe ou à une méthode:

namespace System.Web.Mvc { [AttributeUsage( AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)] public class HandleErrorAttribute : FilterAttribute, IExceptionFilter { // … } }

a portée de gestion des erreurs est limitée aux méthodes d’action dans le cadre MVC. Cela signifie qu’il ne pourra pas capturer et traiter les exceptions générées en dehors du gestionnaire ASP.NET MVC (par exemple, les exceptions à un stade antérieur du cycle de vie ou les erreurs dans d’autres gestionnaires). Il n’atteindra pas non plus une exception si la méthode d’action ne fait pas partie de la pile d’appels (par exemple, des erreurs de routage).

En outre, le HandleErrorAttribute gère uniquement 500 erreurs de serveur interne. Par exemple, cela ne sera pas pris en charge par l’attribut:

[HandleError] public ActionResult Index() { throw new HttpException(404, “Not found”); }

ous pouvez utiliser l’attribut pour décorer une classe de contrôleur ou une méthode d’action particulière. Il prend en charge les pages d’erreur personnalisées par type d’exception hors de la boîte:

[HandleError (ExceptionType = typeof (SqlException), View = “DatabaseError”)]]

Afin d’obtenir le

 fonctionnement de HandleErrorAttribute, vous devez également activer le mode customErrors sur votre web.config:

Cas d’utilisation

Le HandleErrorAttribute est le plus limité dans la portée. De nombreuses erreurs d’application contournent ce filtre et ne sont donc pas idéales pour une gestion globale des erreurs d’application.

Il s’agit d’un excellent outil pour l’action de gestion des erreurs spécifiques comme la tolérance aux pannes supplémentaires pour une méthode d’action critique cependant.

Méthode Controller.OnException

La méthode OnException est invoquée si une méthode d’action du contrôleur lance une exception. Contrairement au HandleErrorAttribute, il capture également les codes d’erreur HTTP 404 et autres et il ne nécessite pas customErrors pour être activé.

Il est implémenté en remplaçant la méthode OnException dans un contrôleur:

protected override void OnException(ExceptionContext filterContext) { filterContext.ExceptionHandled = true; // Redirect on error: filterContext.Result = RedirectToAction(”Index”, “Error”); // OR set the result without redirection: filterContext.Result = new ViewResult { ViewName = “~/Views/Error/Index.cshtml” }; }

Posted in ASP.NET MVC | Réagir »

Bienvenu sur mon blog

Posted by abaze17 on mars 3rd, 2016

A travers ce blog je vais m’éfforcer de vous faire partager mon expérience dans ma profession principale,ma passion pour le développement,

Posted in Uncategorized | 1 Commentaire »

L’approche orientée objet

Posted by abaze17 on avril 19th, 2015

La qualité d’un logiciel

On peut mesurer la qualité d’un logiciel par :

1. L’exactitude : aptitude d’un programme à fournir le résultat

voulu et à répondre ainsi aux spécifications

2. La robustesse : aptitude à bien réagir lorsque l’on s’écarte

des conditions normales d’utilisation

3. L’extensibilité : facilité avec laquelle un programme pourra

être adapté pour répondre à l’évolution des spécifications

4. La ré utilisabilité : possibilité d’utiliser certaines parties du

logiciel pour résoudre un autre problème

5. La portabilité : facilité avec laquelle on peut exploité un

même logiciel dans différentes implémentations

6. L’efficience : temps d’exécution, taille mémoire

 

L’approche orientée objet

La qualité d’un logiciel

On peut mesurer la qualité d’un logiciel par :

1. L’exactitude : aptitude d’un programme à fournir le résultat

voulu et à répondre ainsi aux spécifications

2. La robustesse : aptitude à bien réagir lorsque l’on s’écarte

des conditions normales d’utilisation

3. L’extensibilité : facilité avec laquelle un programme pourra

être adapté pour répondre à l’évolution des spécifications

4. La réutilisabilité : possibilité d’utiliser certaines parties du

logiciel pour résoudre un autre problème

5. La portabilité : facilité avec laquelle on peut exploité un

même logiciel dans différentes implémentations

6. L’efficience : temps d’exécution, taille mémoire

 

La programmation structurée a permis d’améliorer :

1. La robustesse

2. L’exactitude

 

Etendre et réutiliser : casser les modules Intéressants

 

Les limites de l’approche fonctionnelle

 

§  L’approche fonctionnelle : décomposition hiérarchique en fonctions

§  Le découpage impose la hiérarchie : le couplage fonction/ hiérarchie est statique

§  Conséquence : l’évolution nécessite des modifications lourdes

§  Un seul état partagé (mémoire) et toute fonction peut agir sur n’importe quelle partie : code difficilement réutilisable

 

L’approche objet

§  Différence fondamentale entre la programmation

§  procédurale et la programmation objet :

§  1. En programmation procédurale :

§  décomposition de tâches en sous-tâches

§  2. En programmation objet : on identifie les

§  acteurs (les entités comportementales) du

§  problème puis on détermine la façon dont ils

§  doivent interagir pour que le problème soit résolu.

 

 

 

 

 

Un objet

Objet = Etat + Comportement [+ Identité]

1. Etat : valeurs des attributs (données) d’un objet

2. Comportement : opérations possibles sur un

objet déclenchées par des stimulations externes

(appels de méthodes ou messages envoyées par

d’autres objets)

3. Identité : chaque objet à une existence propre

(il occupe une place en mémoire qui lui est

propre). Les objets sont différenciés par leurs noms

 

 

 

 

Posted in P Orientée Objet | Réagir »

[WPF] Regles validation

Posted by abaze17 on juin 19th, 2012

Dans ce blog, il est question de vous parlez d’une propriété assez puissante de WPF,

La documentation de Microsoft qui montre comment afficher les erreurs de validation pour les éléments indique d’utiliser une liaison comme ceci:

Suite à mes travaux,

J’utilise la fenêtre de sortie tout le temps pour les fins de débogage, donc l’avoir remplir avec ces messages d’erreur brise mon flux de travail. J’ai décidé de trouver une meilleure façon d’afficher les messages d’erreur, de sorte que la fenêtre de sortie n’est pas obstruée . Voici ce que je suis venu avec:

en exécutant la démo , on , c’est vrai le libelle est anglais, mais sa ne devrait pas vous gêner

Autre implémentation : implémenter la validation de la liaison

Comment : implémenter la validation de la liaison

Cet exemple montre comment utiliser un ErrorTemplate et un déclencheur de style pour fournir la rétroaction visuelle pour signaler à l’utilisateur l’entrée d’une valeur non valide en fonction d’une règle de validation personnalisée.

Exemple

Le contenu de texte de la TextBox dans l’exemple suivant est lié à la propriété Age (de type int) d’un objet de source de liaison nommé ods. La liaison est définie pour utiliser la règle de validation AgeRangeRule pour que, lorsque l’utilisateur entre des caractères non numériques ou une valeur inférieure à 21 ou supérieure à 130, un point d’exclamation rouge apparaisse à côté de la zone de texte et une info-bulle avec le message d’erreur s’affiche lorsque l’utilisateur place le pointeur de la souris sur la zone de texte.

XAML

<TextBox Name="textBox1" Width="50" FontSize="15"
         Validation.ErrorTemplate="{StaticResource validationTemplate}"
         Style="{StaticResource textBoxInError}"
         Grid.Row="1" Grid.Column="1" Margin="2">
  <TextBox.Text>
    <Binding Path="Age" Source="{StaticResource ods}"
             UpdateSourceTrigger="PropertyChanged" >
      <Binding.ValidationRules>
        <c:AgeRangeRule Min="21" Max="130"/>
      </Binding.ValidationRules>
    </Binding>
  </TextBox.Text>
</TextBox>

L’exemple suivant montre l’implémentation AgeRangeRule qui hérite de ValidationRule et remplace la méthode Validate. La méthode Int32.Parse () est appelée sur la valeur pour vérifier qu’elle ne contient pas de caractères non valides. La méthode Validate retourne unValidationResult qui indique si la valeur est valide en fonction de l’interception d’une exception pendant l’analyse et si la valeur d’âge ne se trouve pas entre la limite inférieure et la limite supérieure.

C#

public class AgeRangeRule : ValidationRule
{
    private int _min;
    private int _max;
 
    public AgeRangeRule()
    {
    }
 
    public int Min
    {
        get { return _min; }
        set { _min = value; }
    }
 
    public int Max
    {
        get { return _max; }
        set { _max = value; }
    }
 
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        int age = 0;
 
        try
        {
            if (((string)value).Length > 0)
                age = Int32.Parse((String)value);
        }
        catch (Exception e)
        {
            return new ValidationResult(false, "Illegal characters or " + e.Message);
        }
 
        if ((age < Min) || (age > Max))
        {
            return new ValidationResult(false,
              "Please enter an age in the range: " + Min + " - " + Max + ".");
        }
        else
        {
            return new ValidationResult(true, null);
        }
    }
}

L’exemple suivant montre le ControlTemplate validationTemplate personnalisé qui crée un point d’exclamation rouge pour signaler à l’utilisateur une erreur de validation. Les modèles de contrôle sont utilisés pour redéfinir l’apparence d’un contrôle.

 

XAML

 <ControlTemplate x:Key="validationTemplate">
  <DockPanel>
    <TextBlock Foreground="Red" FontSize="20">!</TextBlock>
    <AdornedElementPlaceholder/>
  </DockPanel>
</ControlTemplate>
Comme indiqué dans l'exemple suivant, l'ToolTipp qui affiche le message d'erreur est créée à l'aide du style textBoxInError. Si la valeur deHasErrorr est true, le déclencheur affecte à l’info-bulle de la TextBox actuelle sa première erreur de validation. La RelativeSource a la valeur Selffen faisant référence à l’élément actuel.

XAML

<Style x:Key="textBoxInError" TargetType="{x:Type TextBox}">
  <Style.Triggers>
    <Trigger Property="Validation.HasError" Value="true">
      <Setter Property="ToolTip"
        Value="{Binding RelativeSource={x:Static RelativeSource.Self},
                        Path=(Validation.Errors)[0].ErrorContent}"/>
    </Trigger>
  </Style.Triggers>
</Style>

 

 

Posted in WPF | Réagir »

CLR

Posted by abaze17 on avril 22nd, 2012

Common Language Runtime (CLR) est le nom choisi par Microsoft pour le composant de machine virtuelle du framework .NET. Il s’agit de l’implémentation par Microsoft du standard Common Language Infrastructure (CLI) qui définit l’environnement d’exécution des codes de programmes. Le CLR fait tourner une sorte de bytecode nomméCommon Intermediate Language (CIL). Le compilateur à la volée transforme le code CIL en code natif spécifique au système d’exploitation. Le CLR fonctionne sur des systèmes d’exploitation Microsoft Windows.

Le CLR est composé des quatre parties suivantes :

·         Common Type System (CTS) :

Common Type System (CTS) est un terme de Microsoft utilisé pour décrire le traitement des types de données dans le framework .NET.

·         Common Language Specification (CLS) ;

·         Metadata ;

·         Virtual Execution System (VES).

Le CLR est à .NET ce que la JVM est à Java, c’est-à-dire une machine virtuelle, sans laquelle l’exécution de code .NET ne serait pas possible. À l’inverse de son concurrent, leframework .NET a été conçu pour permettre l’interopérabilité entre différents langages.

Quel que soit le langage utilisé pour écrire une application .NET, le code doit être transformé en CIL (Common Intermediate Language). Ce code intermédiaire ne comporte aucune instruction relative au matériel (i.e. hardware) ou au système d’exploitation. Il ne peut donc pas être exécuté directement. Malgré cela, on pourrait tout à fait imaginer écrire directement une application en IL, langage qui ressemble à l’assembleur, sans passer par un langage de dernière génération comme le C#.

Le CLR est nécessaire pour exécuter le code intermédiaire. Il est basé sur le CTS (Common Type System)1 et le CLS (Common Language Specification). Il apporte de nombreuses fonctionnalités comme le ramasse-miettes en anglais : Garbage Collector (la mémoire utilisée par l’application lors de l’exécution est optimisée), la BCL (Base Class Library), et le système de sécurité. Une fois le code présent dans le CLR, il va enfin pouvoir être compilé par le JIT Compiler (Just in Time) en langage natif de la machine.

Il existe trois types de JIT :

·         Pre-JIT : le code entier est directement compilé ;

·         Econo-JIT : le code est compilé par parties, et la mémoire libérée si nécessaire ;

·         Normal-JIT : le code n’est compilé que quand c’est nécessaire, mais est ensuite placé en cache pour pouvoir être réutilisé.

Quel que soit le type de JIT, le but est d’accélérer l’exécution du code en réutilisant dès que possible le cache. Pour voir ceci visuellement, c’est très simple. Il suffit d’écrire une simple application ASP.NET (Hello World par exemple). À la première exécution, le code est compilé. Par la suite et aussi longtemps que l’application ne subit pas de modifications, le cache sera utilisé, d’où une vitesse d’exécution bien plus rapide que lors de la première exécution.

Le JIT fourni par Microsoft ne produit évidemment que du code natif Windows, mais les spécifications étant disponibles, il s’est trouvé un groupe de personnes ayant décidé de porter .NET sur Linux, donnant naissance à la plate-forme de développement libre Mono.

Posted in .C# 4.5 | Réagir »

Polymorphism

Posted by abaze17 on avril 19th, 2012

Le polymorphisme est souvent désigné comme le troisième pilier de la programmation orientée objet, après encapsulation et de l’héritage. Le polymorphisme est un mot grec qui signifie «beaucoup de forme” et il a deux aspects distincts:

• Au moment de l’exécution, les objets d’une classe dérivée peuvent être traités comme des objets d’une classe de base dans des endroits tels que les paramètres de la méthode et des collections ou des tableaux. Lorsque cela se produit, le type déclaré de l’objet est plus identique à son type run-time.

• Les classes de base peuvent définir et mettre en œuvre des méthodes virtuelles, et les classes dérivées peuvent les remplacer, ce qui signifie qu’ils fournissent leur propre définition et la mise en œuvre. Au moment de l’exécution, lorsque le code client appelle la méthode, le CLR regarde le type d’exécution de l’objet, et invoque que substitution de la méthode virtuelle. Ainsi, dans votre code source, vous pouvez appeler une méthode sur une classe de base, et causer la version d’une classe dérivée de la méthode à exécuter.

Les méthodes virtuelles vous permettent de travailler avec des groupes d’objets liés d’une manière uniforme. Par exemple, supposons que vous avez une application de dessin qui permet à un utilisateur de créer différents types de formes sur une surface de dessin. Vous ne savez pas au moment de la compilation quels types spécifiques de formes que l’utilisateur va créer. Toutefois, l’application doit garder une trace de tous les différents types de formes qui sont créés, et il doit les mettre à jour en réponse aux actions de la souris de l’utilisateur. Vous pouvez utiliser le polymorphisme pour résoudre ce

 

public class Shape
{
    // A few example members
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Height { get; set; }
    public int Width { get; set; }
 
    // Virtual method
    public virtual void Draw()
    {
        Console.WriteLine("Performing base class drawing tasks");
    }
}
 
class Circle : Shape
{
    public override void Draw()
    {
        // Code to draw a circle...
        Console.WriteLine("Drawing a circle");
        base.Draw();
    }
}
class Rectangle : Shape
{
    public override void Draw()
    {
        // Code to draw a rectangle...
        Console.WriteLine("Drawing a rectangle");
        base.Draw();
    }
}
class Triangle : Shape
{
    public override void Draw()
    {
        // Code to draw a triangle...
        Console.WriteLine("Drawing a triangle");
        base.Draw();
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        // Polymorphism at work #1: a Rectangle, Triangle and Circle
        // can all be used whereever a Shape is expected. No cast is
        // required because an implicit conversion exists from a derived 
        // class to its base class.
        System.Collections.Generic.List shapes = new System.Collections.Generic.List();
        shapes.Add(new Rectangle());
        shapes.Add(new Triangle());
        shapes.Add(new Circle());
 
        // Polymorphism at work #2: the virtual method Draw is
        // invoked on each of the derived classes, not the base class.
        foreach (Shape s in shapes)
        {
            s.Draw();
        }
 
        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
 

}

Posted in .C# 4.5 | Réagir »

 


Créer un Blog | Nouveaux blogs | Top Tags | 14 articles | blog Gratuit | Abus?