namespace rapportSuccursales
{
class rapportSuccursales
{
static void Main(string[] args)
{
//choixRapport(); // Afin de lancer la classe Donnees par instance
Donnees formulaire = new Donnees();
}
//Méthode du message d'erreur pour les Try catch des boucles
public static void ErreurFormulaire()
{
Console.Write("Erreur....");
Console.ReadKey();
Environment.Exit(0);
}
}
}
class Donnees
namespace rapportSuccursales
{
class Donnees
{
/*choixRapport(choixUser);*/
//Varaiables et assignation
private string[] _succursales = {"Montréal", "Québec", "Trois-rivières", "Sherbrooke"};
private string[] _items = {"chaise", "pelle", "marteau", "tondeuse", "tournevis", "perceuse", "table", "scie", "equerre", "serre-joint", "niveau", "brouette", "tuyau", "lampe"};
private int[] _annees = { 2015, 2016, 2017, 2018 };
private int[] _quantites = {186, 468, 316, 838, 373, 179, 886, 485, 186, 328, 220, 395, 434, 419, 822, 155, 761, 331, 757, 183, 519, 646, 751, 128, 761, 473, 982, 816, 791, 513, 966,
885, 953, 570, 616, 667, 914, 552, 704, 511, 316, 129, 970, 992, 276, 489, 977, 956, 918, 949, 900, 284, 114, 861, 591, 957, 851, 460, 538, 250, 919, 766, 460, 413, 500, 620, 972, 339, 616, 359,
263, 149, 611, 595, 772, 954, 419, 249, 276, 427, 798, 223, 702, 493, 321, 109, 560, 451, 444, 152, 976, 522, 910, 954, 177, 897, 245, 527, 163, 819, 177, 379, 636, 554, 608, 666, 350, 783, 373,
993, 545, 456, 253, 166, 724, 957, 480, 969, 561, 770, 392, 209, 535, 639, 140, 159, 921, 764, 868, 153, 174, 366, 565, 896, 423, 270, 733, 966, 922, 462, 359, 294, 332, 954, 728, 913, 299, 350,
896, 246, 202, 169, 611, 571, 517, 700, 108, 342, 517, 676, 176, 427, 972, 911, 628, 321, 821, 364, 288, 610, 630, 178, 379, 996, 670, 189, 316, 135, 342, 286, 692, 502, 424, 924, 136, 808, 104,
414, 330, 784, 690, 501, 433, 240, 612, 601, 885, 885, 991, 105, 976, 663, 691, 791, 712, 287, 666, 464, 597, 151, 268, 283, 293, 786, 528, 118, 758, 944, 881, 174, 960};
private readonly int[][][] _quantites3D = new int[4][][];
public Donnees()
{
try
{
//Pour remplir le tableau en 3D à partir du constructeur
int compteur = 0;
for (int i = 0; i < _succursales.Length; i++)
{
_quantites3D[i] = new int[_items.Length][];
for (int j = 0; j < _items.Length; j++)
{
_quantites3D[i][j] = new int[_annees.Length];
for (int k = 0; k < _annees.Length; k++)
{
_quantites3D[i][j][k] = _quantites[compteur++];
}
}
}
}
catch (Exception)
{
// Appel de la méthode du message d'erreur
rapportSuccursales.ErreurFormulaire(); }
Console.WriteLine("\nTest");
ChoixRapport();
}
// L'invitation à l'utilisateur de choisir le rapport ou mettre fin au programme
public void ChoixRapport()
{
string choixUser = "";
Console.WriteLine("Bonjour ! Je vous invite à choisir le rapport que vous voulez consulter en tapant au clavier : \n\n" +
"" +
"1- Pour le rapport «Total des ventes par succurcsale»\n" +
"" +
"2- Pour le rapport «Meilleures succurcales»\n" +
"" +
"3- Pour le rapport «Meilleurs produits»\n" +
"" +
"4- Pour le rapport «Meilleures années»\n");
Console.WriteLine();
Console.WriteLine("Sinon, je vous en prie, tapez le mot «fin» à la console si vous désirez quitter le programme.");
// Conversion en string des int
choixUser = Convert.ToString(Console.ReadLine());
Console.WriteLine();
// Si l'utilisateur n'entre aucune des options disponibles, je "throw" une exception
if (choixUser != "1" && choixUser != "2" && choixUser != "3" && choixUser != "4" && choixUser != "fin")
{
throw new Exception();
}
/*do
{
try
{
choixUser = Convert.ToString(Console.ReadLine());
}
catch (Exception e)
{
choixUser = "";
Console.WriteLine(e.Message);
Console.ReadKey();
}
}
while (choixUser != "fin" || choixUser != "«fin»" || choixUser != "FIN" || choixUser != "«FIN»");*/
ChoixRapport();
}
// Méthode pour la résultance du choix des rapports
public static void ResultChoix(string resultChoix)
{
// Sert à à lancer le programme par instance de Donnees
Donnees formulaire = new Donnees();//On créer un objet pour initialiser le programme
switch (resultChoix)
{
case "1":
formulaire.VenteChaqueItems(); // Affichage alphabétique du rapport de vente par succursale
break;
case "2":
break;
case "3":
break;
case "4":
break;
case "fin":
Console.WriteLine("Merci ! Au palisir de se revoir...");
break;
default:
Console.WriteLine("Vous avez fait un mauvais choix. Désolé, il faut recommencer ! ");
/*ChoixRapport();*/
break;
}
Console.ReadKey();
}
/*internal void VenteChaqueSucc()
{
throw new NotImplementedException();
}*/
// Méthode pour construire le tableau AxeSomme pour la liste des succurcales avec les totales de vente
public AxeSomme[] buildTableauSucc(AxeSomme[] axeSomme, int[][][] _quantites3D)
{
for (int i = 0; i < axeSomme.Length; i++)
{
// Appelle la méthode calculant la somme des ventes pour chaque succursale
axeSomme[i] = new AxeSomme(_succursales[i], VenteChaqueSucc(_quantites3D, i));
}
// Remplissage du tableau
return axeSomme;
}
/*****************************************************************************/
// Méthode pour le rapport de la liste des succursales en ordre alphabétique
public void ListeSuccursales(/*int[][][] _quantites3D*/)
{
// Création du tableau d'objets AxeSomme
AxeSomme[] axeSomme = new AxeSomme[_succursales.Length];
// Appel de la méthode pour remplir le tableau d'objets AxeSomme
buildTableauSucc(axeSomme, this._quantites3D);
// Instanciation d'un objet TriAxe
TriAxe triage = new TriAxe();
// Variable de longueur du tableau
int Long = axeSomme.Length;
// Appel de la méthode de tri par sélection
triage.TriSelection(axeSomme);
// Appel de la méthode pour afficher le résultat du rapport
Affiche(axeSomme);
}
// Méthode du rapport de la liste des succursales en ordre décroissant selon meilleures ventes
public void TopSuccurcales(int[][][] _quantites3D)
{
// Création du tableau d'objets AxeSomme
AxeSomme[] axeSomme = new AxeSomme[4];// Faire un tableau vide
// Appel de la méthode pour remplir le tableau d'objets AxeSomme
buildTableauSucc(axeSomme, _quantites3D);
// Variable du premier indice du tableau axeSommeA
int firstIndice = 0;
// Variable du dernier indice du tableau axeSommeA
int lastIndice = axeSomme.Length - 1;
// Instanciation d'un objet TriAxe
TriAxe meilleuresSuccursales = new TriAxe();
// Appel de la méthode de tri rapide
meilleuresSuccursales.TriRapide(axeSomme, firstIndice, lastIndice);
// Appel de la méthode pour afficher le résultat du rapport
Affiche(axeSomme);
}
/******************************************VÉRIF***********************************/
// méthode pour ventre par succurcales
public int VenteChaqueSucc(int[][][] _quantites3D, int succIndice)
{
int venteTotale = 0;
// on créer un tableau objet AxeSomme
AxeSomme[] _tab = new AxeSomme[_succursales.Length];
for (int i = 0; i < _succursales.Length; i++)
{
venteTotale = 0;
for (int j = 0; j < _items.Length; j++)
{
for (int k = 0; k < _annees.Length; k++)
{
venteTotale += this._quantites3D[i][j][k];
}
}
_tab[i] = new AxeSomme(_succursales[i], venteTotale);
}
return venteTotale;
}
/*****************************************************************************/
// méthode pour ventre par items********pt a enlever
public void VenteChaqueItems()
{
Console.WriteLine("Allo");
int venteTotale;
AxeSomme[] _tab = new AxeSomme[_items.Length];
for (int j = 0; j < _items.Length; j++)
{
venteTotale = 0;
for (int i = 0; i < _succursales.Length; i++)
{
for (int k = 0; k < _annees.Length; k++)
{
venteTotale += _quantites3D[i][j][k];
}
}
_tab[j] = new AxeSomme(_items[j], venteTotale);
}
TriAxe triA = new TriAxe(_tab); // a verif
Affichage rapport = new Affichage("\n*** Total des ventes par succursale pour les années 2015 à 2018.", "Succursales", "Total des ventes", _tab);
rapport.Affiche();
}
// méthode pour vente par années****************************pt a enlever
public void MeilleuresAnnées()
{
int total = 0;
AxeSomme[] _tableau = new AxeSomme[_annees.Length];
for (int k = 0; k < _annees.Length; k++) // pour cahque année
{
for (int i = 0; i < _succursales.Length; i++) // Pour chaque succursales de la liste
{
for (int j = 0; j < _items.Length; j++) //Pour chaque item de la liste
{
total += _quantites3D[i][j][k];
}
}
_tableau[k] = new AxeSomme(Convert.ToString(_annees[k]), total); //affecter le total de chaque année dans le tableau tab
}
}
/*****************************************************************************/
// Méthode du rapport de la liste des produits en ordre décroissant selon meilleures ventes
public void DécroBestItems(int[][][] _quantites3D)
{
AxeSomme[] axeSomme = new AxeSomme[14]; // Création du tableau AxeSomme
buildTableauSucc(axeSomme, _quantites3D); // Appel de la méthode pour remplir le tableau
TriAxe topProduits = new TriAxe();// Instanciation
int longueurA = axeSomme.Length;//Variable pour établir la longueur du tableau
topProduits.TriInsertion(axeSomme);// Appel de la méthode de tri par insertion
Affiche(axeSomme);//Affiche le rapport
}
/*****************************************************************************/
// Méthode de construction du tableau AxeSomme pour la liste des produits selon les ventes
public AxeSomme[] buildTableauItems(AxeSomme[] axeSommeB, int[][][] _quantites3D)
{
for (int i = 0; i < axeSommeB.Length; i++)
{
// Instanciation AxeSomme par appel de la méthode qui produit la somme des ventes pour chaque item
axeSommeB[i] = new AxeSomme(_items[i], TotauxItems(this._quantites3D, i));
}
return axeSommeB;
}
/*****************************************************************************/
// Méthode produisant la somme des ventes de chaque produit
public int TotauxItems(int[][][] _quantites3D, int itemIndice)
{
int totalItem = 0;
for (int i = 0; i < _succursales.Length; i++)
{
for (int j = 0; j < _annees.Length; j++)
{
totalItem += _quantites3D[i][itemIndice][j];
}
}
return totalItem;
}
/*****************************************************************************/
// Méthode pour le rapport de la liste des années en ordre décroissant des meilleures ventes
public void BestAnnees(int[][][] _quantites3D)
{
AxeSomme[] axeSomme = new AxeSomme[4]; // Création du tableau AxeSomme
BuildTabAnnees(axeSomme, _quantites3D);// Appel de la méthode pour remplir le tableau AxeSomme
TriAxe BestAnnees = new TriAxe();// Instanciation de TriAxe
int longueurA = axeSomme.Length;//Variable pour établir la longueur du tableau
BestAnnees.TriInsertion(axeSomme);// Appel de la méthode de tri par insertion
Affiche(axeSomme);//Affiche le rapport
}
/*****************************************************************************/
// Méthode de construction du tableau d'objets AxeSomme pour la liste des années et leurs sommes de ventes
public AxeSomme[] BuildTabAnnees(AxeSomme[] axeSomme, int[][][] _quantites3D)
{
for (int i = 0; i < axeSomme.Length; i++)
{
// Instanciation d'AxeSomme par appel de la méthode la somme des ventes pour chaque année
axeSomme[i] = new AxeSomme(Convert.ToString(_annees[i]), SommesAnnees(_quantites3D, i));
}
return axeSomme;
}
/*****************************************************************************/
// Méthode pour la somme des ventes de chaque année
public int SommesAnnees(int[][][] quantites3DB, int anneeIndice)
{
int anneesSomme = 0;
for (int i = 0; i < _succursales.Length; i++)
{
for (int j = 0; j < _items.Length; j++)
{
anneesSomme += quantites3DB[i][j][anneeIndice];
}
}
return anneesSomme;
}
/*****************************************************************************/
// Méthode qui affiche le résultat du rapport
public void Affiche(AxeSomme[] axeSomme)
{
// Juste pour le retour de ligne
Console.WriteLine();
foreach (AxeSomme stat in axeSomme)//stat c'est le nom donné aux objets contenus dans AxeSomme, on choisit le nom qu'on veut
{
Console.WriteLine(stat);
}
}
}
}
class TriAxe :
namespace rapportSuccursales
{
class TriAxe
{
// Champ
private readonly AxeSomme[] _tableau;
//constructeur
public TriAxe(AxeSomme[] tab)
{
_tableau = tab; // .Clone() ?
}
public TriAxe()
{
}
//Méthode 1 : Tri par sélection
public AxeSomme[] TriSelection(AxeSomme[] axeSomme)
{
int min;
for (int i = 0; i <= axeSomme.Length - 2; i++)
{
min = i;
for (int j = i + 1; j <= axeSomme.Length - 1; j++)
{
if (String.Compare(axeSomme[j].Axe, axeSomme[min].Axe) < 0)
{
min = j;
}
}
if (min != i)
{
Interchange(axeSomme, i, min);
}
}
return axeSomme;
}
//Méthode 2 : Tri par sélection Rapide
public AxeSomme[] TriRapide(AxeSomme[] axesomme, int premier, int dernier)
{
if (premier < dernier)
{
int pivot = dernier;
pivot = Partitioner(axesomme, premier, dernier, pivot);
TriRapide(axesomme, premier, pivot - 1);
TriRapide(axesomme, pivot + 1, dernier);
}
return axesomme;
}
// Méthode partitionner appelée par la méthode de tri rapide
public int Partitioner(AxeSomme[] axesomme, int premier, int dernier, int pivot)
{
int j = premier;
for (int i = premier; i <= dernier - 1; i++)
{
if (axesomme[i].Somme >= axesomme[dernier].Somme)
{
Interchange(axesomme, i, j);
j++;
}
}
Interchange(axesomme, dernier, j);
return j;
}
//Méthode 3 : Tri par insertion
public AxeSomme[] TriInsertion(AxeSomme[] axesomme)
{
{
for (int i = 0; i <= axesomme.Length - 1; i++)
{
AxeSomme x = axesomme[i];
int j = i;
while (j > 0 && axesomme[j - 1].Somme < x.Somme)
{
axesomme[j] = axesomme[j - 1];
j = j - 1;
}
axesomme[j] = x;
}
}
return axesomme;
}
// Méthode d'interchange pour les tri par sélection et rapide
public void Interchange(AxeSomme[] axesommeChange, int fist, int second)
{
AxeSomme tampon = axesommeChange[fist];
axesommeChange[fist] = axesommeChange[second];
axesommeChange[second] = tampon;
}
}
}
class AxeSomme :
namespace rapportSuccursales
{
class AxeSomme
{
//Déclaration et assignation de variables
public string Axe { get; set; }
public int Somme { get; set; }
//constructeur
public AxeSomme(string axe, int somme)
{
Axe = axe;
Somme = somme;
}
//Méthode ToString
public override string ToString()
{
return string.Format("{0,-17}\t ===> {1}", Axe,Somme); //17 charactères de largeur pour Trois-Rivières
}
}
}
Voilà, en premier, j'aimerais qu'on m'aide pour mon erreur Out of range comme le démontre la photo. Ou Plus ultimement, j'aimerais pouvoir au moins afficher le résultat du premier rapport à la console. Pour le moment, elle n’affiche que le choix pour l'utilisateur et peu importe se qu'il tape au clavier si je ne met pas le Try catch ou si je le met, le programme ne va pas plus loin et affiche mon message d'erreur Try Catch...
Si tu veux que tes éléments s'ajoute à ton tableau tu as deux solutions.
1) tu connais la taille de ton tableau et donc tu définis directement les dimensions comme tu as fait pour la première dimension
private readonly int[][][] _quantites3D = new int[4][50][60]; //50 et 60 au pif
2) tu ne connais pas d'avance la taille de ton tableau et donc tu vas ajouter à la suite sans préciser d'index.
unTableau[] = "Element 1";
unTableau[] = "Element 2";
//unTableau[0] vaut alors "Element 1"
//unTableau[1] vaut alors "Element 2"
Donc dans ton cas avec plusieurs dimensions, la deuxième solutions ne fonctionnera pas.
Par contre je ne vois pas trop l'intérêt de dupliquer ces informations autant de fois que de succursales et d'années ... mais ça c'est une autre histoire !
c# Index out of range
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
