public static bool CheckIfConditionIsRespected(string Condition, string TableName, ref string msgErr, string IDLine,
ref bool isOk)
{
bool isRespected = true;
try
{
Type T = null;
galadbEntities context = new galadbEntities();
object theLine = GetObjectValueFromTable(TableName, context, IDLine, ref T);
if (null != theLine)
{
//On a l'objet et le type de l'objet, on va tester donc la condition
string[] tokens = Condition.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
//normalement on a trois tokens
if (tokens.Count() == 3)
{
string columnName = tokens[0]; //Nom de la colonne;
OPERATEUR op = EnumerationString.GetOperateurEnum(tokens[1]); //l'Operateur
string value = tokens[2]; //La valeur
//Maintenant on compile notre If
var currentValue = theLine.GetType().GetProperty(columnName).GetValue(theLine);
Type propType = theLine.GetType().GetProperty(columnName).GetMethod.ReturnType;
if (propType.IsGenericType && propType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
{
//Si le type est nullable alors, on récupère la destination
//Par exemple si c'est Nullable<int>, la destination est int
propType = Nullable.GetUnderlyingType(propType);
}
var correctValue = null != currentValue?Convert.ChangeType(currentValue, propType) : null;
var conditionCorrectValue = "null" != value.ToLower() ? Convert.ChangeType(GetValueFromString(value), propType) : null;
//Bon sincèrement il n'ya pas de plusieurs type de données dans la base généralement
//ce qui est sûr on teste
switch (op)
{
case OPERATEUR.Equals:
isRespected = (correctValue == conditionCorrectValue);
break;
case OPERATEUR.Different:
isRespected = (correctValue != conditionCorrectValue);
break;
case OPERATEUR.GreaterOrEquals:
case OPERATEUR.GreatherThan:
case OPERATEUR.LessOrEquals:
case OPERATEUR.LessThan:
{
//peut importe, le type, on utilise double qui est plus grand que
//int, decimal
double dbValueLine = double.Parse(correctValue.ToString());
double dbValueCondition = double.Parse(conditionCorrectValue.ToString());
if (op == OPERATEUR.GreatherThan)
{
isRespected = dbValueLine > dbValueCondition;
}
else if (op == OPERATEUR.GreaterOrEquals)
{
isRespected = dbValueLine >= dbValueCondition;
}
else if (op == OPERATEUR.LessThan)
{
isRespected = dbValueLine < dbValueCondition;
}
else if (op == OPERATEUR.LessOrEquals)
{
isRespected = dbValueLine <= dbValueCondition;
}
};
break;
default:
isRespected = true;
break;
}
//Disposition des var
if (null != currentValue)
{
GC.SuppressFinalize(currentValue);
}
if (null != correctValue)
{
GC.SuppressFinalize(correctValue);
}
if (null != conditionCorrectValue)
{
GC.SuppressFinalize(conditionCorrectValue);
}
if (null != propType)
{
GC.SuppressFinalize(propType);
}
isOk = true;
}
else
{
msgErr = "La valeur n'existe pas dans la base de données";
isOk = false;
isRespected = false;
}
//disposition des variables
context.Dispose();
GC.SuppressFinalize(context);
GC.SuppressFinalize(theLine);
GC.SuppressFinalize(T);
}
}
catch (Exception ex)
{
msgErr = ex.Message;
isOk = false;
isRespected = false;
}
return(isRespected);
}
private static bool DemanderOperation()
{
//int point = 0;
int a = random.Next(MIN, MAX);
int b = random.Next(MIN, MAX);
OPERATEUR operateur = GetOperateur();
int resultatOperation = 0;
while (true)
{
switch (operateur)
{
case OPERATEUR.ADDITION:
{
Console.Write("Combien font " + a + " + " + b + " ? :");
resultatOperation = a + b;
}
break;
case OPERATEUR.MULTIPLICATION:
{
Console.Write("Combien font " + a + " * " + b + " ? :");
resultatOperation = a * b;
}
break;
case OPERATEUR.SOUSTRACTION:
{
if (a < b)
{
int temp = a;
a = b;
b = temp;
}
Console.Write("Combien font " + a + " - " + b + " ? :");
resultatOperation = a - b;
}
break;
default:
{
Console.WriteLine("ERREUR, ce cas n'est pas géré dans le code");
Environment.Exit(0);
}
break;
}
//if(operateur == OPERATEUR.ADDITION)
//{
// //addition
// Console.Write("Combien font " + a + " + " + b + " ? :");
// resultatOperation = a + b;
//}
//else if (operateur == OPERATEUR.MULTIPLICATION)
//{
// //multiplication
// Console.Write("Combien font " + a + " * " + b + " ? :");
// resultatOperation = a * b;
//}
//else if (operateur == OPERATEUR.SOUSTRACTION)
//{
// //soustraction
// if (a < b)
// {
// int temp = a;
// a = b;
// b = temp;
// }
// Console.Write("Combien font " + a + " - " + b + " ? :");
// resultatOperation = a - b;
//}
String resultat = Console.ReadLine();
int nombreUtilisateur = 0;
if (int.TryParse(resultat, out nombreUtilisateur))
{
if (nombreUtilisateur == resultatOperation)
{
Console.WriteLine("BRAVO : Vous avez trouvez la bonne réponse :) ! ");
return(true);
//point++;
}
else
{
Console.WriteLine(nombreUtilisateur + ", ce n'est pas la bonne réponse. Réssayez !");
return(false);
}
}
else
{
Console.WriteLine("ERREUR: Vous devez renter un nombre");
}
Console.WriteLine("");
}
}
private static bool DemanderOperation()
{
int a = random.Next(MIN, MAX);
int b = random.Next(MIN, MAX);
OPERATEUR operateur = GetOperateur();
int resultatOperation = 0;
// Je boucle tant que j'ai pas défini une valeur numérique
while (true)
{
// En fonction du type d'opérateur ...
switch (operateur)
{
case OPERATEUR.ADDITION:
{
Console.Write(a + " + " + b + " = ");
resultatOperation = a + b;
}
break;
case OPERATEUR.MUTLIPLICATION:
{
Console.Write(a + " * " + b + " = ");
resultatOperation = a * b;
}
break;
case OPERATEUR.SOUSTRACTION:
{
if (a < b)
{
int temp = a;
a = b;
b = temp;
}
Console.Write(a + " - " + b + " = ");
resultatOperation = a - b;
}
break;
default:
{
Console.WriteLine("ERREUR : ce cas n'est pas géré dans le programme !");
Environment.Exit(0);
}
break;
}
String reponse = Console.ReadLine();
int responseNum = 0;
// Si il s'agit d'une valeur numérique alors je retourne qqch (sortie de boucle)
if (int.TryParse(reponse, out responseNum))
{
if (responseNum == resultatOperation)
{
Console.WriteLine("Bonne réponse");
return(true);
}
else
{
Console.WriteLine("Mauvaise réponse");
return(false);
}
}
// si il ne s'agit pas de valeur numérique j'affiche qqch et je continue la boucle
else
{
Console.WriteLine("ATTENTION: vous devez entrer une valeur numérique");
}
}
}
